nucleus-core-ts 0.10.14 → 0.10.15

package/dist/.build-ok

@@ -1 +1 @@
-0.10.14
+0.10.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nucleus-core-ts",
-  "version": "0.10.14",
+  "version": "0.10.15",
   "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,10 @@
 import { describe, expect, it } from 'bun:test'
-import { generateColumnCode, generateTableCode, selectEmittedTables } from './generate-schema'
+import {
+  generateColumnCode,
+  generateRelationsFile,
+  generateTableCode,
+  selectEmittedTables,
+} from './generate-schema'
 
 const table = (table_name: string) => ({ table_name })
 
@@ -214,3 +219,57 @@ describe('table-level constraints', () => {
     expect(code).not.toContain('check(')
   })
 })
+
+describe('generateRelationsFile', () => {
+  const branchTable = {
+    table_name: 'survey_branches',
+    columns: [
+      {
+        name: 'trigger_question_id',
+        type: 'uuid',
+        references: { table: 'survey_questions', column: 'id' },
+      },
+      {
+        name: 'target_question_id',
+        type: 'uuid',
+        references: { table: 'survey_questions', column: 'id' },
+      },
+      {
+        name: 'survey_id',
+        type: 'uuid',
+        references: { table: 'surveys', column: 'id' },
+      },
+    ],
+  }
+
+  it('names two references to the SAME table after their columns', () => {
+    /*
+     * Both used to be emitted as `surveyQuestions:`, so the object literal had
+     * the same key twice and the generated file did not compile — a config
+     * change that produces broken output rather than a wrong result. A branch
+     * whose trigger and target are both questions is what found it; `created_by`
+     * with `updated_by` would have found it just as well.
+     */
+    const code = generateRelationsFile([
+      branchTable,
+      { table_name: 'survey_questions' },
+      { table_name: 'surveys' },
+    ] as never)
+
+    expect(code).toContain('triggerQuestion: one(surveyQuestions')
+    expect(code).toContain('targetQuestion: one(surveyQuestions')
+    expect(code.match(/surveyQuestions: one\(/g)).toBeNull()
+  })
+
+  it('and leaves a lone reference named after its table, as before', () => {
+    // The control: renaming everything would churn every existing generated
+    // file and rename relations consumers already query by.
+    const code = generateRelationsFile([
+      branchTable,
+      { table_name: 'survey_questions' },
+      { table_name: 'surveys' },
+    ] as never)
+
+    expect(code).toContain('surveys: one(surveys')
+  })
+})

package/scripts/generate-schema.ts

@@ -607,7 +607,7 @@ function topologicalSort(tables: TableDef[], allTableNames: string[]): TableDef[
   return result
 }
 
-function generateRelationsFile(tables: TableDef[]): string {
+export function generateRelationsFile(tables: TableDef[]): string {
   const allTableNames = new Set(tables.map((t) => t.table_name))
   const relationsByTable: Map<
     string,
@@ -640,9 +640,37 @@ function generateRelationsFile(tables: TableDef[]): string {
     const fromTable = toCamelCase(tableName)
     code += `export const ${fromTable}Relations = relations(${fromTable}, ({ one, many }) => ({\n`
 
+    /*
+     * How many of this table's foreign keys point at the same table.
+     *
+     * The relation used to be named after the TARGET TABLE, which is fine until
+     * a table references the same one twice — and then the generator emits two
+     * properties with the same key and the output does not compile:
+     *
+     *   surveyQuestions: one(surveyQuestions, { fields: [...triggerQuestionId] }),
+     *   surveyQuestions: one(surveyQuestions, { fields: [...targetQuestionId] }),
+     *
+     * That is not an exotic shape. `created_by`/`updated_by`, `from_user`/
+     * `to_user`, and here a branch's trigger question and its target question
+     * all land on it. Found when survey branching grew a second kind of target.
+     */
+    const referencesToTable = new Map<string, number>()
+    for (const rel of rels) {
+      referencesToTable.set(rel.to, (referencesToTable.get(rel.to) ?? 0) + 1)
+    }
+
     for (const rel of rels) {
       const toTable = toCamelCase(rel.to)
-      const relationName = rel.isSelf ? 'parent' : toTable
+      // Only the ambiguous ones are renamed, so a config with one reference per
+      // table generates exactly what it generated before.
+      const ambiguous = (referencesToTable.get(rel.to) ?? 0) > 1
+      const relationName = ambiguous
+        ? // `trigger_question_id` -> `triggerQuestion`: the column says which of
+          // the two this is, which is the only thing that tells them apart.
+          toCamelCase(rel.fromCol.replace(/_id$/, ''))
+        : rel.isSelf
+          ? 'parent'
+          : toTable
       const fields = `${fromTable}.${toCamelCase(rel.fromCol)}`
       const references = `${toTable}.${toCamelCase(rel.toCol)}`