@rebasepro/server-postgres 0.23.0 → 0.24.1-canary.g19596ef

package/dist/schema/generate-postgres-ddl.js

@@ -1,94 +1,23 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-Bt2d2mRH.js";
-import { n as outError, t as out } from "../cli-output-CNdMql-L.js";
-import { loadCollectionsFromDirectory } from "@rebasepro/server";
-import { declaredDatabaseExtensions } from "@rebasepro/types";
-import * as fs$1 from "fs";
-import { promises } from "fs";
+import { r as out } from "../source-DB6xJv3p.js";
+import { r as writePostgresDdl } from "../generate-files-OoRJLEdk.js";
 import path from "path";
-import { pathToFileURL } from "url";
 //#region src/schema/generate-postgres-ddl.ts
-/** Where a project declares its resources, relative to the config directory. */
-var RESOURCE_ENTRIES = [
-	"resources.ts",
-	"resources.js",
-	"resources/index.ts",
-	"resources/index.js"
-];
 /**
-* Evaluate the project's `resources.ts`, so `declaredDatabaseExtensions()` can
-* answer.
-*
-* This generator runs as its own tsx subprocess and loads only the collections
-* directory, so nothing else in it would ever import the resources module — and
-* a permission that reads as absent because nobody loaded it is the worst shape
-* this could take: the push succeeds, `vector.sql` quietly omits the
-* `CREATE EXTENSION`, and the failure lands one statement later looking like a
-* database problem.
-*
-* Imported directly rather than through the config index, for the reason
-* `boot/resource-loading.ts` gives: re-exporting from the index would work only
-* for projects that remember to.
-*
-* A project with no resources module is the normal case and declares nothing.
-* An import that *throws* is not swallowed — a resources module that does not
-* evaluate is a configuration error, and treating it as "declared nothing"
-* would turn it into a silently missing extension.
+* The generator as its own process — what `--watch` runs, because a watch has
+* to re-import the collections on every save and Node's module cache would
+* serve it the first version forever. One-shot generation runs in the driver's
+* own process instead; see `generate-files.ts`.
 */
-async function loadDeclaredResources(configDir) {
-	const entry = RESOURCE_ENTRIES.map((name) => path.join(configDir, name)).find((candidate) => fs$1.existsSync(candidate));
-	if (!entry) return;
-	await import(pathToFileURL(entry).href);
-}
 var runGeneration = async (collectionsFilePath, outputPath) => {
+	if (!collectionsFilePath) throw new Error("No collections file path provided.");
 	try {
-		if (!collectionsFilePath) throw new Error("No collections file path provided.");
-		const resolvedPath = path.resolve(collectionsFilePath);
-		await loadDeclaredResources(path.dirname(resolvedPath));
-		let collections = await loadCollectionsFromDirectory(resolvedPath);
-		if (!collections || !Array.isArray(collections)) collections = [];
-		collections.sort((a, b) => a.slug.localeCompare(b.slug));
-		const ddlContent = generatePostgresDdl(collections, {
-			includePolicies: false,
-			includeSearch: false,
-			includeVector: false
+		await writePostgresDdl({
+			collectionsPath: path.resolve(collectionsFilePath),
+			outputPath
 		});
-		const policiesContent = generatePostgresPoliciesDdl(collections);
-		const searchContent = generatePostgresSearchDdl(collections);
-		const vectorContent = generatePostgresVectorDdl(collections, { extensions: declaredDatabaseExtensions() });
-		const triggersContent = generatePostgresTriggersDdl(collections);
-		if (outputPath) {
-			const outputDir = path.dirname(outputPath);
-			await promises.mkdir(outputDir, { recursive: true });
-			await promises.writeFile(outputPath, ddlContent);
-			out(`✅ PostgreSQL DDL generated successfully at ${outputPath}`);
-			const policiesPath = path.join(outputDir, "policies.sql");
-			await promises.writeFile(policiesPath, policiesContent);
-			out(`✅ PostgreSQL Policies DDL generated successfully at ${policiesPath}`);
-			const searchPath = path.join(outputDir, "search.sql");
-			if (searchContent) {
-				await promises.writeFile(searchPath, searchContent);
-				out(`✅ PostgreSQL search DDL generated successfully at ${searchPath}`);
-			} else if (fs$1.existsSync(searchPath)) await promises.rm(searchPath);
-			const vectorPath = path.join(outputDir, "vector.sql");
-			if (vectorContent) {
-				await promises.writeFile(vectorPath, vectorContent);
-				out(`✅ PostgreSQL vector DDL generated successfully at ${vectorPath}`);
-			} else if (fs$1.existsSync(vectorPath)) await promises.rm(vectorPath);
-			const triggersPath = path.join(outputDir, "triggers.sql");
-			if (triggersContent) {
-				await promises.writeFile(triggersPath, triggersContent);
-				out(`✅ PostgreSQL trigger DDL generated successfully at ${triggersPath}`);
-			} else if (fs$1.existsSync(triggersPath)) await promises.rm(triggersPath);
-		} else {
-			out("✅ PostgreSQL DDL generated successfully.");
-			out(String(ddlContent));
-			out("\n✅ PostgreSQL Policies DDL generated successfully.");
-			out(String(policiesContent));
-		}
 	} catch (error) {
-		outError(`Error generating DDL schema: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
 		process.exitCode = 1;
 		throw error;
 	}

package/dist/schema/generate-postgres-ddl.js.map

@@ -1 +1 @@
-{"version":3,"file":"generate-postgres-ddl.js","names":[],"sources":["../../src/schema/generate-postgres-ddl.ts","../../src/schema/bin/generate-postgres-ddl.ts"],"sourcesContent":["import { promises as fsPromises } from \"fs\";\nimport * as fs from \"fs\";\nimport path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport {\n    generatePostgresDdl,\n    generatePostgresPoliciesDdl,\n    generatePostgresSearchDdl,\n    generatePostgresTriggersDdl,\n    generatePostgresVectorDdl\n} from \"./generate-postgres-ddl-logic\";\nimport { CollectionConfig, declaredDatabaseExtensions } from \"@rebasepro/types\";\nimport { loadCollectionsFromDirectory } from \"@rebasepro/server\";\nimport { out, outError } from \"../cli-output\";\n\n/** Where a project declares its resources, relative to the config directory. */\nconst RESOURCE_ENTRIES = [\"resources.ts\", \"resources.js\", \"resources/index.ts\", \"resources/index.js\"];\n\n/**\n * Evaluate the project's `resources.ts`, so `declaredDatabaseExtensions()` can\n * answer.\n *\n * This generator runs as its own tsx subprocess and loads only the collections\n * directory, so nothing else in it would ever import the resources module — and\n * a permission that reads as absent because nobody loaded it is the worst shape\n * this could take: the push succeeds, `vector.sql` quietly omits the\n * `CREATE EXTENSION`, and the failure lands one statement later looking like a\n * database problem.\n *\n * Imported directly rather than through the config index, for the reason\n * `boot/resource-loading.ts` gives: re-exporting from the index would work only\n * for projects that remember to.\n *\n * A project with no resources module is the normal case and declares nothing.\n * An import that *throws* is not swallowed — a resources module that does not\n * evaluate is a configuration error, and treating it as \"declared nothing\"\n * would turn it into a silently missing extension.\n */\nasync function loadDeclaredResources(configDir: string): Promise<void> {\n    const entry = RESOURCE_ENTRIES\n        .map(name => path.join(configDir, name))\n        .find(candidate => fs.existsSync(candidate));\n    if (!entry) return;\n    await import(pathToFileURL(entry).href);\n}\n\nconst runGeneration = async (collectionsFilePath?: string, outputPath?: string) => {\n    try {\n        if (!collectionsFilePath) {\n            throw new Error(\"No collections file path provided.\");\n        }\n\n        const resolvedPath = path.resolve(collectionsFilePath);\n\n        // `<config>/collections` is the path this is given, so the config\n        // directory is its parent — the same relationship `rebase resources`\n        // and the boot loader assume.\n        await loadDeclaredResources(path.dirname(resolvedPath));\n\n        // Shared with the runtime and the doctor: what gets generated here must\n        // be exactly what the server serves, including directory-level defaults.\n        let collections: CollectionConfig[] = await loadCollectionsFromDirectory(resolvedPath);\n\n\n        if (!collections || !Array.isArray(collections)) {\n            collections = [];\n        }\n\n        // Sort collections by slug alphabetically to ensure deterministic DDL generation\n        collections.sort((a, b) => a.slug.localeCompare(b.slug));\n\n        // `schema.sql` is Atlas's desired state, and it carries neither the RLS\n        // policies, nor the search apparatus, nor the vector columns: Atlas\n        // manages none of them, and in the search and vector cases cannot. All\n        // three are written beside it and applied by the CLI in their own right.\n        const ddlContent = generatePostgresDdl(collections, {\n            includePolicies: false,\n            includeSearch: false,\n            includeVector: false\n        });\n        const policiesContent = generatePostgresPoliciesDdl(collections);\n        const searchContent = generatePostgresSearchDdl(collections);\n        const vectorContent = generatePostgresVectorDdl(collections, {\n            extensions: declaredDatabaseExtensions()\n        });\n        const triggersContent = generatePostgresTriggersDdl(collections);\n\n        if (outputPath) {\n            const outputDir = path.dirname(outputPath);\n            await fsPromises.mkdir(outputDir, { recursive: true });\n            await fsPromises.writeFile(outputPath, ddlContent);\n            out(`✅ PostgreSQL DDL generated successfully at ${outputPath}`);\n\n            const policiesPath = path.join(outputDir, \"policies.sql\");\n            await fsPromises.writeFile(policiesPath, policiesContent);\n            out(`✅ PostgreSQL Policies DDL generated successfully at ${policiesPath}`);\n\n            // Removed when the last `search` block goes: the CLI applies this\n            // file whenever it exists, and a stale one would keep re-creating\n            // functions for collections that no longer want them.\n            const searchPath = path.join(outputDir, \"search.sql\");\n            if (searchContent) {\n                await fsPromises.writeFile(searchPath, searchContent);\n                out(`✅ PostgreSQL search DDL generated successfully at ${searchPath}`);\n            } else if (fs.existsSync(searchPath)) {\n                await fsPromises.rm(searchPath);\n            }\n\n            // Removed when the last `vector` property goes, for the same reason\n            // `search.sql` is: the CLI applies whichever of these files exists,\n            // and a stale one would keep re-adding a column the collections no\n            // longer declare — which Atlas, no longer told to exclude it, would\n            // then plan a DROP for on the very next push.\n            const vectorPath = path.join(outputDir, \"vector.sql\");\n            if (vectorContent) {\n                await fsPromises.writeFile(vectorPath, vectorContent);\n                out(`✅ PostgreSQL vector DDL generated successfully at ${vectorPath}`);\n            } else if (fs.existsSync(vectorPath)) {\n                await fsPromises.rm(vectorPath);\n            }\n\n            // `autoValue: \"on_update\"`, on the same terms as the two above: a\n            // trigger is a function plus a binding, which Atlas's free tier\n            // will not parse, and a stale file would keep re-installing a\n            // trigger for a column nothing declares any more.\n            const triggersPath = path.join(outputDir, \"triggers.sql\");\n            if (triggersContent) {\n                await fsPromises.writeFile(triggersPath, triggersContent);\n                out(`✅ PostgreSQL trigger DDL generated successfully at ${triggersPath}`);\n            } else if (fs.existsSync(triggersPath)) {\n                await fsPromises.rm(triggersPath);\n            }\n        } else {\n            out(\"✅ PostgreSQL DDL generated successfully.\");\n            out(String(ddlContent));\n            out(\"\\n✅ PostgreSQL Policies DDL generated successfully.\");\n            out(String(policiesContent));\n        }\n\n    } catch (error) {\n        outError(`Error generating DDL schema: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);\n        // Step 1 of `rebase db push` is this process, and its exit code is the\n        // only thing the push reads. Printing and exiting 0 made a resources\n        // module that does not evaluate — the single most common cause here —\n        // report `✓ rebase db push completed successfully` while Atlas applied\n        // whatever `drizzle/schema.sql` happened to be on disk, sometimes\n        // minutes old. With no prior file the same run died inside Atlas on\n        // `stat drizzle/schema.sql: no such file or directory`, which hides the\n        // real cause two screens up.\n        process.exitCode = 1;\n        throw error;\n    }\n};\n\nexport const main = async () => {\n    const collectionsFilePathArg = process.argv.find(arg => arg.startsWith(\"--collections=\"));\n    const collectionsFilePath = collectionsFilePathArg ? collectionsFilePathArg.split(\"=\")[1] : process.argv[2];\n\n    const outputPathArg = process.argv.find(arg => arg.startsWith(\"--output=\"));\n    const outputPath = outputPathArg ? outputPathArg.split(\"=\")[1] : undefined;\n\n    const watch = process.argv.includes(\"--watch\");\n\n    if (!collectionsFilePath) {\n        out(\"Usage: ts-node generate-postgres-ddl.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]\");\n        return;\n    }\n\n    const resolvedPath = path.resolve(process.cwd(), collectionsFilePath);\n    const resolvedOutputPath = outputPath ? path.resolve(process.cwd(), outputPath) : undefined;\n\n    if (watch) {\n        out(`Watching for changes in ${resolvedPath}...`);\n        // Imported here rather than at module scope, and this is not a style\n        // choice: chokidar is needed only by `--watch`, which is a\n        // schema-authoring path that never runs inside the runtime image. A\n        // top-level import puts it on the boot path of the published driver\n        // bundle, and the image installs a hand-listed set of runtime\n        // dependencies that does not include it — so the whole driver failed to\n        // load with \"Cannot find package 'chokidar'\", and every self-hosted\n        // container answered 500 with a stack trace about a file watcher.\n        //\n        // Same reasoning the image already applies to @ariga/atlas: an\n        // authoring-only dependency does not belong on a boot path.\n        const { default: chokidar } = await import(\"chokidar\");\n        const watcher = chokidar.watch(resolvedPath, {\n            persistent: true,\n            ignoreInitial: false\n        });\n\n        watcher.on(\"all\", (event, filePath) => {\n            out(`[${event}] ${filePath}. Regenerating DDL schema...`);\n            // A watch session outlives a bad edit: the cause is already on\n            // stderr, and the next save is the retry. Only the one-shot run\n            // below turns a failure into an exit code.\n            void runGeneration(resolvedPath, resolvedOutputPath).catch(() => undefined);\n        });\n    } else {\n        await runGeneration(resolvedPath, resolvedOutputPath);\n    }\n};\n\n// This check ensures the script only runs when executed directly\nif (import.meta.url.endsWith(process.argv[1])) {\n    // `runGeneration` has already printed the cause and set the exit code; the\n    // handler is here so the last thing on the terminal is that message rather\n    // than Node's unhandled-rejection dump of the same stack.\n    main().catch(() => {\n        process.exitCode = 1;\n    });\n}\n","/**\n * The built entry point for `generate-postgres-ddl`.\n *\n * `generate-postgres-ddl.ts` guards its own `main()` with\n * `import.meta.url.endsWith(process.argv[1])`, because `src/index.ts` re-exports\n * the module and importing the driver must not run the generator. That guard is\n * correct when the file IS the process entry — which is how it runs from source\n * under tsx — and silently false once the module is bundled: the executed file\n * is a stub, the code lives in a shared chunk, and the chunk's `import.meta.url`\n * is not the stub's path. The generator then did nothing, exited 0, and the\n * caller reported success over an unwritten schema.\n *\n * So the built path gets an entry that says what it means.\n */\nimport { main } from \"../generate-postgres-ddl\";\n\nmain().catch(() => {\n    process.exitCode = 1;\n});\n"],"mappings":"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"}
+{"version":3,"file":"generate-postgres-ddl.js","names":[],"sources":["../../src/schema/generate-postgres-ddl.ts","../../src/schema/bin/generate-postgres-ddl.ts"],"sourcesContent":["import path from \"path\";\nimport { out } from \"../cli-output\";\nimport { writePostgresDdl } from \"./generate-files\";\n\n/**\n * The generator as its own process — what `--watch` runs, because a watch has\n * to re-import the collections on every save and Node's module cache would\n * serve it the first version forever. One-shot generation runs in the driver's\n * own process instead; see `generate-files.ts`.\n */\nconst runGeneration = async (collectionsFilePath?: string, outputPath?: string) => {\n    if (!collectionsFilePath) {\n        throw new Error(\"No collections file path provided.\");\n    }\n    try {\n        await writePostgresDdl({ collectionsPath: path.resolve(collectionsFilePath), outputPath });\n    } catch (error) {\n        // A caller that reads nothing but this process's exit code must not\n        // see 0 after an error was printed — see `writePostgresDdl`.\n        process.exitCode = 1;\n        throw error;\n    }\n};\n\nexport const main = async () => {\n    const collectionsFilePathArg = process.argv.find(arg => arg.startsWith(\"--collections=\"));\n    const collectionsFilePath = collectionsFilePathArg ? collectionsFilePathArg.split(\"=\")[1] : process.argv[2];\n\n    const outputPathArg = process.argv.find(arg => arg.startsWith(\"--output=\"));\n    const outputPath = outputPathArg ? outputPathArg.split(\"=\")[1] : undefined;\n\n    const watch = process.argv.includes(\"--watch\");\n\n    if (!collectionsFilePath) {\n        out(\"Usage: ts-node generate-postgres-ddl.ts <path-to-collections-file> [--output <path-to-output-file>] [--watch]\");\n        return;\n    }\n\n    const resolvedPath = path.resolve(process.cwd(), collectionsFilePath);\n    const resolvedOutputPath = outputPath ? path.resolve(process.cwd(), outputPath) : undefined;\n\n    if (watch) {\n        out(`Watching for changes in ${resolvedPath}...`);\n        // Imported here rather than at module scope, and this is not a style\n        // choice: chokidar is needed only by `--watch`, which is a\n        // schema-authoring path that never runs inside the runtime image. A\n        // top-level import puts it on the boot path of the published driver\n        // bundle, and the image installs a hand-listed set of runtime\n        // dependencies that does not include it — so the whole driver failed to\n        // load with \"Cannot find package 'chokidar'\", and every self-hosted\n        // container answered 500 with a stack trace about a file watcher.\n        //\n        // Same reasoning the image already applies to @ariga/atlas: an\n        // authoring-only dependency does not belong on a boot path.\n        const { default: chokidar } = await import(\"chokidar\");\n        const watcher = chokidar.watch(resolvedPath, {\n            persistent: true,\n            ignoreInitial: false\n        });\n\n        watcher.on(\"all\", (event, filePath) => {\n            out(`[${event}] ${filePath}. Regenerating DDL schema...`);\n            // A watch session outlives a bad edit: the cause is already on\n            // stderr, and the next save is the retry. Only the one-shot run\n            // below turns a failure into an exit code.\n            void runGeneration(resolvedPath, resolvedOutputPath).catch(() => undefined);\n        });\n    } else {\n        await runGeneration(resolvedPath, resolvedOutputPath);\n    }\n};\n\n// This check ensures the script only runs when executed directly\nif (import.meta.url.endsWith(process.argv[1])) {\n    // `runGeneration` has already printed the cause and set the exit code; the\n    // handler is here so the last thing on the terminal is that message rather\n    // than Node's unhandled-rejection dump of the same stack.\n    main().catch(() => {\n        process.exitCode = 1;\n    });\n}\n","/**\n * The built entry point for `generate-postgres-ddl`.\n *\n * `generate-postgres-ddl.ts` guards its own `main()` with\n * `import.meta.url.endsWith(process.argv[1])`, because `src/index.ts` re-exports\n * the module and importing the driver must not run the generator. That guard is\n * correct when the file IS the process entry — which is how it runs from source\n * under tsx — and silently false once the module is bundled: the executed file\n * is a stub, the code lives in a shared chunk, and the chunk's `import.meta.url`\n * is not the stub's path. The generator then did nothing, exited 0, and the\n * caller reported success over an unwritten schema.\n *\n * So the built path gets an entry that says what it means.\n */\nimport { main } from \"../generate-postgres-ddl\";\n\nmain().catch(() => {\n    process.exitCode = 1;\n});\n"],"mappings":";;;;;;;;;;;;AAUA,IAAM,gBAAgB,OAAO,qBAA8B,eAAwB;CAC/E,IAAI,CAAC,qBACD,MAAM,IAAI,MAAM,oCAAoC;CAExD,IAAI;EACA,MAAM,iBAAiB;GAAE,iBAAiB,KAAK,QAAQ,mBAAmB;GAAG;EAAW,CAAC;CAC7F,SAAS,OAAO;EAGZ,QAAQ,WAAW;EACnB,MAAM;CACV;AACJ;AAEA,IAAa,OAAO,YAAY;CAC5B,MAAM,yBAAyB,QAAQ,KAAK,MAAK,QAAO,IAAI,WAAW,gBAAgB,CAAC;CACxF,MAAM,sBAAsB,yBAAyB,uBAAuB,MAAM,GAAG,CAAC,CAAC,KAAK,QAAQ,KAAK;CAEzG,MAAM,gBAAgB,QAAQ,KAAK,MAAK,QAAO,IAAI,WAAW,WAAW,CAAC;CAC1E,MAAM,aAAa,gBAAgB,cAAc,MAAM,GAAG,CAAC,CAAC,KAAK,KAAA;CAEjE,MAAM,QAAQ,QAAQ,KAAK,SAAS,SAAS;CAE7C,IAAI,CAAC,qBAAqB;EACtB,IAAI,+GAA+G;EACnH;CACJ;CAEA,MAAM,eAAe,KAAK,QAAQ,QAAQ,IAAI,GAAG,mBAAmB;CACpE,MAAM,qBAAqB,aAAa,KAAK,QAAQ,QAAQ,IAAI,GAAG,UAAU,IAAI,KAAA;CAElF,IAAI,OAAO;EACP,IAAI,2BAA2B,aAAa,IAAI;EAYhD,MAAM,EAAE,SAAS,aAAa,MAAM,OAAO;EAM3C,SALyB,MAAM,cAAc;GACzC,YAAY;GACZ,eAAe;EACnB,CAEA,CAAA,CAAQ,GAAG,QAAQ,OAAO,aAAa;GACnC,IAAI,IAAI,MAAM,IAAI,SAAS,6BAA6B;GAIxD,cAAmB,cAAc,kBAAkB,CAAC,CAAC,YAAY,KAAA,CAAS;EAC9E,CAAC;CACL,OACI,MAAM,cAAc,cAAc,kBAAkB;AAE5D;AAGA,IAAI,OAAO,KAAK,IAAI,SAAS,QAAQ,KAAK,EAAE,GAIxC,KAAK,CAAC,CAAC,YAAY;CACf,QAAQ,WAAW;AACvB,CAAC;;;;;;;;;;;;;;;;;AC/DL,KAAK,CAAC,CAAC,YAAY;CACf,QAAQ,WAAW;AACvB,CAAC"}

package/dist/schema/generate-schema-commit.d.ts

@@ -72,6 +72,12 @@ export interface SchemaCommitInput {
      * a statement that applies and one that is rejected.
      */
     existing?: ExistingSchema;
+    /**
+     * Plan a commit of the source alone — "Edit source only". An unapplicable
+     * change is not refused: it is committed with no statements, under a
+     * message that names what the database keeps.
+     */
+    sourceOnly?: boolean;
 }
 export interface SchemaCommit {
     /** Every file the commit writes, source and generated alike. */
@@ -123,6 +129,12 @@ export declare class SchemaCommitError extends Error {
  * where there is no database to describe.
  */
 export declare function additiveStatements(before: CollectionConfig[], after: CollectionConfig[], existing?: ExistingSchema, options?: EnsureOptions): string[];
+/**
+ * The commit of an "Edit source only": what changed in the source, and what
+ * the database keeps — `chore(schema): remove sku from products (source only —
+ * column products.sku kept)`. The body lists what each change leaves behind.
+ */
+export declare function sourceOnlyCommitMessage(classified: ClassifiedChanges): string;
 /** A commit message that says what changed rather than that something did. */
 export declare function commitMessage(classified: ClassifiedChanges): string;
 /**

package/dist/schema/generated-schema-diff.d.ts

@@ -52,5 +52,12 @@ export declare function describeSchemaDifference(difference: SchemaDifference):
  * Per difference rather than one summary block on purpose: these are read out of
  * a log aggregator as often as a terminal, and a single multi-line message
  * cannot be filtered down to the one collection somebody is looking at.
+ *
+ * The fix it names is `rebase db push`. `rebase dev` rewrites
+ * schema.generated.ts from the collections on every change, and boot applies
+ * only additive changes, so what is still different at boot is the database
+ * behind the file: a rename, a dropped column, a narrowed type, a NOT NULL.
+ * `rebase schema generate` rewrites the file and leaves the database as it is,
+ * so it is named only for collections that changed since the file was written.
  */
 export declare function warnOnGeneratedSchemaDrift(differences: SchemaDifference[]): void;

package/dist/schema/introspect-db-logic.d.ts

@@ -56,6 +56,11 @@ export interface UniqueConstraintRow {
     constraint_name: string;
     column_names: string[];
 }
+/** One index, by name. */
+export interface IndexRow {
+    table_name: string;
+    index_name: string;
+}
 /** A CHECK constraint, as `pg_get_constraintdef` renders it. */
 export interface CheckConstraintRow {
     table_name: string;
@@ -68,6 +73,21 @@ export interface CommentRow {
     column_name: string | null;
     comment: string;
 }
+/** A row-level security policy, as `pg_policies` reports it. */
+export interface PolicyRow {
+    table_name: string;
+    policy_name: string;
+    /** `PERMISSIVE` or `RESTRICTIVE`. */
+    permissive: string;
+    /** The `TO` list: database roles, `public` for every role. */
+    roles: string[];
+    /** `SELECT`, `INSERT`, `UPDATE`, `DELETE` or `ALL`. */
+    cmd: string;
+    /** The `USING` expression, as Postgres renders it back. */
+    qual: string | null;
+    /** The `WITH CHECK` expression, as Postgres renders it back. */
+    with_check: string | null;
+}
 /**
  * Everything one introspection run reads from the database.
  *
@@ -83,14 +103,44 @@ export interface SchemaMetadata {
     pks: PrimaryKeyRow[];
     fks: ForeignKeyRow[];
     uniques: UniqueConstraintRow[];
+    /**
+     * Every index on the introspected tables, by name — how a foreign key
+     * whose column Rebase would index is told apart from one it already has.
+     * Absent when the caller did not read them, and then nothing is said
+     * about foreign-key indexes either way.
+     */
+    indexes?: IndexRow[];
     checks: CheckConstraintRow[];
     comments: CommentRow[];
+    /**
+     * The row-level security policies on the introspected tables. Absent when
+     * the caller did not read them, and then no collection is given rules.
+     */
+    policies?: PolicyRow[];
     /**
      * Row counts for the tables that needed one, capped — see `countRowsUpTo`.
      * Absent for every table introspection never had a reason to count.
      */
     rowCounts: Record<string, number>;
 }
+/**
+ * Why a table keyed on several columns is not generated as a collection, or
+ * `undefined` when it is.
+ *
+ * Several `isId` properties are one composite key, and the planner builds that
+ * table under the same `PRIMARY KEY (a, b)` — so such a table round-trips when
+ * two things hold:
+ *
+ * - **Every key column can carry `isId`,** which exists on string and number
+ *   properties only. Read from the column's SQL type, not a data sample: a
+ *   `line_no` holding only 1s is not a boolean. A key with a column of another
+ *   type — pagila's `payment` is keyed on a timestamp too — can be marked on
+ *   some of its columns only, and those would be read as the whole key.
+ * - **Nothing points at it.** A foreign key into it, or a junction, is a link
+ *   into a composite key, which the planner refuses: the relation has one
+ *   column to point with.
+ */
+export declare function compositeKeySkipReason(meta: TableMeta, allFks: ForeignKeyRow[]): string | undefined;
 export interface TableMeta {
     name: string;
     columns: TableColumn[];
@@ -232,6 +282,19 @@ export interface GenerationContext {
      * from the target project and passes it. See `detectCollectionBuilder`.
      */
     builder?: CollectionBuilder;
+    /**
+     * Collects one line per column the planner will not reproduce exactly —
+     * what `rebase db push` would do to it, and how to avoid that when there is
+     * a way. The CLI prints them; the same lines are written at the top of the
+     * generated file.
+     */
+    notes?: string[];
+    /**
+     * Tables this run does not generate a collection for, so nothing may point
+     * at them: a relation whose target file does not exist is an import that
+     * does not resolve.
+     */
+    skippedTables?: ReadonlySet<string>;
 }
 /**
  * Generate the full TypeScript file content for a single collection.

package/dist/schema/introspect-db-queries.d.ts

@@ -71,7 +71,7 @@ export declare const TABLES_QUERY = "\n    SELECT c.relname AS table_name,\n
  * errors. `character_maximum_length` is the declared `varchar(n)` bound —
  * already enforced by the database, and free to surface as validation.
  */
-export declare const COLUMNS_QUERY = "\n    SELECT\n        c.table_name,\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.ordinal_position,\n        c.is_generated,\n        c.is_identity,\n        c.identity_generation,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        (SELECT a.atttypmod FROM pg_attribute a\n         JOIN pg_class pc ON a.attrelid = pc.oid\n         WHERE pc.relname = c.table_name\n           AND a.attname = c.column_name\n           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod\n    FROM information_schema.columns c\n    WHERE c.table_schema = $1\n    ORDER BY c.table_name, c.ordinal_position\n";
+export declare const COLUMNS_QUERY = "\n    SELECT\n        c.table_name,\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.ordinal_position,\n        c.is_generated,\n        c.generation_expression,\n        c.is_identity,\n        c.identity_generation,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        (SELECT a.atttypmod FROM pg_attribute a\n         JOIN pg_class pc ON a.attrelid = pc.oid\n         WHERE pc.relname = c.table_name\n           AND a.attname = c.column_name\n           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod\n    FROM information_schema.columns c\n    WHERE c.table_schema = $1\n    ORDER BY c.table_name, c.ordinal_position\n";
 export declare const ENUMS_QUERY = "\n    SELECT t.typname AS enum_name,\n           e.enumlabel AS enum_value,\n           e.enumsortorder AS sort_order\n    FROM pg_type t\n    JOIN pg_enum e ON t.oid = e.enumtypid\n    JOIN pg_namespace n ON t.typnamespace = n.oid\n    WHERE n.nspname = $1\n    ORDER BY t.typname, e.enumsortorder\n";
 /**
  * Primary key columns, in key order.
@@ -116,6 +116,12 @@ export declare const FOREIGN_KEYS_QUERY = "\n    WITH fk AS (\n        SELECT co
  * `validation: { unique: true }` field makes.
  */
 export declare const UNIQUE_CONSTRAINTS_QUERY = "\n    SELECT t.relname AS table_name,\n           ic.relname AS constraint_name,\n           -- ::text, because the driver has no parser for an array of `name`\n           -- and hands back the raw `{a,b}` literal as a string. Every consumer\n           -- here indexes and compares it as an array, and a string of that\n           -- shape fails those silently rather than loudly.\n           array_agg(a.attname::text ORDER BY k.ord) AS column_names\n    FROM pg_index i\n    JOIN pg_class t ON t.oid = i.indrelid\n    JOIN pg_class ic ON ic.oid = i.indexrelid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)\n    JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = k.attnum\n    WHERE i.indisunique\n      AND NOT i.indisprimary\n      AND i.indpred IS NULL\n      AND n.nspname = $1\n      AND NOT t.relispartition\n    GROUP BY t.relname, ic.relname\n    ORDER BY t.relname, ic.relname\n";
+/**
+ * Every index on the schema's tables, by name. Only the name is needed: it is
+ * what tells a foreign key Rebase already indexed apart from one it would
+ * index on the first push — see `foreignKeyIndexSpec`.
+ */
+export declare const INDEXES_QUERY = "\n    SELECT t.relname AS table_name, ic.relname AS index_name\n    FROM pg_index i\n    JOIN pg_class t ON t.oid = i.indrelid\n    JOIN pg_class ic ON ic.oid = i.indexrelid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    WHERE n.nspname = $1\n      AND NOT t.relispartition\n    ORDER BY t.relname, ic.relname\n";
 /**
  * CHECK constraints, as the source text Postgres reproduces them from.
  *
@@ -127,8 +133,21 @@ export declare const CHECK_CONSTRAINTS_QUERY = "\n    SELECT DISTINCT\n
 /**
  * `COMMENT ON TABLE` / `COMMENT ON COLUMN`, which is documentation the author
  * already wrote and which nothing downstream has ever read.
+ *
+ * Only comments on relations: `pg_description` also holds the stamps boot
+ * writes on each policy (`rebase:<hash>`), and an OID is unique only within
+ * its own catalogue, so a policy's could name a table.
+ */
+export declare const COMMENTS_QUERY = "\n    SELECT t.relname AS table_name,\n           a.attname AS column_name,\n           d.description AS comment\n    FROM pg_description d\n    JOIN pg_class t ON t.oid = d.objoid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.objsubid\n    WHERE n.nspname = $1\n      AND d.classoid = 'pg_catalog.pg_class'::regclass\n      AND t.relkind IN ('r', 'p')\n      AND (d.objsubid = 0 OR a.attname IS NOT NULL)\n    ORDER BY t.relname, d.objsubid\n";
+/**
+ * Every row-level security policy in the schema, as `pg_policies` reports it.
+ *
+ * A table's policies are its access model. Introspection that leaves them out
+ * generates collections describing no rules, and the database's own policies
+ * then read as orphans: `doctor` fails on them, and a `db push` drops any
+ * whose name has the shape an unnamed rule compiles to.
  */
-export declare const COMMENTS_QUERY = "\n    SELECT t.relname AS table_name,\n           a.attname AS column_name,\n           d.description AS comment\n    FROM pg_description d\n    JOIN pg_class t ON t.oid = d.objoid\n    JOIN pg_namespace n ON n.oid = t.relnamespace\n    LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = d.objsubid\n    WHERE n.nspname = $1\n      AND t.relkind IN ('r', 'p')\n      AND (d.objsubid = 0 OR a.attname IS NOT NULL)\n    ORDER BY t.relname, d.objsubid\n";
+export declare const POLICIES_QUERY = "\n    SELECT tablename AS table_name,\n           policyname AS policy_name,\n           permissive,\n           roles,\n           cmd,\n           qual,\n           with_check\n    FROM pg_policies\n    WHERE schemaname = $1\n    ORDER BY tablename, policyname\n";
 /**
  * Counts a table's rows, stopping once the answer can only be "more than
  * `limit`".

package/dist/schema/introspect-db-search.d.ts

@@ -0,0 +1,22 @@
+import type { TableColumn } from "./introspect-db-logic.js";
+/** What introspection makes of a table's search columns. */
+export interface ReconstructedSearch {
+    /** The generated columns that belong to the search block — never emitted as properties. */
+    columns: Set<string>;
+    /** The `search: { … }` source, when the stamp confirmed it. */
+    block?: string;
+    note?: string;
+}
+/**
+ * The search block a table's stamped generated columns were built from, or a
+ * note saying why it could not be read back.
+ */
+export declare function reconstructSearchBlock(input: {
+    schema: string;
+    table: string;
+    columns: TableColumn[];
+    /** column → `COMMENT ON COLUMN`. */
+    comments: Map<string, string>;
+    /** column → the property key it is generated under. */
+    keyByColumn: Map<string, string>;
+}): ReconstructedSearch;

package/dist/schema/introspect-db-storage.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The property keys a column needs for the planner to build that same column.
+ *
+ * Introspection writes collections, and `rebase db push` plans them back into
+ * DDL. The two used to read a column differently: introspection wrote
+ * `type: "number"` for an `integer`, and the planner reads an unqualified
+ * number as `NUMERIC`; `validation.max: 40` for a `varchar(40)`, and the
+ * planner reads an unqualified string as `TEXT`; a `time` as a plain `date`,
+ * which the planner makes a `timestamptz` — a change Postgres refuses to cast.
+ * So adopting a database — introspect, then push, the documented path — planned
+ * a type change on nearly every column, and some it could not even dry-run.
+ *
+ * Each function here answers one question about one column: what to write so
+ * that `planSchema` produces exactly what the catalogue holds. Where no
+ * property can say it, the answer is a note naming the column and what a push
+ * would do to it, so the reader decides before anything runs.
+ *
+ * Pure: catalogue rows in, keys and notes out.
+ */
+import type { ForeignKeyRow, TableColumn } from "./introspect-db-logic.js";
+/** Keys to write on a property, as `key: value` source fragments, plus what could not be said. */
+export interface ColumnStorage {
+    /** e.g. `columnType: "varchar"`, `precision: 10`. */
+    keys: string[];
+    /** Why the planner will not reproduce this column exactly, when it will not. */
+    note?: string;
+}
+/**
+ * The name Postgres gives a `SERIAL` column's sequence — `ChooseRelationName`
+ * with the `seq` label: `<table>_<column>_seq`, and when that is over 63 bytes
+ * the longer of the two names is shortened, one character at a time, until it
+ * fits.
+ */
+export declare function serialSequenceName(table: string, column: string): string;
+/**
+ * The `isId` (and `columnType`) a single-column primary key needs.
+ *
+ * `isId: "increment"` is an identity column, and only an INTEGER one. A serial
+ * key — an integer with a `nextval` default — is `SERIAL`/`BIGSERIAL`, declared
+ * through `columnType` beside `isId: "manual"`. A uuid key is `"uuid"` only when
+ * the database generates it; a key with no default is `"manual"`, which keeps
+ * the planner from inventing one.
+ */
+export declare function primaryKeyStorage(col: TableColumn, propType: string): ColumnStorage;
+/**
+ * The keys a non-key column needs, for the property type introspection chose.
+ *
+ * `enumTypeName` is the type the planner would name for this column
+ * (`<table>_<column>`, cut to 63 bytes); an enum column whose type is called
+ * anything else cannot be declared, and the note says how to rename it.
+ */
+export declare function columnStorage(col: TableColumn, propType: string, context: {
+    isEnumColumn: boolean;
+    enumTypeName: string;
+    enumTypeShared: boolean;
+}): ColumnStorage;
+/**
+ * The `columnType` an array column needs, or a note when its element type is
+ * not one the planner stores natively.
+ *
+ * Only `text[]`, `integer[]`, `boolean[]` and `numeric[]` are. Reading
+ * `bigint[]` as `integer[]` — what this used to do — planned a narrowing.
+ */
+export declare function arrayStorage(col: TableColumn): {
+    columnType?: string;
+    innerType: string;
+    note?: string;
+};
+/**
+ * A column default as a `defaultValue`, when it is a literal a property can carry.
+ *
+ * `undefined` when there is no default to carry, or when the default is one the
+ * generator expresses another way (`now()` is `autoValue`, a key's default is
+ * its `isId`). `{ note }` when there is a default and no property can say it —
+ * a push would plan dropping it.
+ */
+export declare function literalDefaultOf(col: TableColumn, propType: string): {
+    source: string;
+} | {
+    note: string;
+} | undefined;
+/** `ON DELETE` as the relation's `onDelete`, when it is not the default the planner would choose. */
+export declare function onDeleteOf(fk: ForeignKeyRow, required: boolean): string | undefined;

package/dist/schema/introspect-db-structure.d.ts

@@ -240,6 +240,16 @@ export declare function deriveTitleProperty(facts: Map<string, ColumnFacts>): st
  * is stable across runs.
  */
 export declare function deriveKanbanProperty(facts: Map<string, ColumnFacts>): string | undefined;
+/**
+ * The string column that can hold a board's card order, or nothing.
+ *
+ * A board without `orderProperty` cannot keep a card's position within a
+ * column, and the config validator says so on every generate — so a board is
+ * emitted only when the table already has somewhere to store the order. A
+ * legacy table almost never does; asking its owner to add a hidden column
+ * just to satisfy generated output was the wrong way round.
+ */
+export declare function deriveKanbanOrderProperty(facts: Map<string, ColumnFacts>): string | undefined;
 /**
  * The column a list should be sorted by, newest first.
  *

package/dist/schema/introspect-db.js

@@ -1,16 +1,16 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as __toESM, t as require___vite_browser_external } from "../__vite-browser-external-BnuHet1e.js";
-import { _ as isUsableFileName, a as generateCollectionFile, f as classifyTables, g as countRowsUpTo, i as buildTablesMap, l as mergeIndexContent, o as generateIndexContent, p as lookupCandidates, r as buildEnumMap, u as safeHostFromUrl, v as quoteRelation, y as readSchemaMetadata } from "../introspect-db-logic-WMuAfxvw.js";
-import { n as outError, r as outWarn, t as out } from "../cli-output-CNdMql-L.js";
-import { t as chalk } from "../source-Br7L7GOI.js";
-import { t as require_arg } from "../arg-Dni7MzLB.js";
+import { i as __toESM } from "../rolldown-runtime-V7rFbMRe.js";
+import { i as diagnoseDbError } from "../cli-errors-oVUuD8k0.js";
+import { a as outWarn, i as outError, r as out, t as chalk } from "../source-DB6xJv3p.js";
+import { i as readSchemaMetadata, n as isUsableFileName, r as quoteRelation, t as countRowsUpTo } from "../introspect-db-queries-BhhJg0b8.js";
+import { a as compositeKeySkipReason, d as safeHostFromUrl, i as buildTablesMap, m as lookupCandidates, o as generateCollectionFile, p as classifyTables, r as buildEnumMap, s as generateIndexContent, u as mergeIndexContent } from "../introspect-db-logic-BCc1Jym2.js";
+import { n as require_arg, t as promptConfirm } from "../cli-prompt-egtNKkZl.js";
 import pg from "pg";
-import fs from "fs";
 import path from "path";
+import fs from "fs";
 import * as dotenv from "dotenv";
 //#region src/schema/introspect-db-project.ts
-var import___vite_browser_external = /* @__PURE__ */ __toESM(require___vite_browser_external(), 1);
 var import_arg = /* @__PURE__ */ __toESM(require_arg(), 1);
 /**
 * What the project being introspected into can actually import.
@@ -416,10 +416,9 @@ async function main() {
 	}, { permissive: true });
 	const cwd = process.cwd();
 	const defaultOutDir = path.basename(cwd) === "backend" ? path.resolve(cwd, "..", "config", "collections") : path.resolve(cwd, "config", "collections");
-	const outDir = args["--output"] || args["--collections"] || defaultOutDir;
+	const outDir = path.resolve(args["--output"] || args["--collections"] || defaultOutDir);
 	const force = args["--force"] || false;
 	const pgSchema = args["--schema"] || "public";
-	if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
 	const envPaths = [
 		process.env.DOTENV_CONFIG_PATH,
 		path.resolve(process.cwd(), ".env"),
@@ -442,10 +441,15 @@ async function main() {
 	try {
 		await client.connect();
 	} catch (err) {
-		outError(chalk.red(`✗ Failed to connect to database: ${err instanceof Error ? err.message : String(err)}`));
-		outError(chalk.gray("  Check your DATABASE_URL and ensure the database is reachable."));
+		const banner = diagnoseDbError(err, databaseUrl);
+		if (banner) outError(banner);
+		else {
+			outError(chalk.red(`✗ Failed to connect to database: ${err instanceof Error ? err.message : String(err)}`));
+			outError(chalk.gray("  Check your DATABASE_URL and ensure the database is reachable."));
+		}
 		process.exit(1);
 	}
+	if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
 	const hostPart = safeHostFromUrl(databaseUrl);
 	out(chalk.gray(`Connected to database: ${hostPart}`));
 	out(chalk.gray(`Introspecting schema '${pgSchema}'...`));
@@ -474,18 +478,14 @@ async function main() {
 		if (args["--no-data-inference"]) runDataInference = false;
 		else if (args["--data-inference"] !== void 0) runDataInference = args["--data-inference"];
 		else if (!process.stdin.isTTY) out(chalk.gray("Skipping data inference (non-interactive run; pass --data-inference to enable)."));
-		else {
-			const rl = import___vite_browser_external.default.createInterface({
-				input: process.stdin,
-				output: process.stdout
-			});
-			runDataInference = (await new Promise((resolve) => rl.question(chalk.yellow("? Do you want to run comprehensive data inference on sampled rows to auto-detect types, formats, constraints, and UI configurations? (y/N) "), resolve))).trim().toLowerCase() === "y";
-			rl.close();
-		}
+		else runDataInference = await promptConfirm(chalk.yellow("? Do you want to run comprehensive data inference on sampled rows to auto-detect types, formats, constraints, and UI configurations? (y/N) "));
 		if (runDataInference) out(chalk.gray("Sampling database rows for data inference..."));
 		const generatedFiles = [];
 		const skippedFiles = [];
-		const tablesToProcess = Array.from(tablesMap.entries()).filter(([tableName]) => !joinTables.has(tableName));
+		const compositeKeyed = new Map(Array.from(tablesMap.entries()).filter(([tableName]) => !joinTables.has(tableName)).map(([tableName, meta]) => [tableName, compositeKeySkipReason(meta, fks)]).filter((entry) => entry[1] !== void 0));
+		for (const [tableName, reason] of compositeKeyed) outWarn(chalk.yellow(`⚠ Skipping table ${JSON.stringify(tableName)}: it is keyed on (${tablesMap.get(tableName)?.pks.join(", ")}), and ${reason}. \`rebase db push\` leaves a table that is not a collection alone.`));
+		const notes = [];
+		const tablesToProcess = Array.from(tablesMap.entries()).filter(([tableName]) => !joinTables.has(tableName) && !compositeKeyed.has(tableName));
 		const BATCH_SIZE = 10;
 		for (let i = 0; i < tablesToProcess.length; i += BATCH_SIZE) {
 			const batch = tablesToProcess.slice(i, i + BATCH_SIZE);
@@ -511,13 +511,21 @@ async function main() {
 					metadata,
 					classifications,
 					checkFacts,
-					builder
+					builder,
+					notes,
+					skippedTables: new Set(compositeKeyed.keys())
 				});
 				fs.writeFileSync(filePath, fileContent, "utf-8");
 				generatedFiles.push(tableName);
 				out(chalk.green(`  ✓ ${filePath}`));
 			}));
 		}
+		if (notes.length > 0) {
+			outWarn("");
+			outWarn(chalk.yellow(`⚠ ${notes.length} column(s) will not round-trip exactly — \`rebase db push\` would change them:`));
+			for (const note of [...notes].sort()) outWarn(chalk.gray(`  - ${note}`));
+			outWarn(chalk.gray("  Read these before the first push. Run `rebase db push --dry-run` to see the plan."));
+		}
 		if (generatedFiles.length > 0) {
 			const indexPath = path.join(outDir, "index.ts");
 			if (fs.existsSync(indexPath) && !force) {