@byline/db-postgres 3.17.1 → 3.19.0

package/dist/modules/counters/counters-commands.d.ts

@@ -17,6 +17,7 @@ export declare class CounterCommands implements ICounterCommands {
         sequenceName: string;
     }>;
     nextCounterValue(groupName: string): Promise<number>;
+    nextScopedCounterValue(scopeName: string): Promise<number>;
 }
 export declare function createCounterCommands(db: DatabaseConnection): ICounterCommands;
 export {};

package/dist/modules/counters/counters-commands.js

@@ -90,6 +90,25 @@ export class CounterCommands {
         }
         return typeof row.value === 'number' ? row.value : Number(row.value);
     }
+    async nextScopedCounterValue(scopeName) {
+        if (!scopeName || typeof scopeName !== 'string') {
+            throw new Error(`nextScopedCounterValue: scopeName must be a non-empty string`);
+        }
+        // Fast path: the scope has been used before — its registry row and
+        // sequence already exist, so this is exactly a nextCounterValue call.
+        const rows = await this.db
+            .select({ sequence_name: counterGroups.sequence_name })
+            .from(counterGroups)
+            .where(eq(counterGroups.group_name, scopeName))
+            .limit(1);
+        if (rows.length === 0) {
+            // First allocation for this scope: self-register (idempotent — a
+            // concurrent racer leaves exactly one sequence + registry row, and
+            // both callers draw distinct values from the same sequence).
+            await this.ensureCounterGroup(scopeName);
+        }
+        return this.nextCounterValue(scopeName);
+    }
 }
 export function createCounterCommands(db) {
     return new CounterCommands(db);

package/dist/modules/counters/tests/counters-scoped.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/counters/tests/counters-scoped.test.js

@@ -0,0 +1,100 @@
+/**
+ * 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
+ */
+import { eq, sql } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { counterGroups } from '../../../database/schema/index.js';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+import { createCounterCommands } from '../counters-commands.js';
+// ---------------------------------------------------------------------------
+// Track-and-clean fixtures
+// ---------------------------------------------------------------------------
+//
+// Integration tests share the dev database. Each scope this suite touches
+// creates a registry row + a Postgres sequence; track the scope names and
+// drop both on teardown so repeated runs start from a clean slate (and so
+// monotonicity assertions are not satisfied by a previous run's sequence).
+let db;
+let counters;
+const trackedScopes = new Set();
+async function cleanupScope(scopeName) {
+    const rows = await db
+        .select({ sequence_name: counterGroups.sequence_name })
+        .from(counterGroups)
+        .where(eq(counterGroups.group_name, scopeName))
+        .limit(1);
+    const sequenceName = rows[0]?.sequence_name;
+    await db.delete(counterGroups).where(eq(counterGroups.group_name, scopeName));
+    if (sequenceName) {
+        await db.execute(sql.raw(`DROP SEQUENCE IF EXISTS "${sequenceName}"`));
+    }
+}
+function scope(name) {
+    trackedScopes.add(name);
+    return name;
+}
+beforeAll(async () => {
+    const setup = setupTestDB();
+    db = setup.db;
+    counters = createCounterCommands(db);
+    // Clean any leftovers from a previously aborted run.
+    for (const name of trackedScopes) {
+        await cleanupScope(name);
+    }
+});
+afterAll(async () => {
+    for (const name of trackedScopes) {
+        await cleanupScope(name);
+    }
+    await teardownTestDB();
+});
+describe('nextScopedCounterValue', () => {
+    it('self-registers an unknown scope and allocates from 1', async () => {
+        const scopeName = scope('test:doc-a:files');
+        const first = await counters.nextScopedCounterValue(scopeName);
+        expect(first).toBe(1);
+        // The registry row and its backing sequence now exist.
+        const rows = await db
+            .select({ sequence_name: counterGroups.sequence_name })
+            .from(counterGroups)
+            .where(eq(counterGroups.group_name, scopeName));
+        expect(rows).toHaveLength(1);
+    });
+    it('is monotonic within a scope and never reuses a value', async () => {
+        const scopeName = scope('test:doc-b:files');
+        const a = await counters.nextScopedCounterValue(scopeName);
+        const b = await counters.nextScopedCounterValue(scopeName);
+        const c = await counters.nextScopedCounterValue(scopeName);
+        expect([a, b, c]).toEqual([1, 2, 3]);
+    });
+    it('scopes are independent — one scope does not advance another', async () => {
+        const scopeA = scope('test:doc-c:files');
+        const scopeB = scope('test:doc-d:files');
+        await counters.nextScopedCounterValue(scopeA);
+        await counters.nextScopedCounterValue(scopeA);
+        const bFirst = await counters.nextScopedCounterValue(scopeB);
+        expect(bFirst).toBe(1);
+    });
+    it('interoperates with nextCounterValue once registered (same sequence)', async () => {
+        const scopeName = scope('test:doc-e:files');
+        const viaScoped = await counters.nextScopedCounterValue(scopeName);
+        // After self-registration the static-path allocator sees the group too.
+        const viaStatic = await counters.nextCounterValue(scopeName);
+        expect(viaStatic).toBe(viaScoped + 1);
+    });
+    it('rejects an empty scope name', async () => {
+        await expect(counters.nextScopedCounterValue('')).rejects.toThrow(/scopeName must be a non-empty string/);
+    });
+    it('parallel allocations within one scope yield distinct values', async () => {
+        const scopeName = scope('test:doc-f:files');
+        const values = await Promise.all(Array.from({ length: 8 }, () => counters.nextScopedCounterValue(scopeName)));
+        const unique = new Set(values);
+        expect(unique.size).toBe(8);
+        expect(Math.min(...values)).toBe(1);
+        expect(Math.max(...values)).toBe(8);
+    });
+});

package/dist/modules/storage/storage-commands.d.ts

@@ -47,15 +47,15 @@ export declare class CollectionCommands implements ICollectionCommands {
         version?: number;
         schemaHash?: string;
     }): Promise<{
+        config: unknown;
         created_at: Date;
-        updated_at: Date;
         id: string;
-        config: unknown;
         path: string;
-        singular: string;
         plural: string;
-        version: number;
         schema_hash: string | null;
+        singular: string;
+        updated_at: Date;
+        version: number;
     }[]>;
     update(id: string, patch: {
         config?: CollectionDefinition;
@@ -126,18 +126,18 @@ export declare class DocumentCommands implements IDocumentCommands {
         orderKey?: string;
     }): Promise<{
         document: {
-            created_at: Date;
-            updated_at: Date;
-            id: string;
+            change_summary: string | null;
             collection_id: string;
-            document_id: string;
             collection_version: number;
+            created_at: Date;
+            created_by: string | null;
             doc: unknown;
+            document_id: string;
             event_type: string;
-            status: string | null;
+            id: string;
             is_deleted: boolean | null;
-            created_by: string | null;
-            change_summary: string | null;
+            status: string | null;
+            updated_at: Date;
         };
         fieldCount: number;
     }>;

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

@@ -27,26 +27,26 @@ export declare class CollectionQueries implements ICollectionQueries {
         schema_hash: string | null;
     }[]>;
     getCollectionByPath(path: string): Promise<{
+        config: unknown;
         created_at: Date;
-        updated_at: Date;
         id: string;
-        config: unknown;
         path: string;
-        singular: string;
         plural: string;
-        version: number;
         schema_hash: string | null;
+        singular: string;
+        updated_at: Date;
+        version: number;
     } | undefined>;
     getCollectionById(id: string): Promise<{
+        config: unknown;
         created_at: Date;
-        updated_at: Date;
         id: string;
-        config: unknown;
         path: string;
-        singular: string;
         plural: string;
-        version: number;
         schema_hash: string | null;
+        singular: string;
+        updated_at: Date;
+        version: number;
     } | undefined>;
 }
 /**
@@ -250,7 +250,6 @@ export declare class DocumentQueries implements IDocumentQueries {
         lenient?: boolean;
         onMissingLocale?: MissingLocalePolicy;
     }): Promise<{
-        restoreWarnings?: string[] | undefined;
         document_version_id: string;
         document_id: string;
         path: string;
@@ -264,6 +263,7 @@ export declare class DocumentQueries implements IDocumentQueries {
         availableLocales: string[];
         _availableVersionLocales: string[];
         _localeAgnostic: boolean;
+        restoreWarnings?: string[] | undefined;
     } | {
         document_version_id: string;
         document_id: string;
@@ -299,6 +299,9 @@ export declare class DocumentQueries implements IDocumentQueries {
         _availableVersionLocales: string[];
         _localeAgnostic: boolean;
     } | {
+        availableLocales?: undefined;
+        _availableVersionLocales?: undefined;
+        _localeAgnostic?: undefined;
         document_version_id: string;
         document_id: string;
         path: string;
@@ -309,9 +312,6 @@ export declare class DocumentQueries implements IDocumentQueries {
         updated_at: Date;
         created_by: string | null;
         fields: FlattenedStore[];
-        availableLocales?: undefined;
-        _availableVersionLocales?: undefined;
-        _localeAgnostic?: undefined;
     } | null>;
     /**
      * getDocumentByVersion — fetches a specific version and reconstructs its fields.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/db-postgres",
   "private": false,
   "license": "MPL-2.0",
-  "version": "3.17.1",
+  "version": "3.19.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -54,24 +54,24 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "npm-run-all": "^4.1.5",
-    "pg": "^8.21.0",
-    "uuid": "^14.0.0",
-    "@byline/admin": "3.17.1",
-    "@byline/core": "3.17.1",
-    "@byline/auth": "3.17.1"
+    "pg": "^8.22.0",
+    "uuid": "^14.0.1",
+    "@byline/admin": "3.19.0",
+    "@byline/auth": "3.19.0",
+    "@byline/core": "3.19.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.15",
-    "@types/node": "^25.9.1",
+    "@biomejs/biome": "2.5.2",
+    "@types/node": "^26.1.0",
     "@types/pg": "^8.20.0",
     "chokidar": "^5.0.0",
     "chokidar-cli": "^3.0.0",
     "dotenv": "^17.4.2",
     "drizzle-kit": "^0.31.10",
-    "tsc-alias": "^1.8.17",
-    "tsx": "^4.22.3",
-    "typescript": "6.0.3",
-    "vitest": "^4.1.7"
+    "tsc-alias": "^1.9.0",
+    "tsx": "^4.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "publishConfig": {
     "access": "public",