@rebasepro/server-postgres 0.12.1-canary.gcfa333c → 0.12.1-canary.gddbd489

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

@@ -27,12 +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,
     planRelationalColumns,
-    planJunctionTables
+    planJunctionTables,
+    quoteSqlLiteral
 } from "./generate-postgres-ddl-logic";
 
 /**
@@ -75,7 +77,7 @@ export interface ExistingSchema {
 }
 
 export interface EnsureAction {
-    kind: "create-enum" | "create-table" | "add-column" | "add-constraint";
+    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;
@@ -85,6 +87,27 @@ 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 {
@@ -136,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.
  *
@@ -165,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(", ")});`
             });
         }
     }
@@ -218,6 +236,41 @@ export function planCollectionSchemaEnsure(
     }
 
     // 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,
@@ -261,14 +314,17 @@ export function planCollectionSchemaEnsure(
         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);
         }
     }
 
     // 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(
-            `${relational.schema}.${relational.table}`,
+            relKey,
             relational.schema,
             relational.table,
             relational.column,
@@ -297,7 +353,7 @@ export function planCollectionSchemaEnsure(
         });
     }
 
-    return { actions, statements: actions.map(a => a.sql) };
+    return { actions, statements: actions.map(a => a.sql), legacyForeignKeys };
 }
 
 /** Read what the database has, for the schemas the collections live in. */
@@ -386,6 +442,21 @@ export async function ensureCollectionTables(
     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, failures };

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

@@ -137,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}")`;
             }
 
@@ -551,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,
@@ -778,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);
                                 }
                             }

package/src/schema/generate-postgres-ddl-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 } from "@rebasepro/types";
 import { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength } from "@rebasepro/common";
-import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
+import { toSnakeCase, getPolicyNamesForRule, generateForeignKeyName, legacyForeignKeyName } from "@rebasepro/utils";
 
 // --- Helper Functions ---
 
@@ -116,6 +116,16 @@ const generateSinglePolicyStatements = (collection: CollectionConfig, rule: Secu
     return [drop, create];
 };
 
+/**
+ * Single-quote escaping for a SQL string literal (PostgreSQL doubles the
+ * quote). Enum labels come straight from user-authored collection config, so a
+ * label like `it's` closes the literal early and the whole generated file stops
+ * parsing at the `CREATE TYPE`. Lives here rather than next to its other caller
+ * because ensure-collection-tables already imports from this module — the
+ * reverse would be a cycle.
+ */
+export const quoteSqlLiteral = (value: string): string => `'${value.replace(/'/g, "''")}'`;
+
 export const getSqlColumnType = (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]): string => {
     switch (prop.type) {
         case "string": {
@@ -242,6 +252,13 @@ export const generatePostgresDdl = async (
     if (uniqueSchemas.length > 0) ddl += "\n";
 
     // 2. Generate Enums
+    //
+    // The enum type name is derived from table + column, so two collections
+    // mapped onto the same table — or two properties whose `columnName`
+    // resolves to the same column — land on the same name. `CREATE TYPE` has no
+    // IF NOT EXISTS, so emitting it twice aborts the whole file on the second
+    // statement. Dedupe by name, matching planCollectionSchemaEnsure.
+    const emittedEnums = new Set<string>();
     collections.forEach(collection => {
         const collectionTable = getTableName(collection);
         const schema = isPostgresCollectionConfig(collection) && collection.schema ? collection.schema : "public";
@@ -253,8 +270,9 @@ export const generatePostgresDdl = async (
                         String(typeof v === "object" && v !== null && "id" in v ? v.id : v)
                     )
                     : Object.keys(prop.enum);
-                if (values.length > 0) {
-                    ddl += `CREATE TYPE "${schema}"."${enumDbName}" AS ENUM (${values.map(v => `'${v}'`).join(", ")});\n`;
+                if (values.length > 0 && !emittedEnums.has(`${schema}.${enumDbName}`)) {
+                    emittedEnums.add(`${schema}.${enumDbName}`);
+                    ddl += `CREATE TYPE "${schema}"."${enumDbName}" AS ENUM (${values.map(quoteSqlLiteral).join(", ")});\n`;
                 }
             }
         });
@@ -530,6 +548,15 @@ export interface RelationalColumnPlan {
     type: string;
     /** Absent when the target collection is not part of this bundle. */
     foreignKey?: ForeignKeyPlan;
+    /**
+     * What this column would have been called before `generateForeignKeyName`
+     * learned to singularize — set only when the two differ and the column name
+     * is the derived default rather than one the author wrote.
+     *
+     * Carried so the boot-time ensure can notice a database provisioned under
+     * the old rule. It is never used to name anything.
+     */
+    legacyColumn?: string;
 }
 
 /** The table behind a many-to-many `through` relation. */
@@ -537,7 +564,7 @@ export interface JunctionTablePlan {
     schema: string;
     /** Bare table name, no schema prefix. */
     table: string;
-    columns: { name: string; type: string }[];
+    columns: { name: string; type: string; legacyName?: string }[];
     /** Both endpoint columns plus the composite primary key. */
     createTable: string;
     foreignKeys: ForeignKeyPlan[];
@@ -613,10 +640,16 @@ export const planRelationalColumns = (collections: CollectionConfig[]): Relation
                 if (!targetCollection) continue;
 
                 const required = prop.validation?.required;
+                // Only a *derived* column name can be affected by the change to
+                // `generateForeignKeyName`; one the author wrote is theirs.
+                const relationName = refProp.relation?.relationName ?? propName;
+                const legacyKey = legacyForeignKeyName(relationName);
+                const derived = relInfo.localKey === generateForeignKeyName(relationName);
                 plans.push({
                     schema,
                     table,
                     column: relInfo.localKey,
+                    legacyColumn: derived && legacyKey !== relInfo.localKey ? legacyKey : undefined,
                     type: getSqlColumnType(propName, prop, collection, collections),
                     foreignKey: foreignKeyPlan({
                         schema,
@@ -675,9 +708,20 @@ export const planJunctionTables = (collections: CollectionConfig[]): JunctionTab
 
     for (const spec of resolveJunctionSpecs(collections).values()) {
         const [source, target] = spec.endpoints;
+        // A junction column's default name is derived from the endpoint
+        // collection's slug — which is normally plural, so this is where the
+        // singularization change actually lands: a `categories` endpoint used
+        // to give `categorie_id` and now gives `category_id`. Recorded, not
+        // used, so boot-ensure can recognise a table built under the old rule.
+        const legacyFor = (endpoint: typeof source): string | undefined => {
+            const slug = toSnakeCase(endpoint.collection.slug ?? endpoint.collection.name ?? "");
+            const legacy = legacyForeignKeyName(slug);
+            const derived = endpoint.junctionColumn === generateForeignKeyName(slug);
+            return derived && legacy !== endpoint.junctionColumn ? legacy : undefined;
+        };
         const columns = [
-            { name: source.junctionColumn, type: junctionKeyType(source.collection) },
-            { name: target.junctionColumn, type: junctionKeyType(target.collection) }
+            { name: source.junctionColumn, type: junctionKeyType(source.collection), legacyName: legacyFor(source) },
+            { name: target.junctionColumn, type: junctionKeyType(target.collection), legacyName: legacyFor(target) }
         ];
         // Every declaring side agrees on the edge's lifetime; the first one wins,
         // as it does in the generator's walk.