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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.13.0",
+  "version": "0.13.1-canary.gcd6689e",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -47,11 +47,11 @@
     "execa": "^9.6.1",
     "pg": "^8.22.0",
     "ws": "^8.21.1",
-    "@rebasepro/codegen": "0.13.0",
-    "@rebasepro/common": "0.13.0",
-    "@rebasepro/types": "0.13.0",
-    "@rebasepro/server": "0.13.0",
-    "@rebasepro/utils": "0.13.0"
+    "@rebasepro/codegen": "0.13.1-canary.gcd6689e",
+    "@rebasepro/common": "0.13.1-canary.gcd6689e",
+    "@rebasepro/types": "0.13.1-canary.gcd6689e",
+    "@rebasepro/utils": "0.13.1-canary.gcd6689e",
+    "@rebasepro/server": "0.13.1-canary.gcd6689e"
   },
   "devDependencies": {
     "@hono/node-server": "^2.0.12",

package/src/cli.ts

@@ -828,7 +828,86 @@ async function generatePostgresDdlCommand(rawArgs: string[]): Promise<void> {
     }
 }
 
+/**
+ * `schema stale [--fix]` — is the generated Drizzle schema older than the rule
+ * that derives its foreign-key names?
+ *
+ * This exists for one upgrade path and is worth the command. 0.13 derives
+ * `category_id` where 0.12 derived `categorie_id`; boot-ensure renames the
+ * database column to match, and the project's checked-in
+ * `backend/src/schema.generated.ts` is then wrong in a way nothing the developer
+ * did would explain. Relation validation refuses to boot on it, permanently,
+ * because the rename has already been applied and will not run again.
+ *
+ * `rebase dev` calls this with `--fix` before starting the backend, so the
+ * upgrade behaves the way the release note says it does: the column moves and the
+ * project keeps working. Without `--fix` it reports and exits non-zero, which is
+ * what a build or a CI step wants.
+ */
+async function schemaStaleCommand(rawArgs: string[]): Promise<void> {
+    const argsList = arg(
+        {
+            "--collections": String,
+            "--output": String,
+            "--fix": Boolean,
+            "-c": "--collections",
+            "-o": "--output"
+        },
+        { argv: rawArgs.slice(2), permissive: true }
+    );
+
+    const collectionsPath = argsList["--collections"] || path.join("..", "config", "collections");
+    const outputPath = argsList["--output"] || path.join("src", "schema.generated.ts");
+    const schemaFile = path.resolve(process.cwd(), outputPath);
+
+    // No generated schema yet is not staleness — a fresh project has not run the
+    // generator, and saying "stale" about a file that does not exist would send
+    // the reader looking for something to fix.
+    if (!fs.existsSync(schemaFile)) return;
+
+    const { loadCollections } = await import("./schema/doctor");
+    const { findLegacyForeignKeyNames, describeLegacyForeignKeyNames } =
+        await import("./schema/generated-schema-staleness");
+
+    let stale;
+    try {
+        const collections = await loadCollections(path.resolve(process.cwd(), collectionsPath));
+        stale = findLegacyForeignKeyNames(fs.readFileSync(schemaFile, "utf8"), collections);
+    } catch (err) {
+        // Best-effort by design: a collections directory that will not load is a
+        // real error, but it is one the boot reports far better than this does.
+        logger.debug(`schema stale: skipped (${err instanceof Error ? err.message : String(err)})`);
+        return;
+    }
+
+    if (stale.length === 0) return;
+
+    logger.info("");
+    logger.warn(chalk.yellow(
+        `  ⚠️  ${outputPath} names ${stale.length} foreign key(s) the way an earlier release did:`
+    ));
+    logger.info(chalk.gray(describeLegacyForeignKeyNames(stale)));
+    logger.info("");
+
+    if (!argsList["--fix"]) {
+        logger.error(chalk.red(
+            "  The database column has already been renamed at boot, so the generated schema no " +
+            "longer matches it and the server will refuse to start."
+        ));
+        logger.error(chalk.red("  Run `rebase schema generate` to regenerate it."));
+        process.exit(1);
+    }
+
+    logger.info(chalk.gray("  Regenerating the Drizzle schema so it matches..."));
+    await schemaCommand("generate", ["schema", "generate", `--collections=${collectionsPath}`, `--output=${outputPath}`]);
+}
+
 async function schemaCommand(subcommand: string, rawArgs: string[]): Promise<void> {
+    if (subcommand === "stale") {
+        await schemaStaleCommand(rawArgs);
+        return;
+    }
+
     if (subcommand === "generate") {
         const argsList = arg(
             {

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;

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

@@ -0,0 +1,164 @@
+import { CollectionConfig } from "@rebasepro/types";
+import { getTableName, resolveCollectionRelations } 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 });
+    };
+
+    for (const collection of 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        }`);

package/src/services/FetchService.ts

@@ -1454,99 +1454,6 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         return !!this.getQueryBuilder(tableName);
     }
 
-    /**
-     * Attempt to use Drizzle's relational query API (db.query.<table>.findMany)
-     * for efficient JOIN-based relation loading.
-     * Returns null if the API is not available or the query fails.
-     * Note: Primary path now uses `buildWithConfig` + `buildDrizzleQueryOptions`.
-     */
-    private async fetchWithDrizzleQuery<M extends Record<string, unknown>>(
-        collectionPath: string,
-        collection: CollectionConfig,
-        options: {
-            filter?: FilterValues<Extract<keyof M, string>>;
-            orderBy?: string;
-            order?: "desc" | "asc";
-            limit?: number;
-        },
-        include: string[],
-        idInfo: { fieldName: string; type: "string" | "number" },
-        idInfoArray?: { fieldName: string; type: "string" | "number" }[]
-    ): Promise<Record<string, unknown>[] | null> {
-        try {
-
-            const table = getTableForCollection(collection, this.registry);
-            const tableName = getTableName(table);
-            const queryTarget = this.getQueryBuilder(tableName);
-
-            if (!queryTarget?.findMany) return null;
-
-            // Build the `with` config from include array
-            const resolvedRelations = resolveCollectionRelations(collection);
-            const withConfig: Record<string, boolean> = {};
-            for (const [key, relation] of Object.entries(resolvedRelations)) {
-                if (include[0] === "*" || include.includes(key)) {
-                    // Use the Drizzle relation name (from the schema)
-                    const drizzleRelName = relation.relationName || key;
-                    withConfig[drizzleRelName] = true;
-                }
-            }
-
-            // Build query options
-            const queryOpts: Record<string, unknown> = { with: withConfig };
-            if (options.limit) queryOpts.limit = options.limit;
-
-            // Build where clause
-            if (options.filter) {
-                const filterConditions = this.buildFilterConditions(
-                    options.filter, table, collectionPath
-                );
-                if (filterConditions.length > 0) {
-                    queryOpts.where = and(...filterConditions);
-                }
-            }
-
-            // Build orderBy
-            if (options.orderBy) {
-                const orderByField = this.resolveOrderByField(table, options.orderBy, collection);
-                if (orderByField) {
-                    queryOpts.orderBy = options.order === "asc" ? asc(orderByField) : desc(orderByField);
-                }
-            }
-
-
-            const results = await queryTarget.findMany(queryOpts as Parameters<NonNullable<typeof queryTarget>["findMany"]>[0]);
-
-            // Inline the nested Drizzle results, columns only — no synthesized id.
-            return results.map((row: Record<string, unknown>) => {
-                const flat: Record<string, unknown> = {};
-                for (const [k, v] of Object.entries(row)) {
-                    if (Array.isArray(v)) {
-                        // Many relation — inline each nested row
-                        flat[k] = v.map((item: Record<string, unknown>) => {
-                            // Junction table rows may have the target nested, unwrap those
-                            const keys = Object.keys(item);
-                            const nestedObj = keys.find(nk => typeof item[nk] === "object" && item[nk] !== null && !Array.isArray(item[nk]));
-                            if (nestedObj && keys.length <= 3) {
-                                return { ...(item[nestedObj] as Record<string, unknown>) };
-                            }
-                            return { ...item };
-                        });
-                    } else if (typeof v === "object" && v !== null) {
-                        // One-to-one relation — inline the target's columns
-                        flat[k] = { ...(v as Record<string, unknown>) };
-                    } else {
-                        flat[k] = v;
-                    }
-                }
-                return flat;
-            });
-        } catch (e) {
-            logger.warn(`[include] Drizzle relational query failed for '${collectionPath}', falling back`, { error: e });
-            return null;
-        }
-    }
-
     /**
      * Fallback path used when db.query is unavailable.
      * The primary path uses db.query.findMany with `with` config, which