better-supabase 0.0.0 → 0.1.0

package/dist/index-BD6wKthp.d.ts

@@ -0,0 +1,597 @@
+import { E as SchemaMeta, i as Casing } from "./types-C2fslP1z.js";
+import { GeneratorMetadata, Queryable } from "@supabase/postgrest-typegen";
+//#region src/cli/introspect/types.d.ts
+/**
+ * What `better-supabase introspect` reads from Postgres. `generator` is the
+ * `@supabase/postgrest-typegen` contract (the same metadata behind
+ * `supabase gen types`); `extras` holds what that contract leaves out.
+ * Codegen and doctor both work from this snapshot, so either can run offline
+ * from a saved file.
+ */
+interface Snapshot {
+  readonly $schema?: string;
+  readonly version: 2;
+  /** Every schema that was read, including helper schemas for doctor. */
+  readonly schemas: readonly string[];
+  readonly generator: GeneratorMetadata;
+  readonly extras: SnapshotExtras;
+}
+/** Catalog details `GeneratorMetadata` does not carry. */
+interface SnapshotExtras {
+  readonly tables: readonly ExtrasTable[];
+  readonly buckets: readonly SnapshotBucket[];
+  /** Tables in the `supabase_realtime` publication, as `schema.table`. */
+  readonly realtime: readonly string[];
+  /**
+   * `alter role ... set` values for the Data API roles (`authenticator`),
+   * such as `pgrst.db_aggregates_enabled`. Absent in older snapshots.
+   */
+  readonly roleSettings?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  /**
+   * Functions that policies in the read schemas call, plus functions in
+   * those schemas with `set` options. Absent in older snapshots.
+   */
+  readonly functions?: readonly ExtrasFunction[];
+  /**
+   * The Postgres functions `supabase/config.toml` configures as Auth hooks,
+   * in any schema. Absent in older snapshots and without a `config.toml`.
+   */
+  readonly hooks?: readonly ExtrasHook[];
+}
+/** An `[auth.hook.<name>]` with a `pg-functions://` URI. */
+interface ExtrasHook {
+  /** `custom_access_token`, `send_email`, ... */
+  readonly hook: string;
+  readonly schema: string;
+  readonly name: string;
+  /** Every overload with that name; empty when the function does not exist. */
+  readonly functions: readonly ExtrasHookFunction[];
+}
+interface ExtrasHookFunction extends ExtrasFunction {
+  /**
+   * Of `supabase_auth_admin`, `authenticated` and `anon`, the roles that may
+   * execute it (directly or through `public`).
+   */
+  readonly execute: readonly string[];
+  /** Whether `public` may execute it (the default until revoked). */
+  readonly publicExecute: boolean;
+  /** Of the same roles, those with `usage` on its schema. */
+  readonly schemaUsage: readonly string[];
+}
+/** A function as doctor needs it for RLS checks, in any schema. */
+interface ExtrasFunction {
+  readonly schema: string;
+  readonly name: string;
+  /** Identity arguments, e.g. `org uuid`. */
+  readonly signature: string;
+  /** `sql`, `plpgsql`, `c`, ... */
+  readonly language: string;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  readonly securityDefiner: boolean;
+  /** `set` options, e.g. `{ statement_timeout: '5s' }`. */
+  readonly settings: Readonly<Record<string, string>>;
+}
+interface ExtrasTable {
+  /** Table oid, matching `GeneratorMetadata.tables[].id`. */
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  /** Primary key columns in key order. */
+  readonly primaryKey: readonly string[];
+  readonly uniques: readonly CatalogUnique[];
+  readonly foreignKeys: readonly {
+    readonly name: string;
+    readonly onDelete: ForeignKeyAction;
+    readonly onUpdate: ForeignKeyAction;
+  }[];
+  readonly checks: readonly CatalogCheck[];
+  readonly indexes: readonly CatalogIndex[];
+  readonly policies: readonly CatalogPolicy[];
+  readonly triggers: readonly CatalogTrigger[];
+  readonly grants: readonly CatalogGrant[];
+  /** Postgres estimates at least `LARGE_TABLE_ROWS` rows; the `unbounded-read` lint reads it. */
+  readonly large?: true;
+}
+type ForeignKeyAction = "no action" | "restrict" | "cascade" | "set null" | "set default";
+interface CatalogUnique {
+  readonly name: string;
+  readonly columns: readonly string[];
+}
+interface CatalogCheck {
+  readonly name: string;
+  readonly definition: string;
+}
+interface CatalogIndex {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly unique: boolean;
+  readonly primary: boolean;
+  readonly partial: boolean;
+}
+interface CatalogPolicy {
+  readonly name: string;
+  readonly command: "all" | "select" | "insert" | "update" | "delete";
+  readonly roles: readonly string[];
+  readonly permissive: boolean;
+  readonly using: string | null;
+  readonly check: string | null;
+  /**
+   * Functions the policy expressions call, as `schema.name`, from
+   * `pg_depend`. Absent in older snapshots.
+   */
+  readonly functions?: readonly string[];
+}
+interface CatalogTrigger {
+  readonly name: string;
+  readonly timing: "before" | "after" | "instead of";
+  readonly events: readonly ("insert" | "update" | "delete" | "truncate")[];
+  readonly level: "row" | "statement";
+  readonly function: string;
+}
+interface CatalogGrant {
+  readonly role: string;
+  readonly privileges: readonly string[];
+}
+interface SnapshotBucket {
+  readonly id: string;
+  readonly public: boolean;
+  readonly fileSizeLimit: number | null;
+  readonly allowedMimeTypes: readonly string[] | null;
+}
+/**
+ * The snapshot joined into one record per table, function and enum. Codegen
+ * and doctor read this view rather than the raw snapshot.
+ */
+interface Catalog {
+  readonly schemas: readonly string[];
+  readonly tables: readonly CatalogTable[];
+  readonly enums: readonly CatalogEnum[];
+  readonly functions: readonly CatalogFunction[];
+  readonly buckets: readonly SnapshotBucket[];
+  readonly realtime: readonly string[];
+}
+interface CatalogTable {
+  readonly id: number;
+  readonly schema: string;
+  readonly name: string;
+  /** Materialized views count as views; foreign tables as tables. */
+  readonly kind: "table" | "view";
+  readonly rls: boolean;
+  readonly forceRls: boolean;
+  readonly replicaIdentity: "DEFAULT" | "INDEX" | "FULL" | "NOTHING" | null;
+  /** Inserts work (always true for tables). */
+  readonly insertable: boolean;
+  /** Updates work (always true for tables). */
+  readonly updatable: boolean;
+  readonly comment: string | null;
+  readonly columns: readonly CatalogColumn[];
+  readonly primaryKey: readonly string[];
+  readonly uniques: readonly CatalogUnique[];
+  readonly foreignKeys: readonly CatalogForeignKey[];
+  readonly checks: readonly CatalogCheck[];
+  readonly indexes: readonly CatalogIndex[];
+  readonly policies: readonly CatalogPolicy[];
+  readonly triggers: readonly CatalogTrigger[];
+  readonly grants: readonly CatalogGrant[];
+}
+interface CatalogColumn {
+  readonly name: string;
+  /** Type name; the element type for arrays (`uuid`, `int8`, `note_kind`). */
+  readonly udt: string;
+  /** Raw type name as Postgres reports it (`_text` for `text[]`). */
+  readonly format: string;
+  readonly typeSchema: string;
+  readonly isArray: boolean;
+  readonly isEnum: boolean;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly default: string | null;
+  readonly identity: "always" | "by default" | null;
+  readonly generated: boolean;
+  readonly updatable: boolean;
+  readonly comment: string | null;
+}
+interface CatalogForeignKey {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly refSchema: string;
+  readonly refTable: string;
+  readonly refColumns: readonly string[];
+  readonly oneToOne: boolean;
+  readonly onDelete: ForeignKeyAction;
+  readonly onUpdate: ForeignKeyAction;
+}
+interface CatalogEnum {
+  readonly schema: string;
+  readonly name: string;
+  readonly values: readonly string[];
+}
+interface CatalogFunction {
+  readonly schema: string;
+  readonly name: string;
+  /** Signature that tells overloads apart, e.g. `a integer, b text`. */
+  readonly signature: string;
+  readonly args: readonly CatalogFunctionArg[];
+  /** Columns for `returns table (...)` functions. */
+  readonly returnsTable: readonly {
+    readonly name: string;
+    readonly udt: string;
+  }[] | null;
+  /** Return type name (`int4`, `_text`, a table's row type). */
+  readonly returns: string;
+  /** `schema.table` when the function returns rows of a table or view. */
+  readonly returnsRelation: string | null;
+  readonly returnsSet: boolean;
+  readonly volatility: "immutable" | "stable" | "volatile";
+  readonly securityDefiner: boolean;
+  readonly language: string;
+  /** `search_path` from `SET search_path`, or `null` when unset. */
+  readonly searchPath: string | null;
+}
+interface CatalogFunctionArg {
+  readonly name: string;
+  readonly udt: string;
+  readonly isArray: boolean;
+  readonly hasDefault: boolean;
+}
+//#endregion
+//#region src/generators/shared.d.ts
+/** What field planning reads: the metadata and the typed-jsonb config. */
+interface SchemaSource {
+  readonly meta: SchemaMeta;
+  readonly config: {
+    readonly json: Readonly<Record<string, unknown>>;
+  };
+}
+//#endregion
+//#region src/generators/json-schema.d.ts
+interface JsonSchemaGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.schema.json`. */
+  readonly output?: string;
+  /** `$id` of the document. */
+  readonly id?: string;
+}
+type JsonSchema = Record<string, unknown>;
+/** JSON Schema (2020-12) `$defs` for every table: `customersRow`, `customersInsert`, ... */
+declare function buildJsonSchema(input: SchemaSource, id?: string): JsonSchema;
+/** Writes the JSON Schema document; `createOpenApi` reuses the same `$defs`. */
+declare function jsonSchema(options?: JsonSchemaGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/valibot.d.ts
+interface ValibotGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.valibot.ts`. */
+  readonly output?: string;
+  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/** Valibot schemas for every table's Row, Insert and Update shape. */
+declare function valibot(options?: ValibotGeneratorOptions): Generator;
+//#endregion
+//#region src/generators/zod.d.ts
+interface ZodGeneratorOptions {
+  /** Output path relative to the project root. Defaults to `<output>.zod.ts`. */
+  readonly output?: string;
+  /** Schemas for typed jsonb columns: `{ 'customers.metadata': './schemas.ts#metadata' }`. */
+  readonly json?: Readonly<Record<string, string>>;
+}
+/** Zod 4 schemas for every table's Row, Insert and Update shape. */
+declare function zod(options?: ZodGeneratorOptions): Generator;
+//#endregion
+//#region src/config/index.d.ts
+/**
+ * Where codegen reads the database from. Without any of these, `$DATABASE_URL`
+ * and then the local stack (`supabase start`) are used.
+ */
+interface SourceConfig {
+  /** Postgres connection string. */
+  readonly dbUrl?: string;
+  /**
+   * Hosted project ref. Read through the Management API's read-only SQL
+   * endpoint, so no database password is needed.
+   */
+  readonly projectRef?: string;
+  /**
+   * Management API token for `projectRef`. Defaults to
+   * `$SUPABASE_ACCESS_TOKEN`; prefer the env var over committing a token.
+   */
+  readonly accessToken?: string;
+  /** Read a saved `better-supabase introspect` snapshot instead of connecting. */
+  readonly snapshot?: string;
+}
+/**
+ * A JSON Schema object, or a Standard JSON Schema value (zod 4, valibot,
+ * arktype, ...) that can produce one.
+ */
+type JsonSchemaSource = Readonly<Record<string, unknown>> | {
+  readonly "~standard": {
+    readonly jsonSchema: {
+      readonly input: (options: {
+        readonly target: string;
+      }) => Record<string, unknown>;
+    };
+  };
+};
+type JsonTypeConfig = ({
+  readonly import: string;
+} | {
+  readonly type: string;
+}) & {
+  /** Enforced in the database by `sql add jsonb-schemas` (pg_jsonschema). */
+  readonly schema?: JsonSchemaSource;
+};
+/** The JSON Schema document for a `json[...].schema` entry. */
+declare function resolveJsonSchema(source: JsonSchemaSource): Readonly<Record<string, unknown>>;
+interface TableConfig {
+  readonly casing?: Casing;
+  /** Leave the table out of the generated models. */
+  readonly exclude?: boolean;
+  /** Rename generated relations: `{ primaryContact: 'contact' }`. */
+  readonly relations?: Readonly<Record<string, string>>;
+}
+interface TimestampsConfig {
+  readonly createdAt?: string;
+  readonly updatedAt?: string;
+}
+interface SoftDeleteConfig {
+  readonly column?: string;
+}
+interface TenantConfig {
+  readonly column?: string;
+  /** JWT claim holding the tenant id. */
+  readonly claim?: string;
+}
+interface ActorConfig {
+  readonly createdBy?: string;
+  readonly updatedBy?: string;
+}
+interface PluginFlagsConfig {
+  readonly timestamps?: boolean | TimestampsConfig;
+  readonly softDelete?: boolean | SoftDeleteConfig;
+  readonly tenant?: boolean | TenantConfig;
+  readonly actor?: boolean | ActorConfig;
+}
+interface BucketConfig {
+  readonly id?: string;
+  readonly public?: boolean;
+  /** Path template with `{placeholders}`, e.g. `{orgId}/{customerId}/logo.webp`. */
+  readonly path: string;
+  /** Generated storage policy. */
+  readonly policy?: "tenant" | "owner" | "public" | "none";
+  readonly fileSizeLimit?: string;
+  readonly allowedMimeTypes?: readonly string[];
+}
+interface SqlConfig {
+  /** Directory declarative schema files are written to. */
+  readonly dir?: string;
+  /** File name prefix, so generated files sort after yours. */
+  readonly prefix?: string;
+  /** Directory pgTAP files (the `pgtap` module) are written to. */
+  readonly testsDir?: string;
+  /** SQL kit modules to keep in sync (`better-supabase sql add`). */
+  readonly kit?: readonly string[];
+}
+interface SeedConfig {
+  /** Module exporting `defineSeed(...)` as `seed` or default. */
+  readonly entry?: string;
+  /** SQL file `better-supabase seed` writes. Add it to `[db.seed] sql_paths`. */
+  readonly output?: string;
+}
+interface OpenApiConfig {
+  /** Module exporting the document (or a function returning it) as `openapi` or default. */
+  readonly entry?: string;
+  /** JSON file `better-supabase openapi emit` writes. */
+  readonly output?: string;
+}
+interface DoctorConfig {
+  /** Finding codes to skip, e.g. `['BS204']`. */
+  readonly ignore?: readonly string[];
+  /** Treat warnings as errors. */
+  readonly strict?: boolean;
+  /**
+   * App source files doctor scans for API use (BS210). Globs relative to the
+   * root. Defaults to `['src/**\/*.{ts,tsx}']`.
+   */
+  readonly sources?: readonly string[];
+  /**
+   * How many policies a security definer helper may appear in before BS206
+   * asks for an inlinable `language sql stable` function. Defaults to 5.
+   */
+  readonly policyHelperLimit?: number;
+}
+/**
+ * Runtime types for columns whose JSON form loses information. Defaults
+ * match `supabase gen types`: timestamps as ISO strings, `int8` and
+ * `numeric` as numbers.
+ */
+interface CodecsConfig {
+  /** `'date'` decodes `timestamptz`/`timestamp` columns to `Date`. */
+  readonly timestamptz?: "string" | "date";
+  /** `'bigint'` or `'string'` read `int8` exactly (above 2^53). */
+  readonly int8?: "number" | "string" | "bigint";
+  /** `'string'` reads `numeric` exactly. */
+  readonly numeric?: "number" | "string";
+}
+interface GeneratedFile {
+  /** Path relative to the project root. */
+  readonly path: string;
+  readonly contents: string;
+}
+interface GeneratorInput {
+  readonly meta: SchemaMeta;
+  /**
+   * The `@supabase/postgrest-typegen` metadata for the configured schemas,
+   * the same contract `supabase gen types` is built on.
+   */
+  readonly introspection: GeneratorMetadata;
+  /** Constraints, indexes, policies, triggers and grants typegen leaves out. */
+  readonly extras: SnapshotExtras;
+  readonly config: ResolvedConfig;
+  /** Absolute path of the main generated module. */
+  readonly output: string;
+  /** Import path from `from` (a generated file) to `to`, with extension. */
+  readonly importPath: (from: string, to: string) => string;
+}
+/**
+ * Codegen extension point. First-party generators: `zod()`, `valibot()`,
+ * `jsonSchema()`. Prove custom ones with `testGenerator`.
+ */
+interface Generator {
+  readonly name: string;
+  generate(input: GeneratorInput): readonly GeneratedFile[] | Promise<readonly GeneratedFile[]>;
+}
+interface RealtimeConfig {
+  /**
+   * Tables that broadcast a change signal for live queries (`table` or
+   * `schema.table`). Tenant tables broadcast per tenant. Install the
+   * triggers with `better-supabase sql add realtime-tables`.
+   */
+  readonly tables?: readonly string[];
+}
+interface EntitlementsConfig {
+  /**
+   * `table.column` (or `schema.table.column`) holding each tenant's Stripe
+   * customer id, read by the `entitlements` SQL kit module. Defaults to
+   * `organizations.stripe_customer_id`.
+   */
+  readonly customer?: string;
+  /** The tenant id column of that table. Defaults to `id`. */
+  readonly key?: string;
+}
+/** pgvector distance: `<=>` (cosine), `<->` (l2) or `<#>` (negative inner product). */
+type VectorDistance = "cosine" | "l2" | "inner_product";
+/** The embedding column, or the column and its distance (default `cosine`). */
+type VectorSearchConfig = string | {
+  readonly column: string;
+  readonly distance?: VectorDistance;
+};
+/** A privilege the Data API roles can be granted on a table or view. */
+type Privilege = "select" | "insert" | "update" | "delete";
+/**
+ * Data API grants for one table: privileges for `authenticated`, or per
+ * role.
+ */
+type ExposeConfig = readonly Privilege[] | {
+  readonly anon?: readonly Privilege[];
+  readonly authenticated?: readonly Privilege[];
+};
+/** Resolved grants for one table. */
+interface ResolvedExpose {
+  readonly anon: readonly Privilege[];
+  readonly authenticated: readonly Privilege[];
+}
+interface BetterSupabaseConfig {
+  readonly $schema?: string;
+  readonly source?: SourceConfig;
+  /** Postgres schemas to generate. Defaults to `['public']`. */
+  readonly schemas?: readonly string[];
+  /** Casing of generated models and returned rows. Defaults to `'snake'`. */
+  readonly casing?: Casing;
+  readonly tables?: Readonly<Record<string, TableConfig>>;
+  /**
+   * Main generated module. Defaults to `src/lib/supabase/generated.ts`;
+   * `database.types.ts` is written next to it.
+   */
+  readonly output?: string;
+  /**
+   * PostgREST major version, written to `__InternalSupabase` in
+   * `database.types.ts` so `createClient` picks matching behavior.
+   * Defaults to `'13'`.
+   */
+  readonly postgrestVersion?: string;
+  /** Types for jsonb columns, keyed by `table.column`. */
+  readonly json?: Readonly<Record<string, JsonTypeConfig>>;
+  readonly codecs?: CodecsConfig;
+  /**
+   * Columns that must not be read by accident (`table.column` or
+   * `schema.table.column`, database names), for the `noSensitiveSelect` rule.
+   */
+  readonly sensitive?: readonly string[];
+  /**
+   * Text columns that hold an object path, keyed by `table.column` or
+   * `schema.table.column` (database names), with the bucket as the value (a
+   * `buckets` key or a bucket id). Generated rows type them as
+   * `StoragePath<'bucket-id'>`.
+   */
+  readonly storagePaths?: Readonly<Record<string, string>>;
+  /**
+   * Data API grants, keyed by `table` or `schema.table`. Supabase no longer
+   * grants new tables to `anon` and `authenticated` automatically; the
+   * `grants` SQL kit module writes these, and doctor (BS106) checks them.
+   * Tables not listed need `select, insert, update, delete` for
+   * `authenticated` (`select` for views).
+   */
+  readonly expose?: Readonly<Record<string, ExposeConfig>>;
+  /**
+   * Modules that export `defineReadSet` results. `gen` compiles each set to
+   * a function in the `read-sets` SQL kit module. Node imports them, so
+   * relative imports need their `.ts` extension.
+   */
+  readonly readSets?: readonly string[];
+  readonly generators?: readonly Generator[];
+  /** Enables plugin flags in the generated metadata. */
+  readonly plugins?: PluginFlagsConfig;
+  readonly buckets?: Readonly<Record<string, BucketConfig>>;
+  /** Realtime topic templates: `{ notifications: 'org:{orgId}:notifications' }`. */
+  readonly topics?: Readonly<Record<string, string>>;
+  readonly realtime?: RealtimeConfig;
+  readonly entitlements?: EntitlementsConfig;
+  /**
+   * Embedding columns, keyed by `table` or `schema.table`. The
+   * `vector-search` SQL kit module writes `search_<table>(query, k)` for each,
+   * which `db.$search(table, { vector, k })` calls.
+   */
+  readonly vectorSearch?: Readonly<Record<string, VectorSearchConfig>>;
+  readonly sql?: SqlConfig;
+  readonly seed?: SeedConfig;
+  readonly openapi?: OpenApiConfig;
+  readonly doctor?: DoctorConfig;
+}
+/** The config with defaults applied. */
+interface ResolvedConfig {
+  readonly root: string;
+  readonly source: SourceConfig;
+  readonly schemas: readonly string[];
+  readonly casing: Casing;
+  readonly tables: Readonly<Record<string, TableConfig>>;
+  readonly output: string;
+  /** `database.types.ts` next to `output`. */
+  readonly databaseTypesOutput: string;
+  readonly postgrestVersion: string;
+  readonly json: Readonly<Record<string, JsonTypeConfig>>;
+  readonly codecs: Required<CodecsConfig>;
+  readonly sensitive: readonly string[];
+  readonly storagePaths: Readonly<Record<string, string>>;
+  readonly expose: Readonly<Record<string, ResolvedExpose>>;
+  readonly readSets: readonly string[];
+  readonly generators: readonly Generator[];
+  readonly plugins: {
+    readonly timestamps: Required<TimestampsConfig> | undefined;
+    readonly softDelete: Required<SoftDeleteConfig> | undefined;
+    readonly tenant: Required<TenantConfig> | undefined;
+    readonly actor: Required<ActorConfig> | undefined;
+  };
+  readonly buckets: Readonly<Record<string, BucketConfig>>;
+  readonly entitlements: {
+    readonly table: string;
+    readonly column: string;
+    readonly key: string;
+  };
+  readonly vectorSearch: readonly {
+    readonly table: string;
+    readonly column: string;
+    readonly distance: VectorDistance;
+  }[];
+  readonly topics: Readonly<Record<string, string>>;
+  readonly realtime: Required<RealtimeConfig>;
+  readonly sql: Required<SqlConfig>;
+  readonly seed: Required<SeedConfig>;
+  readonly openapi: Required<OpenApiConfig>;
+  readonly doctor: Required<DoctorConfig>;
+}
+declare const CONFIG_SCHEMA_URL = "https://unpkg.com/better-supabase/schemas/config-v1.json";
+/** Identity helper that types `better-supabase.config.ts`. */
+declare function defineConfig(config: BetterSupabaseConfig): BetterSupabaseConfig;
+/** Applies defaults. Paths stay relative to `root`. */
+declare function resolveConfig(config: BetterSupabaseConfig, root: string): ResolvedConfig;
+//#endregion
+export { ExtrasHook as $, resolveConfig as A, CatalogCheck as B, SqlConfig as C, VectorDistance as D, TimestampsConfig as E, valibot as F, CatalogFunctionArg as G, CatalogEnum as H, JsonSchemaGeneratorOptions as I, CatalogPolicy as J, CatalogGrant as K, buildJsonSchema as L, ZodGeneratorOptions as M, zod as N, VectorSearchConfig as O, ValibotGeneratorOptions as P, ExtrasFunction as Q, jsonSchema as R, SourceConfig as S, TenantConfig as T, CatalogForeignKey as U, CatalogColumn as V, CatalogFunction as W, CatalogTrigger as X, CatalogTable as Y, CatalogUnique as Z, RealtimeConfig as _, CodecsConfig as a, SnapshotExtras as at, SeedConfig as b, ExposeConfig as c, GeneratorInput as d, ExtrasHookFunction as et, JsonSchemaSource as f, Privilege as g, PluginFlagsConfig as h, CONFIG_SCHEMA_URL as i, SnapshotBucket as it, resolveJsonSchema as j, defineConfig as k, GeneratedFile as l, OpenApiConfig as m, BetterSupabaseConfig as n, ForeignKeyAction as nt, DoctorConfig as o, GeneratorMetadata as ot, JsonTypeConfig as p, CatalogIndex as q, BucketConfig as r, Snapshot as rt, EntitlementsConfig as s, Queryable as st, ActorConfig as t, ExtrasTable as tt, Generator as u, ResolvedConfig as v, TableConfig as w, SoftDeleteConfig as x, ResolvedExpose as y, Catalog as z };

package/dist/index-DQVvHzjW.d.ts

@@ -0,0 +1,74 @@
+import { E as SchemaMeta } from "./types-C2fslP1z.js";
+import { a as EventHub, s as MutationNotice } from "./events-2OJsVG_d.js";
+import { l as MutationKind } from "./plugin-HvGqCurB.js";
+//#region src/events/index.d.ts
+/** A CloudEvents 1.0 event. Extension attributes are lowercase alphanumerics. */
+interface CloudEvent<T = unknown> {
+  readonly specversion: "1.0";
+  readonly id: string;
+  readonly source: string;
+  readonly type: string;
+  readonly subject?: string;
+  readonly time?: string;
+  readonly datacontenttype?: string;
+  readonly dataschema?: string;
+  readonly data?: T;
+  readonly [extension: string]: unknown;
+}
+declare const ROW_EVENT_TYPES: { readonly [K in MutationKind]: string; };
+interface RowEventData {
+  readonly table: string;
+  readonly row: Readonly<Record<string, unknown>>;
+}
+interface CloudEventOptions {
+  /** URI-reference of the producer, e.g. `https://crm.example.com` or `/crm`. */
+  readonly source: string;
+  /** Replaces the `dev.better-supabase` type prefix. */
+  readonly typePrefix?: string;
+  readonly id?: () => string;
+  readonly now?: () => Date;
+}
+/** Sends events somewhere: a queue, a bus, an outbox table, an HTTP endpoint. */
+interface EventSink {
+  send(events: readonly CloudEvent[]): void | Promise<void>;
+}
+/**
+ * One CloudEvent per mutated row: `dev.better-supabase.row.created` with the
+ * app-cased row as `data`, the primary key as `subject`, the tenant as
+ * `partitionkey` and the actor as `actorid`.
+ */
+declare function toCloudEvents(notice: MutationNotice, options: CloudEventOptions & {
+  readonly meta?: SchemaMeta;
+}): CloudEvent<RowEventData>[];
+interface ForwardOptions extends CloudEventOptions {
+  /** Only forward these tables or kinds. */
+  readonly filter?: (notice: MutationNotice) => boolean;
+  /** Sink failures never fail the mutation. Defaults to the `Logger`. */
+  readonly onError?: (error: unknown, events: readonly CloudEvent[]) => void;
+}
+/**
+ * Sends a CloudEvent for every mutation to `sink`. Returns a function that
+ * stops forwarding. Use an outbox (SQL kit) when events must not be lost.
+ */
+declare function forwardMutations(sb: {
+  readonly events: EventHub;
+  readonly meta: SchemaMeta;
+}, sink: EventSink, options: ForwardOptions): () => void;
+type HttpMode = "structured" | "binary" | "batch";
+/** The HTTP protocol binding: headers and body for one event (or a batch). */
+declare function toHttp(events: CloudEvent | readonly CloudEvent[], mode?: HttpMode): {
+  headers: Record<string, string>;
+  body: string;
+}[];
+declare function isCloudEvent(value: unknown): value is CloudEvent;
+/** Reads CloudEvents from a request in any of the three HTTP modes. */
+declare function fromHttp(request: Request): Promise<CloudEvent[]>;
+interface HttpSinkOptions {
+  readonly mode?: HttpMode;
+  readonly headers?: Readonly<Record<string, string>>;
+  readonly fetch?: typeof fetch;
+}
+/** POSTs events to `url`. Non-2xx responses reject. */
+declare function httpSink(url: string | URL, options?: HttpSinkOptions): EventSink;
+//#endregion
+export { HttpMode as a, RowEventData as c, httpSink as d, isCloudEvent as f, ForwardOptions as i, forwardMutations as l, toHttp as m, CloudEventOptions as n, HttpSinkOptions as o, toCloudEvents as p, EventSink as r, ROW_EVENT_TYPES as s, CloudEvent as t, fromHttp as u };