@rebasepro/server-postgres 0.16.0 → 0.16.1-canary.g0d7af95

package/src/schema/ensure-collection-tables.ts

@@ -48,6 +48,8 @@ import {
     planJunctionTables,
     quoteSqlLiteral
 } from "./generate-postgres-ddl-logic";
+import { buildVectorIndexPlan, vectorIndexStatement, type SkippedVectorIndex } from "./vector-index";
+import { buildCollectionIndexPlan, collectionIndexStatement } from "./collection-index";
 import {
     AUTH_USERS_COLUMNS,
     authUsersColumnDefinition,
@@ -100,11 +102,57 @@ export interface ExistingSchema {
      * and reports nothing as drifted.
      */
     columnComments?: Map<string, string>;
+    /**
+     * `schema.typename` → the values that type currently holds, in order.
+     *
+     * Without this, an enum type that already exists is skipped whole and a
+     * value added to it never reaches the database — the type is there, so
+     * nothing plans anything, and the first row using the new value is rejected
+     * by a constraint nobody changed. Absent is read as "the values are
+     * unknown", which keeps the old skip-by-name behaviour rather than guessing.
+     */
+    enumValues?: Map<string, string[]>;
+    /** `schema.table.column` for every column the database marks NOT NULL. */
+    notNullColumns?: Set<string>;
+    /**
+     * Tables known to hold at least one row.
+     *
+     * The only thing that decides whether a NOT NULL can be added without
+     * reading the data: on an empty table the constraint cannot fail, on a
+     * populated one it is checked against every existing row. Absent is read as
+     * "assume populated", which is the conservative direction — it withholds a
+     * constraint rather than attempting one that aborts the boot.
+     */
+    populatedTables?: Set<string>;
+}
+
+/**
+ * How far the planner may go in making the database's constraints match the
+ * configuration.
+ *
+ * - `additive` — the boot default. Columns, tables, indexes and enum values are
+ *   created; no existing column's constraints are touched. Unattended boots run
+ *   against customer data with nobody reading a diff, and a database adopted by
+ *   introspection legitimately carries NOT NULL on columns the generated
+ *   collection leaves optional (`introspect-db-logic` withholds `required` from
+ *   a column with a default or a trigger behind it). Converging there would
+ *   strip real constraints on first boot.
+ * - `converge` — the live schema editor. Every statement is planned, shown to
+ *   the person making the change, and applied only once they confirm it. That
+ *   is the context in which changing an existing column's constraints is a
+ *   reviewed act rather than a surprise.
+ */
+export type ConstraintPolicy = "additive" | "converge";
+
+export interface EnsureOptions {
+    /** Defaults to `additive`. See {@link ConstraintPolicy}. */
+    constraints?: ConstraintPolicy;
 }
 
 export interface EnsureAction {
     kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column"
-        | "create-extension" | "create-function" | "create-index" | "comment-column";
+        | "create-extension" | "create-function" | "create-index" | "comment-column"
+        | "add-enum-value" | "set-not-null" | "drop-not-null";
     /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
     target: string;
     sql: string;
@@ -138,6 +186,44 @@ export interface EnsurePlan {
      * current block cannot be known, which is what the caller reports.
      */
     searchAdopted: { table: string; column: string }[];
+    /**
+     * Vector columns this plan is deliberately leaving unindexed, because
+     * pgvector cannot build an ANN index that wide.
+     *
+     * Reported rather than thrown: the column is valid, storable and
+     * searchable, and refusing the boot over it would make a working
+     * configuration unbootable. Reported rather than dropped: an unindexed
+     * vector column and an indexed one differ only in latency, so nothing
+     * about the running system says which one you got.
+     */
+    vectorIndexSkipped: SkippedVectorIndex[];
+    /**
+     * Constraints the configuration asks for that this plan is not applying,
+     * and why.
+     *
+     * This is the half of the feature that matters most. Every one of these was
+     * previously withheld in silence: a required property arrived nullable, and
+     * the only evidence was a database that disagreed with its own
+     * configuration. Reporting them is what lets boot warn, the live editor
+     * refuse, and the doctor explain — three surfaces that until now had nothing
+     * to read.
+     */
+    withheldConstraints: WithheldConstraint[];
+}
+
+/** A constraint the configuration asks for that the planner is not applying. */
+export interface WithheldConstraint {
+    /** `schema.table.column`. */
+    target: string;
+    kind: "not-null";
+    /**
+     * Why, in a sentence that names the obstacle rather than the rule. The
+     * reader is looking at a column that is nullable when they asked for
+     * required, and needs to know what to do about it.
+     */
+    reason: string;
+    /** What would make it applicable. */
+    remedy: string;
 }
 
 /**
@@ -238,8 +324,11 @@ function requiredEnums(collection: CollectionConfig): { name: string; values: st
  */
 export function planCollectionSchemaEnsure(
     allCollections: CollectionConfig[],
-    existing: ExistingSchema
+    existing: ExistingSchema,
+    options: EnsureOptions = {}
 ): EnsurePlan {
+    const constraintPolicy: ConstraintPolicy = options.constraints ?? "additive";
+    const withheldConstraints: WithheldConstraint[] = [];
     // Boot receives every collection the bundle declares, including the ones
     // served by another engine entirely. Creating a Postgres table for a
     // Firestore collection is not a harmless extra: the app keeps reading
@@ -257,7 +346,35 @@ export function planCollectionSchemaEnsure(
     //    skipped by name rather than guarded in SQL.
     for (const collection of collections) {
         for (const { name, values } of requiredEnums(collection)) {
-            if (existing.enums.has(name) || plannedEnums.has(name)) continue;
+            if (existing.enums.has(name) || plannedEnums.has(name)) {
+                // The type is there, but that says nothing about its *values*.
+                // Skipping the whole type by name is what made an added enum
+                // value vanish: nothing was planned, the boot reported success,
+                // and the first row using the value was rejected by a type that
+                // had never heard of it. `ADD VALUE` is the one alteration
+                // Postgres offers here, it is purely additive, and it is
+                // idempotent with `IF NOT EXISTS`.
+                //
+                // `enumValues` absent means the caller built the schema by hand
+                // and does not know the values; skip by name as before rather
+                // than plan against a guess.
+                const current = existing.enumValues?.get(name);
+                if (!current || plannedEnums.has(name)) continue;
+                const [schema, typeName] = name.split(".");
+                for (const value of values) {
+                    if (current.includes(value)) continue;
+                    actions.push({
+                        kind: "add-enum-value",
+                        target: `${name}.${value}`,
+                        // Not inside a transaction with any use of the value:
+                        // Postgres refuses to read a value added by the
+                        // transaction still adding it. The applier runs these
+                        // one statement at a time, which is what makes it legal.
+                        sql: `ALTER TYPE "${schema}"."${typeName}" ADD VALUE IF NOT EXISTS ${quoteSqlLiteral(value)};`
+                    });
+                }
+                continue;
+            }
             plannedEnums.add(name);
             const [schema, typeName] = name.split(".");
             actions.push({
@@ -445,11 +562,93 @@ export function planCollectionSchemaEnsure(
             // safe on a live table, and a column added without it would take the
             // value the application forgot to send rather than `now()`.
             const autoValue = (p as { autoValue?: string }).autoValue;
-            if (p.type === "date" && (autoValue === "on_create" || autoValue === "on_update")) {
-                definition += " DEFAULT now()";
+            const hasDefault = p.type === "date" && (autoValue === "on_create" || autoValue === "on_update");
+            if (hasDefault) definition += " DEFAULT now()";
+
+            const required = p.validation?.required === true;
+            const columnKey = `${key}.${column}`;
+            const columnExists = existing.tables.get(key)?.has(column) === true;
+
+            // A NOT NULL is safe exactly when it cannot fail against rows that
+            // are already there, and there are three ways to know that:
+            //
+            //  - the table is being created by this plan (no rows yet);
+            //  - the table exists and is empty;
+            //  - the column arrives with a DEFAULT, which Postgres backfills
+            //    into every existing row as part of ADD COLUMN.
+            //
+            // Anything else is checked against live data and can abort the boot,
+            // which is why it used to be withheld — correctly. What was wrong was
+            // withholding it in *silence*: the config said required, the column
+            // came out nullable, and nothing anywhere said so.
+            // `populatedTables` absent means the caller does not know, and not
+            // knowing has to read as "assume rows" — the other direction emits a
+            // NOT NULL that is checked against live data and aborts the boot.
+            // Written as an explicit `!== undefined` because the optional-chain
+            // form (`!existing.populatedTables?.has(key)`) quietly says *empty*
+            // when the fact is missing, which is the wrong way to be wrong.
+            const tableIsEmpty = existing.populatedTables !== undefined
+                && existing.tables.has(key)
+                && !existing.populatedTables.has(key);
+            const notNullIsSafe = fresh || tableIsEmpty || hasDefault;
+
+            if (required && !columnExists) {
+                if (notNullIsSafe) {
+                    definition += " NOT NULL";
+                } else {
+                    withheldConstraints.push({
+                        target: columnKey,
+                        kind: "not-null",
+                        reason:
+                            `"${column}" is required, but "${key}" already holds rows and the column ` +
+                            "has no default to backfill them with, so NOT NULL would be checked " +
+                            "against data that does not have a value yet.",
+                        remedy:
+                            "Backfill the column, then add the constraint — or give the property a " +
+                            "default so every existing row gets one."
+                    });
+                }
             }
-            if (fresh && p.validation?.required) definition += " NOT NULL";
             addColumn(key, schema, table, column, definition);
+
+            // The column is already there and only its constraint differs. Two
+            // directions, and they are not equally safe — see `ConstraintPolicy`
+            // for why neither runs at an unattended boot.
+            if (columnExists && constraintPolicy === "converge") {
+                const isNotNull = existing.notNullColumns?.has(columnKey) === true;
+                if (required && !isNotNull) {
+                    if (tableIsEmpty) {
+                        actions.push({
+                            kind: "set-not-null",
+                            target: columnKey,
+                            sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" SET NOT NULL;`
+                        });
+                    } else {
+                        withheldConstraints.push({
+                            target: columnKey,
+                            kind: "not-null",
+                            reason:
+                                `"${column}" became required, but "${key}" holds rows and any of them ` +
+                                "with no value would make SET NOT NULL fail.",
+                            remedy:
+                                "Backfill the column first — `UPDATE … SET \"" + column +
+                                "\" = … WHERE \"" + column + "\" IS NULL` — then apply this again."
+                        });
+                    }
+                }
+                if (!required && isNotNull) {
+                    // Loosening never fails and never loses data. It is here
+                    // rather than at boot because a database adopted by
+                    // introspection carries NOT NULL on columns the generated
+                    // collection deliberately leaves optional, and converging
+                    // those unasked would drop constraints nobody edited.
+                    actions.push({
+                        kind: "drop-not-null",
+                        target: columnKey,
+                        sql: `ALTER TABLE "${schema}"."${table}" ALTER COLUMN "${column}" DROP NOT NULL;`
+                    });
+                }
+            }
         }
 
         // The auth columns the collection never mentions. The scaffold's users
@@ -595,7 +794,54 @@ export function planCollectionSchemaEnsure(
         }
     }
 
-    return { actions, statements: actions.map(a => a.sql), legacyForeignKeys, searchDrift, searchAdopted };
+    //    ANN indexes for vector columns, on the same terms: the column has to
+    //    exist, the build is real work against real rows, and CONCURRENTLY is
+    //    what keeps that from locking writes for its duration.
+    //
+    //    A column too wide for pgvector to index is reported, not planned —
+    //    silence there would read as "indexed" to anyone watching the boot.
+    const vectorIndexSkipped: SkippedVectorIndex[] = [];
+    for (const collection of collections) {
+        const plan = buildVectorIndexPlan(collection, resolveColumnName);
+        for (const spec of plan.specs) {
+            actions.push({
+                kind: "create-index",
+                target: `${spec.schema}.${spec.table}`,
+                sql: vectorIndexStatement(spec).replace("CREATE INDEX IF NOT EXISTS", "CREATE INDEX CONCURRENTLY IF NOT EXISTS")
+            });
+        }
+        vectorIndexSkipped.push(...plan.skipped);
+    }
+
+    //    Declared indexes, on exactly the same terms as the ANN ones above.
+    //
+    //    Boot has to emit these, not just `db push`: the managed runtime
+    //    provisions at boot and never runs a push, so a push-only index would
+    //    simply not exist there — and nothing would say so.
+    //    `contracts/derived-names.txt` states the rule ("Both, or it is a
+    //    bug") and the gate enforces it, which is what caught this.
+    //
+    //    `concurrently` is a parameter here rather than a string replacement
+    //    on the rendered SQL. The `.replace("CREATE INDEX IF NOT EXISTS", …)`
+    //    just above silently does nothing for a UNIQUE index, whose text is
+    //    `CREATE UNIQUE INDEX …` and never matches the pattern.
+    for (const spec of buildCollectionIndexPlan(collections, resolveColumnName)) {
+        actions.push({
+            kind: "create-index",
+            target: `${spec.schema}.${spec.table}`,
+            sql: collectionIndexStatement(spec, { concurrently: true, ifNotExists: true })
+        });
+    }
+
+    return {
+        actions,
+        statements: actions.map(a => a.sql),
+        legacyForeignKeys,
+        searchDrift,
+        searchAdopted,
+        vectorIndexSkipped,
+        withheldConstraints
+    };
 }
 
 /** Read what the database has, for the schemas the collections live in. */
@@ -611,12 +857,14 @@ export async function readExistingSchema(
         .map(schema => `'${assertSafeIdentifier(schema, "schema name")}'`)
         .join(", ");
 
+    const notNullColumns = new Set<string>();
     const { rows: columns } = await client.query<{
         table_schema: string;
         table_name: string;
         column_name: string;
+        is_nullable: string;
     }>(
-        `SELECT table_schema, table_name, column_name
+        `SELECT table_schema, table_name, column_name, is_nullable
          FROM information_schema.columns
          WHERE table_schema IN (${inList})`
     );
@@ -624,6 +872,64 @@ export async function readExistingSchema(
         const key = `${row.table_schema}.${row.table_name}`;
         if (!tables.has(key)) tables.set(key, new Set());
         tables.get(key)!.add(row.column_name);
+        if (row.is_nullable === "NO") notNullColumns.add(`${key}.${row.column_name}`);
+    }
+
+    // Which tables hold rows. This is the only fact that decides whether a
+    // NOT NULL can be added without reading the data, so it is worth a query.
+    //
+    // `reltuples` would be cheaper and is wrong for this: it is a planner
+    // estimate, it is -1 on a table that has never been analyzed, and a table
+    // that was full an hour ago still reads as full after a DELETE. A wrong
+    // "empty" here means a boot that aborts on a constraint violation, so the
+    // estimate is not good enough. `EXISTS … LIMIT 1` stops at the first row,
+    // which makes the true cost one page read per table.
+    //
+    // Restricted to ordinary and partitioned tables: `information_schema.columns`
+    // also lists views and materialized views, and probing those runs whatever
+    // query defines them.
+    const populatedTables = new Set<string>();
+    const { rows: realTables } = await client.query<{ schema: string; name: string }>(
+        `SELECT n.nspname AS schema, c.relname AS name
+         FROM pg_class c
+         JOIN pg_namespace n ON c.relnamespace = n.oid
+         WHERE c.relkind IN ('r', 'p') AND n.nspname IN (${inList})`
+    );
+    if (realTables.length > 0) {
+        const probes = realTables.map(row => {
+            const schema = assertSafeIdentifier(row.schema, "schema name");
+            const table = assertSafeIdentifier(row.name, "table name");
+            return `SELECT ${quoteSqlLiteral(`${schema}.${table}`)} AS key, ` +
+                `EXISTS(SELECT 1 FROM "${schema}"."${table}" LIMIT 1) AS populated`;
+        });
+        const { rows: populationRows } = await client.query<{ key: string; populated: boolean }>(
+            probes.join(" UNION ALL ")
+        );
+        for (const row of populationRows) {
+            if (row.populated) populatedTables.add(row.key);
+        }
+    }
+
+    const enumValues = new Map<string, string[]>();
+    const { rows: enumValueRows } = await client.query<{
+        schema: string;
+        name: string;
+        value: string;
+    }>(
+        // Ordered by `enumsortorder`, not by label: an enum's order is part of
+        // its meaning (it is what `<` compares), and reading it back sorted
+        // alphabetically would make a correct type look drifted.
+        `SELECT n.nspname AS schema, t.typname AS name, e.enumlabel AS value
+         FROM pg_enum e
+         JOIN pg_type t ON e.enumtypid = t.oid
+         JOIN pg_namespace n ON t.typnamespace = n.oid
+         WHERE n.nspname IN (${inList})
+         ORDER BY t.typname, e.enumsortorder`
+    );
+    for (const row of enumValueRows) {
+        const key = `${row.schema}.${row.name}`;
+        if (!enumValues.has(key)) enumValues.set(key, []);
+        enumValues.get(key)!.push(row.value);
     }
 
     const { rows: enumRows } = await client.query<{ schema: string; name: string }>(
@@ -672,7 +978,7 @@ export async function readExistingSchema(
         columnComments.set(`${row.schema}.${row.table}.${row.column}`, row.comment);
     }
 
-    return { tables, enums, constraints, columnComments };
+    return { tables, enums, constraints, columnComments, enumValues, notNullColumns, populatedTables };
 }
 
 /**
@@ -707,23 +1013,47 @@ function searchDriftMessage(drift: SearchColumnDrift[]): string {
  * The missing-pgvector explanation, appended to the error that reveals it.
  *
  * A `{ type: "vector" }` property compiles to `VECTOR(n)`, and nothing in the
- * OSS pipeline installs pgvector — not this ensure, not `db push`, not the
- * scaffold's `postgres:18-alpine`, which does not ship it. Installing an
- * extension on someone's database is a decision with a deployment behind it
+ * OSS pipeline installs pgvector — not this ensure, not `db push`. Installing
+ * an extension on someone's database is a decision with a deployment behind it
  * (image, superuser, cloud allow-list), so this path stays a refusal; what it
  * must not stay is a bare `type "vector" does not exist` on a crash-looping
  * pod, which names nothing the reader can act on.
+ *
+ * The scaffold now ships `pgvector/pgvector:pg18`, so this is reached by a
+ * project pointed at a database someone else provisioned — which is exactly
+ * the case where naming the extension and the image is worth the words.
  */
 function vectorExtensionHint(message: string): string {
     if (!/type "(vector|halfvec|sparsevec)" does not exist/i.test(message)) return "";
     return (
         "\n  pgvector is not installed on this database, and Rebase does not install it: it is a server extension, " +
-        "so it needs an image that ships it (e.g. `pgvector/pgvector:pg18` — the scaffold's `postgres:18-alpine` " +
+        "so it needs an image that ships it (the scaffold's `pgvector/pgvector:pg18` does; a stock `postgres:18` " +
         "does not) and a role allowed to run `CREATE EXTENSION vector;`. Install it once, then boot again. " +
-        "Note also that Rebase creates no ANN index for a vector column, so `vectorSearch` is an exact scan."
+        "Rebase then creates an ANN index for the column automatically — see the `index` option on the property."
     );
 }
 
+/**
+ * Read what the database looks like, for the schemas a set of collections
+ * lives in.
+ *
+ * The same read `ensureCollectionTables` does at boot, exposed on its own for
+ * the callers that want to *plan* against a real database without changing it —
+ * the live schema editor, which has to tell somebody what a change would do
+ * before they agree to it.
+ */
+export async function readSchemaFactsFor(
+    client: Queryable,
+    collections: CollectionConfig[]
+): Promise<ExistingSchema> {
+    const relational = relationalCollections(collections);
+    const schemas = Array.from(new Set([
+        ...relational.map(schemaOf),
+        ...planJunctionTables(relational).map(junction => junction.schema)
+    ]));
+    return readExistingSchema(client, schemas);
+}
+
 /**
  * Bring the database up to date. Returns what it did.
  *
@@ -793,6 +1123,27 @@ export async function ensureCollectionTables(
         log?.(message);
     }
 
+    // Said once per column, every boot: an unindexed vector column and an
+    // indexed one behave identically apart from latency, so the only way anyone
+    // learns which one they have is if the boot says so.
+    for (const skip of plan.vectorIndexSkipped) {
+        const message = `No ANN index on "${skip.table}"."${skip.column}": ${skip.reason}`;
+        logger.warn(`[schema] ${message}`);
+        log?.(message);
+    }
+
+    // Said once per column, every boot, because the alternative is what this
+    // whole feature exists to end: a column the configuration calls required,
+    // sitting there nullable, with every surface reporting success. The boot
+    // does not fail over it — the column is usable and the data is intact — but
+    // it stops being invisible.
+    for (const withheld of plan.withheldConstraints) {
+        const message =
+            `No NOT NULL on "${withheld.target}": ${withheld.reason} ${withheld.remedy}`;
+        logger.warn(`[schema] ${message}`);
+        log?.(message);
+    }
+
     if (plan.actions.length === 0) {
         log?.("Schema is up to date; nothing to create.");
         return { ...plan, failures };

package/src/schema/generate-drizzle-schema-logic.ts

@@ -308,7 +308,12 @@ export const getDrizzleColumn = (propName: string, prop: Property, collection: C
             const targetTableVar = getTableVarName(getTableName(targetCollection));
             const pkProp = getPrimaryKeyProp(targetCollection);
             const targetIdField = pkProp.name;
-            const baseColumn = pkProp.type === "number" ? `integer("${fkColumnName}")` : (pkProp.isUuid ? `uuid("${fkColumnName}")` : `text("${fkColumnName}")`);
+            // `quote`, like every other column literal in this file: a column
+            // name only has to be quotable in Postgres, and this one is derived
+            // from a relation the author wrote.
+            const baseColumn = pkProp.type === "number"
+                ? `integer(${quote(fkColumnName)})`
+                : (pkProp.isUuid ? `uuid(${quote(fkColumnName)})` : `text(${quote(fkColumnName)})`);
 
             const onUpdate = relation.onUpdate ? `onUpdate: "${relation.onUpdate}"` : "";
             const required = prop.validation?.required;
@@ -681,10 +686,13 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
             const targetId = getPrimaryKeyName(targetCollection);
 
             schemaContent += `export const ${tableVarName} = ${tableCreator}(\"${baseTableName}\", {\n`;
-            schemaContent += `    ${sourceColumn}: ${sourceColType}(\"${sourceColumn}\").notNull().references(() => ${getTableVarName(getTableName(sourceCollection))}.${sourceId}, ${refOptions}),\n`;
-            schemaContent += `    ${targetColumn}: ${targetColType}(\"${targetColumn}\").notNull().references(() => ${getTableVarName(getTableName(targetCollection))}.${targetId}, ${refOptions}),\n`;
+            // The junction block was the one place these three helpers were not
+            // applied, so a junction column containing a space or a hyphen —
+            // both legal in Postgres — produced a file that does not parse.
+            schemaContent += `    ${propKey(sourceColumn)}: ${sourceColType}(${quote(sourceColumn)}).notNull().references(() => ${member(getTableVarName(getTableName(sourceCollection)), sourceId)}, ${refOptions}),\n`;
+            schemaContent += `    ${propKey(targetColumn)}: ${targetColType}(${quote(targetColumn)}).notNull().references(() => ${member(getTableVarName(getTableName(targetCollection)), targetId)}, ${refOptions}),\n`;
             schemaContent += "}, (table) => ([\n";
-            schemaContent += `    primaryKey({ columns: [table.${sourceColumn}, table.${targetColumn}] }),\n`;
+            schemaContent += `    primaryKey({ columns: [${member("table", sourceColumn)}, ${member("table", targetColumn)}] }),\n`;
 
             // Junctions are generated tables like any other: locked by default,
             // with derived policies (reads follow the endpoints, writes follow
@@ -719,19 +727,20 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
             const searchSpec = buildSearchColumnSpec(collection);
             if (searchSpec) {
                 columns.add(
-                    `    ${searchSpec.column}: customType({ dataType() { return 'tsvector'; } })("${searchSpec.column}")` +
+                    `    ${propKey(searchSpec.column)}: customType({ dataType() { return 'tsvector'; } })(${quote(searchSpec.column)})` +
                     `.generatedAlwaysAs(sql\`${searchSpec.expression}\`)`
                 );
                 if (searchSpec.fuzzy) {
                     columns.add(
-                        `    ${searchSpec.fuzzy.column}: text("${searchSpec.fuzzy.column}")` +
+                        `    ${propKey(searchSpec.fuzzy.column)}: text(${quote(searchSpec.fuzzy.column)})` +
                         `.generatedAlwaysAs(sql\`${searchSpec.fuzzy.expression}\`)`
                     );
                 }
             }
 
-            // Backwards compatibility: if no id/primary key column is found in properties, but `id` wasn't explicitly provided
-            // We should generate a basic id column if one was completely omitted.
+            // A collection that declares no primary key gets an implicit one:
+            // `id TEXT PRIMARY KEY`. The DDL generator emits the same column,
+            // and `derivePrimaryKeys` reads it back.
             const hasIdColumn = Array.from(columns).some(col => col.includes(".primaryKey()"));
             if (!hasIdColumn) {
                 columns.add("    id: text(\"id\").primaryKey()");
@@ -860,11 +869,14 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
                             // `fields`/`references` here is invalid and crashes
                             // `normalizeRelation` with "Cannot read properties of
                             // undefined (reading 'referencedTable')".
-                            tableRelations.push(`    "${relationKey}": one(${targetTableVar}, {\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                            // A `relationName` is authored, and a `"` in one
+                            // closed this string literal early — in a file that
+                            // is compiled and imported by the server.
+                            tableRelations.push(`    ${quote(relationKey)}: one(${targetTableVar}, {\n        relationName: ${quote(drizzleRelationName)}\n    })`);
                             break;
 
                         case "hasMany":
-                            tableRelations.push(`    "${relationKey}": many(${targetTableVar}, { relationName: \"${drizzleRelationName}\" })`);
+                            tableRelations.push(`    ${quote(relationKey)}: many(${targetTableVar}, { relationName: ${quote(drizzleRelationName)} })`);
                             break;
 
                         case "manyToMany": {
@@ -874,7 +886,7 @@ export const generateSchema = async (allCollections: CollectionConfig[], stripPo
                             // junction table — unnecessary now that each side names
                             // its own.
                             const junctionTableVar = getTableVarName(rel.through.table);
-                            tableRelations.push(`    "${relationKey}": many(${junctionTableVar}, { relationName: \"${drizzleRelationName}\" })`);
+                            tableRelations.push(`    ${quote(relationKey)}: many(${junctionTableVar}, { relationName: ${quote(drizzleRelationName)} })`);
                             break;
                         }
 

package/src/schema/generate-drizzle-schema.ts

@@ -2,7 +2,6 @@ import { promises as fsPromises } from "fs";
 import * as fs from "fs";
 import path from "path";
 import { pathToFileURL } from "url";
-import chokidar from "chokidar";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { CollectionConfig } from "@rebasepro/types";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
@@ -93,7 +92,7 @@ const runGeneration = async (collectionsFilePath?: string, outputPath?: string)
     }
 };
 
-const main = () => {
+const main = async () => {
     const collectionsFilePathArg = process.argv.find(arg => arg.startsWith("--collections="));
     const collectionsFilePath = collectionsFilePathArg ? collectionsFilePathArg.split("=")[1] : process.argv[2];
 
@@ -112,6 +111,18 @@ const main = () => {
 
     if (watch) {
         out(`Watching for changes in ${resolvedPath}...`);
+        // Imported here rather than at module scope, and this is not a style
+        // choice: chokidar is needed only by `--watch`, which is a
+        // schema-authoring path that never runs inside the runtime image. A
+        // top-level import puts it on the boot path of the published driver
+        // bundle, and the image installs a hand-listed set of runtime
+        // dependencies that does not include it — so the whole driver failed to
+        // load with "Cannot find package 'chokidar'", and every self-hosted
+        // container answered 500 with a stack trace about a file watcher.
+        //
+        // Same reasoning the image already applies to @ariga/atlas: an
+        // authoring-only dependency does not belong on a boot path.
+        const { default: chokidar } = await import("chokidar");
         const watcher = chokidar.watch(resolvedPath, {
             persistent: true,
             ignoreInitial: false