@bakery-framework/orm 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bakery-framework/orm",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Bakery database layer: adapters, query builder, schema sync and backup.",
   "keywords": [
     "bakery",

package/src/sync/builder.ts

@@ -184,7 +184,20 @@ export class SchemaBuilder {
       if (r.onUpdate) opts.push(`onUpdate: '${r.onUpdate}'`)
       parts.push(`_references: { ${opts.join(', ')} }`)
     }
-    return `${indent}${colName}: { ${parts.join(', ')} },\n`
+    // `as const`, and without it the folder layout loses these columns' types.
+    //
+    // `table()` takes `C extends ColumnMap`, which is `Record<string, unknown>`
+    // — a constraint that does not preserve literals, so `{ type: 'integer' }`
+    // widens to `{ type: string }` and `InferSchema` has no `'integer'` left to
+    // match. Every column the `Field` vocabulary cannot name — which since
+    // foreign keys round-trip includes *every referencing column* — then infers
+    // as a string.
+    //
+    // Invisible in the single-file layout, where `DBInfo.constraints` is already
+    // `as const`, and that is why it took a real app on the folder layout to
+    // surface: 28 errors of the form `number is not assignable to string` on
+    // inserts into tables whose foreign keys are integers.
+    return `${indent}${colName}: { ${parts.join(', ')} } as const,\n`
   }
 
   /**
@@ -505,12 +518,106 @@ ${body}`
    * neither is the generator's to rewrite. That separation is the reason the
    * folder layout exists (see `load.ts`).
    */
+  /**
+   * The constraints key a `_references.table` names, or `undefined`.
+   *
+   * Introspection reports SQL identifiers while the constraints map is keyed the
+   * way the schema declares them, so the two are compared through `Case.camel`.
+   */
+  private static tableKeyFor(
+    constraints: Record<string, any>,
+    sqlName: string,
+  ): string | undefined {
+    return Object.keys(constraints).find(
+      k => Case.camel(k) === Case.camel(sqlName),
+    )
+  }
+
+  /**
+   * Table names ordered so every table follows the ones it references.
+   *
+   * A depth-first walk with a visiting set, which is also the cycle break: a
+   * table already on the stack is left where it is, and the column pointing back
+   * at it falls through to the object literal — correct, just not pretty.
+   * Circular references between tables are legal SQL and this must not fail on
+   * them or, worse, emit a forward reference that is `undefined` at module
+   * evaluation.
+   */
+  private static tablesParentsFirst(
+    constraints: Record<string, any>,
+  ): string[] {
+    const order: string[] = []
+    const done = new Set<string>()
+    const visiting = new Set<string>()
+
+    const visit = (name: string) => {
+      if (done.has(name) || visiting.has(name)) return
+      visiting.add(name)
+
+      const cols = constraints[name]
+      if (cols && !cols._view) {
+        for (const cons of Object.values<any>(cols)) {
+          const parent = cons?._references?.table
+          if (!parent) continue
+          const key = SchemaBuilder.tableKeyFor(constraints, parent)
+          if (key && key !== name) visit(key)
+        }
+      }
+
+      visiting.delete(name)
+      done.add(name)
+      order.push(name)
+    }
+
+    for (const name of Object.keys(constraints)) visit(name)
+    return order
+  }
+
+  /**
+   * `Field.Foreign(parent.column, …)` when the parent is already in scope.
+   *
+   * Returns null when it is not — the cycle case above — so the caller falls
+   * back to the literal rather than emitting a reference to a `const` declared
+   * further down the file, which is a TDZ error at import time.
+   */
+  private static asForeignCall(
+    cons: any,
+    constraints: Record<string, any>,
+    declared: Set<string>,
+  ): string | null {
+    const ref = cons?._references
+    if (!ref) return null
+
+    const key = SchemaBuilder.tableKeyFor(constraints, ref.table)
+    if (!key || !declared.has(key)) return null
+
+    const opts: string[] = []
+    // The literal form spells nullability as `nullable: true, default: null`;
+    // `Field.Foreign` takes the one flag and writes both.
+    if (cons.nullable) opts.push('nullable: true')
+    if (ref.onDelete) opts.push(`onDelete: '${ref.onDelete}'`)
+    if (ref.onUpdate) opts.push(`onUpdate: '${ref.onUpdate}'`)
+
+    const target = `${exportNameFor(key)}.${ref.column}`
+    return opts.length
+      ? `Field.Foreign(${target}, { ${opts.join(', ')} })`
+      : `Field.Foreign(${target})`
+  }
+
   private static buildTableModule(
     constraints: Record<string, any>,
     adapter: SQLAdapter,
   ): string {
+    // Parents before children, so a referencing column can name the table value
+    // it points at. `Field.Foreign(sections.id)` is the form a person writes and
+    // the one the scaffolder's own template uses; the alternative is the object
+    // literal below, which states the same thing in four times the width.
+    const order = SchemaBuilder.tablesParentsFirst(constraints)
+    const declared = new Set<string>()
+
     let body = ''
-    for (const [tableName, cols] of Object.entries(constraints)) {
+    for (const tableName of order) {
+      const cols = constraints[tableName]
       // Views are left to `views.ts`, exactly as indexes are left to
       // `indexes.ts`. This file is the only one the generator owns; emitting a
       // view here as well would leave the same declaration in two files after
@@ -521,15 +628,19 @@ ${body}`
       for (const [colName, cons] of Object.entries(
         cols as Record<string, SyncTypes.ColumnConstraint>,
       )) {
-        colsStr += SchemaBuilder.formatColumnConstraint(
-          colName,
-          cons,
-          adapter,
-          // Never a view here — those were skipped above.
-          false,
-          '  ',
-        )
+        const ref = SchemaBuilder.asForeignCall(cons, constraints, declared)
+        colsStr += ref
+          ? `  ${colName}: ${ref},\n`
+          : SchemaBuilder.formatColumnConstraint(
+              colName,
+              cons,
+              adapter,
+              // Never a view here — those were skipped above.
+              false,
+              '  ',
+            )
       }
+      declared.add(tableName)
       body += `export const ${exportNameFor(tableName)} = table('${tableName}', {\n${colsStr}})\n\n`
     }
 

package/src/sync/engine.ts

@@ -334,7 +334,15 @@ export class SyncEngine {
     // ledger, so the first real sync afterwards diffs against introspection
     // instead: the one place enum changes are invisible.
     if (process.argv.includes('--migrate')) {
-      await genLocal(constraints)
+      // `{}`, not `constraints`: adoption generates from the **database alone**.
+      //
+      // Passing the loaded schema in makes `syncNullableConstraints` reconcile
+      // view column nullability against it, which is right for a regeneration of
+      // a schema you are keeping and wrong for this — the point of `--migrate`
+      // is that the database is the source of truth, and quietly carrying a
+      // detail over from the file being replaced would make the result depend on
+      // what happened to be there.
+      await genLocal({})
       await SyncEngine.seedLedger(adapter)
       MESSAGES.MIGRATE_DONE()
       return

package/src/sync/index.ts

@@ -16,6 +16,8 @@ const syncMsgs = {
   SCHEMA_NOT_FOUND:
     'E %rConfigured schema path not found%*: {path}. %yschema%* in server.config.ts must name a file or an orm/ folder that exists; remove it to auto-detect. Generating one from the database? Create the (empty) file first, or run %ydb:sync --migrate%*.',
   MIGRATE_SCAFFOLDED: 'I Created %y{dir}%* — the generator owns tables.ts.',
+  MIGRATE_RETIRED:
+    'I Converted to the orm/ folder. The previous %yschema.ts%* was moved to %y{to}%*, not deleted.',
 } as const
 
 const MESSAGES = messageLogger(logger, syncMsgs)
@@ -134,6 +136,31 @@ Flags:
     MESSAGES.MIGRATE_SCAFFOLDED({ dir: 'orm/' })
   }
 
+  /**
+   * Move the old single-file `schema.ts` out of the way after a conversion.
+   *
+   * Moved, never deleted: it goes to `bakery/backups/`, beside the copies the
+   * generator already keeps there. `loadSchema` prefers `orm/index.ts`, so a
+   * leftover `schema.ts` would be *ignored* rather than used — which is the
+   * quiet kind of wrong, since it looks like the file still describes the app
+   * while nothing reads it.
+   */
+  static async retireSingleFileSchema(
+    cwd: string,
+    previous: 'folder' | 'file' | 'none',
+  ): Promise<void> {
+    if (previous !== 'file') return
+
+    const from = `${cwd}/schema.ts`
+    const file = Bun.file(from)
+    if (!(await file.exists())) return
+
+    const to = `${cwd}/bakery/backups/schema.pre-migrate.${Date.now()}.ts`
+    await Bun.write(to, await file.text())
+    await file.delete()
+    MESSAGES.MIGRATE_RETIRED({ to: to.slice(cwd.length + 1) })
+  }
+
   static async run() {
     // Before initConfig/initDB/loadSchema: help must not depend on a working
     // connection, a loadable schema, or the absence of a `foreign()`.
@@ -185,7 +212,13 @@ Flags:
     // cannot touch the views, indexes and registration beside it — which for an
     // adopted database is the difference between re-running the command and
     // hand-restoring what it overwrote.
-    const adopting = SyncService.migrateRequested() && loaded.layout === 'none'
+    // `--migrate` always lands on the folder layout, including from an existing
+    // single-file `schema.ts`. It used to convert only from *nothing*, which
+    // read as an arbitrary distinction: the reason to prefer the folder is that
+    // the generator owns `tables.ts` and cannot touch the views, indexes and
+    // registration beside it — and that is worth exactly as much to a project
+    // that already has a schema as to one that does not.
+    const adopting = SyncService.migrateRequested()
     const layout = adopting ? 'folder' : loaded.layout
     const targetPath = adopting ? `${process.cwd()}/orm/tables.ts` : schemaPath
 
@@ -195,7 +228,10 @@ Flags:
     // `indexes.ts`, which the generator writes only when the database has views
     // or indexes to write. Deciding what to import before knowing which files
     // exist is how the first version produced a barrel pointing at nothing.
-    if (adopting) await SyncService.writeOrmIndex(process.cwd())
+    if (adopting) {
+      await SyncService.writeOrmIndex(process.cwd())
+      await SyncService.retireSingleFileSchema(process.cwd(), loaded.layout)
+    }
 
     await closeDB()
   }