nucleus-core-ts 0.9.813 → 0.9.815

package/dist/fe/components/IntegrationsPage/components/EndpointForm.js

@@ -5,6 +5,7 @@ import { useIntegrationsStore } from '../store';
 import { useLabels } from '../text/context';
 import { integrationsPageTheme } from '../theme';
 import { EndpointFormFields } from './EndpointFormFields';
+import { asArray } from './jsonArray';
 import { formatJsonObject, parseJsonObject } from './jsonObjectField';
 import { PaginationFields } from './PaginationFields';
 import { ParamBindingRows } from './ParamBindingRows';
@@ -33,7 +34,7 @@ export function EndpointForm({ sourceId, endpoint, actions, onSaved, onDeleted,
         pagination: endpoint?.pagination ?? {
             kind: 'none'
         },
-        paramBindings: endpoint?.paramBindings ?? [],
+        paramBindings: asArray(endpoint?.paramBindings),
         queryParams: formatJsonObject(endpoint?.queryParams),
         requestBody: formatJsonObject(endpoint?.requestBody)
     });

package/dist/fe/components/IntegrationsPage/components/jsonArray.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reading a jsonb column that is supposed to hold a list.
+ *
+ * It is not always a list. The schema generator wrote every object-shaped
+ * default — including `[]` — into Postgres as `'{}'`, which is an empty OBJECT.
+ * So every row that never had a value reads back as `{}`, and the first
+ * `for…of` over it throws "object is not iterable". That is every existing row
+ * the moment a new column is added to a table already in use, which is exactly
+ * when nobody is looking: the column is new, nothing has filled it in, and the
+ * screen that reads it dies on the next click.
+ *
+ * The generator is fixed. This exists because the rows it already wrote are
+ * still there, and because a value crossing the wire from a database is not
+ * something a component should have to trust.
+ */
+export declare function asArray<T>(value: unknown): T[];

package/dist/fe/components/IntegrationsPage/components/jsonArray.js

@@ -0,0 +1,17 @@
+/**
+ * Reading a jsonb column that is supposed to hold a list.
+ *
+ * It is not always a list. The schema generator wrote every object-shaped
+ * default — including `[]` — into Postgres as `'{}'`, which is an empty OBJECT.
+ * So every row that never had a value reads back as `{}`, and the first
+ * `for…of` over it throws "object is not iterable". That is every existing row
+ * the moment a new column is added to a table already in use, which is exactly
+ * when nobody is looking: the column is new, nothing has filled it in, and the
+ * screen that reads it dies on the next click.
+ *
+ * The generator is fixed. This exists because the rows it already wrote are
+ * still there, and because a value crossing the wire from a database is not
+ * something a component should have to trust.
+ */ export function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}

package/dist/fe/components/IntegrationsPage/components/mappingDraft.js

@@ -1,3 +1,4 @@
+import { asArray } from './jsonArray';
 import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
 /** Upsert and ignore: the two choices that cannot lose a row by themselves. */ export function blankMappingDraft(endpointId) {
     return {
@@ -16,14 +17,14 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
         endpointId: mapping.endpointId,
         name: mapping.name,
         targetEntity: mapping.targetEntity,
-        fieldMappings: mapping.fieldMappings,
+        fieldMappings: asArray(mapping.fieldMappings),
         dedupSourceField: mapping.dedupSourceField,
         dedupTargetField: mapping.dedupTargetField,
         writeMode: mapping.writeMode,
         missingRecordPolicy: mapping.missingRecordPolicy,
         missingRecordColumn: mapping.missingRecordColumn,
         missingRecordValue: mapping.missingRecordValue,
-        referenceChecks: mapping.referenceChecks ?? [],
+        referenceChecks: asArray(mapping.referenceChecks),
         passwordTargetColumn: mapping.passwordTargetColumn ?? null,
         enabled: mapping.enabled
     };
@@ -38,9 +39,9 @@ import { missingRecordFieldsIncomplete } from './MappingWriteModeFields';
     if (draft.name.trim() === '') issues.push('Give the mapping a name.');
     if (draft.targetEntity.trim() === '') issues.push('Choose a target entity.');
     if (draft.endpointId.trim() === '') issues.push('Select the endpoint this mapping reads from.');
-    const usable = draft.fieldMappings.some((row)=>row.target.trim() !== '' && (row.source.trim() !== '' || (row.constant ?? '').trim() !== ''));
+    const usable = asArray(draft.fieldMappings).some((row)=>row.target.trim() !== '' && (row.source.trim() !== '' || (row.constant ?? '').trim() !== ''));
     if (!usable) issues.push('Map at least one field to a target column.');
-    for (const check of draft.referenceChecks){
+    for (const check of asArray(draft.referenceChecks)){
         if (check.column.trim() === '' || check.entity.trim() === '' || check.entityColumn.trim() === '') issues.push('Every reference needs a column, an entity and the column to match against.');
     }
     if (missingRecordFieldsIncomplete(draft.missingRecordPolicy, draft.missingRecordColumn ?? '', draft.missingRecordValue ?? '')) {

package/dist/fe/components/IntegrationsPage/components/mappingDraft.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fe/components/IntegrationsPage/components/mappingDraft.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'bun:test';
+import { mappingDraftIssues, toMappingDraft } from './mappingDraft';
+/**
+ * A jsonb column that is supposed to hold a list, and does not.
+ *
+ * The schema generator wrote every object-shaped default — `[]` included — into
+ * Postgres as `'{}'`, an empty OBJECT. So every row that never had a value reads
+ * back as `{}`. `for…of` over that throws "object is not iterable", which took
+ * the whole admin panel down to a blank error page the first time a mapping was
+ * opened after the column was added. The generator is fixed; these rows are
+ * still in the database.
+ */ describe('a list column that came back as an object', ()=>{
+    const mapping = (over)=>({
+            id: 'm1',
+            endpointId: 'e1',
+            name: 'Çalışanlar',
+            targetEntity: 'employees',
+            fieldMappings: [],
+            writeMode: 'upsert',
+            missingRecordPolicy: 'ignore',
+            ...over
+        });
+    it('reads an empty object as an empty list', ()=>{
+        const draft = toMappingDraft(mapping({
+            referenceChecks: {},
+            fieldMappings: {}
+        }));
+        expect(draft.referenceChecks).toEqual([]);
+        expect(draft.fieldMappings).toEqual([]);
+    });
+    it('keeps a real list', ()=>{
+        const checks = [
+            {
+                column: 'department',
+                entity: 'departments',
+                entityColumn: 'name',
+                onMissing: 'create'
+            }
+        ];
+        const draft = toMappingDraft(mapping({
+            referenceChecks: checks
+        }));
+        expect(draft.referenceChecks).toEqual(checks);
+    });
+    it('validates a draft whose lists arrived as objects instead of throwing', ()=>{
+        // This is the call that ran during render, so what it threw was not an error
+        // message on the screen — it was the screen.
+        const issues = mappingDraftIssues({
+            endpointId: 'e1',
+            name: 'Çalışanlar',
+            targetEntity: 'employees',
+            fieldMappings: {},
+            referenceChecks: {},
+            writeMode: 'upsert',
+            missingRecordPolicy: 'ignore'
+        });
+        expect(issues).toContain('Map at least one field to a target column.');
+    });
+});