@byline/db-postgres 1.1.0 → 1.2.1

package/dist/modules/storage/@types.d.ts

@@ -29,8 +29,8 @@ interface FlattenedDateTimeFieldValue extends BaseFlattenedFieldData {
     field_type: 'datetime';
     date_type: 'datetime' | 'date' | 'time';
     value_time?: string;
-    value_date?: Date;
-    value_timestamp_tz?: Date;
+    value_date?: Date | string;
+    value_timestamp_tz?: Date | string;
 }
 interface FlattenedFileFieldValue extends BaseFlattenedFieldData {
     field_type: 'file';

package/dist/modules/storage/storage-insert.js

@@ -63,9 +63,20 @@ export const prepareFieldInsertBuckets = (flattenedFields, document_version_id,
                 buckets.datetime.push({
                     ...base,
                     date_type: field.date_type,
-                    value_date: field.value_date?.toISOString(), // TODO: Is this the appropriate conversion?
+                    // The Postgres `date` column (drizzle default mode) round-trips as
+                    // a 'YYYY-MM-DD' string, while admin form widgets produce `Date`
+                    // objects. Both shapes need to flatten cleanly because restore
+                    // (and any other path that re-feeds previously-read content)
+                    // hands us the string form.
+                    value_date: toDateOnlyString(field.value_date),
                     value_time: field.value_time,
-                    value_timestamp_tz: field.value_timestamp_tz,
+                    // `value_timestamp_tz` arrives as a `Date` from form widgets but
+                    // as a string from `getAllFieldValues` — the UNION ALL declares
+                    // the column as `timestamp` (no TZ) via `storage-store-manifest`,
+                    // and node-postgres maps non-TZ timestamps to strings. Drizzle's
+                    // own `mapToDriverValue` calls `.toISOString()` unguarded on
+                    // insert, so we coerce here.
+                    value_timestamp_tz: toDate(field.value_timestamp_tz),
                 });
                 continue;
             case 'file':
@@ -112,3 +123,34 @@ export const prepareFieldInsertBuckets = (flattenedFields, document_version_id,
     }
     return buckets;
 };
+/**
+ * Coerce a date-only field value to the 'YYYY-MM-DD' string shape the
+ * Postgres `date` column uses on read. Accepts:
+ *   - `Date`  → ISO date prefix
+ *   - string  → passed through (already in storage shape)
+ *   - null / undefined → undefined (no insert)
+ */
+function toDateOnlyString(value) {
+    if (value == null)
+        return undefined;
+    if (value instanceof Date)
+        return value.toISOString().slice(0, 10);
+    return value;
+}
+/**
+ * Coerce a timestamp-with-tz field value to a `Date` instance. Accepts:
+ *   - `Date`   → passed through
+ *   - string   → parsed via `new Date(...)` (ISO or PG `timestamp` shape)
+ *   - null / undefined → undefined (no insert)
+ *
+ * Drizzle's `mapToDriverValue` for `timestamp({ withTimezone: true })` calls
+ * `.toISOString()` on the supplied value with no guard, so callers must
+ * present a `Date`.
+ */
+function toDate(value) {
+    if (value == null)
+        return undefined;
+    if (value instanceof Date)
+        return value;
+    return new Date(value);
+}

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

@@ -0,0 +1,159 @@
+/**
+ * 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 test for the "make current" / restore-version flow.
+ *
+ * Validates that the Postgres locale='all' round-trip
+ * (`getDocumentByVersion` → `createDocumentVersion`) preserves multi-locale
+ * content and stable block `_id`s — the core invariant
+ * `restoreDocumentVersion` in @byline/core depends on. Pure storage-layer:
+ * the lifecycle wrapper, auth, and hooks are covered by unit tests in
+ * `packages/core/src/services/document-lifecycle.test.node.ts`.
+ */
+import assert from 'node:assert';
+import { after, before, describe, it } from 'node:test';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+let commandBuilders;
+let queryBuilders;
+const timestamp = Date.now();
+const RestoreCollectionConfig = {
+    path: `restore-${timestamp}`,
+    labels: { singular: 'Restorable', plural: 'Restorables' },
+    fields: [
+        { name: 'sku', type: 'text' },
+        { name: 'title', type: 'text', localized: true },
+        {
+            name: 'sections',
+            type: 'array',
+            fields: [
+                {
+                    name: 'sectionItem',
+                    type: 'array',
+                    fields: [
+                        { name: 'heading', type: 'text', localized: true },
+                        { name: 'body', type: 'text', localized: true },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+let testCollection = {};
+describe('Document version restore — storage round-trip', () => {
+    before(async () => {
+        const testDB = setupTestDB([RestoreCollectionConfig]);
+        commandBuilders = testDB.commandBuilders;
+        queryBuilders = testDB.queryBuilders;
+        const result = await commandBuilders.collections.create(RestoreCollectionConfig.path, RestoreCollectionConfig);
+        const collection = result[0];
+        if (collection == null)
+            throw new Error('Failed to create test collection');
+        testCollection = { id: collection.id };
+    });
+    after(async () => {
+        try {
+            await commandBuilders.collections.delete(testCollection.id);
+        }
+        catch (err) {
+            console.error('Failed to cleanup test collection:', err);
+        }
+        await teardownTestDB();
+    });
+    it('round-trips multi-locale fields and preserves block _ids when re-emitted via locale: "all"', async () => {
+        const v1Data = {
+            sku: `RESTORE-${timestamp}`,
+            title: { en: 'V1 EN', fr: 'V1 FR' },
+            sections: [
+                {
+                    sectionItem: [
+                        { heading: { en: 'Intro EN', fr: 'Intro FR' }, body: { en: 'A', fr: 'A-fr' } },
+                        { heading: { en: 'Body EN', fr: 'Body FR' }, body: { en: 'B', fr: 'B-fr' } },
+                    ],
+                },
+            ],
+        };
+        const v1 = await commandBuilders.documents.createDocumentVersion({
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: RestoreCollectionConfig,
+            action: 'create',
+            documentData: v1Data,
+            path: v1Data.sku,
+            locale: 'all',
+            status: 'draft',
+        });
+        const documentId = v1.document.document_id;
+        const v1Id = v1.document.id;
+        // v1 reconstruct — captures the assigned _ids
+        const v1Read = await queryBuilders.documents.getDocumentByVersion({
+            document_version_id: v1Id,
+            locale: 'all',
+        });
+        const v1Sections = v1Read.fields.sections;
+        const v1ItemIds = v1Sections[0].sectionItem.map((item) => item._id);
+        assert.ok(v1ItemIds.every((id) => typeof id === 'string' && id.length > 0), 'v1 items should have stable _ids');
+        // Mutate to v2 (different content)
+        const v2Data = {
+            sku: v1Data.sku,
+            title: { en: 'V2 EN', fr: 'V2 FR' },
+            sections: [
+                {
+                    sectionItem: [
+                        { heading: { en: 'Replaced EN', fr: 'Replaced FR' }, body: { en: 'X', fr: 'X-fr' } },
+                    ],
+                },
+            ],
+        };
+        await commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: RestoreCollectionConfig,
+            action: 'update',
+            documentData: v2Data,
+            path: v1Data.sku,
+            locale: 'all',
+            status: 'draft',
+        });
+        // Restore: read v1 with locale='all' and re-emit verbatim with locale='all'.
+        // This is what `restoreDocumentVersion` in @byline/core does.
+        const sourceFields = v1Read.fields;
+        const v3 = await commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: RestoreCollectionConfig,
+            action: 'restore',
+            documentData: sourceFields,
+            path: v1Data.sku,
+            locale: 'all',
+            status: 'draft',
+        });
+        assert.strictEqual(v3.document.event_type, 'restore', 'event_type should be persisted as "restore"');
+        // Reconstruct v3. Multi-locale fields, block _ids, and per-item content
+        // should match v1 — not v2.
+        const v3Read = await queryBuilders.documents.getDocumentByVersion({
+            document_version_id: v3.document.id,
+            locale: 'all',
+        });
+        const v3Fields = v3Read.fields;
+        assert.deepStrictEqual(v3Fields.title, v1Data.title, 'restored title should match v1 across all locales');
+        const v3Sections = v3Fields.sections;
+        const v3ItemIds = v3Sections[0].sectionItem.map((item) => item._id);
+        assert.deepStrictEqual(v3ItemIds, v1ItemIds, 'restored block items should keep the v1 _ids verbatim (identity preserved across restore)');
+        assert.strictEqual(v3Sections[0].sectionItem.length, 2, "restored version should have v1's two items, not v2's single item");
+        assert.deepStrictEqual(v3Sections[0].sectionItem[0].heading, {
+            en: 'Intro EN',
+            fr: 'Intro FR',
+        });
+        assert.deepStrictEqual(v3Sections[0].sectionItem[1].heading, {
+            en: 'Body EN',
+            fr: 'Body FR',
+        });
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/db-postgres",
   "private": false,
   "license": "MPL-2.0",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -52,9 +52,9 @@
     "pg": "^8.20.0",
     "uuid": "^14.0.0",
     "zod": "^4.4.2",
-    "@byline/core": "1.1.0",
-    "@byline/auth": "1.1.0",
-    "@byline/admin": "1.1.0"
+    "@byline/core": "1.2.1",
+    "@byline/auth": "1.2.1",
+    "@byline/admin": "1.2.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.14",