pf_app/routes/log.js

const express = require('express');
const { grainOf } = require('../lib/sql_generator');
const { fcTable } = require('../lib/utils');

module.exports = function(pool) {
    const router = express.Router();

    // list log entries for a version, newest first, with row counts and value/units totals
    router.get('/versions/:id/log', async (req, res) => {
        const versionId = parseInt(req.params.id);
        try {
            const verResult = await pool.query(
                `SELECT v.*, s.tname, s.id AS source_id FROM pf.version v JOIN pf.source s ON s.id = v.source_id WHERE v.id = $1`,
                [versionId]
            );
            if (!verResult.rows.length) return res.status(404).json({ error: 'Version not found' });
            const { tname, source_id } = verResult.rows[0];
            const table = fcTable(tname, versionId);

            const colMeta = await pool.query(
                `SELECT cname, role FROM pf.col_meta WHERE source_id = $1 AND role IN ('value', 'units')`,
                [source_id]
            );
            const valueCol = colMeta.rows.find(c => c.role === 'value')?.cname;
            const unitsCol = colMeta.rows.find(c => c.role === 'units')?.cname;

            const aggCols = [
                `count(f.pf_id)::int AS row_count`,
                valueCol ? `sum(f."${valueCol}")::float8 AS value_total` : `NULL::float8 AS value_total`,
                unitsCol ? `sum(f."${unitsCol}")::float8 AS units_total` : `NULL::float8 AS units_total`
            ].join(', ');

            // ?kind=adjustments drops the baseline and reference entries. That is not
            // only about what gets listed: the aggregate below joins the whole
            // forecast table, and on a real version the load entries own almost
            // every row of it -- 2.5M against a few thousand for the adjustments.
            // Filtering in the WHERE keeps them out of the join rather than
            // totalling them and discarding the answer.
            const adjustmentsOnly = req.query.kind === 'adjustments';
            const opFilter = adjustmentsOnly
                ? `AND l.operation NOT IN ('baseline', 'reference')`
                : '';

            const result = await pool.query(`
                SELECT l.*, ${aggCols},
                       $2::text AS value_col,
                       $3::text AS units_col
                FROM pf.log l
                LEFT JOIN ${table} f ON f.pf_logid = l.id
                WHERE l.version_id = $1
                ${opFilter}
                GROUP BY l.id
                ORDER BY l.id DESC
            `, [versionId, valueCol || null, unitsCol || null]);
            res.json(result.rows);
        } catch (err) {
            console.error(err);
            res.status(err.status || 500).json({ error: err.message });
        }
    });

    // undo a log entry — delete all fc rows with this logid, then delete the log entry
    router.delete('/log/:logid', async (req, res) => {
        const logId = parseInt(req.params.logid);
        try {
            const logResult = await pool.query(`
                SELECT l.*, v.status, s.tname, v.id AS version_id, v.source_id
                FROM pf.log l
                JOIN pf.version v ON v.id = l.version_id
                JOIN pf.source s ON s.id = v.source_id
                WHERE l.id = $1
            `, [logId]);
            if (!logResult.rows.length) return res.status(404).json({ error: 'Log entry not found' });
            const log = logResult.rows[0];
            if (log.status === 'closed') return res.status(403).json({ error: 'Version is closed' });
            const table = fcTable(log.tname, log.version_id);

            // In grain mode the client's table is indexed on pf_gkey, so undo has to
            // report the grain keys to remove rather than raw pf_ids. The keys are
            // distinct while rows_deleted still counts the raw rows removed.
            const colMeta = await pool.query(
                `SELECT cname, role, in_grain, opos FROM pf.col_meta WHERE source_id = $1 ORDER BY opos`,
                [log.source_id]
            );
            const grain = grainOf(colMeta.rows);

            const client = await pool.connect();
            try {
                await client.query('BEGIN');
                const deleted = grain
                    ? await client.query(`
                        WITH
                        del AS (
                            DELETE FROM ${table}
                            WHERE pf_logid = $1
                            RETURNING ${grain.groupCols().join(', ')}
                        )
                        SELECT
                             count(*)::int                        AS rows_deleted
                            ,array_agg(DISTINCT ${grain.key()})   AS pf_gkeys
                        FROM del
                      `, [logId])
                    : await client.query(
                        `DELETE FROM ${table} WHERE pf_logid = $1 RETURNING pf_id`, [logId]
                      );
                await client.query('DELETE FROM pf.log WHERE id = $1', [logId]);
                await client.query('COMMIT');
                res.json(grain
                    ? {
                        rows_deleted: deleted.rows[0].rows_deleted,
                        pf_gkeys:     deleted.rows[0].pf_gkeys || []
                      }
                    : {
                        rows_deleted: deleted.rowCount,
                        pf_ids:       deleted.rows.map(r => r.pf_id)
                      });
            } catch (err) {
                await client.query('ROLLBACK');
                throw err;
            } finally {
                client.release();
            }
        } catch (err) {
            console.error(err);
            res.status(err.status || 500).json({ error: err.message });
        }
    });

    // update the note and/or tag on a log entry. Both are annotations — they never
    // affect the forecast rows — so they stay editable after the fact, including on
    // a closed version, where relabelling history is still legitimate.
    router.patch('/log/:logid', async (req, res) => {
        const logId = parseInt(req.params.logid);
        const { note, tag, bucket } = req.body;
        if (note === undefined && tag === undefined && bucket === undefined) {
            return res.status(400).json({ error: 'Nothing to update — send note, tag and/or bucket' });
        }
        try {
            // COALESCE on the flag, not the value: an explicit null or '' must be
            // able to clear a field, which COALESCE on the value alone would ignore
            const result = await pool.query(
                `UPDATE pf.log SET
                     note   = CASE WHEN $2::bool THEN $3::text ELSE note   END,
                     tag    = CASE WHEN $4::bool THEN $5::text ELSE tag    END,
                     bucket = CASE WHEN $6::bool THEN $7::text ELSE bucket END
                 WHERE id = $1 RETURNING *`,
                [
                    logId,
                    note   !== undefined, note   === undefined ? null : (String(note).trim()   || null),
                    tag    !== undefined, tag    === undefined ? null : (String(tag).trim()    || null),
                    bucket !== undefined, bucket === undefined ? null : (String(bucket).trim() || null),
                ]
            );
            if (!result.rows.length) return res.status(404).json({ error: 'Log entry not found' });
            res.json(result.rows[0]);
        } catch (err) {
            console.error(err);
            res.status(err.status || 500).json({ error: err.message });
        }
    });

    return router;
};