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

package/dist/schema/doctor.d.ts

@@ -1,8 +1,9 @@
 import { CollectionConfig, Property } from "@rebasepro/types";
+import type { PgType, SchemaPlan, TablePlan } from "./plan/types.js";
 export type IssueSeverity = "error" | "warning" | "info";
 export interface DoctorIssue {
     severity: IssueSeverity;
-    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "sdk_stale" | "sdk_not_generated" | "sdk_ungeneratable";
+    category: "missing_table" | "missing_column" | "type_mismatch" | "missing_constraint" | "primary_key_mismatch" | "schema_stale" | "missing_enum" | "enum_value_mismatch" | "missing_foreign_key" | "orphaned_junction" | "sdk_stale" | "sdk_not_generated" | "sdk_ungeneratable";
     table?: string;
     column?: string;
     expected?: string;
@@ -84,6 +85,14 @@ export declare function getExpectedColumnType(prop: Property): string | null;
 export declare function loadCollections(collectionsPath: string): Promise<CollectionConfig[]>;
 export declare function checkCollectionsVsSchema(collections: CollectionConfig[], schemaFilePath: string): Promise<DoctorPhase>;
 export declare function checkCollectionsVsSdk(collections: CollectionConfig[], sdkFilePath: string): Promise<DoctorPhase>;
+interface DbColumn {
+    table_schema: string;
+    table_name: string;
+    column_name: string;
+    data_type: string;
+    is_nullable: string;
+    udt_name: string;
+}
 /**
  * Extensions the collections need, that the database does not have installed.
  *
@@ -115,7 +124,49 @@ export declare function schemaStampIssues(pool: {
         rows: T[];
     }>;
 }, collections: CollectionConfig[]): Promise<DoctorIssue[]>;
+/**
+ * What to do about a column whose type is not the one the collection plans.
+ *
+ * Both ways out, because the doctor cannot know which side is right: the
+ * property moved, or the database did. Putting the property back always clears
+ * the finding; converting the column clears it when every value converts.
+ */
+export declare function typeMismatchFix(schema: string, table: string, column: string, actual: string, planned: PgType | undefined): string;
+/**
+ * The table's primary key against the one the collection reads it by.
+ *
+ * Rebase addresses a row by the key the plan names — the `isId` property, or
+ * the implicit `id` — so a table keyed on other columns, or on none, serves
+ * reads and writes against a key that does not hold. An error, because that is
+ * what it is at runtime.
+ */
+export declare function primaryKeyIssues(tablePlan: TablePlan, dbPk: string[], displayName: string): DoctorIssue[];
+/**
+ * A junction's two key columns: present, typed like the keys they point at,
+ * and the table keyed on the pair. Order is not compared — boot and `db push`
+ * have built the key in both orders, and either one serves the same rows.
+ */
+export declare function junctionKeyIssues(junctionPlan: TablePlan, dbColumns: DbColumn[], dbPk: string[], displayName: string): DoctorIssue[];
 export declare function checkCollectionsVsDatabase(collections: CollectionConfig[], databaseUrl: string): Promise<DoctorPhase>;
+/**
+ * A `public` table in the junction shape that no collection declares.
+ *
+ * The shape is the planner's: exactly two columns, together the primary key,
+ * each a single-column foreign key to a collection's table. Renaming or
+ * removing a many-to-many leaves such a table behind — push and boot only
+ * create — with every link row still in it and nothing reading it.
+ *
+ * Info, never more: the table may be data somebody still wants. The remedy is
+ * shown, never run.
+ */
+export declare function orphanedJunctionIssues(plan: SchemaPlan, columnsByTable: Map<string, {
+    column_name: string;
+}[]>, pksByTable: Map<string, string[]>, fksByTable: Map<string, {
+    constraint_name: string;
+    column_name: string;
+    foreign_table_schema: string;
+    foreign_table_name: string;
+}[]>): DoctorIssue[];
 export declare function renderReport(report: DoctorReport): void;
 export declare function runDoctor(options: {
     collectionsPath: string;
@@ -123,3 +174,4 @@ export declare function runDoctor(options: {
     sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport>;
+export {};

package/dist/schema/ensure-collection-policies.d.ts

@@ -1,43 +1,17 @@
-/**
- * Applying a bundle's RLS policies to a database at boot, idempotently.
- *
- * ## Why this exists
- *
- * {@link ensureCollectionTables} creates the collection *tables* a managed
- * runtime boots against, but a table with row-level security disabled and no
- * policies is not servable: authenticated requests run as the restricted
- * `rebase_user` role, so a read with no `SELECT` policy returns nothing (a
- * public collection answered 401) and a write with no `INSERT`/`UPDATE` policy
- * is denied. The policies live in the collections' `securityRules`; nothing at
- * boot applied them. `rebase db push` does — but it drives Atlas against a
- * local `DATABASE_URL`, and a managed tenant's database is reachable only from
- * inside the cluster, by the runtime that is already connected to it. So the
- * runtime is the only thing that *can* apply them, and this is where it does.
- *
- * ## Why this is safe to run on every boot
- *
- * Every statement is idempotent: `ENABLE ROW LEVEL SECURITY` is a no-op once
- * enabled, and each policy is a `DROP POLICY IF EXISTS` immediately followed by
- * a `CREATE POLICY`, so re-applying asserts exactly the declared state. It adds
- * and replaces; it never drops data. (It does not *reconcile* — a policy a
- * previous push left behind under an old name is not removed here; that stays a
- * `db push` / `db migrate` concern, alongside destructive schema changes.)
- *
- * Unlike table creation, a failure here is not fatal: RLS stays enabled, so a
- * table whose policies could not be applied fails **closed** (denies) rather
- * than leaking rows. One collection's policy failing (e.g. a rule that
- * references a table a real migration has not created yet) must not crash-loop
- * the whole deployment and take the other collections' working routes down with
- * it. Failures are reported loudly and per-table so the operator can see
- * exactly which collection is not yet servable and why.
- */
 import { type CollectionConfig } from "@rebasepro/types";
+import { type CollectionPolicyPlan } from "./generate-postgres-ddl-logic.js";
 import { type Queryable } from "./ensure-collection-tables.js";
+import { type BootLockOptions } from "./boot-ddl.js";
 export interface PolicyEnsureResult {
     /** `CREATE POLICY` statements that ran successfully. */
     policiesApplied: number;
-    /** Tables that had RLS enabled. */
+    /** Tables that had RLS enabled — including the {@link unchanged} ones, which already had it. */
     tablesSecured: number;
+    /**
+     * Tables whose policies were already exactly the declared ones, RLS on, by
+     * the stamp each policy carries — left alone: no statement, no lock.
+     */
+    unchanged: number;
     /** Declared tables absent from the database — left to a real migration. */
     skipped: {
         table: string;
@@ -80,5 +54,91 @@ export interface PolicyEnsureResult {
      * database — which is the reason this module exists. So boot has to do it.
      */
     orphansDropped: number;
+    /**
+     * Tables whose policies were not re-applied because another session held
+     * the table's lock for every attempt — a long transaction, a report, a
+     * dump. Each table's policy statements run in one transaction, so a table
+     * here was left exactly as it was: RLS on, its existing policies in force.
+     * `rulesChanged` says whether those differ from the declared ones by name
+     * (a rule whose policy is missing, or an orphan still granting), in which
+     * case the new rules are not in force on this table until a later boot.
+     */
+    deferred: {
+        table: string;
+        error: string;
+        rulesChanged: boolean;
+    }[];
+}
+/** What every policy stamp starts with. See {@link policyStampSql}. */
+export declare const POLICY_STAMP_PREFIX = "rebase:";
+/**
+ * One statement that stamps every policy the plan just created on its table:
+ * `COMMENT ON POLICY … IS 'rebase:<hash>'`, the hash taken over the rendered
+ * statement's hash and the definition Postgres stored — read back here, after
+ * the `CREATE`s, in the same transaction. A `DO` block because the stored
+ * definition is only known once the policy exists, and a `COMMENT` takes a
+ * literal. One line, and it names only this table.
+ *
+ * `undefined` for a table the plan gives no policies.
+ */
+export declare function policyStampSql(plan: CollectionPolicyPlan): string | undefined;
+export interface TableLockResult {
+    /** Tables RLS is now on for. */
+    locked: number;
+    /** Tables it could not be switched on for. See {@link PolicyEnsureResult.unsecured}. */
+    unsecured: PolicyEnsureResult["unsecured"];
 }
-export declare function ensureCollectionPolicies(client: Queryable, collections: CollectionConfig[], log?: (message: string) => void): Promise<PolicyEnsureResult>;
+/**
+ * Switch RLS on for every table the collections declare — each collection's
+ * and each junction's — and do nothing else.
+ *
+ * The first thing `rebase db push` does once Atlas has committed. Atlas cannot
+ * carry `ENABLE ROW LEVEL SECURITY` (its free tier neither plans nor reads it),
+ * so a table it creates arrives with RLS off — while the user role already
+ * holds DML on it through the schema's default privileges. Everything push runs
+ * after Atlas can refuse: the vector, search and trigger DDL, the policies
+ * themselves. Locking first means none of those failures can leave a table
+ * open: RLS with no policy denies, which is a state a failed push may leave.
+ *
+ * A declared table that is not in the database is skipped — nothing can reach
+ * a table that does not exist, and the step that creates it locks it.
+ */
+export declare function lockCollectionTables(client: Queryable, collections: CollectionConfig[]): Promise<TableLockResult>;
+/**
+ * Bring the declared collections' RLS policies up to date. Returns what it did.
+ *
+ * Only tables that already exist are touched: the boot-time table creator runs
+ * first, so anything still missing is a table this additive path did not
+ * create (it creates junctions too) — one a failed boot DDL left out, or a
+ * project whose schema a migration owns. Enabling RLS on a
+ * non-existent table would error, so those are recorded as skipped, not failed.
+ *
+ * ## One transaction per table
+ *
+ * Each table's statements — `ENABLE` when RLS is off, every `DROP POLICY IF
+ * EXISTS` / `CREATE POLICY` pair, the orphan drops — go to Postgres as one
+ * string, which it runs as one transaction (see `boot-ddl`). Before, each was
+ * its own autocommit: at 240 tables, 4,080 commits and 4,080 ACCESS EXCLUSIVE
+ * lock acquisitions per boot, 6–22 s on a disk that really flushes. And between
+ * a policy's DROP and its CREATE, every other replica evaluated the table with
+ * that policy missing — a user's continuous reads of their own row came back
+ * empty once per boot (measured, Postgres 18). Now a concurrent request sees the
+ * old policies or the new ones, never neither.
+ *
+ * If the transaction fails for any reason but a lock timeout, the table is
+ * applied again one statement at a time, exactly as before — so a rule that
+ * cannot be created (a function a migration has not added yet) leaves the
+ * table in the same deny-leaning partial state it always did, rather than
+ * rolling back to the old, possibly looser, policies.
+ *
+ * ## Lock budget
+ *
+ * The transaction runs under `lock_timeout` (`boot-ddl`), so a table that a
+ * long transaction, a report or a dump is holding costs live traffic one
+ * second, not the statement timeout. A contended table is retried after the
+ * others, with backoff, within a retry budget for the whole step; one still
+ * held after that is reported in `deferred` — its transaction rolled back, so
+ * it is exactly as it was before this boot — or, if RLS was off on it, closed
+ * by revoking the user role's grant, as any table RLS cannot be enabled on is.
+ */
+export declare function ensureCollectionPolicies(client: Queryable, collections: CollectionConfig[], log?: (message: string) => void, options?: BootLockOptions): Promise<PolicyEnsureResult>;

package/dist/schema/ensure-collection-tables.d.ts

@@ -22,8 +22,9 @@
  * See `diff-plan.ts` for the whole of that argument.
  */
 import { type CollectionConfig } from "@rebasepro/types";
-import { type ConstraintPolicy, type DiffOptions, type EnsureAction, type EnsurePlan, type ExistingSchema, type LegacyForeignKey, type OrphanedRequiredColumn, type SearchColumnDrift, type WithheldConstraint } from "./plan/diff-plan.js";
-export type { ConstraintPolicy, EnsureAction, EnsurePlan, ExistingSchema, LegacyForeignKey, OrphanedRequiredColumn, SearchColumnDrift, WithheldConstraint };
+import { type ConstraintPolicy, type DeferredIndexBuild, type DiffOptions, type EnsureAction, type EnsurePlan, type ExistingSchema, type LegacyForeignKey, type OrphanedRequiredColumn, type SearchColumnDrift, type WithheldConstraint } from "./plan/diff-plan.js";
+import { type DeferredIndexOutcome, type OpenIndexBuildSession } from "./deferred-index-build.js";
+export type { ConstraintPolicy, DeferredIndexBuild, EnsureAction, EnsurePlan, ExistingSchema, LegacyForeignKey, OrphanedRequiredColumn, SearchColumnDrift, WithheldConstraint };
 /**
  * The subset of a database handle this needs: run a statement, get rows back.
  *
@@ -51,6 +52,36 @@ export interface EnsureOptions extends DiffOptions {
      * reads the world.
      */
     databaseExtensions?: readonly string[];
+    /**
+     * Run each statement that changes an existing table under this
+     * `lock_timeout` (ms), retrying a timeout with backoff — see
+     * `schema/boot-ddl`. The boot sets it; absent, statements wait on locks for
+     * as long as the connection's `statement_timeout` allows, as the live schema
+     * editor's confirmed changes do.
+     */
+    lockTimeoutMs?: number;
+    /**
+     * Apply the statements that build tables this run creates — and the enum
+     * types they use — in transactions of up to {@link NEW_TABLE_BATCH}
+     * statements instead of one autocommit each. The boot sets it; see
+     * `ensureCollectionTables`.
+     */
+    batchNewTables?: boolean;
+    /**
+     * Leave the indexes a live table is missing (or holds INVALID) to the
+     * caller, in {@link EnsureOutcome.deferredIndexes}, instead of building
+     * them before returning. The boot sets it and builds them in the
+     * background once it serves — see `deferred-index-build`. A UNIQUE one is
+     * built before returning either way: see {@link DeferredIndexBuild.unique}.
+     */
+    deferIndexBuilds?: boolean;
+    /**
+     * The connection those builds run on when they are not deferred. Absent,
+     * they share `client` — fine for a small table, and cut short by the
+     * pool's `statement_timeout` on a large one, which is why the boot hands
+     * over a dedicated connection.
+     */
+    openIndexBuildSession?: OpenIndexBuildSession;
 }
 export interface EnsureOutcome extends EnsurePlan {
     /**
@@ -68,6 +99,14 @@ export interface EnsureOutcome extends EnsurePlan {
         target: string;
         error: string;
     }[];
+    /**
+     * What happened to the indexes built here rather than left to the caller —
+     * every one of {@link EnsurePlan.deferredIndexes}, or under
+     * `deferIndexBuilds` the UNIQUE ones only; absent when there were none.
+     * An index on a table that already exists reports here, not in
+     * {@link failures}.
+     */
+    indexBuilds?: DeferredIndexOutcome;
 }
 /**
  * Decide what to add. Pure — the caller supplies what exists and runs the
@@ -82,8 +121,22 @@ export interface EnsureOutcome extends EnsurePlan {
  * with no developer in the loop.
  */
 export declare function planCollectionSchemaEnsure(allCollections: CollectionConfig[], existing: ExistingSchema, options?: EnsureOptions): EnsurePlan;
+export interface ReadSchemaOptions {
+    /**
+     * The existing tables worth probing for rows, given every table's columns.
+     *
+     * Whether a table holds rows decides one thing: whether a NOT NULL or a
+     * UNIQUE can be added with a column *being added* to it. So the boot asks
+     * only about tables gaining a column — none at all on a boot that changes
+     * nothing — rather than probing every table in the schema, adopted and
+     * unmanaged ones included, on every boot. A table that is not probed is
+     * reported as holding rows: the answer that never plans a constraint that
+     * could fail against data. Absent, every table is probed.
+     */
+    probeTables?: (tables: ReadonlyMap<string, ReadonlySet<string>>) => Iterable<string>;
+}
 /** Read what the database has, for the schemas the collections live in. */
-export declare function readExistingSchema(client: Queryable, schemas: string[]): Promise<ExistingSchema>;
+export declare function readExistingSchema(client: Queryable, schemas: string[], options?: ReadSchemaOptions): Promise<ExistingSchema>;
 /**
  * Read what the database looks like, for the schemas a set of collections
  * lives in.

package/dist/schema/enum-labels-kept.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Enum labels the database holds and the collections no longer declare.
+ *
+ * PostgreSQL has no `ALTER TYPE … DROP VALUE`, and Atlas plans nothing for a
+ * removed label — `db push` reported success while the database kept the old
+ * label, so writes of it (by SQL, or an older client) went on succeeding, and
+ * `rebase doctor` sent the developer back to the same push. Boot behaves the
+ * same way by design: it adds labels and never removes one. So this is not a
+ * refusal — the push stays what boot would do — but the push says it, with the
+ * real way to retire a label.
+ */
+import { type CollectionConfig } from "@rebasepro/types";
+import type { EnumPlan } from "./plan/types.js";
+import { type Queryable } from "./ensure-collection-tables.js";
+export interface KeptEnumLabels {
+    /** `schema.type`, as the catalogue names it. */
+    type: string;
+    /** Labels in the database that no collection declares, in the type's order. */
+    labels: string[];
+}
+/** Pure: the declared enums against the catalogue's labels, keyed `schema.type`. */
+export declare function findKeptEnumLabels(declared: Pick<EnumPlan, "qualified" | "labels">[], existing: ReadonlyMap<string, string[]>): KeptEnumLabels[];
+/** Plans the collections and reads the catalogue's enum labels. */
+export declare function keptEnumLabels(client: Queryable, collections: CollectionConfig[]): Promise<KeptEnumLabels[]>;
+/** What the push prints: which labels stay, and how one is actually retired. */
+export declare function formatKeptEnumLabelsNotice(kept: KeptEnumLabels[]): string;

package/dist/schema/generate-drizzle-schema.js

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "module";
 __createRequire(import.meta.url);
-import { t as main } from "../generate-drizzle-schema-yzY_BLhr.js";
+import { t as main } from "../generate-drizzle-schema-Bz52jH2h.js";
 //#region src/schema/bin/generate-drizzle-schema.ts
 /**
 * The built entry point for `generate-drizzle-schema`.

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

@@ -0,0 +1,44 @@
+/**
+ * The two generators `rebase db push` runs as its step 1, as functions.
+ *
+ * They used to exist only as scripts, each its own `tsx` process: the driver
+ * (itself a `tsx` process) spawned one for the Drizzle schema and then one for
+ * the DDL, and each paid a Node start, tsx's loader and an import of the whole
+ * server package before reading a single collection — about 0.5 s apiece, a
+ * second per push. The driver process is one-shot, so a fresh module graph per
+ * generation bought nothing: the collections cannot change under it.
+ *
+ * The scripts remain (`generate-drizzle-schema.ts`, `generate-postgres-ddl.ts`)
+ * for `--watch`, which re-imports the collections on every save and does need a
+ * process of its own — Node's module cache would serve it the first version
+ * forever.
+ *
+ * Both functions print their own success lines and their own error, exactly as
+ * the scripts did, and throw {@link GenerationFailed} after printing — so a
+ * caller can tell "the generator said why" from "the generator never ran".
+ */
+/** Thrown once the generator has printed why it failed. */
+export declare class GenerationFailed extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface GenerateFileOptions {
+    /** The collections directory (or single module), resolved against the cwd. */
+    collectionsPath: string;
+    /** Where to write. Absent: print to stdout instead. */
+    outputPath?: string;
+    /**
+     * End on the line that says what to run next. Only `rebase schema
+     * generate` itself wants it: inside `db push` it told the push to run
+     * `db generate`, and inside `db generate` to run itself.
+     */
+    nextStep?: boolean;
+}
+/** `src/schema.generated.ts`, from the collections. */
+export declare function writeDrizzleSchema(options: GenerateFileOptions): Promise<void>;
+/**
+ * `schema.sql` (Atlas's desired state) and, beside it, `policies.sql`,
+ * `search.sql`, `vector.sql` and `triggers.sql` — the parts Atlas does not own.
+ */
+export declare function writePostgresDdl(options: GenerateFileOptions): Promise<void>;

package/dist/schema/generate-next-step.d.ts

@@ -1,16 +1,3 @@
-/**
- * The line `rebase schema generate` ends on.
- *
- * Its own module because `generate-drizzle-schema.ts` uses `import.meta` to
- * decide whether it was executed directly, which the driver's jest suite cannot
- * load at all — so the one sentence in that file with a decision in it had no
- * test and could not have one where it stood.
- */
-export declare const formatTerminalText: (text: string, options?: {
-    bold?: boolean;
-    backgroundColor?: "blue" | "green" | "red" | "yellow" | "cyan" | "magenta";
-    textColor?: "white" | "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan";
-}) => string;
 /**
  * What to do with the file that was just generated.
  *

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

@@ -31,7 +31,7 @@ type ResolveCollection = (slug: string) => CollectionConfig | undefined;
  */
 export declare const generatePolicyStatements: (collection: CollectionConfig, rule: SecurityRule, resolveCollection: ResolveCollection) => string[];
 /**
- * `drizzle/schema.sql` — the desired state Atlas diffs the database against.
+ * `.rebase/sql/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
@@ -39,10 +39,10 @@ export declare const generatePolicyStatements: (collection: CollectionConfig, ru
  * `[object Promise]`.
  */
 export declare const generatePostgresDdl: (allCollections: CollectionConfig[], options?: DdlRenderOptions) => string;
-/** `drizzle/policies.sql` — the RLS policies. Atlas has no model for a policy. */
+/** `.rebase/sql/policies.sql` — the RLS policies. Atlas has no model for a policy. */
 export declare const generatePostgresPoliciesDdl: (allCollections: CollectionConfig[]) => string;
 /**
- * `drizzle/search.sql` — everything a `search` block needs, as a file Rebase
+ * `.rebase/sql/search.sql` — everything a `search` block needs, as a file Rebase
  * applies itself.
  *
  * Search is one of the parts of the schema Atlas does not own, for two
@@ -70,7 +70,7 @@ export declare const generatePostgresSearchDdl: (allCollections: CollectionConfi
  */
 export declare const searchExcludePatterns: (allCollections: CollectionConfig[]) => string[];
 /**
- * `drizzle/vector.sql` — the `vector` columns, their ANN indexes and, when a
+ * `.rebase/sql/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
@@ -86,7 +86,7 @@ export declare const generatePostgresVectorDdl: (allCollections: CollectionConfi
 /** @see searchExcludePatterns */
 export declare const vectorExcludePatterns: (allCollections: CollectionConfig[]) => string[];
 /**
- * `drizzle/triggers.sql` — the `BEFORE UPDATE` triggers behind
+ * `.rebase/sql/triggers.sql` — the `BEFORE UPDATE` triggers behind
  * `autoValue: "on_update"`, and the one function they share.
  *
  * A trigger is a function plus a binding, so it is carved out of Atlas's view

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-DBDbBTL4.js";
+import { r as writePostgresDdl } from "../generate-files-CdEckX6c.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;
 /**