@rebasepro/server-postgres 0.22.0 → 0.24.0

package/dist/schema/doctor.d.ts

@@ -1,8 +1,9 @@
 import { CollectionConfig, Property } from "@rebasepro/types";
+import type { PgType, 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,6 +124,29 @@ 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>;
 export declare function renderReport(report: DoctorReport): void;
 export declare function runDoctor(options: {
@@ -123,3 +155,4 @@ export declare function runDoctor(options: {
     sdkPath: string;
     databaseUrl?: string;
 }): Promise<DoctorReport>;
+export {};

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

@@ -81,4 +81,26 @@ export interface PolicyEnsureResult {
      */
     orphansDropped: number;
 }
+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"];
+}
+/**
+ * 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>;
 export declare function ensureCollectionPolicies(client: Queryable, collections: CollectionConfig[], log?: (message: string) => void): Promise<PolicyEnsureResult>;

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-B537GIvz.js";
+import { t as main } from "../generate-drizzle-schema-93M0lUxK.js";
 //#region src/schema/bin/generate-drizzle-schema.ts
 /**
 * The built entry point for `generate-drizzle-schema`.

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,6 +1,6 @@
 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-D7imhYV8.js";
+import { a as generatePostgresVectorDdl, i as generatePostgresTriggersDdl, n as generatePostgresPoliciesDdl, r as generatePostgresSearchDdl, t as generatePostgresDdl } from "../generate-postgres-ddl-logic-BJsLaVNX.js";
 import { n as outError, t as out } from "../cli-output-CNdMql-L.js";
 import { loadCollectionsFromDirectory } from "@rebasepro/server";
 import { declaredDatabaseExtensions } from "@rebasepro/types";

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

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

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

@@ -91,6 +91,24 @@ export interface SchemaMetadata {
      */
     rowCounts: Record<string, number>;
 }
+/**
+ * Why a table keyed on several columns is not generated as a collection, or
+ * `undefined` when it is.
+ *
+ * Several `isId` properties are one composite key, and the planner builds that
+ * table under the same `PRIMARY KEY (a, b)` — so such a table round-trips when
+ * two things hold:
+ *
+ * - **Every key column can carry `isId`,** which exists on string and number
+ *   properties only. Read from the column's SQL type, not a data sample: a
+ *   `line_no` holding only 1s is not a boolean. A key with a column of another
+ *   type — pagila's `payment` is keyed on a timestamp too — can be marked on
+ *   some of its columns only, and those would be read as the whole key.
+ * - **Nothing points at it.** A foreign key into it, or a junction, is a link
+ *   into a composite key, which the planner refuses: the relation has one
+ *   column to point with.
+ */
+export declare function compositeKeySkipReason(meta: TableMeta, allFks: ForeignKeyRow[]): string | undefined;
 export interface TableMeta {
     name: string;
     columns: TableColumn[];
@@ -232,6 +250,19 @@ export interface GenerationContext {
      * from the target project and passes it. See `detectCollectionBuilder`.
      */
     builder?: CollectionBuilder;
+    /**
+     * Collects one line per column the planner will not reproduce exactly —
+     * what `rebase db push` would do to it, and how to avoid that when there is
+     * a way. The CLI prints them; the same lines are written at the top of the
+     * generated file.
+     */
+    notes?: string[];
+    /**
+     * Tables this run does not generate a collection for, so nothing may point
+     * at them: a relation whose target file does not exist is an import that
+     * does not resolve.
+     */
+    skippedTables?: ReadonlySet<string>;
 }
 /**
  * Generate the full TypeScript file content for a single collection.

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

@@ -71,7 +71,7 @@ export declare const TABLES_QUERY = "\n    SELECT c.relname AS table_name,\n
  * errors. `character_maximum_length` is the declared `varchar(n)` bound —
  * already enforced by the database, and free to surface as validation.
  */
-export declare const COLUMNS_QUERY = "\n    SELECT\n        c.table_name,\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.ordinal_position,\n        c.is_generated,\n        c.is_identity,\n        c.identity_generation,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        (SELECT a.atttypmod FROM pg_attribute a\n         JOIN pg_class pc ON a.attrelid = pc.oid\n         WHERE pc.relname = c.table_name\n           AND a.attname = c.column_name\n           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod\n    FROM information_schema.columns c\n    WHERE c.table_schema = $1\n    ORDER BY c.table_name, c.ordinal_position\n";
+export declare const COLUMNS_QUERY = "\n    SELECT\n        c.table_name,\n        c.column_name,\n        c.data_type,\n        c.udt_name,\n        c.is_nullable,\n        c.column_default,\n        c.ordinal_position,\n        c.is_generated,\n        c.generation_expression,\n        c.is_identity,\n        c.identity_generation,\n        c.character_maximum_length,\n        c.numeric_precision,\n        c.numeric_scale,\n        (SELECT a.atttypmod FROM pg_attribute a\n         JOIN pg_class pc ON a.attrelid = pc.oid\n         WHERE pc.relname = c.table_name\n           AND a.attname = c.column_name\n           AND pc.relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = c.table_schema)) as atttypmod\n    FROM information_schema.columns c\n    WHERE c.table_schema = $1\n    ORDER BY c.table_name, c.ordinal_position\n";
 export declare const ENUMS_QUERY = "\n    SELECT t.typname AS enum_name,\n           e.enumlabel AS enum_value,\n           e.enumsortorder AS sort_order\n    FROM pg_type t\n    JOIN pg_enum e ON t.oid = e.enumtypid\n    JOIN pg_namespace n ON t.typnamespace = n.oid\n    WHERE n.nspname = $1\n    ORDER BY t.typname, e.enumsortorder\n";
 /**
  * Primary key columns, in key order.

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

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

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

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