nucleus-core-ts 0.9.855 → 0.9.856

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

@@ -141,6 +141,34 @@ export function ReferenceCheckRows({ rows, targetFields, sourceFields = [], targ
                                             })
                                         ]
                                     }),
+                                    /*#__PURE__*/ _jsxs("label", {
+                                        className: theme.field.wrapper,
+                                        children: [
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: theme.field.label,
+                                                children: "Write the matched id to"
+                                            }),
+                                            /*#__PURE__*/ _jsxs("select", {
+                                                className: theme.field.input,
+                                                disabled: disabled,
+                                                id: `${uid}-${index}-write-id`,
+                                                onChange: (event)=>patch(index, {
+                                                        writeIdTo: event.target.value || null
+                                                    }),
+                                                value: row.writeIdTo ?? '',
+                                                children: [
+                                                    /*#__PURE__*/ _jsx("option", {
+                                                        value: "",
+                                                        children: "Only check that it exists"
+                                                    }),
+                                                    (targetFields ?? []).map((field)=>/*#__PURE__*/ _jsx("option", {
+                                                            value: field,
+                                                            children: field
+                                                        }, field))
+                                                ]
+                                            })
+                                        ]
+                                    }),
                                     /*#__PURE__*/ _jsxs("label", {
                                         className: theme.field.wrapper,
                                         children: [

package/dist/fe/components/IntegrationsPage/types/records.d.ts

@@ -113,6 +113,15 @@ export type ReferenceCheckValue = {
     /** Column in that entity to match against. */
     entityColumn: string;
     onMissing: 'create' | 'skipRecord' | 'ignore';
+    /**
+     * Column that receives the MATCHED ROW'S ID instead of its value.
+     *
+     * The engine has done this since references learned to resolve, and nothing
+     * in the panel could ask for it — so a product whose link is a uuid got the
+     * text column filled and the uuid column left null, and no screen that joins
+     * on the id found anything.
+     */
+    writeIdTo?: string | null;
     /**
      * Other columns to fill when this run CREATES the missing value.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "nucleus-core-ts",
-	"version": "0.9.855",
+	"version": "0.9.856",
 	"description": "Production-ready, enterprise-grade TypeScript framework for building multi-tenant APIs",
 	"author": "Hidayet Can Özcan <hidayetcan@gmail.com>",
 	"license": "SEE LICENSE IN LICENSE",

package/scripts/generate-schema.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'bun:test'
-import { generateColumnCode, selectEmittedTables } from './generate-schema'
+import { generateColumnCode, generateTableCode, selectEmittedTables } from './generate-schema'
 
 const table = (table_name: string) => ({ table_name })
 
@@ -85,8 +85,7 @@ describe('selectEmittedTables', () => {
  * typecheck did not cover the folder it landed in.
  */
 describe('numeric defaults are quoted', () => {
-  const emit = (col: Record<string, unknown>) =>
-    generateColumnCode(col as never, [], 'widgets')
+  const emit = (col: Record<string, unknown>) => generateColumnCode(col as never, [], 'widgets')
 
   it('quotes a numeric default, because the column reads as a string', () => {
     expect(emit({ name: 'position_x', type: 'numeric', notNull: true, default: 0 })).toContain(
@@ -126,7 +125,9 @@ describe('jsonb defaults keep their own shape', () => {
   it('a REAL array column gets array syntax, not JSON', () => {
     // `[]` is not array syntax; Postgres refuses the statement outright, and it
     // took the other sixty in the same batch with it.
-    expect(emit({ name: 'visible_roles', type: 'text', array: true, default: [] })).toContain("'{}'")
+    expect(emit({ name: 'visible_roles', type: 'text', array: true, default: [] })).toContain(
+      "'{}'"
+    )
   })
 
   it('writes the members of a non-empty array default', () => {
@@ -136,9 +137,7 @@ describe('jsonb defaults keep their own shape', () => {
   })
 
   it('quotes an array member that needs it', () => {
-    expect(emit({ name: 'roles', type: 'text', array: true, default: ['a b'] })).toContain(
-      '"a b"'
-    )
+    expect(emit({ name: 'roles', type: 'text', array: true, default: ['a b'] })).toContain('"a b"')
   })
 
   it('an empty object default stays an object', () => {
@@ -153,3 +152,65 @@ describe('jsonb defaults keep their own shape', () => {
     expect(emit({ name: 'labels', type: 'jsonb', default: ["it's"] })).toContain("''s")
   })
 })
+
+/**
+ * `constraints` has been in the config shape since the beginning and nothing
+ * ever read it. Twelve tables in the shipped configs declare a composite unique
+ * key; none of them existed in any database. That is why a user could hold the
+ * same role twice, a reader could react to one article twice instead of
+ * changing their reaction, and two integration connections could be created
+ * with the identical slug — which was then matched by an import that wrote to
+ * whichever it found first.
+ */
+describe('table-level constraints', () => {
+  const table = {
+    table_name: 'user_roles',
+    add_base_columns: false,
+    columns: [
+      { name: 'user_id', type: 'uuid' },
+      { name: 'role_id', type: 'uuid' },
+    ],
+    constraints: {
+      unique: [{ name: 'unique_user_role', columns: ['user_id', 'role_id'] }],
+    },
+  }
+
+  it('emits a composite unique constraint that was declared', () => {
+    const code = generateTableCode(table as never, [], [])
+    expect(code).toContain("unique('unique_user_role')")
+    expect(code).toContain('t.userId')
+    expect(code).toContain('t.roleId')
+  })
+
+  it('emits a check constraint as the config wrote it', () => {
+    const code = generateTableCode(
+      {
+        ...table,
+        constraints: { check: [{ name: 'band_range', expression: 'band between 1 and 8' }] },
+      } as never,
+      [],
+      []
+    )
+    expect(code).toContain("check('band_range'")
+    expect(code).toContain('band between 1 and 8')
+  })
+
+  /** A constraint over a column that is not there would fail at push time. */
+  it('leaves out a constraint naming a column the table does not have', () => {
+    const code = generateTableCode(
+      {
+        ...table,
+        constraints: { unique: [{ name: 'ghost', columns: ['user_id', 'not_a_column'] }] },
+      } as never,
+      [],
+      []
+    )
+    expect(code).not.toContain("unique('ghost')")
+  })
+
+  it('adds no constraint block to a table that declares none', () => {
+    const code = generateTableCode({ ...table, constraints: undefined } as never, [], [])
+    expect(code).not.toContain('unique(')
+    expect(code).not.toContain('check(')
+  })
+})

package/scripts/generate-schema.ts

@@ -330,7 +330,15 @@ export function generateColumnCode(
   return code
 }
 
-function generateTableCode(table: TableDef, allTables: string[], allTableDefs: TableDef[]): string {
+/**
+ * Exported for the tests that hold this generator to what the config declares —
+ * the table-level `constraints` in particular, which were parsed and dropped.
+ */
+export function generateTableCode(
+  table: TableDef,
+  allTables: string[],
+  allTableDefs: TableDef[]
+): string {
   const tableName = toCamelCase(table.table_name)
   const TableName = tableName.charAt(0).toUpperCase() + tableName.slice(1)
   const columns = table.add_base_columns
@@ -369,8 +377,31 @@ function generateTableCode(table: TableDef, allTables: string[], allTableDefs: T
     code += '];\n\n'
   }
 
+  /*
+   * Table-level `constraints`, which were parsed and then dropped.
+   *
+   * `TableDef.constraints` has been in the config shape all along and nothing
+   * ever read it: twelve tables declare a composite unique key and not one of
+   * them exists in any database. That is not a missing nicety — it is the
+   * reason a user could hold the same role twice, a reader could react to the
+   * same article twice instead of changing their reaction, and an integration
+   * connection could be created twice under the identical slug (seen live: two
+   * connections named the same, and an import that matched by slug wrote to
+   * whichever one it found first).
+   *
+   * Emitted as a unique CONSTRAINT rather than a unique index, because that is
+   * what the config says and because `ON CONFLICT (cols)` needs one to target.
+   * A check constraint is emitted as written; the config owns its SQL.
+   */
+  const uniqueConstraints = (table.constraints?.unique ?? []).filter((c) =>
+    c.columns.every((col) => columns.some((defined) => defined.name === col))
+  )
+  const checkConstraints = table.constraints?.check ?? []
+  const hasTableExtras =
+    validIndexes.length > 0 || uniqueConstraints.length > 0 || checkConstraints.length > 0
+
   code += `export const ${tableName} = pgTable('${table.table_name}', ${tableName}Columns`
-  if (validIndexes.length > 0) {
+  if (hasTableExtras) {
     code += `, (t) => [\n`
     for (const idx of validIndexes) {
       const idxName = idx.name || `${table.table_name}_${idx.columns.join('_')}_idx`
@@ -381,6 +412,13 @@ function generateTableCode(table: TableDef, allTables: string[], allTableDefs: T
         code += `\tindex('${idxName}').on(${cols}),\n`
       }
     }
+    for (const constraint of uniqueConstraints) {
+      const cols = constraint.columns.map((c) => `t.${toCamelCase(c)}`).join(', ')
+      code += `\tunique('${constraint.name}').on(${cols}),\n`
+    }
+    for (const constraint of checkConstraints) {
+      code += `\tcheck('${constraint.name}', sql\`${constraint.expression}\`),\n`
+    }
     code += `]`
   }
   code += ');\n\n'
@@ -480,6 +518,10 @@ function generateSchemaFile(tables: TableDef[]): string {
   imports.add('boolean')
   imports.add('index')
   imports.add('uniqueIndex')
+  // Table-level constraints from `constraints` — a composite unique key is a
+  // CONSTRAINT, not an index, and a check needs `sql` for its expression.
+  imports.add('unique')
+  imports.add('check')
 
   for (const table of tables) {
     const columns = table.add_base_columns