@supabase/lite 0.2.1-next.1 → 0.2.1-next.2

package/dist/index.d.ts

@@ -1,20 +1,169 @@
 import * as _supabase_supabase_js from '@supabase/supabase-js';
 import { SupabaseClientOptions } from '@supabase/supabase-js';
 import { D as DefaultSchema, S as Schema } from './index-xv_pDjEt.js';
-import { Connection } from '@supabase/lite';
+import { Connection, ConnectionMigrator, MaybePromise as MaybePromise$1, SchemaDiffResult, PlanStep, PlanResult, IConnectionConfig, Dialect as Dialect$2, IntrospectResult as IntrospectResult$1, TransactionOptions } from '@supabase/lite';
 import * as hono_hono_base from 'hono/hono-base';
-import { b as CacheDriver, c as CacheSetOptions, P as PolicyCommand, e as PolicyRole, f as Policy } from './Connection-rAPmec1m.js';
-export { g as AST, h as ASTType, i as AggregateFunction, A as AnyAST, B as BaseAST, j as BodyResult, k as CheckConstraintInfo, l as ColumnDef, m as ColumnDiff, n as ColumnInfo, o as ColumnRef, p as CommentInfo, C as Connection, q as ConnectionContextOptions, r as ConnectionMigrator, s as CustomTypesInfo, D as DataLossError, t as DataLossWarning, u as DeleteAST, v as Dialect, w as DiffResult, E as EmbedDef, x as EmbedTransform, y as ExplainOptions, F as FiltersResult, z as ForeignKeyDiff, G as ForeignKeyInfo, H as HeadersResult, a as IConnectionConfig, J as IndexDiff, K as IndexInfo, L as InsertAST, M as IntrospectOptions, I as IntrospectResult, N as JoinDef, O as JoinMap, Q as Meta, R as MigrationError, S as OrderEntry, U as PlanResult, W as PlanStep, X as PlanStepType, Y as PreferToken, Z as PrimaryKeyInfo, _ as Qb, $ as QbDelete, a0 as QbInsert, a1 as QbSelect, a2 as QbUpdate, a3 as QueryAST, a4 as QueryParamsResult, a5 as RelationNotFoundError, a6 as RouteResult, a7 as RpcAST, a8 as RpcResult, a9 as SchemaDiffResult, aa as SelectEntry, ab as SelectResult, ac as TableDiff, ad as TableInfo, ae as TextSearchValue, T as TransactionOptions, af as TransformsResult, ag as TranslatorConfig, ah as TriggerInfo, ai as UniqueConstraintInfo, aj as UpdateAST, ak as UpsertAST, al as UpsertResult, V as VarsContext, am as ViewInfo, an as Where, ao as WhereValue, ap as isRef, aq as translatePostgresDdl } from './Connection-rAPmec1m.js';
+import { W as Where, a as IntrospectResult, b as CacheDriver, c as CacheSetOptions, A as AnyAST, V as VarsContext, T as TransactionOptions$1 } from './Connection-CSVCuMv-.js';
+export { d as AST, e as ASTType, f as AggregateFunction, B as BaseAST, g as BodyResult, h as CheckConstraintInfo, i as ColumnDef, j as ColumnDiff, k as ColumnInfo, l as ColumnRef, m as CommentInfo, C as Connection, n as ConnectionContextOptions, o as ConnectionMigrator, p as CustomTypesInfo, D as DataLossError, q as DataLossWarning, r as DeleteAST, s as Dialect, t as DiffResult, E as EmbedDef, u as EmbedTransform, v as ExplainOptions, F as FiltersResult, w as ForeignKeyDiff, x as ForeignKeyInfo, H as HeadersResult, I as IConnectionConfig, y as IndexDiff, z as IndexInfo, G as InsertAST, J as IntrospectOptions, K as JoinDef, L as JoinMap, M as Meta, N as MigrationError, O as OrderEntry, P as PlanResult, Q as PlanStep, R as PlanStepType, S as PreferToken, U as PrimaryKeyInfo, X as Qb, Y as QbDelete, Z as QbInsert, _ as QbSelect, $ as QbUpdate, a0 as QueryAST, a1 as QueryParamsResult, a2 as RelationNotFoundError, a3 as RouteResult, a4 as RpcAST, a5 as RpcResult, a6 as SchemaDiffResult, a7 as SelectEntry, a8 as SelectResult, a9 as TableDiff, aa as TableInfo, ab as TextSearchValue, ac as TransformsResult, ad as TranslatorConfig, ae as TriggerInfo, af as UniqueConstraintInfo, ag as UpdateAST, ah as UpsertAST, ai as UpsertResult, aj as ViewInfo, ak as WhereValue, al as isRef } from './Connection-CSVCuMv-.js';
 import * as hono_utils_http_status from 'hono/utils/http-status';
 import * as hono_utils_types from 'hono/utils/types';
 import * as hono_types from 'hono/types';
 import * as hono from 'hono';
 import { MiddlewareHandler, Context } from 'hono';
-import { Kysely } from 'kysely';
+import { Kysely, KyselyPlugin } from 'kysely';
 import { ReadableStream as ReadableStream$1 } from 'node:stream/web';
+import { ParseResult } from 'libpg-query';
+import { DeparserOptions } from 'pgsql-deparser';
 import 'jsonv-ts';
-import 'libpg-query';
-import 'pgsql-deparser';
+
+type TUnwrappedConst = string | number | boolean | null | undefined;
+
+type PolicyCommand = "SELECT" | "INSERT" | "UPDATE" | "DELETE" | "ALL";
+type PolicyRole = "anon" | "authenticated" | string;
+interface PolicyData {
+    name: string;
+    table: string;
+    schema?: string;
+    command: PolicyCommand;
+    permissive: boolean;
+    roles: PolicyRole[];
+    using?: Where;
+    withCheck?: Where;
+}
+declare class Policy {
+    readonly data: PolicyData;
+    constructor(data: PolicyData);
+    appliesTo(cmd: "SELECT" | "INSERT" | "UPDATE" | "DELETE"): boolean;
+    appliesToRole(role: string): boolean;
+    toJSON(): PolicyData;
+    static fromJSON(data: PolicyData): Policy;
+}
+
+declare class CheckConstraintError extends Error {
+    readonly table: string;
+    readonly column: string;
+    readonly constraint: string;
+    readonly value: unknown;
+    constructor(table: string, column: string, constraint: string, value: unknown);
+}
+
+type SqliteType = "INTEGER" | "REAL" | "TEXT" | "BLOB" | "ANY";
+type DefaultFn = () => unknown;
+interface ValidationResult {
+    status: "pass" | "warn" | "fail";
+    message: string | null;
+    action?: string;
+}
+interface FieldContext {
+    schema: string;
+    table: string;
+    column: string;
+    pgTypeName: string;
+    nullable: boolean;
+    defaultValue: string | null;
+    defaultFn?: DefaultFn | null;
+    isPrimaryKey: boolean;
+    isUnique: boolean;
+    isSerial: boolean;
+    isGenerated?: boolean;
+    fkRef?: {
+        refSchema?: string;
+        refTable: string;
+        refColumn: string;
+        constraintName?: string;
+    };
+    hasCheck?: boolean;
+    checkConstraintName?: string;
+    uniqueConstraintName?: string;
+}
+interface ColumnDDLOptions {
+    includeNullable?: boolean;
+}
+declare abstract class Field {
+    readonly context: FieldContext;
+    constructor(context: FieldContext);
+    abstract get sqliteType(): SqliteType;
+    get isShimBacked(): boolean;
+    checkConstraint(): string | null;
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): unknown;
+    validateStorage(_rawSqliteValue: unknown): ValidationResult;
+    protected validationFail(message: string, action?: string): ValidationResult;
+    protected validationPass(): ValidationResult;
+    protected isNullish(value: unknown): value is null | undefined;
+    toColumnDDL(options?: ColumnDDLOptions): string;
+    protected checkError(constraint: string, value: unknown): CheckConstraintError;
+    protected quoteIfNeeded(name: string): string;
+}
+
+type FunctionResolutionMode = "synthetic" | "translate" | "auto";
+
+declare class TableSchema {
+    readonly table: string;
+    readonly schema: string;
+    private fields;
+    constructor(table: string, schema?: string, fields?: Map<string, Field>);
+    get(col: string): Field | undefined;
+    has(col: string): boolean;
+    set(col: string, field: Field): void;
+    columns(): string[];
+    all(): Field[];
+    serializeRow(row: Record<string, unknown>): Record<string, unknown>;
+    deserializeRow(row: Record<string, unknown>): Record<string, unknown>;
+    applyDefaults(row: Record<string, unknown>): Record<string, unknown>;
+}
+
+type CollectedEnums = Map<string, string[]>;
+type CollectedVariable = {
+    local?: boolean;
+    value: TUnwrappedConst;
+};
+type CollectedVariables = Map<string, CollectedVariable>;
+type CollectedRlsTables = Set<string>;
+type CollectedSchema = Map<string, TableSchema>;
+type CollectedTableConstraint = {
+    schema: string;
+    table: string;
+    kind: "unique" | "check" | "foreign_key";
+    name?: string;
+    columns: string[];
+    refSchema?: string;
+    refTable?: string;
+    refColumns?: string[];
+};
+type CollectedComment = {
+    schema: string;
+    table: string;
+    column?: string;
+    text: string;
+};
+
+type SchemaHandling = "default" | "prefix";
+interface DeparseOptions extends DeparserOptions {
+    schemaHandling?: SchemaHandling;
+    forceDefaultSchema?: string | false;
+    enums?: CollectedEnums;
+    /** Current DB introspection. Required for ALTER TABLE ops that need 12-step rebuild. */
+    introspection?: IntrospectResult;
+    functionResolution?: FunctionResolutionMode;
+}
+
+declare function translatePostgresDdl(pgSql: string, options?: DeparseOptions): Promise<string>;
+declare function deparsePostgresDdl(pgSql: string, options?: DeparseOptions & {
+    strict?: boolean;
+}): Promise<{
+    ddl: string;
+    enums: CollectedEnums;
+    rls: {
+        tables: CollectedRlsTables;
+        policies: Policy[];
+    };
+    schema: CollectedSchema;
+    vars: CollectedVariables;
+    tableConstraints: CollectedTableConstraint[];
+    comments: CollectedComment[];
+    ast: ParseResult;
+}>;
 
 interface UsersTable {
     id: string;
@@ -2356,6 +2505,179 @@ declare class InvalidPostgresToSQLiteTranslation extends Error {
     constructor(pgSql: string, sqliteDdl: string, cause: Error | unknown);
 }
 
+type SqliteMigratorOptions = {
+    onTranslation?: (result: SqlitePostgresTranslationResult) => MaybePromise$1<void>;
+};
+declare class SqliteMigrator implements ConnectionMigrator {
+    private readonly conn;
+    private readonly desiredSchema;
+    private readonly options;
+    private readonly differ;
+    private readonly planner;
+    translationResult?: SqlitePostgresTranslationResult;
+    constructor(conn: SqliteConnection, desiredSchema: string, options?: SqliteMigratorOptions);
+    getDesiredSchema(): Promise<string>;
+    diff(): Promise<SchemaDiffResult>;
+    safeSortPlanSteps(steps: PlanStep[]): PlanStep[];
+    migratePlan(planResult: PlanResult, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    migrate(opts?: {
+        force?: boolean;
+    }): Promise<SchemaDiffResult>;
+}
+
+interface ISqliteConnectionConfig extends IConnectionConfig {
+    /**
+     * The origin dialect for schema declarations. If "postgres",
+     * the schema declarations will be translated to SQLite syntax.
+     * If "sqlite", the schema declarations will be left as is.
+     * @default "postgres"
+     */
+    ddlDialect?: "postgres" | "sqlite";
+    /**
+     * The origin dialect for query execution. If "sqlite", the queries will be executed as is.
+     * Currently only "sqlite" is supported.
+     * @default "sqlite"
+     */
+    queryDialect?: "sqlite";
+    /**
+     * Max bound parameters per statement. Enforced across all SQLite drivers
+     * for portability: drivers and hosts vary in how many parameters they
+     * accept (e.g. Cloudflare D1, sqlite-wasm), so we cap conservatively.
+     * Statements exceeding this throw before execution.
+     * @default 100
+     */
+    maxBoundParameters?: number;
+    /**
+     * Translation options for SQLite databases
+     */
+    translation?: {
+        /**
+         * The approach to take when translating PostgreSQL schema declarations to SQLite syntax.
+         * Only applies if `ddl` is "postgres".
+         */
+        schemas?: {
+            /**
+             * The approach to take when translating PostgreSQL schema declarations to SQLite syntax.
+             * If "quote" -> `public`.`table` -> `"public.table"`
+             * If "snake_case" -> `public`.`table` -> `public__table`
+             * @default "quote"
+             */
+            approach?: "quote" | "snake_case";
+            /**
+             * Whether to append the default schema to the table name when a table does not have a schema
+             * @default false
+             */
+            appendDefaultSchema?: boolean;
+            /**
+             * The default schema to use when a table does not have a schema
+             * @default "public"
+             */
+            defaultSchema?: string | false;
+        };
+        /**
+         * Deparse details the connection must be aware of
+         */
+        deparse?: SqlitePostgresDeparseInfo;
+    };
+}
+type DeparsePostgresDdlResult = Awaited<ReturnType<typeof deparsePostgresDdl>>;
+type SqlitePostgresDeparseInfo = Pick<DeparsePostgresDdlResult, "enums" | "rls" | "schema" | "vars"> & Partial<Pick<DeparsePostgresDdlResult, "tableConstraints" | "comments">>;
+type SqlitePostgresTranslationResult = Pick<DeparsePostgresDdlResult, "ddl"> & Partial<DeparsePostgresDdlResult>;
+declare abstract class SqliteConnection<Driver = unknown, DB = any, Config extends ISqliteConnectionConfig = ISqliteConnectionConfig> extends Connection<Driver, DB, Config> {
+    dialect: Dialect$2;
+    deserializeRow(row: Record<string, unknown>): Record<string, unknown>;
+    constructor(config?: Config);
+    static parseDeparseInfo(details: any): {
+        rls?: undefined;
+        vars?: undefined;
+    } | {
+        rls: {
+            tables: any;
+            policies: any;
+        };
+        vars: any;
+    };
+    updateDeparseInfo(details: NonNullable<ISqliteConnectionConfig["translation"]>["deparse"]): void;
+    protected withSqlitePlugins(add_plugins?: KyselyPlugin[]): KyselyPlugin[];
+    translateDdl(ddl: string): Promise<SqlitePostgresTranslationResult>;
+    introspect(options?: {
+        useCache?: boolean;
+        postprocess?: boolean;
+    }): Promise<IntrospectResult$1>;
+    transaction(statements: string[], opts?: TransactionOptions): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * When ddlDialect === "postgres", enrich the PRAGMA-derived IntrospectResult
+     * with metadata recovered from the parsed Postgres DDL: real FK constraint
+     * names, table-level UNIQUE/CHECK constraints, column pg_type / is_generated,
+     * and comments.
+     */
+    private mergeDeparseMetadata;
+    private markForeignKeyVisibility;
+    /**
+     * Create a migrator for the given schema.
+     * @param desiredSchema The desired schema to migrate to. Input DDL is expected to be `config.ddlDialect`.
+     * @returns A migrator instance.
+     */
+    createMigrator(desiredSchema: string): SqliteMigrator;
+    get maxBoundParameters(): number;
+    /**
+     * Throws if the compiled statement has more bound parameters than
+     * `maxBoundParameters`. Drivers call this from their query executor so
+     * the same limit is enforced regardless of host capability.
+     */
+    assertParamLimit(parameters: readonly unknown[] | undefined): void;
+    /**
+     * Asserts the parameter limit and normalizes bind values. Drivers call
+     * this once per statement; same limit and same value coercion everywhere.
+     */
+    prepareBindParams(parameters: readonly unknown[] | undefined): unknown[];
+    /**
+     * Coerces JS values to types every SQLite driver accepts. Drivers vary:
+     * `bun:sqlite` silently coerces booleans, `node:sqlite` throws. Normalize
+     * centrally so the executor boundary behaves identically everywhere.
+     *
+     * - `undefined` is dropped (matches prior DO behaviour and Kysely slots
+     *   that never bound a value).
+     * - `boolean` → `0` / `1`.
+     * - pass-through: `null`, `number`, `bigint`, `string`, `Uint8Array`,
+     *   `ArrayBuffer`, `Date` (drivers handle these, or upstream field
+     *   serializers have already converted).
+     * - unknown types throw with the offending index so divergence surfaces
+     *   loudly instead of as a driver-specific bind error.
+     */
+    normalizeBindParams(parameters: readonly unknown[] | undefined): unknown[];
+    normalizeDbError(e: unknown): unknown;
+    onPostgrestAST(ast: AnyAST, vars?: VarsContext): Promise<AnyAST>;
+    private applyRls;
+}
+
+interface ICloudConnectionConfig extends ISqliteConnectionConfig {
+    projectRef: string;
+    token: string;
+    host: string;
+}
+declare class CloudConnection<DB = any> extends SqliteConnection<never, DB> {
+    readonly config: ICloudConnectionConfig;
+    dialect: "sqlite";
+    driver: never;
+    kysely: never;
+    constructor(config: ICloudConnectionConfig);
+    private fetch;
+    introspect(options?: {
+        useCache?: boolean;
+        postprocess?: boolean;
+    }): Promise<IntrospectResult>;
+    transaction(statements: string[], opts?: TransactionOptions$1): Promise<void>;
+    exec<T = {
+        rows: unknown[];
+    } | void>(statement: string, ...parameters: readonly unknown[]): Promise<T>;
+    close(): Promise<void>;
+}
+declare function cloud<DB = any>(config: ICloudConnectionConfig): CloudConnection<DB>;
+
 type Primitive = string | number | boolean;
 declare function isPrimitive(value: any): value is Primitive;
 type BooleanLike = boolean | 0 | 1;
@@ -2495,4 +2817,4 @@ declare function isExperimentalEnabled(name: ExperimentalFeature): boolean;
 declare function setExperimental(name: ExperimentalFeature, enabled: boolean): void;
 declare function listEnabledExperimentals(): ExperimentalFeature[];
 
-export { App, type AppDrivers, AwsSesEmailDriver, type AwsSesEmailDriverOptions, type BooleanLike, CacheDriver, CacheSetOptions, CloudflareKvCacheDriver, type CloudflareKvCacheDriverOptions, type DefaultAppConfig, type EmailDriver, type EmailMessage, type ExperimentalFeature, type HonoContext, type IAppConfig, InMemoryEmailDriver, type InMemoryEmailDriverOptions, InMemoryLruCacheDriver, type InMemoryLruCacheDriverOptions, InvalidPostgresToSQLiteTranslation, type MatchPattern, type MaybePromise, NoopEmailDriver, type NoopEmailDriverOptions, NoopSmsDriver, type NoopSmsDriverOptions, type PartialAppDrivers, type Primitive, type RedisCacheClient, RedisCacheDriver, type RedisCacheDriverOptions, ResendEmailDriver, type ResendEmailDriverOptions, Schema, SendmailEmailDriver, type SendmailEmailDriverOptions, type ServerOptions, type SmsDriver, type SmsMessage, type StoredEmailMessage, UnableToCreateRuntimeConnection, checkPasswordStrength, cleanSql, createAppDrivers, ensureVar, filterSearchParams, formatSendmailMessage, fuzzyMatch, getAuthSchemaSql, getPath, getStatementsArray, invariant, isBooleanLike, isBun, isEmail, isEqual, isExperimentalEnabled, isNode, isObject, isPlainObject, isPrimitive, isString, jsonStringify, listEnabledExperimentals, measureTime, mergeObject, mergeObjectWith, normalizeDefault, normalizeSql, normalizeString, normalizeType, objectDiff, omit, params, parseBigInt, patternMatch, pick, pipe, pipeEach, quote, randomString, replacePlaceholders, requireAuth, resolveAuth, setExperimental, setPath, slugify, snakeToPascalWithSpaces, splitSqlStatements, studioRouteHandler, threw, threwAsync, truncate, trySync, ucFirst, ucFirstAll, uuid };
+export { AnyAST, App, type AppDrivers, AwsSesEmailDriver, type AwsSesEmailDriverOptions, type BooleanLike, CacheDriver, CacheSetOptions, CloudConnection, CloudflareKvCacheDriver, type CloudflareKvCacheDriverOptions, type DefaultAppConfig, type EmailDriver, type EmailMessage, type ExperimentalFeature, type HonoContext, type IAppConfig, type ICloudConnectionConfig, type ISqliteConnectionConfig, InMemoryEmailDriver, type InMemoryEmailDriverOptions, InMemoryLruCacheDriver, type InMemoryLruCacheDriverOptions, IntrospectResult, InvalidPostgresToSQLiteTranslation, type MatchPattern, type MaybePromise, NoopEmailDriver, type NoopEmailDriverOptions, NoopSmsDriver, type NoopSmsDriverOptions, type PartialAppDrivers, type Primitive, type RedisCacheClient, RedisCacheDriver, type RedisCacheDriverOptions, ResendEmailDriver, type ResendEmailDriverOptions, Schema, SendmailEmailDriver, type SendmailEmailDriverOptions, type ServerOptions, type SmsDriver, type SmsMessage, SqliteConnection, type SqlitePostgresTranslationResult, type StoredEmailMessage, TransactionOptions$1 as TransactionOptions, UnableToCreateRuntimeConnection, VarsContext, Where, checkPasswordStrength, cleanSql, cloud, createAppDrivers, ensureVar, filterSearchParams, formatSendmailMessage, fuzzyMatch, getAuthSchemaSql, getPath, getStatementsArray, invariant, isBooleanLike, isBun, isEmail, isEqual, isExperimentalEnabled, isNode, isObject, isPlainObject, isPrimitive, isString, jsonStringify, listEnabledExperimentals, measureTime, mergeObject, mergeObjectWith, normalizeDefault, normalizeSql, normalizeString, normalizeType, objectDiff, omit, params, parseBigInt, patternMatch, pick, pipe, pipeEach, quote, randomString, replacePlaceholders, requireAuth, resolveAuth, setExperimental, setPath, slugify, snakeToPascalWithSpaces, splitSqlStatements, studioRouteHandler, threw, threwAsync, translatePostgresDdl, truncate, trySync, ucFirst, ucFirstAll, uuid };