@rebasepro/server-postgres 0.13.0 → 0.13.1-canary.g394d868

package/src/collections/validate-relations.ts

@@ -2,6 +2,7 @@ import { getTableColumns } from "drizzle-orm";
 import { PgTable } from "drizzle-orm/pg-core";
 import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations } from "@rebasepro/common";
+import { generateForeignKeyName, legacyForeignKeyName } from "@rebasepro/utils";
 
 import { PostgresCollectionRegistry } from "./PostgresCollectionRegistry";
 
@@ -58,6 +59,68 @@ const quote = (xs: Iterable<string>) => Array.from(xs).map(s => `\`${s}\``).join
 /** `on.from` / `on.to` accept a single column or a composite tuple. */
 const asColumns = (value: string | string[]): string[] => Array.isArray(value) ? value : [value];
 
+/**
+ * Distinguish "this column name is wrong" from "the generated schema is old".
+ *
+ * They present identically here — a relation asks for a column the registered
+ * table does not have — but they are opposite problems with opposite fixes, and
+ * getting them the wrong way round is how the 0.12 → 0.13 upgrade bricked
+ * projects.
+ *
+ * The registered table is not the database. It comes from the project's
+ * checked-in `backend/src/schema.generated.ts`, and 0.13 changed the rule that
+ * derives foreign-key names: `categories` yields `category_id` where it used to
+ * yield `categorie_id`. Boot-ensure renames the database column to match, so by
+ * the time this runs the *database* is correct and the *generated module* is the
+ * stale one. Reporting "not a column" then points at the wrong artifact, and the
+ * generic fix — "set `through.targetColumn` to one of: …", listing the legacy
+ * name because that is what the stale module still has — talks the reader into
+ * pinning a column that no longer exists.
+ *
+ * So when the wanted name is what the current rule derives, and the table
+ * carries what the *previous* rule would have derived from the same source, say
+ * that instead.
+ *
+ * @param wanted   the column the relation asks for
+ * @param available every column the registered table has
+ * @param sources  names the default could have been derived from (a slug, a
+ *                 relation name) — checking against these rather than guessing
+ *                 backwards from `wanted` keeps the match exact
+ */
+function staleCodegenRename(
+    wanted: string,
+    available: Set<string>,
+    sources: string[]
+): { legacy: string; current: string } | null {
+    for (const source of sources) {
+        if (!source) continue;
+        const current = generateForeignKeyName(source);
+        const legacy = legacyForeignKeyName(source);
+        // Only a name that actually moved, and only when the table still has the
+        // old spelling and not the new one.
+        if (current !== wanted || legacy === current) continue;
+        if (available.has(legacy) && !available.has(current)) return { legacy, current };
+    }
+    return null;
+}
+
+/** The shared explanation, so every relation kind reports it identically. */
+function staleCodegenDefect(
+    table: string,
+    { legacy, current }: { legacy: string; current: string }
+): Pick<RelationDefect, "problem" | "fix"> {
+    return {
+        problem:
+            `the generated Drizzle schema still declares \`${legacy}\` on \`${table}\`, but this ` +
+            `release derives \`${current}\` — the generated schema predates the foreign-key ` +
+            "naming fix and no longer describes the database",
+        fix:
+            "regenerate it with `rebase schema generate` (or `pnpm run schema:generate`). The " +
+            "database column has already been renamed for you at boot, so nothing else is needed. " +
+            `To keep \`${legacy}\` instead, name it explicitly on the relation and regenerate.`
+    };
+}
+
 /**
  * Relations whose names do not resolve against the registered schema.
  *
@@ -117,11 +180,20 @@ kind: relation.kind };
             switch (relation.kind) {
                 case "belongsTo": {
                     if (!sourceColumns.has(relation.localKey)) {
-                        defects.push({
-                            ...at,
-                            problem: `\`localKey: "${relation.localKey}"\` is not a column on \`${sourceTableName}\``,
-                            fix: `add the column, or set \`localKey\` to one of: ${quote(sourceColumns)}`
-                        });
+                        // `localKey` defaults to the relation name run through
+                        // the foreign-key rule, so it moves with that rule.
+                        const stale = staleCodegenRename(
+                            relation.localKey,
+                            sourceColumns,
+                            [relation.relationName, targetCollection.slug]
+                        );
+                        defects.push(stale
+                            ? { ...at, ...staleCodegenDefect(sourceTableName, stale) }
+                            : {
+                                ...at,
+                                problem: `\`localKey: "${relation.localKey}"\` is not a column on \`${sourceTableName}\``,
+                                fix: `add the column, or set \`localKey\` to one of: ${quote(sourceColumns)}`
+                            });
                     }
                     break;
                 }
@@ -129,11 +201,20 @@ kind: relation.kind };
                 case "hasOne":
                 case "hasMany": {
                     if (!targetColumns.has(relation.foreignKeyOnTarget)) {
-                        defects.push({
-                            ...at,
-                            problem: `\`foreignKeyOnTarget: "${relation.foreignKeyOnTarget}"\` is not a column on the target table \`${targetTableName}\``,
-                            fix: `add the column, or set \`foreignKeyOnTarget\` to one of: ${quote(targetColumns)}`
-                        });
+                        // The default is derived from *this* collection's slug —
+                        // the column on the target that points back here.
+                        const stale = staleCodegenRename(
+                            relation.foreignKeyOnTarget,
+                            targetColumns,
+                            [collection.slug]
+                        );
+                        defects.push(stale
+                            ? { ...at, ...staleCodegenDefect(targetTableName, stale) }
+                            : {
+                                ...at,
+                                problem: `\`foreignKeyOnTarget: "${relation.foreignKeyOnTarget}"\` is not a column on the target table \`${targetTableName}\``,
+                                fix: `add the column, or set \`foreignKeyOnTarget\` to one of: ${quote(targetColumns)}`
+                            });
                     }
                     // `sourceKey` is the easiest of the two to put on the wrong
                     // side — it is the only column in a `hasMany` that lives
@@ -167,14 +248,24 @@ kind: relation.kind };
                         break;
                     }
                     const junctionColumns = columnNames(junction);
+                    // Junction columns are the ones that actually moved in 0.13:
+                    // each defaults to its endpoint collection's *slug* run
+                    // through the foreign-key rule, and slugs are plural.
+                    const derivedFrom = {
+                        sourceColumn: [collection.slug],
+                        targetColumn: [targetCollection.slug]
+                    } as const;
                     for (const [label, column] of [["sourceColumn", sourceColumn], ["targetColumn", targetColumn]] as const) {
                         if (!junctionColumns.has(column)) {
-                            defects.push({
-                                ...at,
-                                problem: `\`through.${label}: "${column}"\` is not a column on the junction table \`${table}\``,
-                                fix: `set \`through.${label}\` to one of: ${quote(junctionColumns)}` +
-                                    (label === "sourceColumn" ? " — it is the column naming *this* collection" : "")
-                            });
+                            const stale = staleCodegenRename(column, junctionColumns, [...derivedFrom[label]]);
+                            defects.push(stale
+                                ? { ...at, ...staleCodegenDefect(table, stale) }
+                                : {
+                                    ...at,
+                                    problem: `\`through.${label}: "${column}"\` is not a column on the junction table \`${table}\``,
+                                    fix: `set \`through.${label}\` to one of: ${quote(junctionColumns)}` +
+                                        (label === "sourceColumn" ? " — it is the column naming *this* collection" : "")
+                                });
                         }
                     }
                     break;
@@ -287,9 +378,25 @@ export function assertRelationsResolve(
     );
 
     throw new Error(
-        `${defects.length} relation${defects.length === 1 ? "" : "s"} cannot resolve against the database schema.\n\n` +
+        `${defects.length} relation${defects.length === 1 ? "" : "s"} cannot resolve against ` +
+        "`backend/src/schema.generated.ts`.\n\n" +
         "Each of these would return no rows at query time rather than reporting an error, " +
         "so they are fatal at boot instead.\n\n" +
+        // This reads the *generated file*, not the database, and the difference
+        // is the whole diagnosis after an upgrade. Boot-ensure renames columns
+        // in the database — a 0.12 → 0.13 upgrade singularises a junction key,
+        // `categorie_id` → `category_id` — and the checked-in file still
+        // declares the old name. The config is then correct and the file is
+        // stale, so the per-defect advice below, which lists the columns this
+        // file has, names a column that no longer exists in the database.
+        // Following it turns a recoverable state into a broken config.
+        //
+        // Hence the ordering: regenerate first, and only then consider that the
+        // collection might be the thing that is wrong.
+        "If the database was migrated recently — an upgrade, a `db push`, a restore — this file is\n" +
+        "probably older than the schema it describes. Regenerate it before changing anything else:\n\n" +
+        "    rebase schema generate\n\n" +
+        "If it is already current, then the collection is what disagrees with it:\n\n" +
         lines.join("\n\n") + "\n"
     );
 }

package/src/data-transformer.ts

@@ -3,6 +3,7 @@ import { AnyPgColumn } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { CollectionConfig, Properties, Property, ResolvedRelation, RelationProperty, Vector, BinaryProperty, hasForeignKeyOnTarget, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, type ResolvedVia } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations, findRelation, createRelationRef, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "@rebasepro/common";
+import { isPrototypePollutingKey } from "@rebasepro/utils";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
 import { getPrimaryKeys, buildCompositeId } from "./services/collection-helpers";
@@ -68,9 +69,15 @@ export function sanitizeAndConvertDates(obj: unknown): unknown {
     if (typeof obj === "object") {
         const newObj: Record<string, unknown> = {};
         for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                newObj[key] = sanitizeAndConvertDates((obj as Record<string, unknown>)[key]);
-            }
+            if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+            // `JSON.parse` creates `__proto__` as an *own* property, so it gets
+            // past the check above — and `newObj[key] = …` then invokes the
+            // prototype setter instead of creating a property. The row's
+            // prototype becomes whatever the request body supplied, so
+            // `row.isAdmin` answers `true` while `Object.keys(row)` shows
+            // nothing of the sort. No column can be reached by these names.
+            if (isPrototypePollutingKey(key)) continue;
+            newObj[key] = sanitizeAndConvertDates((obj as Record<string, unknown>)[key]);
         }
         return newObj;
     }
@@ -126,6 +133,9 @@ joinPathRelationUpdates: [] };
     });
 
     for (const [key, value] of Object.entries(row)) {
+        // Same reasoning as `sanitizeAndConvertDates`: these keys come from the
+        // request body, and no column answers to them.
+        if (isPrototypePollutingKey(key)) continue;
         const property = properties[key as keyof M] as Property;
 
         // Coerce empty strings to null for any field that acts as a foreign key

package/src/schema/doctor.ts

@@ -15,7 +15,7 @@ import chalk from "chalk";
 import { CollectionConfig, isPostgresCollectionConfig, Property, NumberProperty, StringProperty, DateProperty, ArrayProperty, MapProperty, RelationProperty, type ResolvedManyToMany, type ResolvedBelongsTo, isManyToMany } from "@rebasepro/types";
 import { generateSchema } from "./generate-drizzle-schema-logic";
 import { generateTypedefs } from "@rebasepro/codegen";
-import { getTableName, resolveCollectionRelations, findRelation } from "@rebasepro/common";
+import { getTableName, resolveCollectionRelations, findRelation, relationalCollections } from "@rebasepro/common";
 import { toSnakeCase } from "@rebasepro/utils";
 import { logger, loadCollectionsFromDirectory } from "@rebasepro/server";
 
@@ -164,8 +164,10 @@ export async function checkCollectionsVsSchema(
 issues };
     }
 
-    // Re-generate schema in-memory and compare with file on disk
-    const postgresCollections = collections.filter(isPostgresCollectionConfig);
+    // Re-generate schema in-memory and compare with file on disk. Only the
+    // collections the generator itself will emit — a Firestore collection has
+    // no table in the generated file and must not be reported as missing one.
+    const postgresCollections = relationalCollections(collections);
     if (postgresCollections.length === 0) {
         return { passed: true,
 issues };
@@ -292,7 +294,7 @@ export async function checkCollectionsVsDatabase(
     const schemas = Array.from(new Set([
         "public",
         "rebase",
-        ...collections
+        ...relationalCollections(collections)
             .filter(isPostgresCollectionConfig)
             .map(c => c.schema)
             .filter((s): s is string => !!s)
@@ -383,7 +385,7 @@ export async function checkCollectionsVsDatabase(
 
         // ── Compare each collection against the database ─────────────────
 
-        const postgresCollections = collections.filter(isPostgresCollectionConfig);
+        const postgresCollections = relationalCollections(collections);
 
         for (const collection of postgresCollections) {
             const tableName = getTableName(collection);

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

@@ -26,7 +26,7 @@
  * no-op.
  */
 import { type CollectionConfig, type Property, isPostgresCollectionConfig } from "@rebasepro/types";
-import { getTableName } from "@rebasepro/common";
+import { getTableName, relationalCollections } from "@rebasepro/common";
 import { logger } from "@rebasepro/server";
 import {
     getSqlColumnType,
@@ -167,9 +167,15 @@ function requiredEnums(collection: CollectionConfig): { name: string; values: st
  * table may be the target of a relation), and nothing is emitted twice.
  */
 export function planCollectionSchemaEnsure(
-    collections: CollectionConfig[],
+    allCollections: CollectionConfig[],
     existing: ExistingSchema
 ): EnsurePlan {
+    // 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
+    // documents from Firestore while an empty table with the same name accretes
+    // policies and shows up in every drift report.
+    const collections = relationalCollections(allCollections);
     const actions: EnsureAction[] = [];
     const plannedEnums = new Set<string>();
 

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, resolveStringColumnLength } from "@rebasepro/common";
+import { getEnumVarName, getTableName, getTableVarName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength, relationalCollections } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule } from "@rebasepro/utils";
 import { logger } from "@rebasepro/server";
 // --- Helper Functions ---
@@ -451,7 +451,13 @@ const computeSharedRelationName = (
 };
 
 // --- Main Schema Generation Logic ---
-export const generateSchema = async (collections: CollectionConfig[], stripPolicies = false): Promise<string> => {
+export const generateSchema = async (allCollections: CollectionConfig[], stripPolicies = false): Promise<string> => {
+    // A Firestore or MongoDB collection has no table to generate, and generating
+    // one for it is not merely wasted output: `db push` would create it, and
+    // `rebase doctor` would then report the store the collection actually reads
+    // from as drift. Non-SQL collections leave the toolchain here, once, rather
+    // than being filtered again in each stage below.
+    const collections = relationalCollections(allCollections);
     let schemaContent = "// This file is auto-generated by the Rebase Drizzle generator. Do not edit manually.\n\n";
 
 

package/src/schema/generate-postgres-ddl-logic.ts

@@ -1,5 +1,5 @@
 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 { getEnumVarName, getTableName, resolveCollectionRelations, findRelation, securityRuleToConditions, policyToPostgres, getEffectiveSecurityRules, getInjectedSecurityRules, resolveJunctionSpecs, getJunctionSecurityRules, getJunctionCollectionConfig, resolveStringColumnLength, relationalCollections } from "@rebasepro/common";
 import { toSnakeCase, getPolicyNamesForRule, generateForeignKeyName, legacyForeignKeyName } from "@rebasepro/utils";
 
 // --- Helper Functions ---
@@ -236,9 +236,11 @@ export const getSqlColumnType = (propName: string, prop: Property, collection: C
 };
 
 export const generatePostgresDdl = async (
-    collections: CollectionConfig[],
+    allCollections: CollectionConfig[],
     options: { includePolicies?: boolean } = { includePolicies: true }
 ): Promise<string> => {
+    // Only the collections this engine stores. See `relationalCollections`.
+    const collections = relationalCollections(allCollections);
     let ddl = "-- This file is auto-generated by the Rebase DDL generator. Do not edit manually.\n\n";
 
     // 1. Create custom schemas
@@ -355,8 +357,8 @@ export const generatePostgresDdl = async (
             ddl += `  PRIMARY KEY ("${sourceColumn}", "${targetColumn}")\n`;
             ddl += `);\n\n`;
 
-            fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${baseTableName}_${sourceColumn}_fkey" FOREIGN KEY ("${sourceColumn}") REFERENCES "${sourceSchema}"."${sourceTable}" ("${sourceId}") ON DELETE ${onDelete.toUpperCase()};`);
-            fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${baseTableName}_${targetColumn}_fkey" FOREIGN KEY ("${targetColumn}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
+            fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${sourceColumn}_fkey`)}" FOREIGN KEY ("${sourceColumn}") REFERENCES "${sourceSchema}"."${sourceTable}" ("${sourceId}") ON DELETE ${onDelete.toUpperCase()};`);
+            fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${targetColumn}_fkey`)}" FOREIGN KEY ("${targetColumn}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
 
             if (options.includePolicies) {
                 // Junction tables are generated tables like any other: locked by
@@ -414,7 +416,7 @@ export const generatePostgresDdl = async (
                     if (required) colDef += " NOT NULL";
                     columns.push(colDef);
 
-                    fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${baseTableName}_${relInfo.localKey}_fkey" FOREIGN KEY ("${relInfo.localKey}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDeleteVal.toUpperCase()}${onUpdate};`);
+                    fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${relInfo.localKey}_fkey`)}" FOREIGN KEY ("${relInfo.localKey}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDeleteVal.toUpperCase()}${onUpdate};`);
                 } else if (prop.type === "reference") {
                     const refProp = prop as ReferenceProperty;
                     const targetCollection = collections.find(c => c.slug === refProp.path || getTableName(c) === refProp.path);
@@ -436,7 +438,7 @@ export const generatePostgresDdl = async (
                         if (required) colDef += " NOT NULL";
                         columns.push(colDef);
 
-                        fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${baseTableName}_${colName}_fkey" FOREIGN KEY ("${colName}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
+                        fkStatements.push(`ALTER TABLE "${schema}"."${baseTableName}" ADD CONSTRAINT "${toPostgresIdentifier(`${baseTableName}_${colName}_fkey`)}" FOREIGN KEY ("${colName}") REFERENCES "${targetSchema}"."${targetTable}" ("${targetId}") ON DELETE ${onDelete.toUpperCase()};`);
                     }
                 } else {
                     const colName = resolveColumnName(propName, prop);
@@ -575,10 +577,35 @@ const schemaOfCollection = (collection: CollectionConfig): string =>
 
 const bareTableName = (name: string): string => (name.includes(".") ? name.split(".").pop()! : name);
 
+/**
+ * Truncate a derived identifier the way Postgres does: to 63 bytes, silently.
+ *
+ * This is not cosmetic, and not really a naming choice at all — it is agreeing
+ * with the name the database ALREADY stored. `ADD CONSTRAINT` on a longer name
+ * succeeds and records the truncated form, so the untruncated name this used to
+ * derive matched nothing in the catalogue. Boot-ensure compares its planned
+ * constraints against `readExistingSchema`, which reads catalogue names, so the
+ * comparison could never hit: every boot re-issued `ADD CONSTRAINT` for the same
+ * constraint, forever, and got "already exists" every time. Non-fatal (foreign
+ * keys are the one action allowed to fail) and therefore permanent — an error in
+ * the log on every restart of a project whose table and column names happened to
+ * be long.
+ *
+ * Byte length, not string length: NAMEDATALEN is 64 bytes, and a multi-byte
+ * character straddling the boundary would be cut mid-sequence by `slice(0, 63)`.
+ */
+const toPostgresIdentifier = (name: string): string => {
+    const bytes = Buffer.from(name, "utf8");
+    if (bytes.byteLength <= 63) return name;
+    // `toString` on a slice that ends mid-character yields U+FFFD; dropping it
+    // lands on the last whole character that fits, which is what Postgres does.
+    return bytes.subarray(0, 63).toString("utf8").replace(/�+$/, "");
+};
+
 const foreignKeyPlan = (
     args: Omit<ForeignKeyPlan, "constraintName" | "sql"> & { onDelete: string; onUpdate?: string }
 ): ForeignKeyPlan => {
-    const constraintName = `${args.table}_${args.column}_fkey`;
+    const constraintName = toPostgresIdentifier(`${args.table}_${args.column}_fkey`);
     const onUpdate = args.onUpdate ? ` ON UPDATE ${args.onUpdate.toUpperCase()}` : "";
     return {
         constraintName,
@@ -610,7 +637,8 @@ const foreignKeyPlan = (
  * is unknown yields the column without a constraint. Both mirror the generator
  * exactly — a divergence here is a schema fork between boot and `db push`.
  */
-export const planRelationalColumns = (collections: CollectionConfig[]): RelationalColumnPlan[] => {
+export const planRelationalColumns = (allCollections: CollectionConfig[]): RelationalColumnPlan[] => {
+    const collections = relationalCollections(allCollections);
     const plans: RelationalColumnPlan[] = [];
 
     for (const collection of collections) {
@@ -703,7 +731,8 @@ export const planRelationalColumns = (collections: CollectionConfig[]): Relation
  * junction with row-level security left off is readable and writable by every
  * signed-in user, which is why the two must ship together.
  */
-export const planJunctionTables = (collections: CollectionConfig[]): JunctionTablePlan[] => {
+export const planJunctionTables = (allCollections: CollectionConfig[]): JunctionTablePlan[] => {
+    const collections = relationalCollections(allCollections);
     const plans: JunctionTablePlan[] = [];
 
     for (const spec of resolveJunctionSpecs(collections).values()) {
@@ -780,7 +809,10 @@ export interface CollectionPolicyPlan {
  * writable by every signed-in user. A junction whose table is still absent is
  * skipped by the applier, not planned away here.
  */
-export const planCollectionPolicies = (collections: CollectionConfig[]): CollectionPolicyPlan[] => {
+export const planCollectionPolicies = (allCollections: CollectionConfig[]): CollectionPolicyPlan[] => {
+    // A store with no RLS gets no policies planned for it — `supportsRLS` is
+    // false for exactly the engines `relationalCollections` filters out.
+    const collections = relationalCollections(allCollections);
     const resolveCollection: ResolveCollection = (slug) => collections.find(c => c.slug === slug || getTableName(c) === slug);
     const plans: CollectionPolicyPlan[] = [];
     const seen = new Set<string>();
@@ -833,7 +865,11 @@ export const planCollectionPolicies = (collections: CollectionConfig[]): Collect
     return plans;
 };
 
-export const generatePostgresPoliciesDdl = (collections: CollectionConfig[]): string => {
+export const generatePostgresPoliciesDdl = (allCollections: CollectionConfig[]): string => {
+    // Also the expectation `checkPolicyDrift` reconciles the database against,
+    // so a non-SQL collection filtered out here is one the drift report cannot
+    // invent a missing policy for.
+    const collections = relationalCollections(allCollections);
     let ddl = "-- This file contains RLS policies generated by Rebase. Applied separately from migrations.\n\n";
 
     const allTablesToGenerate = new Map<string, {

package/src/schema/generated-schema-staleness.ts

@@ -0,0 +1,169 @@
+import { CollectionConfig } from "@rebasepro/types";
+import { getTableName, resolveCollectionRelations, relationalCollections } from "@rebasepro/common";
+import { generateForeignKeyName, legacyForeignKeyName } from "@rebasepro/utils";
+
+/**
+ * Notice a generated Drizzle schema that a *library upgrade* invalidated.
+ *
+ * `rebase dev` already watches `config/collections` and warns when a collection
+ * file changes. That covers drift the developer caused. It cannot cover this one,
+ * because nothing the developer owns changed: 0.13 derives `category_id` where
+ * 0.12 derived `categorie_id`, from the same unedited collection. The watcher
+ * never fires, and `backend/src/schema.generated.ts` quietly stops describing the
+ * schema the runtime expects.
+ *
+ * The consequence is not cosmetic. Boot-ensure renames the column in the
+ * database, then relation validation reads the stale module and refuses to
+ * start — on that boot and every boot after it, because the rename is already
+ * applied and will not be attempted again.
+ *
+ * Deliberately narrow: this answers "does the generated schema name a foreign key
+ * the way the previous rule did", not "is this file what we would generate now".
+ * The wide question would report every whitespace change in the generator as a
+ * fatal staleness, and a check that cries wolf gets switched off.
+ */
+
+/** One column the generated schema names under the pre-0.13 rule. */
+export interface LegacyForeignKeyName {
+    /** Table whose column declaration is stale. */
+    table: string;
+    /** The name the generated schema declares. */
+    legacy: string;
+    /** The name this release derives, and which the database now carries. */
+    current: string;
+    /** `<collection>.<relation>` that derives it, for the message. */
+    relation: string;
+}
+
+/**
+ * The slice of the generated source declaring one table.
+ *
+ * Scoping matters: two junctions in one file can carry columns of the same name,
+ * and a whole-file match would attribute a stale column to whichever table the
+ * reader looks at first. Returns "" when the table is not in the file at all,
+ * which is not staleness — it is a table the generator has not been asked about.
+ */
+function tableBlock(source: string, table: string): string {
+    const start = source.indexOf(`pgTable("${table}"`);
+    if (start === -1) return "";
+    // Generated files put every table in its own `export const`, so the next one
+    // is the end of this block. No brace counting, nothing to get wrong.
+    const next = source.indexOf("\nexport ", start);
+    return next === -1 ? source.slice(start) : source.slice(start, next);
+}
+
+/**
+ * Whether a block *declares* the column, rather than merely mentioning it.
+ *
+ * A comment explaining the rename, or a policy expression naming the old column,
+ * must not read as a declaration — otherwise regenerating the file would not
+ * clear the finding and the check would be permanently red.
+ */
+function declaresColumn(block: string, column: string): boolean {
+    // `categorie_id: integer("categorie_id")` — the Drizzle column shape. The key
+    // and the string argument agree in generated output, so requiring both is
+    // both precise and cheap.
+    const key = column.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[\\s,{])${key}\\s*:\\s*\\w+\\(\\s*["']${key}["']`, "m").test(block);
+}
+
+/**
+ * @param generatedSource contents of `backend/src/schema.generated.ts`
+ * @param collections     the project's collections, as this release reads them
+ */
+export function findLegacyForeignKeyNames(
+    generatedSource: string,
+    collections: CollectionConfig[]
+): LegacyForeignKeyName[] {
+    const found: LegacyForeignKeyName[] = [];
+    const seen = new Set<string>();
+
+    /**
+     * Report `wanted` as stale when the generated schema declares what the
+     * previous rule would have derived from `source` instead.
+     *
+     * The `wanted !== current` guard is what honours an explicitly named column.
+     * An author who pinned `categorie_id` has said so on the relation, so the
+     * generated file agreeing with them is correct, not stale — and the rename
+     * note documents exactly that opt-out.
+     */
+    const consider = (
+        table: string,
+        wanted: string,
+        sourceName: string | undefined,
+        relation: string
+    ): void => {
+        if (!table || !wanted || !sourceName) return;
+
+        const current = generateForeignKeyName(sourceName);
+        const legacy = legacyForeignKeyName(sourceName);
+        if (legacy === current) return;   // this name never moved
+        if (wanted !== current) return;   // pinned by the author, or unrelated
+
+        const block = tableBlock(generatedSource, table);
+        if (!block) return;
+        if (!declaresColumn(block, legacy)) return;
+        if (declaresColumn(block, current)) return;   // already regenerated
+
+        const key = `${table}.${legacy}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        found.push({ table, legacy, current, relation });
+    };
+
+    // Same rule as the generator whose output this reads: a collection that
+    // gets no table cannot have named a column in it. Inert in practice today —
+    // the finding also requires the generated file to declare the table — but
+    // the guard is what keeps that true when a non-SQL collection's slug happens
+    // to match a SQL one's table.
+    for (const collection of relationalCollections(collections)) {
+        const sourceTable = getTableName(collection);
+
+        for (const [name, relation] of Object.entries(resolveCollectionRelations(collection))) {
+            const at = `${collection.slug}.${name}`;
+
+            let target: CollectionConfig | undefined;
+            try {
+                target = relation.target?.();
+            } catch {
+                // A throwing target thunk is its own defect, reported at boot by
+                // `validate-relations`. Nothing to say about its column names.
+                continue;
+            }
+
+            switch (relation.kind) {
+                case "belongsTo":
+                    consider(sourceTable, relation.localKey, relation.relationName, at);
+                    break;
+
+                case "hasOne":
+                case "hasMany":
+                    if (target) {
+                        consider(getTableName(target), relation.foreignKeyOnTarget, collection.slug, at);
+                    }
+                    break;
+
+                case "manyToMany":
+                    consider(relation.through.table, relation.through.sourceColumn, collection.slug, at);
+                    if (target) {
+                        consider(relation.through.table, relation.through.targetColumn, target.slug, at);
+                    }
+                    break;
+
+                default:
+                    // `via` joins are written by hand — there is no derived name
+                    // for the rule change to have moved.
+                    break;
+            }
+        }
+    }
+
+    return found;
+}
+
+/** One-line summary for a log or a CLI notice. */
+export function describeLegacyForeignKeyNames(found: LegacyForeignKeyName[]): string {
+    return found
+        .map(f => `  • ${f.table}.${f.legacy} → ${f.current}  (${f.relation})`)
+        .join("\n");
+}

package/src/schema/introspect-db-logic.ts

@@ -1089,7 +1089,7 @@ export function generateCollectionFile(
 
         if (derivedFacts) {
             const titleProperty = deriveTitleProperty(derivedFacts);
-            if (titleProperty) adminEntries.push(`titleProperty: ${quote(titleProperty)}`);
+            if (titleProperty) adminEntries.push(`display: { title: ${quote(titleProperty)} }`);
 
             const kanbanProperty = deriveKanbanProperty(derivedFacts);
             if (kanbanProperty) adminEntries.push(`kanban: {\n            columnProperty: ${quote(kanbanProperty)}\n        }`);