@supabase/lite 0.0.1-next.1

package/dist/db/fallback.d.ts

@@ -0,0 +1,182 @@
+import { d as deparsePostgresDdl, A as AnyAST, V as VarsContext, I as IntrospectResult$1, T as TransactionOptions$1, a as IConnectionConfig$1, C as Connection$1 } from '../Connection-rAPmec1m.js';
+import { ConnectionMigrator, MaybePromise, SchemaDiffResult, PlanStep, PlanResult, IConnectionConfig, Connection, Dialect, IntrospectResult, TransactionOptions } from '@supabase/lite';
+import { KyselyPlugin } from 'kysely';
+import 'libpg-query';
+import 'pgsql-deparser';
+
+type SqliteMigratorOptions = {
+    onTranslation?: (result: SqlitePostgresTranslationResult) => MaybePromise<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;
+    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>;
+    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$1>;
+    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>;
+
+declare function createConnection(_config?: IConnectionConfig$1): Promise<Connection$1>;
+
+export { CloudConnection, Connection$1 as Connection, type ICloudConnectionConfig, IConnectionConfig$1 as IConnectionConfig, type ISqliteConnectionConfig, SqliteConnection, type SqlitePostgresTranslationResult, cloud, createConnection };