@byline/db-postgres 3.13.2 → 3.14.0

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

@@ -109,6 +109,22 @@ function* flattenFieldDataGen(field, data, locale, field_path) {
             yield* flattenFieldSetDataGen(block.fields, item_data, locale, item_path);
         }
     }
+    // Ordered multi-target relation: emit one relation row per item at an
+    // indexed path (`<field>.0`, `<field>.1`, …), mirroring the array path
+    // convention. `restoreFieldSetData` reassembles the ordered array.
+    // Relations are non-localized, so every row carries locale 'all'. Identity
+    // is the `targetDocumentId` (the widget dedups), so no `store_meta` rows are
+    // needed. Must intercept before the generic value branch, which would
+    // otherwise read the whole array as a single relation value.
+    else if (field.type === 'relation' && field.hasMany) {
+        const items = data;
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            if (item == null)
+                continue;
+            yield flattenValueFieldData(field, [...field_path, `${i}`], item, 'all');
+        }
+    }
     // Handle localized fields separately.
     else if (field.localized) {
         // If locale is 'all', data is expected to be an object that maps locales to

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

@@ -39,9 +39,13 @@ export const restoreFieldSetData = (fields, flattenedData, resolveLocale) => {
             result[fieldName] = restoreFieldData(field, result[fieldName], item, 1, warnings, resolveLocale);
         }
     }
-    // Array/blocks/group fixup.
+    // Array/blocks/group/hasMany-relation fixup — a required list-shaped field
+    // with no stored rows reconstructs as an empty array rather than absent.
     for (const field of fields) {
-        if ((field.type === 'array' || field.type === 'blocks') && !field.optional) {
+        if ((field.type === 'array' ||
+            field.type === 'blocks' ||
+            (field.type === 'relation' && field.hasMany)) &&
+            !field.optional) {
             result[field.name] = result[field.name] || [];
         }
         else if (field.type === 'group' && !field.optional) {
@@ -60,6 +64,9 @@ const restoreFieldData = (field, target, data, pathIndex, warnings, resolveLocal
     else if (field.type === 'blocks') {
         return restoreBlocksFieldData(field, target, data, pathIndex, warnings, resolveLocale);
     }
+    else if (field.type === 'relation' && field.hasMany) {
+        return restoreMultiRelationFieldData(target, data, pathIndex, warnings);
+    }
     if (field.localized) {
         if (data.locale === 'all') {
             warnings.push(`Received non-localized data for localized field at path ${data.field_path.join('.')}`);
@@ -172,6 +179,22 @@ const restoreBlocksFieldData = (field, target, data, pathIndex, warnings, resolv
     target[arrayIndex][fieldName] = restoreFieldData(subField, target[arrayIndex][fieldName], data, pathIndex + 3, warnings, resolveLocale);
     return target;
 };
+const restoreMultiRelationFieldData = (target, data, pathIndex, warnings) => {
+    // Path shape: `[...prefix, <field>, <index>]`. At `pathIndex` we have the
+    // ordered position; the row itself is a single relation value.
+    const arrayIndex = Number.parseInt(data.field_path[pathIndex] ?? '', 10);
+    if (Number.isNaN(arrayIndex) || arrayIndex < 0) {
+        warnings.push(`Invalid relation index '${data.field_path[pathIndex]}' in path ${data.field_path.join('.')}`);
+        return target;
+    }
+    if (data.field_type !== 'relation') {
+        warnings.push(`Expected relation row for hasMany relation but got ${data.field_type} at path ${data.field_path.join('.')}`);
+        return target;
+    }
+    target = target || [];
+    target[arrayIndex] = extractValueFieldData(data);
+    return target;
+};
 const extractValueFieldData = (data) => {
     switch (data.field_type) {
         case 'text':

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

@@ -0,0 +1,92 @@
+/**
+ * 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
+ */
+/**
+ * Storage round-trip for `hasMany` relations — an ordered list of relation
+ * values flattens to indexed `store_relation` rows (`<field>.0`, `<field>.1`,
+ * …) and reconstructs back into the same ordered array. Pure functions; no
+ * Postgres needed.
+ */
+import { defineCollection } from '@byline/core';
+import { describe, expect, it } from 'vitest';
+import { flattenFieldSetData } from '../storage-flatten.js';
+import { restoreFieldSetData } from '../storage-restore.js';
+const Articles = defineCollection({
+    path: 'articles',
+    labels: { singular: 'Article', plural: 'Articles' },
+    fields: [
+        { name: 'title', type: 'text' },
+        {
+            name: 'authors',
+            type: 'relation',
+            targetCollection: 'people',
+            hasMany: true,
+            optional: true,
+        },
+        // A required hasMany to exercise the empty-list fixup.
+        {
+            name: 'tags',
+            type: 'relation',
+            targetCollection: 'tags',
+            hasMany: true,
+        },
+    ],
+});
+const Single = defineCollection({
+    path: 'single',
+    labels: { singular: 'Single', plural: 'Singles' },
+    fields: [{ name: 'lead', type: 'relation', targetCollection: 'people', optional: true }],
+});
+describe('hasMany relation storage round-trip', () => {
+    it('flattens an ordered list to indexed relation rows', () => {
+        const flat = flattenFieldSetData(Articles.fields, {
+            title: 'Hello',
+            authors: [
+                { targetDocumentId: 'a1', targetCollectionId: 'people' },
+                { targetDocumentId: 'a2', targetCollectionId: 'people' },
+                { targetDocumentId: 'a3', targetCollectionId: 'people' },
+            ],
+            tags: [],
+        }, 'all');
+        const relRows = flat.filter((r) => r.field_type === 'relation');
+        expect(relRows.map((r) => r.field_path.join('.'))).toEqual([
+            'authors.0',
+            'authors.1',
+            'authors.2',
+        ]);
+        // Relations are non-localized — every row carries locale 'all'.
+        expect(relRows.every((r) => r.locale === 'all')).toBe(true);
+    });
+    it('reconstructs the ordered array (and preserves order)', () => {
+        const data = {
+            title: 'Hello',
+            authors: [
+                { targetDocumentId: 'a3', targetCollectionId: 'people' },
+                { targetDocumentId: 'a1', targetCollectionId: 'people' },
+                { targetDocumentId: 'a2', targetCollectionId: 'people' },
+            ],
+            tags: [{ targetDocumentId: 't1', targetCollectionId: 'tags' }],
+        };
+        const { data: restored, warnings } = restoreFieldSetData(Articles.fields, flattenFieldSetData(Articles.fields, data, 'all'));
+        expect(warnings).toEqual([]);
+        expect(restored.authors.map((a) => a.targetDocumentId)).toEqual(['a3', 'a1', 'a2']);
+        expect(restored.authors[0]).toMatchObject({
+            targetDocumentId: 'a3',
+            targetCollectionId: 'people',
+        });
+        expect(restored.tags.map((t) => t.targetDocumentId)).toEqual(['t1']);
+    });
+    it('reconstructs a required empty hasMany as []', () => {
+        const { data: restored } = restoreFieldSetData(Articles.fields, flattenFieldSetData(Articles.fields, { title: 'x', authors: [], tags: [] }, 'all'));
+        expect(restored.tags).toEqual([]);
+    });
+    it('leaves single (non-hasMany) relations as scalar values', () => {
+        const { data: restored } = restoreFieldSetData(Single.fields, flattenFieldSetData(Single.fields, { lead: { targetDocumentId: 'p1', targetCollectionId: 'people' } }, 'all'));
+        expect(Array.isArray(restored.lead)).toBe(false);
+        expect(restored.lead).toMatchObject({ targetDocumentId: 'p1', targetCollectionId: 'people' });
+    });
+});

package/package.json

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