@byline/db-postgres 3.10.1 → 3.11.0

package/dist/modules/audit/audit-queries.d.ts

@@ -24,6 +24,15 @@ export declare class AuditQueries implements IAuditQueries {
         page?: number;
         page_size?: number;
     }): Promise<AuditLogPage>;
+    findAuditLog(params: {
+        actorId?: string;
+        collectionId?: string;
+        action?: string;
+        from?: Date;
+        to?: Date;
+        page?: number;
+        page_size?: number;
+    }): Promise<AuditLogPage>;
 }
 export declare function createAuditQueries(db: DatabaseConnection): AuditQueries;
 export {};

package/dist/modules/audit/audit-queries.js

@@ -6,7 +6,7 @@
  * Copyright (c) Infonomic Company Limited
  */
 import { desc, eq, sql } from 'drizzle-orm';
-import { auditLog } from '../../database/schema/index.js';
+import { auditLog, documentVersions } from '../../database/schema/index.js';
 function toEntry(row) {
     return {
         id: row.id,
@@ -49,6 +49,78 @@ export class AuditQueries {
             meta: { total, page, pageSize, totalPages },
         };
     }
+    async findAuditLog(params) {
+        const page = params.page ?? 1;
+        const pageSize = params.page_size ?? 20;
+        const offset = (page - 1) * pageSize;
+        // The activity feed is the UNION of two disjoint event sources, normalised
+        // onto the audit-log column shape (see IAuditQueries.findAuditLog):
+        //
+        //   1. byline_document_versions — content saves. event_type maps to a
+        //      `document.created` / `document.updated` action; created_by/created_at
+        //      become actor_id/occurred_at; field/before/after are null. Restricted
+        //      to create+update so any legacy 'delete' version rows can't surface
+        //      (deletions live only in the audit log — the union double-counts
+        //      nothing).
+        //   2. byline_audit_log — path/locale/status changes, deletions, and
+        //      future admin-realm events, used as-is.
+        //
+        // Filters and ordering apply to the unioned result; occurred_at is the only
+        // cross-source sort key (the per-source UUIDv7 ids are separate sequences).
+        const union = sql `
+      SELECT id, document_id, collection_id, actor_id, actor_realm, action, field, before, after, occurred_at FROM (
+        SELECT
+          ${documentVersions.id} AS id,
+          ${documentVersions.document_id} AS document_id,
+          ${documentVersions.collection_id} AS collection_id,
+          ${documentVersions.created_by} AS actor_id,
+          CASE WHEN ${documentVersions.created_by} IS NULL THEN 'system' ELSE 'admin' END AS actor_realm,
+          CASE ${documentVersions.event_type}
+            WHEN 'create' THEN 'document.created'
+            WHEN 'update' THEN 'document.updated'
+            ELSE 'document.' || ${documentVersions.event_type}
+          END AS action,
+          NULL::varchar AS field,
+          NULL::jsonb AS before,
+          NULL::jsonb AS after,
+          ${documentVersions.created_at} AS occurred_at
+        FROM ${documentVersions}
+        WHERE ${documentVersions.event_type} IN ('create', 'update')
+        UNION ALL
+        SELECT
+          ${auditLog.id} AS id,
+          ${auditLog.document_id} AS document_id,
+          ${auditLog.collection_id} AS collection_id,
+          ${auditLog.actor_id} AS actor_id,
+          ${auditLog.actor_realm} AS actor_realm,
+          ${auditLog.action} AS action,
+          ${auditLog.field} AS field,
+          ${auditLog.before} AS before,
+          ${auditLog.after} AS after,
+          ${auditLog.occurred_at} AS occurred_at
+        FROM ${auditLog}
+      ) AS activity`;
+        const filters = [];
+        if (params.actorId)
+            filters.push(sql `actor_id = ${params.actorId}`);
+        if (params.collectionId)
+            filters.push(sql `collection_id = ${params.collectionId}`);
+        if (params.action)
+            filters.push(sql `action = ${params.action}`);
+        if (params.from)
+            filters.push(sql `occurred_at >= ${params.from}`);
+        if (params.to)
+            filters.push(sql `occurred_at <= ${params.to}`);
+        const whereClause = filters.length > 0 ? sql ` WHERE ${sql.join(filters, sql ` AND `)}` : sql ``;
+        const totalResult = await this.db.execute(sql `SELECT count(*) AS count FROM (${union}${whereClause}) AS filtered`);
+        const total = Number(totalResult.rows[0]?.count) || 0;
+        const totalPages = Math.ceil(total / pageSize);
+        const result = await this.db.execute(sql `${union}${whereClause} ORDER BY occurred_at DESC, id DESC LIMIT ${pageSize} OFFSET ${offset}`);
+        return {
+            entries: result.rows.map((row) => toEntry(row)),
+            meta: { total, page, pageSize, totalPages },
+        };
+    }
 }
 export function createAuditQueries(db) {
     return new AuditQueries(db);

package/dist/modules/audit/tests/activity-feed.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/modules/audit/tests/activity-feed.test.js

@@ -0,0 +1,175 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+/**
+ * Integration tests for the system-wide activity feed (docs/AUDIT.md — W4):
+ * `audit.findAuditLog`, the read-time UNION of the version stream (content
+ * saves → `document.created` / `document.updated`) and the audit log
+ * (everything else). Exercises both sources, the cross-source `occurred_at`
+ * ordering, every filter (actor / collection / action / date range), and
+ * pagination.
+ *
+ * The version-stream side requires real `collections` + `documents` FK rows,
+ * so the fixture seeds two collections and one document each before inserting
+ * version rows with controlled `created_at` timestamps.
+ */
+import { v7 as uuidv7 } from 'uuid';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { collections, documents, documentVersions } from '../../../database/schema/index.js';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+import { createAuditCommands } from '../audit-commands.js';
+import { createAuditQueries } from '../audit-queries.js';
+let auditCommands;
+let auditQueries;
+let db;
+const colA = uuidv7();
+const colB = uuidv7();
+const docA = uuidv7();
+const docB = uuidv7();
+const actor1 = uuidv7();
+const actor2 = uuidv7();
+// Fixed version-save timestamps in the past, so the (now()-stamped) audit rows
+// always sort ahead of them and the version rows have a deterministic order.
+const t1 = new Date('2026-01-01T10:00:00.000Z'); // docA create
+const t2 = new Date('2026-01-02T10:00:00.000Z'); // docB create
+const t3 = new Date('2026-01-03T10:00:00.000Z'); // docA update
+describe('audit findAuditLog (system activity union)', () => {
+    beforeAll(async () => {
+        const testDB = setupTestDB([]);
+        db = testDB.db;
+        auditCommands = createAuditCommands(testDB.dbManager);
+        auditQueries = createAuditQueries(testDB.db);
+        // Collection + document FK fixtures for the version-stream side.
+        await db.insert(collections).values([
+            {
+                id: colA,
+                path: 'articles',
+                singular: 'Article',
+                plural: 'Articles',
+                config: {},
+                version: 1,
+            },
+            { id: colB, path: 'pages', singular: 'Page', plural: 'Pages', config: {}, version: 1 },
+        ]);
+        await db.insert(documents).values([
+            { id: docA, collection_id: colA, source_locale: 'en' },
+            { id: docB, collection_id: colB, source_locale: 'en' },
+        ]);
+        // Version stream: two creates and one update. event_type drives the
+        // synthesised action; created_by/created_at become actor/occurred_at.
+        await db.insert(documentVersions).values([
+            {
+                id: uuidv7(),
+                document_id: docA,
+                collection_id: colA,
+                collection_version: 1,
+                event_type: 'create',
+                status: 'draft',
+                created_by: actor1,
+                created_at: t1,
+            },
+            {
+                id: uuidv7(),
+                document_id: docB,
+                collection_id: colB,
+                collection_version: 1,
+                event_type: 'create',
+                status: 'draft',
+                created_by: actor2,
+                created_at: t2,
+            },
+            {
+                id: uuidv7(),
+                document_id: docA,
+                collection_id: colA,
+                collection_version: 1,
+                event_type: 'update',
+                status: 'draft',
+                created_by: actor1,
+                created_at: t3,
+            },
+        ]);
+        // Audit log: a status change on docA (actor1) and a system deletion of docB.
+        await auditCommands.append({
+            documentId: docA,
+            collectionId: colA,
+            actorId: actor1,
+            actorRealm: 'admin',
+            action: 'document.status.changed',
+            field: 'status',
+            before: 'draft',
+            after: 'published',
+        });
+        await auditCommands.append({
+            documentId: docB,
+            collectionId: colB,
+            actorId: null,
+            actorRealm: 'system',
+            action: 'document.deleted',
+        });
+    });
+    afterAll(async () => {
+        await teardownTestDB();
+    });
+    it('unions version-stream + audit-log rows, newest first', async () => {
+        const page = await auditQueries.findAuditLog({});
+        expect(page.meta.total).toBe(5); // 3 version rows + 2 audit rows
+        // Audit rows are now()-stamped, so they lead; version rows follow by
+        // created_at DESC (t3 update, t2 docB create, t1 docA create).
+        const actions = page.entries.map((e) => e.action);
+        expect(actions.slice(-3)).toEqual([
+            'document.updated', // t3
+            'document.created', // t2 (docB)
+            'document.created', // t1 (docA)
+        ]);
+        // A content-save row surfaces with the synthesised action, its actor, and
+        // no field/before/after diff.
+        const created = page.entries.find((e) => e.action === 'document.created' && e.documentId === docA);
+        expect(created?.actorId).toBe(actor1);
+        expect(created?.actorRealm).toBe('admin');
+        expect(created?.field).toBeNull();
+        expect(created?.before).toBeNull();
+        expect(created?.after).toBeNull();
+    });
+    it('filters by action', async () => {
+        const created = await auditQueries.findAuditLog({ action: 'document.created' });
+        expect(created.meta.total).toBe(2);
+        expect(created.entries.every((e) => e.action === 'document.created')).toBe(true);
+        const updated = await auditQueries.findAuditLog({ action: 'document.updated' });
+        expect(updated.meta.total).toBe(1);
+    });
+    it('filters by collection across both sources', async () => {
+        // colA: docA create + docA update (versions) + status change (audit) = 3.
+        const page = await auditQueries.findAuditLog({ collectionId: colA });
+        expect(page.meta.total).toBe(3);
+        expect(page.entries.every((e) => e.collectionId === colA)).toBe(true);
+    });
+    it('filters by actor across both sources', async () => {
+        // actor1: docA create + docA update (versions) + status change (audit) = 3.
+        const page = await auditQueries.findAuditLog({ actorId: actor1 });
+        expect(page.meta.total).toBe(3);
+        expect(page.entries.every((e) => e.actorId === actor1)).toBe(true);
+    });
+    it('filters by date range on occurred_at', async () => {
+        // Only the version rows fall in the fixed January window; the audit rows
+        // are now()-stamped and excluded.
+        const page = await auditQueries.findAuditLog({
+            from: new Date('2026-01-01T00:00:00.000Z'),
+            to: new Date('2026-01-31T23:59:59.000Z'),
+        });
+        expect(page.meta.total).toBe(3);
+        expect(page.entries.every((e) => e.action.startsWith('document.created') || e.action === 'document.updated')).toBe(true);
+    });
+    it('paginates', async () => {
+        const page1 = await auditQueries.findAuditLog({ page: 1, page_size: 2 });
+        expect(page1.entries).toHaveLength(2);
+        expect(page1.meta.total).toBe(5);
+        expect(page1.meta.totalPages).toBe(3);
+        const page3 = await auditQueries.findAuditLog({ page: 3, page_size: 2 });
+        expect(page3.entries).toHaveLength(1);
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/db-postgres",
   "private": false,
   "license": "MPL-2.0",
-  "version": "3.10.1",
+  "version": "3.11.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -57,9 +57,9 @@
     "pg": "^8.21.0",
     "uuid": "^14.0.0",
     "zod": "^4.4.3",
-    "@byline/admin": "3.10.1",
-    "@byline/auth": "3.10.1",
-    "@byline/core": "3.10.1"
+    "@byline/admin": "3.11.0",
+    "@byline/auth": "3.11.0",
+    "@byline/core": "3.11.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.15",