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

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

@@ -0,0 +1,171 @@
+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 {
+    // `categorieId: integer("categorie_id")` — the Drizzle column shape. Only
+    // the string argument is the column; the key beside it is the *wire* name
+    // and no longer agrees with it (`authorId: integer("author_id")`). Matching
+    // both, as this did, made every camelCased key look like a column the
+    // generated file did not declare.
+    const literal = column.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[\\s,{])[\\w$"']+\\s*:\\s*\\w+\\(\\s*["']${literal}["']`, "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-inference.ts

@@ -15,7 +15,14 @@ export function inferPropertyFromData(
     pgDataType: string,
     currentPropType: string,
     sampleValues: unknown[],
-    isPk: boolean
+    isPk: boolean,
+    /**
+     * False when generating for a project without `@rebasepro/admin-types`, where
+     * `BaseProperty` declares no `admin` field and the block below would not
+     * compile. The type-level inferences (`propType`, `url`, `storage`) are
+     * unaffected — only the form-widget hints are dropped.
+     */
+    emitAdmin = true
 ): InferenceResult {
     const result: InferenceResult = {};
     const extraLines: string[] = [];
@@ -239,7 +246,7 @@ export function inferPropertyFromData(
         }
     }
 
-    if (adminOptions.length > 0) {
+    if (emitAdmin && adminOptions.length > 0) {
         extraLines.push(`            admin: {\n${adminOptions.map((o) => `                ${o}`).join(",\n")}\n            }`);
     }