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

package/src/cli-helpers.ts

@@ -86,10 +86,16 @@ export function resolveLocalBin(binName: string): string | null {
     return null;
 }
 
-export async function getTableIncludesFromCollections(collections: CollectionConfig[]): Promise<string[]> {
-    const { getTableName, resolveCollectionRelations } = await import("@rebasepro/common");
+export async function getTableIncludesFromCollections(allCollections: CollectionConfig[]): Promise<string[]> {
+    const { getTableName, resolveCollectionRelations, relationalCollections } = await import("@rebasepro/common");
     const { isPostgresCollectionConfig } = await import("@rebasepro/types");
 
+    // The include list is the inverse of {@link getTableExcludes}: a name on it
+    // is a name Atlas is allowed to drop. A Firestore collection called
+    // `exercises` must not put `public.exercises` here — a real, unrelated table
+    // of that name would lose its protection and be dropped by the next
+    // auto-approved `db push`.
+    const collections = relationalCollections(allCollections);
     const includes: string[] = [];
     for (const col of collections) {
         const tableName = getTableName(col);
@@ -113,6 +119,19 @@ export async function getTableIncludesFromCollections(collections: CollectionCon
 }
 
 export async function getTableIncludes(collectionsPath: string): Promise<string[]> {
+    return getTableIncludesFromCollections(await loadCollectionsForCli(collectionsPath));
+}
+
+/**
+ * Load a project's collections the way the Atlas-facing commands need them.
+ *
+ * Deliberately forgiving — a file that fails to import is skipped rather than
+ * fatal — because the callers use this to *narrow* what Atlas may touch, and a
+ * hard failure here would block a push over an unrelated broken file. Callers
+ * that cannot tolerate a partial answer (the table excludes, which fail closed)
+ * check the result themselves.
+ */
+export async function loadCollectionsForCli(collectionsPath: string): Promise<CollectionConfig[]> {
     // Note: a relative --collections path resolves against the *current working
     // directory*, not the backend package. When invoked via the generated npm
     // script (cwd = backend/), the script uses "../config/collections" to
@@ -152,7 +171,7 @@ export async function getTableIncludes(collectionsPath: string): Promise<string[
         }
     }
 
-    return getTableIncludesFromCollections(collections);
+    return collections;
 }
 
 export function getDevDatabaseUrl(databaseUrl: string): string {
@@ -189,6 +208,99 @@ export async function ensureDevDatabaseExists(databaseUrl: string, devDatabaseUr
     }
 }
 
+/**
+ * The generated SQL for the project's `search` blocks, if it has any.
+ *
+ * @param drizzleDir directory holding the generated SQL. Defaults to `drizzle`
+ *        under the working directory.
+ */
+export function readSearchDdl(drizzleDir: string = path.resolve(process.cwd(), "drizzle")): string {
+    const searchFile = path.join(drizzleDir, "search.sql");
+    if (!fs.existsSync(searchFile)) return "";
+    return fs.readFileSync(searchFile, "utf-8").trim();
+}
+
+/**
+ * Bring the search column, its index and their helpers up to date.
+ *
+ * Runs *after* Atlas, not before: the statements are `ALTER TABLE ... ADD
+ * COLUMN`, so the table has to exist. Atlas is told to ignore these objects
+ * entirely (`getSearchExcludes`) — it cannot manage them, and left to itself it
+ * would plan a `DROP COLUMN` for every one, since they are absent from the
+ * desired state it was given.
+ *
+ * A no-op when no collection declared `search`. A failure is *not* swallowed:
+ * silently pushing a schema whose search column never appeared is how a
+ * collection ends up with search configured, no error anywhere, and no results.
+ */
+export async function applySearchDdl(
+    databaseUrl: string,
+    drizzleDir: string = path.resolve(process.cwd(), "drizzle")
+): Promise<void> {
+    const sql = readSearchDdl(drizzleDir);
+    if (!sql) return;
+
+    const { Client } = await import("pg");
+    const client = new Client({ connectionString: databaseUrl });
+    await client.connect();
+    try {
+        await client.query(sql);
+    } finally {
+        await client.end();
+    }
+    logger.info(chalk.gray("  ✓ Applied full-text search columns and indexes"));
+}
+
+/**
+ * Glob patterns keeping Atlas away from the search objects.
+ *
+ * Returns an empty list — and so changes nothing — for a project with no
+ * `search` block, which is every project that has not opted in.
+ */
+export async function getSearchExcludes(collectionsPath: string): Promise<string[]> {
+    const { searchExcludePatterns } = await import("./schema/generate-postgres-ddl-logic");
+    return searchExcludePatterns(await loadCollectionsForCli(collectionsPath));
+}
+
+/**
+ * Give the dev database the search helper functions before Atlas plans.
+ *
+ * Excluding the search column keeps Atlas from *diffing* it, but not from
+ * materialising the inspected schema — column and all — in the dev database to
+ * analyse the plan against. That replay is where a push against an
+ * already-searchable database died with `function public.rebase_search_text
+ * (jsonb) does not exist`: the column came across, the function it calls did
+ * not, because Atlas will not carry a function at all.
+ *
+ * Only the extensions and functions, never the tables: the dev database holds
+ * whatever Atlas puts there and nothing of ours.
+ *
+ * Best-effort by design. Failing here would block a push for a project whose
+ * collections merely failed to import, and if the functions really are needed
+ * and really are missing, Atlas says so a moment later in its own words.
+ */
+export async function seedDevDatabaseSearchHelpers(
+    devDatabaseUrl: string,
+    collectionsPath: string
+): Promise<void> {
+    try {
+        const { searchPrerequisiteStatements } = await import("./schema/generate-postgres-ddl-logic");
+        const statements = searchPrerequisiteStatements(await loadCollectionsForCli(collectionsPath));
+        if (statements.length === 0) return;
+
+        const { Client } = await import("pg");
+        const client = new Client({ connectionString: devDatabaseUrl });
+        await client.connect();
+        try {
+            await client.query(statements.join("\n"));
+        } finally {
+            await client.end();
+        }
+    } catch {
+        // See above: not worth failing a push over.
+    }
+}
+
 /**
  * Query the live database for every user table/view outside the system
  * catalogs. Separated from {@link getTableExcludes} so its failure mode can
@@ -249,13 +361,20 @@ export async function getTableExcludes(
     const queryTables = deps.queryExistingTables ?? queryExistingTables;
 
     const includes = await getIncludes(collectionsPath);
-    // Framework-owned schemas Rebase manages itself — the declarative apply
-    // must never touch them. `auth` holds the helper functions; `rebase` holds
-    // the auth tables (users, refresh_tokens, …) and Atlas's own revision
-    // table. Excluding both the schema object AND its contents keeps Atlas
-    // from planning a `DROP SCHEMA … CASCADE` — which on a live database would
-    // take the user/auth tables with it. `atlas_schema_revisions.*` is kept
-    // for backwards-compatibility with any external revision schema.
+    // Schemas the declarative apply must never touch. `rebase` holds the auth
+    // tables (users, refresh_tokens, …), the RLS helper functions and Atlas's
+    // own revision table. Excluding both the schema object AND its contents
+    // keeps Atlas from planning a `DROP SCHEMA … CASCADE` — which on a live
+    // database would take the user/auth tables with it.
+    // `atlas_schema_revisions.*` is kept for backwards-compatibility with any
+    // external revision schema.
+    //
+    // `auth` stays on this list even though Rebase no longer creates it, and
+    // that is the point: on a database still holding the pre-1.0 schema it must
+    // survive until the guarded cleanup retires it, and on a Supabase database
+    // it is somebody else's and must never be in scope at all. Removing it here
+    // would let a `db push` plan `DROP SCHEMA auth CASCADE` against a live
+    // Supabase installation.
     const excludes: string[] = ["atlas_schema_revisions.*", "auth", "auth.*", "rebase", "rebase.*"];
 
     let existingTables: string[];

package/src/cli.ts

@@ -5,19 +5,24 @@ import path from "path";
 import fs from "fs";
 import { fileURLToPath } from "url";
 import { logger } from "@rebasepro/server";
+import { formatRelativeTime } from "@rebasepro/utils";
 import {
     diagnoseMissingBin,
     resolveLocalBin,
     getTableIncludes,
     getDevDatabaseUrl,
     ensureDevDatabaseExists,
+    applySearchDdl,
+    getSearchExcludes,
+    readSearchDdl,
+    seedDevDatabaseSearchHelpers,
     getTableExcludes,
     ExcludeIntrospectionError,
     promptConfirm
 } from "./cli-helpers";
 import { checkDatabaseConnectivity, diagnoseDbError } from "./cli-errors";
 import { forLibpq } from "./utils/connection-string";
-import { AUTH_BOOTSTRAP_SQL } from "./schema/auth-bootstrap-sql";
+import { dropLegacyAuthSchema, RLS_BOOTSTRAP_SQL } from "./schema/rls-bootstrap-sql";
 import { detectDestructiveStatements, decidePushSafety } from "./schema/destructive-sql";
 
 const __cliDirname = path.dirname(fileURLToPath(import.meta.url));
@@ -69,6 +74,13 @@ export async function runPluginCommand(args: string[]) {
     }
 }
 
+/** The migration files on disk, sorted, or none if the directory is absent. */
+function listMigrationFiles(): string[] {
+    const dir = path.resolve(process.cwd(), "drizzle", "migrations");
+    if (!fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir).filter(f => f.endsWith(".sql")).sort();
+}
+
 async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
     const VALID_ACTIONS = ["push", "generate", "migrate", "branch", "backup", "restore", "backups"];
     if (!subcommand || !VALID_ACTIONS.includes(subcommand)) {
@@ -115,7 +127,9 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
         logger.info(chalk.gray("  Step 2/2: Generating SQL migration files with Atlas..."));
         logger.info("");
         const migrationName = argsList._[0] || "migration";
+        const migrationsBefore = listMigrationFiles();
         await runAtlas("migrate", ["diff", migrationName, "--dir", "file://drizzle/migrations", "--to", "file://drizzle/schema.sql"], collectionsPath);
+        const wroteNewMigration = listMigrationFiles().length > migrationsBefore.length;
         
         // Post-process the newest migration file
         try {
@@ -136,16 +150,43 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
                         /CREATE SCHEMA (?!IF NOT EXISTS)("[^"]+");/g,
                         "CREATE SCHEMA IF NOT EXISTS $1;"
                     );
+                    // Atlas never writes the search objects into a migration —
+                    // it is not shown them — so a migration replayed against a
+                    // fresh database would build every table except the part
+                    // that makes search work. Appending, because these are
+                    // `ALTER TABLE ... ADD COLUMN` over the tables the
+                    // migration just created.
+                    //
+                    // Only into a migration Atlas just wrote. The file picked
+                    // here is simply the newest one, which when there was no
+                    // diff is a migration that has already run in production:
+                    // editing it changes a hash Atlas has recorded, and the
+                    // appended SQL would never be applied anywhere.
+                    const searchContent = readSearchDdl();
+                    if (searchContent && wroteNewMigration) {
+                        migrationContent = `${migrationContent}\n\n${searchContent}`;
+                        logger.info(chalk.gray("  ✓ Appended search DDL to the migration"));
+                    } else if (searchContent) {
+                        // Reachable whenever a `search` block is the *only*
+                        // thing that changed: Atlas cannot see one, so it finds
+                        // nothing to diff and writes no file.
+                        logger.info(chalk.gray(
+                            "  ℹ Search DDL not written to a migration — this change produced none.\n" +
+                            "    It is applied by `rebase db push`, and at boot by the schema ensure.\n" +
+                            "    For a migration-only deployment, add drizzle/search.sql to a migration by hand."
+                        ));
+                    }
+
                     fs.writeFileSync(newestMigrationFile, migrationContent, "utf-8");
 
-                    // Append RLS policies, preceded by the auth bootstrap so the
+                    // Append RLS policies, preceded by the RLS bootstrap so the
                     // migration is self-contained: Atlas replays migrations
-                    // against a clean dev database where `auth.uid()` would not
-                    // otherwise exist.
+                    // against a clean dev database where `rebase.uid()` would
+                    // not otherwise exist.
                     const policiesFile = path.resolve(process.cwd(), "drizzle", "policies.sql");
                     if (fs.existsSync(policiesFile)) {
                         const policiesContent = fs.readFileSync(policiesFile, "utf-8");
-                        fs.appendFileSync(newestMigrationFile, "\n\n" + AUTH_BOOTSTRAP_SQL + "\n" + policiesContent);
+                        fs.appendFileSync(newestMigrationFile, "\n\n" + RLS_BOOTSTRAP_SQL + "\n" + policiesContent);
                         logger.info(chalk.gray(`  ✓ Appended RLS policies to migration file: ${path.basename(newestMigrationFile)}`));
                         
                         // Re-hash the migration directory
@@ -233,9 +274,14 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
             
             if (databaseUrl) {
                 await ensureAuthTables(databaseUrl, collectionsPath);
+                // After the tables exist and before the policies: the search
+                // column is `ALTER TABLE ... ADD COLUMN`, and a policy may
+                // reference the table it is added to.
+                await applySearchDdl(databaseUrl);
                 await applyPolicies(databaseUrl);
                 await reconcilePolicies(databaseUrl, collectionsPath);
                 await ensureRlsUserRole(databaseUrl);
+                await retireLegacyAuthSchema(databaseUrl);
             } else {
                 logger.warn(chalk.yellow("  ⚠️  DATABASE_URL not found in environment, skipping RLS policies application."));
             }
@@ -248,6 +294,7 @@ async function dbCommand(subcommand: string, rawArgs: string[]): Promise<void> {
             await runAtlas("migrate", ["apply", "--dir", "file://drizzle/migrations", ...extraArgs], collectionsPath);
             if (databaseUrl) {
                 await ensureRlsUserRole(databaseUrl);
+                await retireLegacyAuthSchema(databaseUrl);
             }
         }
 
@@ -263,16 +310,20 @@ async function ensureAuthSchemaAndFunctions(databaseUrl: string): Promise<void>
         const client = new Client({ connectionString: databaseUrl });
         await client.connect();
         try {
-            await client.query(AUTH_BOOTSTRAP_SQL);
-            // Runtime-only: pre-create the schema Atlas uses for its revision
-            // table (`--revisions-schema rebase`). Kept out of
-            // AUTH_BOOTSTRAP_SQL so it never enters the migration stream.
-            await client.query("CREATE SCHEMA IF NOT EXISTS rebase");
+            // Creates the `rebase` schema as its first statement, which also
+            // covers the schema Atlas puts its revision table in
+            // (`--revisions-schema rebase`). That used to need a separate,
+            // deliberately migration-stream-excluded statement here, because the
+            // helper functions lived in `auth` and creating `rebase` from the
+            // preamble would have made Atlas plan a DROP for it. The generator
+            // now always declares `rebase` in the desired schema, so there is
+            // nothing to keep out.
+            await client.query(RLS_BOOTSTRAP_SQL);
         } finally {
             await client.end();
         }
     } catch (err) {
-        logger.warn(chalk.yellow(`  ⚠️  Failed to bootstrap auth schema and helper functions: ${err instanceof Error ? err.message : String(err)}`));
+        logger.warn(chalk.yellow(`  ⚠️  Failed to bootstrap the RLS helper functions: ${err instanceof Error ? err.message : String(err)}`));
     }
 }
 
@@ -320,19 +371,82 @@ async function ensureAuthTables(databaseUrl: string, collectionsPath: string): P
  * connection would bypass RLS (superuser / BYPASSRLS / table owner).
  */
 async function ensureRlsUserRole(databaseUrl: string): Promise<void> {
-    const { detectConnectionPosture, ensureAppRole, REBASE_USER_ROLE } = await import("./security/rls-enforcement");
-    const { Client } = await import("pg");
-    const client = new Client({ connectionString: databaseUrl });
-    await client.connect();
+    // Every failure in here used to escape uncaught, and `db migrate`'s caller
+    // turns that into a bare `process.exit(1)` — so the migration would apply,
+    // print `-- ok`, and then the command would die with NO output whatsoever
+    // and a non-zero status. Seen with a module-resolution error inside the
+    // dynamic import, where the entire diagnosis was one silent exit code.
+    //
+    // Reported rather than rethrown, and deliberately not fatal: the schema
+    // change has already landed at this point, so failing the command implies a
+    // rollback that did not happen. What is actually lost is the role
+    // provisioning, and the message says so and how to finish it by hand.
+    // No `auth`: the RLS helpers live in `rebase` now, and a schema the
+    // framework no longer creates must not be granted on — on a Supabase
+    // database that would hand the end-user role USAGE on their auth schema.
+    const schemas = ["public", "rebase"];
+    let rls: typeof import("./security/rls-enforcement");
+    try {
+        rls = await import("./security/rls-enforcement");
+    } catch (err) {
+        // A module-resolution failure here is a build problem, not a database
+        // one, and it is exactly the case that used to produce the silent exit.
+        logger.error(chalk.red(
+            `\n  ✗ Could not load the RLS provisioning module: ${err instanceof Error ? err.message : String(err)}`
+        ));
+        return;
+    }
+
     try {
-        const runSql = async (text: string) => (await client.query(text)).rows as Record<string, unknown>[];
-        const posture = await detectConnectionPosture(runSql);
-        if (posture.privileged) {
-            await ensureAppRole(runSql, ["public", "rebase", "auth"]);
-            logger.info(chalk.gray(`  ✓ RLS role "${REBASE_USER_ROLE}" provisioned/refreshed.`));
+        const { Client } = await import("pg");
+        const client = new Client({ connectionString: databaseUrl });
+        await client.connect();
+        try {
+            const runSql = async (text: string) => (await client.query(text)).rows as Record<string, unknown>[];
+            const posture = await rls.detectConnectionPosture(runSql);
+            if (posture.privileged) {
+                await rls.ensureAppRole(runSql, schemas);
+                logger.info(chalk.gray(`  ✓ RLS role "${rls.REBASE_USER_ROLE}" provisioned/refreshed.`));
+            }
+        } finally {
+            await client.end();
         }
-    } finally {
-        await client.end();
+    } catch (err) {
+        logger.error(chalk.red(
+            `\n  ✗ The schema change was applied, but the "${rls.REBASE_USER_ROLE}" role could not be ` +
+            `provisioned: ${err instanceof Error ? err.message : String(err)}`
+        ));
+        logger.error(chalk.gray(rls.appRoleSetupInstructions("your database user", schemas)));
+    }
+}
+
+/**
+ * Retire the pre-1.0 `auth` schema, once nothing depends on it any more.
+ *
+ * Runs last on purpose. Postgres refuses to drop a function an RLS policy still
+ * calls, so this only succeeds after the policies above have been rewritten to
+ * `rebase.uid()`. See `dropLegacyAuthSchema` for what it reports when something
+ * hand-written is still holding the schema open, and DROP_LEGACY_AUTH_SCHEMA_SQL
+ * for the guards that keep it off a Supabase `auth` schema.
+ */
+async function retireLegacyAuthSchema(databaseUrl: string): Promise<void> {
+    try {
+        const { Client } = await import("pg");
+        const client = new Client({ connectionString: databaseUrl });
+        await client.connect();
+        try {
+            await dropLegacyAuthSchema(
+                async (text) => (await client.query(text)).rows as Record<string, unknown>[],
+                {
+                    info: (m) => logger.info(chalk.gray(`  ${m}`)),
+                    warn: (m) => logger.warn(chalk.yellow(`  ⚠️  ${m}`))
+                }
+            );
+        } finally {
+            await client.end();
+        }
+    } catch {
+        // Connection-level failure only; the schema is inert either way.
     }
 }
 
@@ -599,15 +713,11 @@ function formatBytes(bytes: number): string {
     return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
 }
 
+/** A branch's age, for "…created 6d ago". */
 function timeAgo(date: Date): string {
-    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-    if (seconds < 60) return "just now";
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60) return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24) return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
+    // No horizon: a branch created a year ago should still report an age here,
+    // rather than fall back to a bare date in a one-line list entry.
+    return formatRelativeTime(date, { maxMs: Number.POSITIVE_INFINITY }) ?? "unknown";
 }
 
 
@@ -693,6 +803,9 @@ async function runAtlas(
 
     const devDatabaseUrl = getDevDatabaseUrl(databaseUrl);
     await ensureDevDatabaseExists(databaseUrl, devDatabaseUrl);
+    if (collectionsPath) {
+        await seedDevDatabaseSearchHelpers(devDatabaseUrl, collectionsPath);
+    }
 
     // Atlas speaks libpq, which rejects the `sslmode=no-verify` that
     // node-postgres accepts — see `forLibpq`. Rewritten only for the argv, so
@@ -719,6 +832,16 @@ async function runAtlas(
         }
     }
 
+    // Search objects are Rebase's, not Atlas's — on both paths. `schema apply`
+    // would drop them as absent from the desired state; `migrate diff` would
+    // write that same drop into the next migration file, where it would sit
+    // waiting to be applied later.
+    if (collectionsPath && (args.includes("apply") || args.includes("diff"))) {
+        for (const exc of await getSearchExcludes(collectionsPath)) {
+            atlasArgs.push("--exclude", exc);
+        }
+    }
+
     if (domain === "schema" && args.includes("apply") && collectionsPath) {
         // Fail CLOSED: the exclude list is the only thing shielding
         // non-collection tables from the auto-approved apply. If we can't
@@ -828,7 +951,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(
             {