@rebasepro/server-postgres 0.19.1 → 0.19.2-canary.g08eed46

package/dist/schema/generate-postgres-ddl-logic.d.ts

@@ -1,42 +1,25 @@
-import { CollectionConfig, Property, SecurityRule } from "@rebasepro/types";
-export declare const resolveColumnName: (propName: string, prop?: Property | null) => string;
-export declare const getPrimaryKeyProp: (collection: CollectionConfig) => {
-    name: string;
-    type: "string" | "number";
-    isUuid: boolean;
-};
-export declare const isNumericId: (collection: CollectionConfig) => boolean;
-export declare const getPrimaryKeyName: (collection: CollectionConfig) => string;
-export declare const isIdProperty: (propName: string, prop: Property, collection: CollectionConfig) => boolean;
-type ResolveCollection = (slug: string) => CollectionConfig | undefined;
 /**
- * The `ON DELETE` a foreign key gets when the author did not say.
- *
- * One rule for every property that emits one — `belongsTo` relations and
- * `reference` properties alike. `reference` kept its own `CASCADE` default for
- * a release after this rule was written, which is exactly the split this
- * function exists to prevent: two spellings of the same link, two data-retention
- * behaviours, and only one of them documented.
- *
- * An optional link is `SET NULL`: the column can hold NULL, so dropping the
- * parent leaves the child row with an empty pointer, which is what "optional"
- * already means.
- *
- * A required link is **`RESTRICT`**, not `CASCADE`. `NOT NULL` says the child
- * cannot exist without a parent; it does not say deleting the parent should
- * take the child with it. That second claim is a data-retention decision, and
- * defaulting to it meant `onDelete` — a field nobody has to write — silently
- * turned every `DELETE FROM authors` into a cascade through posts, comments and
- * anything else that hung off them. `RESTRICT` fails the delete instead and
- * names the constraint, so the author chooses `cascade` on purpose or clears
- * the children first.
- *
- * Both DDL paths — the `CREATE TABLE` generator and {@link planRelationalColumns},
- * which boot-ensure compares the live database against — call this, so a
- * default that appears in one and not the other cannot make `db push` plan a
- * constraint rewrite on every run.
+ * The SQL half of `rebase db generate`, as a plan and a renderer.
+ *
+ * There is no interpretation left in this file. `schema/plan/plan-schema.ts`
+ * reads the collections into a {@link SchemaPlan} and `schema/plan/render-ddl.ts`
+ * writes the files; what remains here is the public entry points those two are
+ * reached through, plus the smaller plans (`planRelationalColumns`,
+ * `planJunctionTables`, `planCollectionPolicies`) that other modules ask for as
+ * slices of the same plan.
+ *
+ * It used to hold `getSqlColumnType` and a `CREATE TABLE` walk with its own
+ * reading of relations, junctions, enums and search — one of three such
+ * readings. See `schema/plan/types.ts` for what that cost.
  */
-export declare const defaultBelongsToOnDelete: (required: boolean | undefined) => "RESTRICT" | "SET NULL";
+import { CollectionConfig, SecurityRule } from "@rebasepro/types";
+import { quoteSqlLiteral, defaultBelongsToOnDelete } from "./plan/plan-schema.js";
+import { type DdlRenderOptions } from "./plan/render-ddl.js";
+import type { ForeignKeyPlan } from "./plan/types.js";
+import type { GeneratedColumnDependency } from "./generated-column-conflicts.js";
+export { quoteSqlLiteral, defaultBelongsToOnDelete };
+export type { ForeignKeyPlan };
+type ResolveCollection = (slug: string) => CollectionConfig | undefined;
 /**
  * The individual SQL statements a single security rule compiles to: a
  * `DROP POLICY IF EXISTS` / `CREATE POLICY` pair per operation, each a complete
@@ -48,20 +31,22 @@ export declare const defaultBelongsToOnDelete: (required: boolean | undefined) =
  */
 export declare const generatePolicyStatements: (collection: CollectionConfig, rule: SecurityRule, resolveCollection: ResolveCollection) => string[];
 /**
- * Single-quote escaping for a SQL string literal (PostgreSQL doubles the
- * quote). Enum labels come straight from user-authored collection config, so a
- * label like `it's` closes the literal early and the whole generated file stops
- * parsing at the `CREATE TYPE`. Lives here rather than next to its other caller
- * because ensure-collection-tables already imports from this module — the
- * reverse would be a cycle.
+ * `drizzle/schema.sql` — the desired state Atlas diffs the database against.
+ *
+ * Synchronous. It was `async` with nothing to await, which made every caller
+ * (the writer script, the doctor, the live editor, two gates) carry a promise
+ * for no reason and made the one place that forgot to await it silently compare
+ * `[object Promise]`.
  */
-export declare const quoteSqlLiteral: (value: string) => string;
-export declare const getSqlColumnType: (propName: string, prop: Property, collection: CollectionConfig, collections: CollectionConfig[]) => string;
+export declare const generatePostgresDdl: (allCollections: CollectionConfig[], options?: DdlRenderOptions) => string;
+/** `drizzle/policies.sql` — the RLS policies. Atlas has no model for a policy. */
+export declare const generatePostgresPoliciesDdl: (allCollections: CollectionConfig[]) => string;
 /**
- * Everything a `search` block needs, as a file Rebase applies itself.
+ * `drizzle/search.sql` — everything a `search` block needs, as a file Rebase
+ * applies itself.
  *
- * Search is the one part of the schema Atlas does not own. Two independent
- * reasons, and either alone would be enough:
+ * Search is one of the parts of the schema Atlas does not own, for two
+ * independent reasons and either alone would be enough:
  *
  * 1. Its free tier refuses to *parse* a desired-state file that so much as
  *    contains a function — "functions and procedures are available to
@@ -73,24 +58,7 @@ export declare const getSqlColumnType: (propName: string, prop: Property, collec
  *    against, so a helper seeded there beforehand is gone by the time the plan
  *    is analysed. There is no hook to reinstate it.
  *
- * So the column, its index and its helpers are excluded from Atlas's view
- * (`searchExcludePatterns`) and applied from here — the same arrangement the
- * RLS policies already use, and for the same underlying reason.
- *
- * Ordered as it must run: extensions, then helpers, then the column whose
- * expression calls them, then the index over that column. Every statement is
- * `IF NOT EXISTS` / `OR REPLACE`, because this is replayed on every push and
- * appended to migrations that run against databases at any stage of their
- * life. Empty when nothing opted in — the caller writes no file then.
- *
- * The dev database Atlas plans against needs none of this. `searchExcludePatterns`
- * removes the search column from the *inspected* state, so the state Atlas
- * replays there never mentions the column and never calls a helper. Seeding the
- * helpers into that database was tried and removed: measured on Atlas 1.2.3, a
- * `schema apply --dry-run` produces byte-identical output seeded or not, and
- * Atlas wipes the dev database before it plans anyway — so a seed could not have
- * helped even where the excludes are missing, which is the case that really does
- * fail with `function public.rebase_search_unaccent(text) does not exist`.
+ * Empty when nothing opted in — the caller writes no file then.
  */
 export declare const generatePostgresSearchDdl: (allCollections: CollectionConfig[]) => string;
 /**
@@ -99,103 +67,57 @@ export declare const generatePostgresSearchDdl: (allCollections: CollectionConfi
  * Without these, a desired state that omits search reads to Atlas as an
  * instruction to drop the column — taking the index and the whole search
  * feature with it on the next push.
- *
- * Fully qualified, `schema.table.object`, matching the include list. The
- * two-part form is what Atlas wants when the connection URL scopes it to one
- * schema and is *silently ignored* otherwise: it reads `posts.search_vector`
- * as a table named `search_vector` in a schema named `posts`, matches nothing,
- * and reports no error for the pattern that never fired.
  */
 export declare const searchExcludePatterns: (allCollections: CollectionConfig[]) => string[];
 /**
- * Everything a `{ type: "vector" }` property needs, as a file Rebase applies
- * itself.
- *
- * Vector is the second part of the schema Atlas does not own, and it is out for
- * a narrower reason than search: not that Atlas refuses to parse the file, but
- * that it cannot *execute* it. To compute a desired state Atlas materialises
- * `schema.sql` in a dev database, that database is created empty, and Atlas
- * empties it again at the start of every run — so `VECTOR(384)` resolves
- * against a database that structurally cannot have pgvector, and every push
- * dies with `type "vector" does not exist`. Seeding the extension beforehand
- * does not survive the clean (measured: present before the run, gone after),
- * putting `CREATE EXTENSION` in `schema.sql` is refused as an Atlas Pro
- * feature, and `--exclude` alone cannot help because Atlas still parses and
- * applies the whole file.
- *
- * So the column, its ANN indexes and the extension are excluded from Atlas's
- * view ({@link vectorExcludePatterns}) and applied from here — the same
- * arrangement search and the RLS policies already use.
- *
- * `CREATE EXTENSION` appears only when the project's database named `vector` in
- * its `extensions` — see `DatabaseOptions.extensions`. Everything else is
- * emitted either way: a database that already has pgvector installed by hand
- * needs no permission from anyone, and one that does not gets the column
- * refused by Postgres with a message this repo makes name the opt-in.
- *
- * Ordered as it must run: the extension, then the drift guard, then the column
- * whose type needs the extension, then the indexes over that column. Every
- * statement is `IF NOT EXISTS`, because this is replayed on every push and
- * appended to migrations that run against databases at any stage of their life.
- * Empty when no collection declares a vector — the caller writes no file then.
+ * `drizzle/vector.sql` — the `vector` columns, their ANN indexes and, when a
+ * database declared it, the extension.
+ *
+ * Vector is out of Atlas's hands for a narrower reason than search: not that
+ * Atlas refuses to parse the file, but that it cannot *execute* it. To compute
+ * a desired state Atlas materialises `schema.sql` in a dev database, that
+ * database is created empty, and Atlas empties it again at the start of every
+ * run — so `VECTOR(384)` resolves against a database that structurally cannot
+ * have pgvector, and every push dies with `type "vector" does not exist`.
  */
 export declare const generatePostgresVectorDdl: (allCollections: CollectionConfig[], options?: {
     extensions?: readonly string[];
 }) => string;
-/**
- * Glob patterns telling Atlas to leave the vector column and its ANN indexes
- * alone.
- *
- * Without these, a desired state that omits the column reads to Atlas as an
- * instruction to drop it, taking the embeddings and the indexes with it on the
- * next push.
- *
- * Fully qualified, `schema.table.object`, for the reason spelled out on
- * {@link searchExcludePatterns}: the two-part form matches nothing and reports
- * no error, which turns a protection into a `DROP COLUMN`.
- */
+/** @see searchExcludePatterns */
 export declare const vectorExcludePatterns: (allCollections: CollectionConfig[]) => string[];
-export declare const generatePostgresDdl: (allCollections: CollectionConfig[], options?: {
-    includePolicies?: boolean;
-    includeSearch?: boolean;
-    includeVector?: boolean;
-}) => Promise<string>;
-/** The RLS statements one declared collection's table needs, ready to run. */
 /**
- * A foreign key, as both its parts and the statement that creates it.
+ * `drizzle/triggers.sql` — the `BEFORE UPDATE` triggers behind
+ * `autoValue: "on_update"`, and the one function they share.
  *
- * `ALTER TABLE … ADD CONSTRAINT` has no `IF NOT EXISTS`, so a caller applying
- * these has to skip by name — hence the name is a field and not only a substring
- * of the SQL.
+ * A trigger is a function plus a binding, so it is carved out of Atlas's view
+ * for the first of the two reasons search is. Empty when no property declares
+ * `on_update` — the caller writes no file then, and removes a stale one.
  */
-export interface ForeignKeyPlan {
-    constraintName: string;
-    schema: string;
-    /** Bare table name, no schema prefix. */
-    table: string;
-    column: string;
-    targetSchema: string;
-    targetTable: string;
-    targetColumn: string;
-    sql: string;
-}
+export declare const generatePostgresTriggersDdl: (allCollections: CollectionConfig[]) => string;
+/** @see searchExcludePatterns */
+export declare const triggerExcludePatterns: (allCollections: CollectionConfig[]) => string[];
 /** A column a `relation` or `reference` property owns on its own table. */
 export interface RelationalColumnPlan {
     schema: string;
     /** Bare table name, no schema prefix. */
     table: string;
     column: string;
-    /** Postgres type, exactly as the DDL generator declares it. */
+    /** Postgres type, exactly as the DDL renderer declares it. */
     type: string;
+    /** `validation.required` on the property that owns the link. */
+    required: boolean;
+    /**
+     * True when a declared property emits this column and the relation
+     * contributes only the constraint — `postId` with `columnName: "post_id"`
+     * beside a `belongsTo` on `post_id`.
+     */
+    columnOwnedByProperty?: boolean;
     /** Absent when the target collection is not part of this bundle. */
     foreignKey?: ForeignKeyPlan;
     /**
      * What this column would have been called before `generateForeignKeyName`
-     * learned to singularize — set only when the two differ and the column name
-     * is the derived default rather than one the author wrote.
-     *
-     * Carried so the boot-time ensure can notice a database provisioned under
-     * the old rule. It is never used to name anything.
+     * learned to singularize. Carried so the boot-time ensure can notice a
+     * database provisioned under the old rule; never used to name anything.
      */
     legacyColumn?: string;
 }
@@ -217,25 +139,17 @@ export interface JunctionTablePlan {
  * The FK columns the declared collections own — one entry per `relation`
  * (`belongsTo` side) or `reference` property.
  *
- * Split out of {@link generatePostgresDdl} so the boot-time schema ensure can
- * create the same columns with the same names, types and constraints. Before
- * this it skipped them outright, which was survivable only because `db push`
- * always followed; on a managed tenant nothing follows, so a table arrived
- * without the column its own collection reads and wrote 400 on every insert.
- *
- * A relation whose target is not in the bundle yields no column at all (the
- * generator returns early on an unresolvable target); a `reference` whose target
- * is unknown yields the column without a constraint. Both mirror the generator
- * exactly — a divergence here is a schema fork between boot and `db push`.
+ * A view over the schema plan. It was a second walk of the collections beside
+ * the `CREATE TABLE` one, which is how boot-ensure came to add every relation
+ * column bare while `db push` made the same column `NOT NULL`.
  */
 export declare const planRelationalColumns: (allCollections: CollectionConfig[]) => RelationalColumnPlan[];
 /**
  * The junction tables a bundle's many-to-many relations imply.
  *
- * Derived from {@link resolveJunctionSpecs}, the same source the junction RLS
- * comes from, so a table created here always has policies planned for it — a
- * junction with row-level security left off is readable and writable by every
- * signed-in user, which is why the two must ship together.
+ * Derived from the same plan the derived RLS comes from, so a table created
+ * here always has policies planned for it — a junction with row-level security
+ * left off is readable and writable by every signed-in user.
  */
 export declare const planJunctionTables: (allCollections: CollectionConfig[]) => JunctionTablePlan[];
 export interface CollectionPolicyPlan {
@@ -251,20 +165,22 @@ export interface CollectionPolicyPlan {
     policyStatements: string[];
 }
 /**
- * The per-table RLS plan for the *declared* collections, as executable
- * statements — what the managed runtime applies at boot so a freshly
+ * The per-table RLS plan for the declared collections and their junctions, as
+ * executable statements — what the managed runtime applies at boot so a freshly
  * provisioned tenant database serves data instead of 401ing every read.
  *
- * Mirrors {@link generatePostgresPoliciesDdl} exactly (same
- * `generatePolicyStatements`, same enable-RLS, same effective rules, same
- * derived junction rules), so boot and `db push` produce identical policies from
- * identical collections.
- *
- * Junction tables are included, and have to be: boot creates them now
- * ({@link planJunctionTables}), and a junction with RLS left off is readable and
- * writable by every signed-in user. A junction whose table is still absent is
- * skipped by the applier, not planned away here.
+ * The same policies `policies.sql` carries, from the same plan, so boot and
+ * `db push` produce identical RLS from identical collections.
  */
 export declare const planCollectionPolicies: (allCollections: CollectionConfig[]) => CollectionPolicyPlan[];
-export declare const generatePostgresPoliciesDdl: (allCollections: CollectionConfig[]) => string;
-export {};
+/**
+ * The `generated column → column it reads` edges a project's `search` blocks
+ * imply, derived from the collections alone.
+ *
+ * The same edges `queryGeneratedColumnDependencies` reads out of `pg_depend`,
+ * but available where no database is: `rebase db generate` writes a migration
+ * that will run somewhere else, later, against a database it cannot inspect.
+ * A spec's `fields[].column` is the physical column each search field starts
+ * at, which is exactly what the generated expression depends on.
+ */
+export declare const searchColumnDependencies: (allCollections: CollectionConfig[]) => GeneratedColumnDependency[];

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

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { a as generatePostgresVectorDdl, i as generatePostgresSearchDdl, n as generatePostgresDdl, r as generatePostgresPoliciesDdl } from "../generate-postgres-ddl-logic-CtnpIBVv.js";
+import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-CR2xcS7e.js";
 import { n as outError, t as out } from "../cli-output-CNdMql-L.js";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
 import { declaredDatabaseExtensions } from "@rebasepro/types";
@@ -49,7 +49,7 @@ var runGeneration = async (collectionsFilePath, outputPath) => {
 		let collections = await loadCollectionsFromDirectory(resolvedPath);
 		if (!collections || !Array.isArray(collections)) collections = [];
 		collections.sort((a, b) => a.slug.localeCompare(b.slug));
-		const ddlContent = await generatePostgresDdl(collections, {
+		const ddlContent = generatePostgresDdl(collections, {
 			includePolicies: false,
 			includeSearch: false,
 			includeVector: false
@@ -57,6 +57,7 @@ var runGeneration = async (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 });
@@ -75,6 +76,11 @@ var runGeneration = async (collectionsFilePath, outputPath) => {
 				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));

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    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 = await 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\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        } 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 { 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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"}

package/dist/schema/generated-column-conflicts.d.ts

@@ -0,0 +1,84 @@
+/** An operation on a column that PostgreSQL refuses while a dependant exists. */
+export type ColumnMutationKind = "type" | "drop";
+export interface ColumnMutation {
+    /** Absent when the plan did not qualify the table; matched loosely then. */
+    schema?: string;
+    table: string;
+    column: string;
+    kind: ColumnMutationKind;
+}
+/** One `generated column → column it reads` edge, as read from the catalogue. */
+export interface GeneratedColumnDependency {
+    schema: string;
+    table: string;
+    /** The generated column. */
+    column: string;
+    /** A column its expression reads. */
+    dependsOn: string;
+}
+/** A generated column standing in the way of the plan, and why. */
+export interface GeneratedColumnConflict {
+    schema: string;
+    table: string;
+    /** The generated column that has to go before the apply. */
+    column: string;
+    /** The mutated columns it reads, deduplicated and sorted. */
+    blocking: {
+        column: string;
+        kind: ColumnMutationKind;
+    }[];
+}
+/**
+ * Every column an Atlas plan retypes or drops, with the table it belongs to.
+ *
+ * One statement carries many clauses — Atlas emits `ALTER TABLE "public"."posts"
+ * ALTER COLUMN "title" TYPE text, ALTER COLUMN "slug" TYPE text, …` — so the
+ * table is read once per statement and the clauses are scanned within it.
+ */
+export declare function parseColumnMutations(planSql: string): ColumnMutation[];
+/**
+ * The generated columns that block a plan: those reading a column it retypes
+ * or drops.
+ *
+ * A mutation with no schema matches on table name alone. That is deliberately
+ * loose — a bare `ALTER TABLE posts` resolves through `search_path` at
+ * execution time, and guessing wrong in the *permissive* direction costs a
+ * generated column that is rebuilt seconds later, while guessing wrong in the
+ * strict direction costs the whole push.
+ */
+export declare function findGeneratedColumnConflicts(mutations: ColumnMutation[], dependencies: GeneratedColumnDependency[]): GeneratedColumnConflict[];
+/**
+ * Split the conflicts into the ones Rebase can rebuild and the ones it cannot.
+ *
+ * `managed` is decided by the very list that hid the column from Atlas: a
+ * `schema.table.column` exclude pattern means Rebase generated the column and
+ * `search.sql` will put it back. Anything else is somebody's hand-written
+ * generated column — dropping it would destroy a definition Rebase has no copy
+ * of, so it is reported and the push stops instead.
+ */
+export declare function partitionByOwnership(conflicts: GeneratedColumnConflict[], excludePatterns: string[]): {
+    managed: GeneratedColumnConflict[];
+    foreign: GeneratedColumnConflict[];
+};
+/**
+ * `ALTER TABLE … DROP COLUMN …` for each conflict, in catalogue order.
+ *
+ * `ifExists` is for the migration path, where the statement is written now and
+ * runs later against a database nobody can inspect: on a fresh one the column
+ * does not exist yet (the migration is about to create the table), on a live
+ * one it does, and the same file has to survive both.
+ */
+export declare function dropGeneratedColumnStatements(conflicts: GeneratedColumnConflict[], opts?: {
+    ifExists?: boolean;
+}): string[];
+/**
+ * The preamble a migration needs when it retypes a column a search block reads.
+ *
+ * Prepended, because the drop has to precede the `ALTER COLUMN … TYPE` that
+ * PostgreSQL would otherwise refuse. The column comes back at the end of the
+ * same migration: `db generate` appends `search.sql`, whose
+ * `ADD COLUMN IF NOT EXISTS` rebuilds the column, its index and its stamp.
+ */
+export declare function migrationDropPreamble(conflicts: GeneratedColumnConflict[]): string;
+/** `public.posts.search_vector`, the way every message here names one. */
+export declare function describeConflict(conflict: GeneratedColumnConflict): string;

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

@@ -0,0 +1,56 @@
+import { CollectionConfig } from "@rebasepro/types";
+import type { TableMeta } from "./introspect-db-logic.js";
+export type SchemaDifferenceKind = "missing-table" | "missing-column" | "extra-column" | "type" | "nullability";
+export interface SchemaDifference {
+    kind: SchemaDifferenceKind;
+    /** Bare table name, as both sides spell it. */
+    table: string;
+    /** The collection backed by that table, when one is. */
+    collection?: string;
+    /** The column, in database terms. */
+    column?: string;
+    /** The field it is served under — the property key, where there is one. */
+    property?: string;
+    /** What `schema.generated.ts` says. */
+    generated?: string;
+    /** What the database says. */
+    live?: string;
+}
+/**
+ * The families a boot warning is worth raising over.
+ *
+ * Deliberately coarse. `varchar(120)` and `text` are the same family because the
+ * runtime treats them identically and a warning about the difference would fire
+ * on every boot of a correct project — the widths still reach Postgres, which
+ * enforces them. What this is looking for is the kind of drift that changes what
+ * a value *is*: a number that became text, a timestamp that became a date, a
+ * column that stopped existing.
+ */
+export declare function typeFamily(sqlType: string | undefined): string;
+/**
+ * Every way the generated module and the database disagree, for the tables both
+ * describe.
+ *
+ * One-directional in one respect only: a table the module has and the database
+ * does not is reported (that is the stale-file case), while a table the database
+ * has and the module does not is left alone — a database may hold anything, and
+ * the collections-vs-file question is `generated-schema-staleness`'s.
+ */
+export declare function diffGeneratedSchemaAgainstCatalogue(options: {
+    /** The `tables` export of the bundle's schema module. */
+    generated: Record<string, unknown> | undefined;
+    /** What was introspected for this data source, keyed by bare table name. */
+    catalogue: Map<string, TableMeta>;
+    /** Collections of this source, so a column can be named as a property. */
+    collections: CollectionConfig[];
+}): SchemaDifference[];
+/** One line, in the terms the reader has: collection, property, column. */
+export declare function describeSchemaDifference(difference: SchemaDifference): string;
+/**
+ * Report the differences, one warning each, and never throw.
+ *
+ * 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.
+ */
+export declare function warnOnGeneratedSchemaDrift(differences: SchemaDifference[]): void;

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

@@ -93,3 +93,36 @@ export declare function staleVerdict(input: {
     /** Whether `--fix` was given. */
     fix: boolean;
 }): StaleVerdict;
+/** One exported declaration that differs between two generated schemas. */
+export interface DeclarationDifference {
+    /** The exported symbol: a table, an enum, a relations block. */
+    name: string;
+    kind: "missing" | "unexpected" | "changed";
+}
+/**
+ * What differs between the schema the current collections generate and the one
+ * on disk — by declaration, not by byte.
+ *
+ * `rebase doctor` used to whitespace-normalise both files and compare the
+ * strings, which answers "are these the same text" when the question is "does
+ * this file still describe the same schema". The difference is not academic:
+ * the answer was a single yes/no with nothing to act on, so a developer told
+ * their schema was stale had to regenerate and read the diff to find out what
+ * had changed.
+ *
+ * Comparing declarations answers the question the reader actually has. The
+ * generated file is a flat list of `export const`s — one per table, enum and
+ * relations block, each the rendering of a piece of the schema plan — and two
+ * files declaring the same symbols with the same bodies describe the same
+ * database whatever their formatting.
+ *
+ * Not a plan-to-plan comparison, and deliberately not: reading a plan back out
+ * of `schema.generated.ts` means interpreting drizzle-orm builder calls, which
+ * is a second interpreter — the exact thing this area was just rid of. The
+ * rendered declarations are the closest honest proxy, and the renderer is
+ * deterministic, so the only things normalised away are what it is free to vary
+ * independently of the plan: whitespace and its own comments.
+ */
+export declare function compareGeneratedDeclarations(expected: string, actual: string): DeclarationDifference[];
+/** The differences, as the line a developer reads in `rebase doctor`. */
+export declare function describeDeclarationDifferences(differences: DeclarationDifference[]): string;

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

@@ -18,6 +18,8 @@ export interface TableColumn {
     ordinal_position?: number;
     /** `"ALWAYS"` for a generated column, `"NEVER"` otherwise. */
     is_generated?: string;
+    /** The `GENERATED ALWAYS AS (…)` expression, when `is_generated` says so. */
+    generation_expression?: string | null;
     /** `"YES"` for an identity column. */
     is_identity?: string;
     /** `"ALWAYS"` or `"BY DEFAULT"` on an identity column. */