@rebasepro/server-postgres 0.12.1-canary.gf5f1d39 → 0.13.0

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

@@ -27,10 +27,14 @@
  */
 import { type CollectionConfig, type Property, isPostgresCollectionConfig } from "@rebasepro/types";
 import { getTableName } from "@rebasepro/common";
+import { logger } from "@rebasepro/server";
 import {
     getSqlColumnType,
     resolveColumnName,
-    isIdProperty
+    isIdProperty,
+    planRelationalColumns,
+    planJunctionTables,
+    quoteSqlLiteral
 } from "./generate-postgres-ddl-logic";
 
 /**
@@ -62,10 +66,18 @@ export interface ExistingSchema {
     tables: Map<string, Set<string>>;
     /** `schema.typename` of every enum type that already exists. */
     enums: Set<string>;
+    /**
+     * `schema.table.constraint` of every constraint that already exists.
+     *
+     * Optional so a caller that only cares about tables can still build one by
+     * hand; absent is read as "none known", which at worst re-attempts a
+     * constraint that then fails harmlessly as a duplicate.
+     */
+    constraints?: Set<string>;
 }
 
 export interface EnsureAction {
-    kind: "create-enum" | "create-table" | "add-column";
+    kind: "create-enum" | "create-table" | "add-column" | "add-constraint" | "rename-column";
     /** Qualified target, for logging: `public.posts` or `public.posts.title`. */
     target: string;
     sql: string;
@@ -75,6 +87,39 @@ export interface EnsurePlan {
     actions: EnsureAction[];
     /** Every statement, in dependency order. Empty when the schema is current. */
     statements: string[];
+    /**
+     * Relation columns this plan is about to create where the table already
+     * carries the same column under its pre-singularization name.
+     *
+     * The reason this is reported rather than silently handled: the ensure is
+     * additive, so it would add `category_id` beside a populated
+     * `categorie_id` and the relation would then read the new, empty one. No
+     * statement fails, no table is missing, and the only symptom is relations
+     * resolving to nothing — which is indistinguishable from having no data.
+     */
+    legacyForeignKeys: LegacyForeignKey[];
+}
+
+/** A relation column whose old and new spellings both plausibly apply. */
+export interface LegacyForeignKey {
+    /** `schema.table`. */
+    table: string;
+    /** The name the current rule derives, and what this plan would create. */
+    expected: string;
+    /** The name the old rule derived, which the table already has. */
+    legacy: string;
+}
+
+export interface EnsureOutcome extends EnsurePlan {
+    /**
+     * Constraints that could not be added — always non-fatal.
+     *
+     * A foreign key can only fail on data that already violates it, and the
+     * column it would police exists either way, so the collection still serves.
+     * Refusing to boot over one would turn a pre-existing data problem into an
+     * outage. Reported loudly instead.
+     */
+    failures: { target: string; error: string }[];
 }
 
 function schemaOf(collection: CollectionConfig): string {
@@ -114,11 +159,6 @@ function requiredEnums(collection: CollectionConfig): { name: string; values: st
     return out;
 }
 
-/** Single-quote escaping for an enum label. */
-function quoteLiteral(value: string): string {
-    return `'${value.replace(/'/g, "''")}'`;
-}
-
 /**
  * Decide what to add. Pure — the caller supplies what exists and runs the result.
  *
@@ -143,7 +183,7 @@ export function planCollectionSchemaEnsure(
             actions.push({
                 kind: "create-enum",
                 target: name,
-                sql: `CREATE TYPE "${schema}"."${typeName}" AS ENUM (${values.map(quoteLiteral).join(", ")});`
+                sql: `CREATE TYPE "${schema}"."${typeName}" AS ENUM (${values.map(quoteSqlLiteral).join(", ")});`
             });
         }
     }
@@ -183,35 +223,137 @@ export function planCollectionSchemaEnsure(
         });
     }
 
+    // 2b. Junction tables behind many-to-many relations. No collection declares
+    //     them, so the walk above never sees them — and until they existed, an
+    //     m2m write had nowhere to land and the junction's derived RLS had
+    //     nothing to attach to.
+    const junctions = planJunctionTables(collections);
+    for (const junction of junctions) {
+        const key = `${junction.schema}.${junction.table}`;
+        if (existing.tables.has(key) || created.has(key)) continue;
+        created.add(key);
+        actions.push({ kind: "create-table", target: key, sql: junction.createTable });
+    }
+
     // 3. Missing columns, on both brand-new and pre-existing tables.
+    const legacyForeignKeys: LegacyForeignKey[] = [];
+
+    /**
+     * Move a relation column that is only missing because it was renamed.
+     *
+     * Returns true when it handled the column, so the caller skips the ordinary
+     * ADD. Adding here would be the wrong move and a quiet one: the data is in
+     * the old column, `ADD COLUMN` creates the new one empty beside it, every
+     * statement succeeds, and the relation reads the empty one. A rename is
+     * metadata-only in Postgres, keeps the values, and carries the column's
+     * indexes and constraints with it.
+     *
+     * Only ever reached when the new name is absent and the old name is
+     * present, so there is nothing to overwrite and nothing to choose between.
+     */
+    const renameLegacyColumn = (
+        key: string,
+        schema: string,
+        table: string,
+        column: string,
+        legacyName: string | undefined
+    ): boolean => {
+        const present = existing.tables.get(key);
+        if (!legacyName || !present) return false;
+        if (present.has(column) || !present.has(legacyName)) return false;
+
+        legacyForeignKeys.push({ table: key, expected: column, legacy: legacyName });
+        actions.push({
+            kind: "rename-column",
+            target: `${key}.${column}`,
+            sql: `ALTER TABLE "${schema}"."${table}" RENAME COLUMN "${legacyName}" TO "${column}";`
+        });
+        return true;
+    };
+
+    const addColumn = (
+        key: string,
+        schema: string,
+        table: string,
+        column: string,
+        type: string
+    ): void => {
+        const present = existing.tables.get(key);
+        if (present?.has(column)) return;
+        actions.push({
+            kind: "add-column",
+            target: `${key}.${column}`,
+            // Never NOT NULL: an existing table with rows cannot take a
+            // non-null column without a default, and inventing one would be
+            // guessing at the customer's data.
+            sql: `ALTER TABLE "${schema}"."${table}" ADD COLUMN IF NOT EXISTS "${column}" ${type};`
+        });
+    };
+
     for (const collection of collections) {
         const key = qualified(collection);
         const schema = schemaOf(collection);
         const table = getTableName(collection);
-        const present = existing.tables.get(key) ?? new Set<string>();
         for (const [propName, prop] of Object.entries(collection.properties ?? {})) {
             const p = prop as Property;
             if (isIdProperty(propName, p, collection)) continue;
-            // A relation's own column is emitted by the DDL generator with a
-            // foreign key; adding a bare column here would create the column
-            // without the constraint and make the generator's later output
-            // disagree with the database. Left to a real migration.
+            // Relation and reference columns are planned from the shared
+            // relational planner below, which derives the column name, type and
+            // foreign key the same way `db push` does. Deriving them here as
+            // plain columns is what once produced a column with no constraint.
             if (p.type === "reference" || p.type === "relation") continue;
-            const column = resolveColumnName(propName, p);
-            if (present.has(column)) continue;
-            const type = getSqlColumnType(propName, p, collection, collections);
-            actions.push({
-                kind: "add-column",
-                target: `${key}.${column}`,
-                // Never NOT NULL: an existing table with rows cannot take a
-                // non-null column without a default, and inventing one would be
-                // guessing at the customer's data.
-                sql: `ALTER TABLE "${schema}"."${table}" ADD COLUMN IF NOT EXISTS "${column}" ${type};`
-            });
+            addColumn(key, schema, table, resolveColumnName(propName, p), getSqlColumnType(propName, p, collection, collections));
+        }
+    }
+
+    // 3b. A junction that already existed, but is short a column. One created
+    //     above already carries both — unlike a collection table, whose CREATE
+    //     declares only the identity column — so re-listing them would log two
+    //     no-op statements and inflate the count of changes applied.
+    for (const junction of junctions) {
+        const key = `${junction.schema}.${junction.table}`;
+        if (created.has(key)) continue;
+        for (const column of junction.columns) {
+            if (renameLegacyColumn(key, junction.schema, junction.table, column.name, column.legacyName)) continue;
+            addColumn(key, junction.schema, junction.table, column.name, column.type);
         }
     }
 
-    return { actions, statements: actions.map(a => a.sql) };
+    // 3c. The columns relation and reference properties own.
+    for (const relational of planRelationalColumns(collections)) {
+        const relKey = `${relational.schema}.${relational.table}`;
+        if (renameLegacyColumn(relKey, relational.schema, relational.table, relational.column, relational.legacyColumn)) continue;
+        addColumn(
+            relKey,
+            relational.schema,
+            relational.table,
+            relational.column,
+            relational.type
+        );
+    }
+
+    // 4. Foreign keys, last: the tables and columns on both ends have to exist
+    //    first, and a constraint is the one thing here that can fail on data
+    //    rather than on schema, so nothing else depends on it.
+    const knownConstraints = existing.constraints ?? new Set<string>();
+    const plannedConstraints = new Set<string>();
+    const foreignKeys = [
+        ...planRelationalColumns(collections).map(r => r.foreignKey),
+        ...junctions.flatMap(j => j.foreignKeys)
+    ];
+    for (const fk of foreignKeys) {
+        if (!fk) continue;
+        const name = `${fk.schema}.${fk.table}.${fk.constraintName}`;
+        if (knownConstraints.has(name) || plannedConstraints.has(name)) continue;
+        plannedConstraints.add(name);
+        actions.push({
+            kind: "add-constraint",
+            target: `${fk.schema}.${fk.table}.${fk.constraintName}`,
+            sql: fk.sql
+        });
+    }
+
+    return { actions, statements: actions.map(a => a.sql), legacyForeignKeys };
 }
 
 /** Read what the database has, for the schemas the collections live in. */
@@ -250,7 +392,23 @@ export async function readExistingSchema(
     );
     for (const row of enumRows) enums.add(`${row.schema}.${row.name}`);
 
-    return { tables, enums };
+    // `ADD CONSTRAINT` has no IF NOT EXISTS, so an existing foreign key is
+    // skipped by name rather than guarded in SQL.
+    const constraints = new Set<string>();
+    const { rows: constraintRows } = await client.query<{
+        schema: string;
+        table: string;
+        name: string;
+    }>(
+        `SELECT n.nspname AS schema, c.relname AS table, con.conname AS name
+         FROM pg_constraint con
+         JOIN pg_class c ON con.conrelid = c.oid
+         JOIN pg_namespace n ON c.relnamespace = n.oid
+         WHERE n.nspname IN (${inList})`
+    );
+    for (const row of constraintRows) constraints.add(`${row.schema}.${row.table}.${row.name}`);
+
+    return { tables, enums, constraints };
 }
 
 /**
@@ -265,8 +423,14 @@ export async function ensureCollectionTables(
     client: Queryable,
     collections: CollectionConfig[],
     log?: (message: string) => void
-): Promise<EnsurePlan> {
-    const schemas = Array.from(new Set(collections.map(schemaOf)));
+): Promise<EnsureOutcome> {
+    // Junctions live alongside the collections that declare them, so their
+    // schema has to be read too — otherwise an existing junction reads as
+    // missing and its constraints as unplanned.
+    const schemas = Array.from(new Set([
+        ...collections.map(schemaOf),
+        ...planJunctionTables(collections).map(j => j.schema)
+    ]));
     for (const schema of schemas) {
         assertSafeIdentifier(schema, "schema name");
         if (schema !== "public") {
@@ -276,10 +440,26 @@ export async function ensureCollectionTables(
 
     const existing = await readExistingSchema(client, schemas);
     const plan = planCollectionSchemaEnsure(collections, existing);
+    const failures: { target: string; error: string }[] = [];
+
+    // Reported, not warned: this is a rename the ensure is about to perform, and
+    // the operator should be able to see in the log why a column changed name.
+    // The interesting case is the one that no longer happens — before this,
+    // ensure added the new column empty beside the populated old one, every
+    // statement succeeded, and the relation read the empty one.
+    for (const legacy of plan.legacyForeignKeys) {
+        const message =
+            `Renaming "${legacy.table}"."${legacy.legacy}" to "${legacy.expected}". The old name is ` +
+            "the one Rebase derived for this relation before it singularized properly; the column " +
+            "keeps its data, indexes and constraints. To keep the old name instead, set " +
+            `\`localKey: "${legacy.legacy}"\` on the relation and this will stop.`;
+        logger.info(`[schema] ${message}`);
+        log?.(message);
+    }
 
     if (plan.actions.length === 0) {
         log?.("Schema is up to date; nothing to create.");
-        return plan;
+        return { ...plan, failures };
     }
 
     for (const action of plan.actions) {
@@ -287,11 +467,19 @@ export async function ensureCollectionTables(
             await client.query(action.sql);
             log?.(`${action.kind}: ${action.target}`);
         } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            // A foreign key is the only action that can fail on the customer's
+            // data rather than on the schema. The column it polices is already
+            // there, so the collection serves either way — record it and carry
+            // on rather than crash-looping the deployment.
+            if (action.kind === "add-constraint") {
+                failures.push({ target: action.target, error: message });
+                continue;
+            }
             throw new Error(
-                `Failed to ${action.kind} ${action.target}: ` +
-                `${err instanceof Error ? err.message : String(err)}\n  ${action.sql}`
+                `Failed to ${action.kind} ${action.target}: ${message}\n  ${action.sql}`
             );
         }
     }
-    return plan;
+    return { ...plan, failures };
 }

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

@@ -1,6 +1,6 @@
 import { CollectionConfig, NumberProperty, Property, ResolvedRelation, RelationProperty, SecurityOperation, SecurityRule, StringProperty, isPostgresCollectionConfig, DateProperty, ArrayProperty, MapProperty, ReferenceProperty, VectorProperty, BinaryProperty, isManyToMany, type ResolvedManyToMany, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, hasForeignKeyOnTarget } from "@rebasepro/types";
 import { getPrimaryKeys } from "../services/collection-helpers";
-import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig } from "@rebasepro/common";
+import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 import { logger } from "@rebasepro/server";
 // --- Helper Functions ---
@@ -98,9 +98,13 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             } else if (stringProp.columnType === "uuid") {
                 columnDefinition = `uuid("${colName}")`;
             } else if (stringProp.columnType === "char") {
-                columnDefinition = `char("${colName}")`;
+                columnDefinition = `char("${colName}", { length: ${resolveStringColumnLength(stringProp)} })`;
             } else if (stringProp.columnType === "varchar") {
-                columnDefinition = `varchar("${colName}")`;
+                // The length is not optional decoration: `varchar("col")` with
+                // no length is an UNBOUNDED varchar in Postgres, which is what
+                // this emitted while the DDL generator emitted VARCHAR(255) for
+                // the very same property.
+                columnDefinition = `varchar("${colName}", { length: ${resolveStringColumnLength(stringProp)} })`;
             } else {
                 // `text` is the default, and the only length-unbounded choice.
                 // Ask for `varchar` explicitly if you want the length constraint.
@@ -133,6 +137,25 @@ const getDrizzleColumn = (propName: string, prop: Property, collection: Collecti
             let baseType = (numProp.validation?.integer || isId) ? `integer("${colName}")` : `numeric("${colName}")`;
             if (numProp.columnType) {
                 if (numProp.columnType === "double precision") baseType = `doublePrecision("${colName}")`;
+                // `bigint` and `bigserial` are the only pg-core builders that
+                // *require* a config argument: without `mode`, drizzle cannot
+                // know whether to hand back a `number` or a `bigint`, and the
+                // emitted call does not typecheck.
+                //
+                // This is why `schema.generated.ts` drifted. Regenerating it
+                // produced a file that would not compile, so the bigint lines
+                // were hand-patched — and every regeneration after that looked
+                // like a large, alarming diff nobody wanted to ship. The file
+                // then sat stale for long enough that a security fix to two RLS
+                // policies never reached production.
+                //
+                // `number` rather than `bigint`: these are counters and byte
+                // totals that every caller already treats as numbers, and
+                // switching the runtime type would be a breaking change to
+                // every consumer of the generated schema.
+                else if (numProp.columnType === "bigint" || numProp.columnType === "bigserial") {
+                    baseType = `${numProp.columnType}("${colName}", { mode: "number" })`;
+                }
                 else baseType = `${numProp.columnType}("${colName}")`;
             }
 
@@ -547,8 +570,15 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
         const tableVarName = getTableVarName(tableName);
         if (isJunction && relation && sourceCollection && isManyToMany(relation)) {
             const targetCollection = relation.target();
-            const schema = (isPostgresCollectionConfig(targetCollection) ? targetCollection.schema : undefined) || (isPostgresCollectionConfig(sourceCollection) ? sourceCollection.schema : undefined);
-            const tableCreator = schema ? `${schema}Schema.table` : "pgTable";
+            // Junctions live in `public`, full stop — `resolveJunctionSpecs`
+            // hardcodes that, so it is where `planJunctionTables` CREATEs them
+            // and where the derived RLS policies are applied. Inheriting the
+            // endpoint's schema here (as this used to) put the junction of any
+            // m2m onto `users` in `rebase`, while its policies were still
+            // created against `public.<junction>` — RLS enabled on one table,
+            // rows written to another. The three generators have to agree, and
+            // the other two already did.
+            const tableCreator = "pgTable";
             const baseTableName = tableName.includes(".") ? tableName.split(".").pop()! : tableName;
             const {
                 sourceColumn,
@@ -774,8 +804,14 @@ export const generateSchema = async (collections: CollectionConfig[], stripPolic
                                     // name (e.g. "client_id") may differ from the property key
                                     // (e.g. "clientId") when `columnName` is set.
                                     const drizzleFieldKey = resolvePropertyKeyForColumn(collection, otherRel.foreignKeyOnTarget);
+                                    // The column the far side points at: its
+                                    // primary key, unless the link names another
+                                    // one with `sourceKey`.
+                                    const referencedKey = otherRel.sourceKey
+                                        ? resolvePropertyKeyForColumn(otherCollection, otherRel.sourceKey)
+                                        : getPrimaryKeyName(otherCollection);
                                     const synthKey = `_synth_${otherTableVar}_${drizzleFieldKey}`;
-                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${getPrimaryKeyName(otherCollection)}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
+                                    tableRelations.push(`    "${synthKey}": one(${otherTableVar}, {\n        fields: [${tableVarName}.${drizzleFieldKey}],\n        references: [${otherTableVar}.${referencedKey}],\n        relationName: \"${drizzleRelationName}\"\n    })`);
                                     emittedRelationNames.add(deduplicationKey);
                                 }
                             }