palgres 0.0.0-stage → 0.1.0

package/types/palgres/src/dsl/policy.d.ts

@@ -0,0 +1,181 @@
+import { type ColumnMap, type TableHandle } from './schema.js';
+/**
+ * policy.ts — the RLS policy authoring DSL.
+ *
+ * `policy(name)` returns a fluent builder that mirrors the `ColumnBuilder`
+ * style in columns.ts: each chainable method mutates the underlying
+ * definition and returns the builder so calls compose. The terminal value is
+ * a plain {@link PolicyDef}; policySQL() says its expressions in SQL.
+ *
+ * @example
+ * import { policy } from "palbase/backend";
+ *
+ * policy("owner_select")
+ *   .for("select")
+ *   .to("authenticated")
+ *   .using("owner = (select auth.uid())");
+ */
+export type PolicyExpr = {
+    kind: "col";
+    name: string;
+    alias?: string;
+} | {
+    kind: "authUid";
+} | {
+    kind: "lit";
+    value: string | number | boolean | null;
+} | {
+    kind: "binop";
+    op: PolicyBinOp;
+    left: PolicyExpr;
+    right: PolicyExpr;
+} | {
+    kind: "and";
+    parts: PolicyExpr[];
+} | {
+    kind: "or";
+    parts: PolicyExpr[];
+} | {
+    kind: "not";
+    expr: PolicyExpr;
+} | {
+    kind: "isNull";
+    expr: PolicyExpr;
+    negated: boolean;
+} | {
+    kind: "exists";
+    table: string;
+    alias: string;
+    outer: string;
+    predicate: PolicyExpr;
+};
+export type PolicyBinOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in";
+export declare class PolicyExprRef {
+    readonly expr: PolicyExpr;
+    constructor(expr: PolicyExpr);
+    private bin;
+    eq(other: PolicyOperand): PolicyExprRef;
+    neq(other: PolicyOperand): PolicyExprRef;
+    gt(other: PolicyOperand): PolicyExprRef;
+    gte(other: PolicyOperand): PolicyExprRef;
+    lt(other: PolicyOperand): PolicyExprRef;
+    lte(other: PolicyOperand): PolicyExprRef;
+    isNull(negated?: boolean): PolicyExprRef;
+    and(...others: PolicyExprRef[]): PolicyExprRef;
+    or(...others: PolicyExprRef[]): PolicyExprRef;
+    not(): PolicyExprRef;
+}
+export type TableRef<Cols extends string, N extends string = string> = TableHandle<Record<Cols, ColumnMap[string]>, N>;
+export type PolicyOperand = PolicyExprRef | string | number | boolean | null;
+export interface PolicyExprCtx<Cols extends string = string> {
+    /** Bu tablonun bir kolonu. Bilinmeyen ad DERLENMEZ. */
+    col(name: Cols): PolicyExprRef;
+    existsIn<C extends ColumnMap, N extends string>(table: TableHandle<C, N>, predicate: (row: PolicyExprCtx<Extract<keyof C, string>>) => PolicyExprRef): PolicyExprRef;
+    auth: {
+        uid(): PolicyExprRef;
+    };
+    lit(v: string | number | boolean | null): PolicyExprRef;
+    and(...parts: PolicyExprRef[]): PolicyExprRef;
+    or(...parts: PolicyExprRef[]): PolicyExprRef;
+    not(part: PolicyExprRef): PolicyExprRef;
+}
+export declare function exprCtx<Cols extends string = string>(_columns?: readonly Cols[], depth?: number, 
+ownTable?: string): PolicyExprCtx<Cols>;
+/** The SQL command a policy applies to. `"all"` covers SELECT/INSERT/UPDATE/DELETE. */
+export type PolicyCommand = "all" | "select" | "insert" | "update" | "delete";
+/** Whether a policy is permissive (OR-combined, the default) or restrictive
+ * (AND-combined). Mirrors Postgres `CREATE POLICY ... AS PERMISSIVE|RESTRICTIVE`. */
+export type PolicyMode = "permissive" | "restrictive";
+export interface PolicyDef {
+    name: string;
+    command: PolicyCommand;
+    roles: string[];
+    using: string | PolicyExpr | null;
+    withCheck: string | PolicyExpr | null;
+    permissive: boolean;
+    /** false: the columns it reads get no index of their own from it (withoutIndexes()). */
+    indexes?: false;
+}
+export type PolicyRole = "anon" | "authenticated" | "service_role" | "backend_anon" | "backend_authenticated" | "backend_service_role"
+/** Every role (Postgres' PUBLIC): a database taken over may have a policy for it (palgres pull writes it). */
+ | "public"
+/** A database role by its own name: what a database taken over has a policy for (palgres pull writes it). */
+ | `role:${string}`;
+export declare class PolicyBuilder {
+    readonly _def: PolicyDef;
+    constructor(name: string);
+    /** Restrict the policy to a single SQL command (default `"all"`). */
+    for(command: PolicyCommand): this;
+    /**
+     * Set the DB roles the policy applies to (the `TO` clause), replacing any
+     * previously-set roles. Call with no arguments to target PUBLIC (all roles).
+     *
+     * @example
+     * policy("p").to("authenticated")
+     * policy("p").to("authenticated", "service_role")
+     * policy("p").to() // PUBLIC
+     */
+    to(...roles: PolicyRole[]): this;
+    using(expr: string | PolicyExprRef): this;
+    /**
+     * "Rows of THIS table whose owner the caller is a member of" — the membership
+     * pattern, written so it cannot recurse.
+     *
+     * THE TRAP IT EXISTS FOR. Written by hand, membership policies point at each
+     * other: `channels` is visible to members, so its policy reads
+     * `channel_members`; `channel_members` is visible to members, so its policy
+     * reads `channels`. Postgres refuses the pair at query time with `infinite
+     * recursion detected in policy for relation ...`, and the error names the
+     * relation but not the cycle. The way out is asymmetry — the MEMBERSHIP table
+     * is protected by `user_id = auth.uid()` and nothing else, and every other
+     * table subqueries INTO it. That shape was in the platform's own schema and
+     * written down nowhere; a customer recovered it by reading that schema.
+     *
+     * `(select auth.uid())` rather than a bare call: the scalar subquery is
+     * evaluated ONCE per statement instead of per row.
+     *
+     * @example
+     * // channels: visible to members. The membership table gets the simple one.
+     * policy("member_read").for("select").to("authenticated")
+     *   .memberOf("channel_members", "channel_id")
+     * // → id IN (SELECT "channel_id" FROM "channel_members"
+     * //          WHERE "user_id" = (select auth.uid()))
+     */
+    memberOf(membershipTable: string, foreignKey: string, options?: {
+        column?: string;
+        userColumn?: string;
+    }): this;
+    withCheck(expr: string | PolicyExprRef): this;
+    /**
+     * The columns this policy reads get no index of their own from it (Palbase
+     * indexes them unasked, `<table>_<column>_idx`). For a database taken over
+     * whose table has none: `palgres pull` writes it, so the take-over builds
+     * nothing nobody asked for.
+     */
+    withoutIndexes(): this;
+    /** Set the policy mode: `"permissive"` (default, OR-combined) or
+     * `"restrictive"` (AND-combined). */
+    as(mode: PolicyMode): this;
+}
+/**
+ * Start authoring an RLS policy. Returns a {@link PolicyBuilder}; the resulting
+ * `PolicyBuilder` is accepted directly in a table's `policies: [...]` array
+ * (its `_def` is read at schema-extract time).
+ *
+ * @param name The policy name. Palbase reconciliation keys policies by
+ *             `(table, name)`, so names must be unique per table.
+ */
+export declare function policy(name: string): PolicyBuilder;
+export interface CheckDef {
+    name: string;
+    expr: string;
+}
+export declare function check(name: string, expr: PolicyExprRef): CheckDef;
+/**
+ * The SQL of a policy expression: a raw string as it is, a structure rendered.
+ * `auth.uid()` is `(SELECT auth.uid())` — evaluated once per statement, not
+ * per row. Inside `existsIn` a column without an alias is the POLICY's own
+ * table's, written with that table's name: left bare, Postgres would read it
+ * as the inner table's and the policy would filter nothing.
+ */
+export declare function policySQL(expr: string | PolicyExpr | null): string | undefined;

package/types/palgres/src/dsl/raw.d.ts

@@ -0,0 +1,43 @@
+export interface RawConstraintDef {
+    name: string;
+    up: string;
+}
+/**
+ * A SCHEMA-LEVEL named raw unit — `defineSchema(name, { tables, raw: [...] })` —
+ * for what belongs to no single table: a view, a materialized view, a function
+ * that reads several tables.
+ *
+ * Unlike the table-level form it HAS a teardown, and the deploy RUNS it:
+ *   - a new unit runs `up`;
+ *   - a unit whose `up` changed first runs the `drop` recorded with its PREVIOUS
+ *     body, then the new `up` — in one transaction;
+ *   - a unit removed from the declaration runs its recorded `drop`. A unit with
+ *     no `drop` cannot be removed: the push is refused until one is added.
+ *
+ * A body may not create a TABLE — tables are always declared with
+ * `defineTable()` (use `control: "external"` for one something else manages).
+ * A view must say `WITH (security_invoker = true)`. A materialized view has no
+ * row-level security, so the platform lets only the service roles read it:
+ * reach it from backend code with `$asService()`.
+ *
+ * ```ts
+ * raw("monthly_totals",
+ *   `CREATE MATERIALIZED VIEW public.monthly_totals AS SELECT … FROM public.entries GROUP BY …`,
+ *   { drop: "DROP MATERIALIZED VIEW public.monthly_totals" })
+ * ```
+ */
+export interface RawUnitDef extends RawConstraintDef {
+    drop?: string;
+    /**
+     * Made before the schema's tables, not after: what a column's type or
+     * default needs — a domain, a composite type, a sequence, a function a
+     * default calls (`palgres pull` writes these so). Function bodies are not
+     * checked while it is made (check_function_bodies off, as pg_dump does).
+     */
+    before?: boolean;
+}
+export declare function raw(name: string, up: string): RawConstraintDef;
+export declare function raw(name: string, up: string, options: {
+    drop?: string;
+    before?: boolean;
+}): RawUnitDef;

package/types/palgres/src/dsl/schema.d.ts

@@ -0,0 +1,288 @@
+import type { ColumnBuilder } from './columns.js';
+import { ForeignKeyBuilder, foreignKey, toForeignKeyDef, type ForeignKeyDef } from './foreign-key.js';
+import { PolicyBuilder, check, type CheckDef, type PolicyDef, type PolicyExpr, type PolicyExprCtx, type PolicyExprRef } from './policy.js';
+import type { RawConstraintDef, RawUnitDef } from './raw.js';
+import { type Search, type SearchMetric } from '../model.js';
+/** A table's key: bare in public, "schema.table" in any other. */
+export declare function qualifiedTableKey(schemaName: string, tableName: string): string;
+/**
+ * A map of column builders keyed by column name — the value you write under
+ * the `columns` key of `defineTable("<name>", { columns })`.
+ *
+ * The default `Record<string, ColumnBuilder>` keeps bare references compiling
+ * without a type argument.
+ */
+export type ColumnMap = Record<string, ColumnBuilder>;
+/**
+ * The author-facing value written under each table key:
+ * `{ columns, rls?, policies? }`.
+ *
+ * - `columns`: the column map (required).
+ * - `rls`: enable + FORCE row-level security on this table. **Defaults to
+ *   `true`**, and is forced on when `policies` is non-empty. A table with RLS
+ *   and no policies is deny-all, which is the starting state: nothing reads it
+ *   until a policy says who may. Set `rls: false` only for a genuinely public
+ *   table — it is an explicit opt-out that a reviewer can grep for, not
+ *   something you get by forgetting.
+ * - `policies`: the RLS policies for this table, authored with `policy(name)`.
+ *   Each entry may be a {@link PolicyBuilder} (the normal `policy(...)` chain)
+ *   or a raw {@link PolicyDef} object.
+ *
+ * The `C` type parameter preserves the precise per-column phantom types so the
+ * typed `Database.public.*` surface keeps inferring insert/row shapes.
+ */
+export interface IndexDef {
+    name: string;
+    unique?: boolean;
+    columns?: string[];
+    expression?: string;
+    where?: PolicyExpr;
+    sort?: "asc" | "desc";
+    nulls?: "first" | "last";
+    include?: string[];
+}
+export declare class IndexBuilder {
+    readonly _def: IndexDef;
+    constructor(name: string);
+    unique(): this;
+    on(...cols: PolicyExprRef[]): this;
+    onExpression(expr: string): this;
+    where(expr: PolicyExprRef): this;
+    desc(): this;
+    asc(): this;
+    nulls(where: "first" | "last"): this;
+    include(cols: string[]): this;
+}
+export declare function index(name: string): IndexBuilder;
+/**
+ * A table's rows found by meaning and by word — `Database.public.<table>.search("…")`.
+ *
+ * ```ts
+ * search: { from: ["title", "body"], model: "default" }
+ * ```
+ *
+ * The platform embeds each row's `from` columns when the row is written and
+ * when one of them changes; the app writes no embedding code. Changing
+ * `model`, `dimensions`, `metric` or `from` embeds every row again in the
+ * background, and search goes on answering from the vectors it had until the
+ * new ones are complete.
+ */
+export interface SearchInput<Col extends string = string> {
+    /** The text columns (text, varchar, citext) a row is found by; their text is joined in this order. */
+    from: readonly Col[];
+    /** The embedding model, as the embedder names it — the platform's: "default", or a catalogue model as provider:model. */
+    model: string;
+    /** The vectors' dimensions (default 1536; at most 4000 — past 2000 they are kept in half precision). */
+    dimensions?: number;
+    /** How two vectors are compared (default "cosine"). */
+    metric?: SearchMetric;
+    /**
+     * A row whose text changed, until it is embedded again: "null" (default) —
+     * not found by its old meaning, only by its words; "keep" — still found by
+     * its old meaning.
+     */
+    staleness?: 'null' | 'keep';
+}
+export interface TableInput<C extends ColumnMap = ColumnMap> {
+    columns: C;
+    rls?: boolean;
+    policies?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (PolicyBuilder | PolicyDef)[];
+    ignored?: boolean;
+    /** Composite/named primary key (ordered column names). Omit for single-column inline .primaryKey(). */
+    primaryKey?: string[];
+    /** Named multi-column UNIQUE constraints. */
+    unique?: {
+        name: string;
+        columns: string[];
+    }[];
+    /** Named raw-SQL DDL objects (EXCLUDE, triggers, views) that the typed DSL cannot express. */
+    raw?: RawConstraintDef[];
+    checks?: CheckDef[] | ((c: PolicyExprCtx<Extract<keyof C, string>>) => CheckDef[]);
+    /**
+     * Plain (non-unique) btree indexes over an ordered column list, emitted as
+     * standalone `CREATE INDEX [IF NOT EXISTS] name ON table (col1, col2)`
+     * statements (NOT a table clause — a separate migration statement category).
+     * Structural compare by NAME (no expression normalization). `name` and each
+     * column are identifier-validated by the Go differ.
+     *
+     * NAME is the WHOLE diff key. Editing `.where()`, `.onExpression()`,
+     * `.include()` or the sort under a name that is already live does NOTHING —
+     * the deploy matches the name, sees the index, and skips. Give a changed
+     * definition a new name.
+     *
+     * Scope, via `index(name)`: `.on(...cols)` · `.onExpression(sql)` (expression
+     * index) · `.where(pred)` (partial index, typed predicate) · `.unique()`
+     * (UNIQUE, and WITH `.where()` a PARTIAL UNIQUE index) · `.include(cols)`
+     * (covering) · `.asc()`/`.desc()`/`.nulls()`. Predicates and expressions are
+     * probed against the live database before the push — as a prepared statement
+     * AND as a real CREATE INDEX on an empty `LIKE` clone, which is what catches
+     * a subquery predicate or a non-IMMUTABLE function before the apply.
+     *
+     * `index(n).unique().where(p)` is the ONE declarative way to say "NULLs are
+     * free, non-NULLs are unique" — the table-level `unique:` cannot carry a
+     * predicate, because it renders a CONSTRAINT and PostgreSQL has no partial
+     * unique CONSTRAINT (only a partial unique INDEX).
+     *
+     * NOT expressible here: another index method (gin/gist/brin/hash), an
+     * opclass, or CONCURRENTLY.
+     */
+    indexes?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (IndexBuilder | IndexDef)[];
+    foreignKeys?: (p: PolicyExprCtx<Extract<keyof C, string>>) => (ForeignKeyBuilder | ForeignKeyDef)[];
+}
+/**
+ * A table definition: its name, its columns and what else it declares, as
+ * toModel() and the typed queries read it.
+ *
+ * `defineSchema` derives `name` from the object key, so authors never repeat
+ * the table name. `rls`/`policies` are always present after normalization
+ * (defaulted to `true`/`[]`).
+ *
+ * The `C` type parameter preserves the precise per-column phantom types so that
+ * downstream mapped types (InsertShape, RowShape) can discriminate on them.
+ */
+export interface TableDef<C extends ColumnMap = ColumnMap> {
+    name: string;
+    columns: C;
+    rls: boolean;
+    ignored?: boolean;
+    policies: PolicyDef[];
+    primaryKey?: string[];
+    unique?: {
+        name: string;
+        columns: string[];
+    }[];
+    /** Named raw-SQL DDL objects emitted verbatim on deploy. Tracked by name. */
+    raw?: RawConstraintDef[];
+    checks?: CheckDef[];
+    indexes?: IndexDef[];
+    foreignKeys?: ForeignKeyDef[];
+    /** The table's search, its defaults said — see SearchInput. */
+    search?: Search;
+}
+/**
+ * A schema definition containing multiple tables, keyed by table name.
+ *
+ * The `T` type parameter preserves the exact `TableDef<...>` type for each
+ * table so that `SchemaDef["tables"]["rooms"]` resolves to the precise
+ * `TableDef<{ id: ColumnBuilder<'uuid', false, true, never>; ... }>`.
+ */
+export interface SchemaDef<T extends Record<string, TableDef> = Record<string, TableDef>> {
+    /** The schema's own name — `public`, `billing`, … Declared, never derived. */
+    name: string;
+    /** Kept for the schema files v2 wrote; v3 has no REST surface over tables, so it changes nothing. */
+    exposed: boolean;
+    tables: T;
+    /** Postgres extensions the deploy creates (CREATE EXTENSION IF NOT EXISTS). */
+    extensions: string[];
+    /** Schema-level named raw units (views, materialized views, functions) — see
+     * `RawUnitDef`. `defineSchema` always sets it (`[]` when none); OPTIONAL so a
+     * hand-built `SchemaDef` from before the field still compiles. */
+    raw?: RawUnitDef[];
+}
+/** The author-facing input to `defineSchema` — a `tables` map whose keys are
+ * the table names and whose values are `{ columns, rls?, policies? }`, plus an
+ * optional `extensions` allowlist. */
+export interface SchemaInput<T extends Record<string, TableInput> = Record<string, TableInput>> {
+    tables: T;
+    /**
+     * Postgres extensions the deploy creates, e.g. `["pg_trgm"]` — those the
+     * database machine allows.
+     */
+    extensions?: string[];
+}
+/** Map the author's `{ tables: { <name>: { columns } } }` input to the
+ * `{ tables: { <name>: TableDef<columns> } }` runtime/type shape, threading the
+ * per-table column map `T[K]["columns"]` so column-level inference survives. */
+type TablesByName<T extends readonly TableHandle[]> = {
+    [K in T[number] as K[typeof TABLE_META]["name"]]: K[typeof TABLE_META];
+};
+/**
+ * How a schema file reads. One file per schema — `db/public.ts`, `db/billing.ts`
+ * — and the schema says its own name:
+ *
+ *   const todos = defineTable("todos", {
+ *     columns: {
+ *       id:    uuid().primaryKey().defaultRandom(),
+ *       owner: text().notNull(),
+ *       title: text().notNull(),
+ *     },
+ *     rls: true,
+ *     policies: (p) => [
+ *       policy("owner_all").for("all").to("authenticated")
+ *         .using(p.col("owner").eq(p.auth.uid()))
+ *         .withCheck(p.col("owner").eq(p.auth.uid())),
+ *     ],
+ *   });
+ *
+ *   export default defineSchema("public", { tables: [todos] });
+ *
+ * The dictionary form `defineSchema({ tables: { todos: {…} } })` is RETIRED and
+ * refused by name: a table whose name comes from a key does not know what it is
+ * called while it is being built, so it cannot resolve `references(() =>
+ * other.id)`, and a schema that does not say its own name cannot tell one
+ * `invoices` from another schema's `invoices`.
+ *
+ * The returned value is `{ name, tables: { todos: { name, columns, rls,
+ * policies } }, extensions, exposed }` — the exact shape the runtime schema
+ * extractor parses. Per-column phantom types are preserved so
+ * `Database.public.todos.insert({...})` stays typed.
+ *
+ * RLS normalization: `rls` defaults to **`true`**, `policies` to `[]`. A table
+ * that declares neither is therefore deny-all — nothing reads it until a policy
+ * says who may, which is the safe starting point rather than a bug. Declare
+ * `rls: false` for a genuinely public table; that is an explicit, greppable
+ * statement of intent instead of an omission. When `policies` is non-empty,
+ * `rls` is forced on (ENABLE + FORCE) regardless of the declared flag — a table
+ * with policies must have RLS enabled or the policies would be inert.
+ */
+/**
+ * Where a table's metadata lives.
+ *
+ * The table VALUE is its columns, so `lists.id` is the column — which means a
+ * column called `name` would overwrite the table's own name if metadata sat in
+ * a plain field. Measured, not imagined: the existing `users` / `rooms` tests
+ * (both declare a `name` column) produced an `[object Object]` table key.
+ * `columns`, `rls`, `unique` and `indexes` are all plausible column
+ * names too. A column cannot collide with a symbol.
+ */
+export declare const TABLE_META: unique symbol;
+/**
+ * A value produced by `defineTable`: the columns, plus metadata behind the
+ * symbol. `S` is the table's search as declared: with one, the table's type
+ * says so, and `search()` is typed for it.
+ */
+export type TableHandle<C extends ColumnMap = ColumnMap, N extends string = string, S = undefined> = C & {
+    readonly [TABLE_META]: TableDef<C> & {
+        name: N;
+    } & ([S] extends [undefined] ? unknown : {
+        search: Search;
+    });
+};
+/**
+ * Declare one table as a standalone value that KNOWS ITS OWN NAME.
+ *
+ * The name lives here, not in a dictionary key. A table whose name comes from a
+ * key cannot resolve `references(() => other.id)` when it is built — it does not
+ * know what to call itself — which forces a two-phase resolution with an
+ * empty-name intermediate state. One name source, no empty identity.
+ *
+ * The returned object spreads its own columns, so a sibling can point at it:
+ * `references(() => lists.id)`.
+ */
+export declare function defineTable<const N extends string, C extends ColumnMap, const S extends SearchInput<Extract<keyof C, string>> | undefined = undefined>(name: N, input: TableInput<C> & {
+    search?: S;
+}): TableHandle<C, N, S>;
+/**
+ * Collect declared tables into one schema.
+ *
+ * Takes an ARRAY, not a dictionary: the tables already carry their names, and a
+ * second name source is a second thing that can disagree.
+ */
+export declare function defineSchema<const T extends readonly TableHandle[]>(name: string, input: {
+    tables: T;
+    exposed?: boolean;
+    extensions?: string[];
+    raw?: RawUnitDef[];
+}): SchemaDef<TablesByName<T>>;
+export { check, foreignKey, toForeignKeyDef };
+export type { CheckDef, ForeignKeyBuilder, ForeignKeyDef };

package/types/palgres/src/dsl/to-model.d.ts

@@ -0,0 +1,6 @@
+import { type Policy, type Schema, type Table } from '../model.js';
+import type { SchemaDef } from './schema.js';
+/** One or more schemas (db/public.ts, db/billing.ts, …) as the model. */
+export declare function toModel(schemas: SchemaDef | SchemaDef[]): Schema;
+/** The columns of `t` a policy's SQL names quoted — as the renderer writes a column; a hand-written policy that quotes nothing names none. */
+export declare function policyColumns(t: Table, p: Policy): string[];

package/types/palgres/src/forget.d.ts

@@ -0,0 +1,12 @@
+import { type Binding } from './connect.js';
+import { type Schema } from './model.js';
+interface Begin {
+    begin<T>(fn: (tx: {
+        unsafe(sql: string, params?: unknown[]): PromiseLike<unknown>;
+    }) => Promise<T>): Promise<T>;
+}
+export declare function forgetUser(sql: Begin, binding: Binding, schema: Schema, userId: string, serviceRole?: string): Promise<{
+    deleted: number;
+    detached: number;
+}>;
+export {};

package/types/palgres/src/index.d.ts

@@ -0,0 +1,15 @@
+export { canonicalType, digest, emptySchema, normalize, SchemaError, validate } from './model.js';
+export type { Check, Column, Enum, FkAction, ForeignKey, Index, IndexKey, Policy, Raw, Schema, Search, SearchMetric, Table, Unique } from './model.js';
+export { plan, versionSchema } from './plan.js';
+export type { Layout, Plan, PlanInput, Roles, Step } from './plan.js';
+export { applicationName, cutOff, DEFAULT_ROLES, isDirect, MigrationOpen, MigrationRefused, Migrator, RowsHeld, searchPath, VersionStillConnected } from './migrate.js';
+export type { Adoption, MigratorOptions, Pool, Reserved, StartResult, Status, Version } from './migrate.js';
+export { bind, binding, bindStatement, VersionNotMigrated } from './connect.js';
+export type { Binding } from './connect.js';
+export { forgetUser } from './forget.js';
+export { adoptionBaseline, drift, type Baseline } from './adopt.js';
+export { introspect, type Introspected } from './introspect.js';
+export { pullSchema, type Pulled } from './pull.js';
+export { SEARCH_SCHEMA, vectorTable, type SearchGeneration } from './search.js';
+export { createSearchWorker, type SearchWorker, type SearchWorkerOptions } from './search-worker.js';
+export * from './query/index.js';

package/types/palgres/src/introspect.d.ts

@@ -0,0 +1,17 @@
+import { type Schema } from './model.js';
+import type { Pool } from './migrate.js';
+import type { Roles } from './plan.js';
+import { type SchemaUnit } from './units.js';
+export interface Introspected {
+    schema: Schema;
+    /** What the database holds that the model cannot say, one line each: left as it is. */
+    unmanaged: string[];
+    /** Tables whose row-level security is FORCEd on their owner, as v2 made every table. */
+    forced: string[];
+    /** The objects outside the model by kind and name, each with Postgres' text of it: what a raw unit makes is compared by these. */
+    objects: Map<string, string>;
+    /** Those of them a schema file can carry as raw units, in an order they can be made in (units.ts). */
+    units: SchemaUnit[];
+}
+/** Reads `schemas` (and the enums and extensions they use) off the catalog, on one connection of `pool`. */
+export declare function introspect(pool: Pool, schemas: readonly string[], roles: Roles): Promise<Introspected>;