@adminiumjs/adminium 0.3.29 → 0.3.30

package/dist/routes/data/index.js

@@ -63,7 +63,8 @@ import { recipientLocale } from '../../i18n/server-i18n.js';
 import { TreeCheckRefused } from '../../public-api/tree-checks.js';
 import { staffTreeRules } from './tree.js';
 import { declaredColumns, expectColumnOf, priceCheck, staffRetryKey } from './staff-quote.js';
-import { scrubRefusal } from './refusal-scrub.js';
+import { scrubRefusal, scrubUnreadRefusal } from './refusal-scrub.js';
+import { refusalTableOf } from '../../crud/refusal-table.js';
 import { clientKeySecret } from '../public/tree.js';
 /**
  * How many links one record's field reads and replaces.
@@ -301,6 +302,24 @@ export function dataRoutes(deps) {
                 Object.defineProperty(error, 'message', { value: scrubbed.message, configurable: true, writable: true });
             }
         });
+        /*
+         * A refusal about another row than the one written (an effect's row, the
+         * parent a new child moves) told to somebody who may not read that row's
+         * table: it names nothing of the row — its state, what its move waits for.
+         */
+        app.addHook('onError', async (request, _reply, error) => {
+            if (!(error instanceof AppError))
+                return;
+            const about = refusalTableOf(error);
+            const connectionId = request.params?.connectionId;
+            if (about === undefined || typeof connectionId !== 'string')
+                return;
+            if (await request.can(`table:${connectionId}:${about}:read`))
+                return;
+            const scrubbed = scrubUnreadRefusal(error);
+            Object.defineProperty(error, 'details', { value: scrubbed.details, configurable: true });
+            Object.defineProperty(error, 'message', { value: scrubbed.message, configurable: true, writable: true });
+        });
         /*
          * A REQUEST OF SOMEBODY WHO REACHES ONLY SOME ROWS (`crud/row-limit.ts`).
          *
@@ -817,6 +836,8 @@ export function dataRoutes(deps) {
                 })();
                 undo.added.push(keyOf(written));
                 (undo.addedRows ??= []).push(written);
+                // The parent outside this record a new child moved (`moveOnCreate`).
+                options.effects?.push(...effectsOf(prepared.values));
                 settled.push({ action: 'create', record: written, before: null });
                 options.events?.push({ table: child.child, action: 'create', pk: keyOf(written), row: written });
             }
@@ -1544,6 +1565,28 @@ export function dataRoutes(deps) {
             if (entry.fileIds.length > 0 && deps.files !== undefined) {
                 await deps.files.restoreAll(entry.fileIds);
             }
+            /*
+             * A change taken back puts its files back too: a file of the record's
+             * it names again comes out of the bin the change put it in, and one it
+             * names no more goes there, as a replaced one does. A new row taken
+             * back takes its files with it, as a deleted one does.
+             */
+            if (deps.files !== undefined && entry.action !== 'delete') {
+                for (const row of changed) {
+                    const entity = { connectionId: entry.connectionId, table: table.id, pk: row.pk, label: pkLabel(table, row.pk) };
+                    if (entry.action === 'create') {
+                        if (row.record !== null)
+                            await trashRecordFiles(undone, entity, row.record);
+                        continue;
+                    }
+                    if (row.before === null)
+                        continue;
+                    const after = await fetchByPk(db, table, row.pk);
+                    if (after === undefined)
+                        continue;
+                    await deps.files.reconcile({ connectionId: entry.connectionId, table: table.id, entity, before: row.before, after, ruled: ruledBlocksOf(table.columns.values()), restoring: true });
+                }
+            }
             await app.rbac.audit(request, {
                 category: 'data',
                 action: 'record.undo',
@@ -1900,10 +1943,12 @@ export function dataRoutes(deps) {
                             context,
                             recheck: (final) => assertFileColumns(ctx, final),
                             mapError: (error) => mapDbError(error, ctx.table),
-                            announce: async (row, _values, posted) => {
+                            announce: async (row, written, posted) => {
                                 told = postingAnswers(posted);
                                 await afterMutation(request, ctx, 'create', recordRef(ctx, Object.fromEntries(ctx.table.primaryKey.map((c) => [c, row[c]]))), null, row);
                                 await tellPostings(app, { connectionId: ctx.connectionId, view: ctx.view, postings: posted, origin: 'dashboard', request });
+                                // The parent a new row moved (`moveOnCreate`).
+                                await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: effectsOf(written), origin: 'bulk', request });
                             },
                         });
                         const key = ctx.table.primaryKey.length === 1 ? inserted[ctx.table.primaryKey[0]] : Object.fromEntries(ctx.table.primaryKey.map((c) => [c, inserted[c]]));
@@ -2118,9 +2163,24 @@ export function dataRoutes(deps) {
                 }
             });
             const okCount = results.filter((r) => r.ok).length;
+            /*
+             * Each row's files, as a row's own write moves them: a deleted row's go
+             * to the bin (and come back with its undo), a changed row holds what it
+             * names now and lets go of what it named.
+             */
+            const trashedFileIds = [];
+            if (deps.files !== undefined) {
+                for (const event of events) {
+                    const entity = recordRef(ctx, event.pk);
+                    if (action === 'delete')
+                        trashedFileIds.push(...(await trashRecordFiles(ctx, entity, event.before)));
+                    else
+                        await deps.files.reconcile({ connectionId: ctx.connectionId, table: ctx.table.id, entity, before: event.before, after: event.after, ruled: ruledBlocksOf(ctx.table.columns.values()) });
+                }
+            }
             const undoToken = okCount === 0
                 ? null
-                : await issueUndo(request, ctx, action, beforeImages, afterImages, action === 'update' && values !== null ? changedColumns(values, readied) : [], [], [], [], effected);
+                : await issueUndo(request, ctx, action, beforeImages, afterImages, action === 'update' && values !== null ? changedColumns(values, readied) : [], trashedFileIds, [], [], effected);
             await app.rbac.audit(request, {
                 category: 'data',
                 action: `record.bulk-${action}`,
@@ -2810,13 +2870,17 @@ export function dataRoutes(deps) {
                     }
                     return written;
                 });
+                // The parents the new rows moved (`moveOnCreate`): such a save offers no Undo.
+                const moved = prepared.flatMap((row) => effectsOf(row.values));
                 // One token over every row: the create-undo path already deletes
                 // each `after` it holds, in order.
-                undoToken = await issueUndo(request, ctx, 'create', [], rows);
+                if (moved.length === 0)
+                    undoToken = await issueUndo(request, ctx, 'create', [], rows);
                 for (const row of rows) {
                     const pk = Object.fromEntries(ctx.table.primaryKey.map((c) => [c, row[c]]));
                     await afterMutation(request, ctx, 'create', recordRef(ctx, pk), null, row);
                 }
+                await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: moved, origin: 'dashboard', request });
                 await writes.afterEach('create', ctx.target, context, rows.map((record) => ({ record, before: null })));
                 // The reply is the row as stored, its own totals settled after the commit.
                 const [first] = (await writes.stored(ctx.target, rows.slice(0, 1)));
@@ -2838,10 +2902,12 @@ export function dataRoutes(deps) {
                 if (tree.outcome.replayed)
                     return reply.status(200).send({ data: staffRow(ctx.dialect, created, ctx.readTable, ctx.unmasked), undoToken: null, replayed: true });
                 const told = postingAnswers(tree.outcome.postings);
-                // A save that posted is not undone by a token: the rule's own way back is.
-                if (told === undefined && !pricedBy(tree.outcome.adjusted))
+                // A save that posted is not undone by a token: the rule's own way back is. Nor one that moved its parent.
+                if (told === undefined && !pricedBy(tree.outcome.adjusted) && tree.outcome.effects === undefined)
                     undoToken = await issueUndo(request, ctx, 'create', [], [created], [], [], [], []);
                 await tellPostings(app, { connectionId: ctx.connectionId, view: ctx.view, postings: tree.outcome.postings, origin: 'dashboard', request });
+                // The parent the new row moved (`moveOnCreate`): announced as a change of its own, after the row's.
+                await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: tree.outcome.effects, origin: 'dashboard', request });
                 const once = onceFor(ctx.connectionId, request.user?.id ?? null, tree.outcome.rows.map((made) => ({ table: made.node.target.table, row: made.record })));
                 return reply.status(201).send({ data: staffRow(ctx.dialect, created, ctx.readTable, ctx.unmasked), undoToken, ...(told === undefined ? {} : { postings: told }), ...(once === undefined ? {} : { once }), ...(await pricedAs(request, ctx, tree.outcome.adjusted, tree.outcome.rows)), ...(await paidAs(request, ctx, treeRows(tree.outcome), tree.outcome.postings)) });
             }
@@ -2855,16 +2921,19 @@ export function dataRoutes(deps) {
                     context,
                     recheck: (final) => assertFileColumns(ctx, final),
                     mapError: (error) => mapDbError(error, ctx.table),
-                    announce: async (row, _values, posted, adjusted) => {
+                    announce: async (row, written, posted, adjusted) => {
                         const pk = Object.fromEntries(ctx.table.primaryKey.map((c) => [c, row[c]]));
                         told = postingAnswers(posted);
                         asked = adjusted;
                         outcomes = posted;
-                        // A save that moved an order's price has no Undo: its way back is another save, priced in its turn.
-                        if (told === undefined && !pricedBy(adjusted))
+                        // The parent the new row moved (`moveOnCreate`): announced as a change of its own, after the row's.
+                        const moved = effectsOf(written);
+                        // A save that moved an order's price has no Undo: its way back is another save, priced in its turn. Nor one that moved its parent.
+                        if (told === undefined && !pricedBy(adjusted) && moved.length === 0)
                             undoToken = await issueUndo(request, ctx, 'create', [], [row]);
                         await afterMutation(request, ctx, 'create', recordRef(ctx, pk), null, row);
                         await tellPostings(app, { connectionId: ctx.connectionId, view: ctx.view, postings: posted, origin: 'dashboard', request });
+                        await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: moved, origin: 'dashboard', request });
                     },
                 });
                 const once = onceFor(ctx.connectionId, request.user?.id ?? null, [{ table: ctx.table, row: inserted }]);
@@ -2893,9 +2962,10 @@ export function dataRoutes(deps) {
                         return reply.status(200).send({ data: staffRow(ctx.dialect, created, ctx.readTable, ctx.unmasked), undoToken: null, replayed: true });
                     const pk = Object.fromEntries(ctx.table.primaryKey.map((c) => [c, created[c]]));
                     const told = postingAnswers(tree.outcome.postings);
-                    if (told === undefined && !pricedBy(tree.outcome.adjusted))
+                    if (told === undefined && !pricedBy(tree.outcome.adjusted) && tree.outcome.effects === undefined)
                         undoToken = await issueUndo(request, ctx, 'create', [], [created], [], [], tree.links, tree.children);
                     await tellPostings(app, { connectionId: ctx.connectionId, view: ctx.view, postings: tree.outcome.postings, origin: 'dashboard', request });
+                    await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: tree.outcome.effects, origin: 'dashboard', request });
                     for (const event of tree.events)
                         publishChildWrite(app, { connectionId: ctx.connectionId, ...event });
                     await tellChildMentions(request, ctx, tree.events);
@@ -2957,6 +3027,8 @@ export function dataRoutes(deps) {
             const written = [];
             const childWrites = [];
             const childEvents = [];
+            /** The parents the new rows moved (`moveOnCreate`): the record's own, and its children's. */
+            const childEffects = [];
             const numbered = children.map((requested) => ({ target: childTargetOf(ctx, requested.child, ctx.db), row: {} }));
             const agrees = await recordAgrees(ctx);
             let inserted = await writes.transaction(ctx.target, [prepared.values], async (trx) => {
@@ -2980,6 +3052,7 @@ export function dataRoutes(deps) {
                     childWrites.push(await applyChildren(ctx, tdb, requested, row[requested.child.parentKeyColumn], context, {
                         existing: [],
                         events: childEvents,
+                        effects: childEffects,
                     }));
                 }
                 // The record as its children left it: a total over them has moved,
@@ -2997,8 +3070,12 @@ export function dataRoutes(deps) {
                 return made;
             }, numbered);
             const pk = Object.fromEntries(ctx.table.primaryKey.map((c) => [c, inserted[c]]));
-            undoToken = await issueUndo(request, ctx, 'create', [], [inserted], [], [], written, childWrites);
+            const moved = [...effectsOf(prepared.values), ...childEffects];
+            // A save that moved a parent offers no Undo: taking the row back would leave the parent moved.
+            if (moved.length === 0)
+                undoToken = await issueUndo(request, ctx, 'create', [], [inserted], [], [], written, childWrites);
             await afterMutation(request, ctx, 'create', recordRef(ctx, pk), null, inserted);
+            await announceEffects(app, { connectionId: ctx.connectionId, view: ctx.view, effects: moved, origin: 'dashboard', request });
             for (const event of childEvents)
                 publishChildWrite(app, { connectionId: ctx.connectionId, ...event });
             await tellChildMentions(request, ctx, childEvents);
@@ -3452,6 +3529,8 @@ export function dataRoutes(deps) {
                 context,
                 mapError: (error) => mapDbError(error, ctx.table),
                 ...withinReach(ctx, 'delete'),
+                // A DELETE that matched nothing (somebody else's landed first) announces nothing: no file to the bin, no Undo.
+                skipIfNone: true,
                 announce: async (_count, _before, adjusted) => {
                     asked = adjusted;
                     const entity = recordRef(ctx, pk);