@supabase/lite 0.0.1-next.1

package/dist/Connection-rAPmec1m.d.ts

@@ -0,0 +1,710 @@
+import { ParseResult } from 'libpg-query';
+import { DeparserOptions } from 'pgsql-deparser';
+import { SelectQueryBuilder, InsertQueryBuilder, UpdateQueryBuilder, DeleteQueryBuilder, KyselyConfig, Kysely } from 'kysely';
+
+/**
+ * Nested object for runtime variable substitution.
+ * Paths are resolved via lodash-style dot-path access (e.g. "auth.jwt.role" → vars.auth.jwt.role).
+ * e.g. { auth: { uid: "uuid-here", role: "authenticated", jwt: { role: "admin" } } }
+ */
+type VarsContext = Record<string, unknown>;
+
+type ASTType = "query" | "insert" | "update" | "delete" | "upsert" | "put" | "rpc";
+type QbSelect = SelectQueryBuilder<any, any, any>;
+type QbInsert = InsertQueryBuilder<any, any, any>;
+type QbUpdate = UpdateQueryBuilder<any, any, any, any>;
+type QbDelete = DeleteQueryBuilder<any, any, any>;
+type Qb = QbSelect | QbInsert | QbUpdate | QbDelete;
+type ColumnDef = {
+    column?: string;
+    cast?: string;
+    preCast?: string;
+    aggregate?: AggregateFunction;
+    bareCount?: boolean;
+    path?: string;
+    /** True when the trailing JSON-path operator was `->>` (text extract). */
+    pathText?: boolean;
+    /** First key reached after an earlier `->>` text extraction. */
+    invalidJsonTextTraversalKey?: string;
+};
+type EmbedDef = {
+    select?: SelectEntry[];
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    spread?: boolean;
+    join?: JoinMap;
+};
+type SelectEntry = string | Record<string, ColumnDef | EmbedDef>;
+type JoinDef = {
+    from?: string;
+    type?: "inner" | "left";
+    hint?: string;
+    on?: Where;
+};
+type JoinMap = Record<string, JoinDef>;
+type ColumnRef = {
+    $ref: string;
+};
+declare function isRef(val: unknown): val is ColumnRef;
+type WhereValue = {
+    [op: string]: unknown;
+};
+type Where = Record<string, unknown>;
+type OrderEntry = {
+    column: string;
+    direction?: "asc" | "desc";
+    nullsFirst?: boolean;
+    /** For ordering by embedded resource column: embed alias */
+    embed?: string;
+};
+type TextSearchValue = {
+    query: string;
+    type?: "plain" | "phrase" | "websearch";
+    config?: string;
+};
+type ExplainOptions = {
+    analyze?: boolean;
+    verbose?: boolean;
+    settings?: boolean;
+    buffers?: boolean;
+    wal?: boolean;
+};
+type Meta = {
+    cardinality?: "one" | "maybe" | "many";
+    count?: "exact" | "planned" | "estimated";
+    head?: boolean;
+    maxAffected?: number;
+    rollback?: boolean;
+    missing?: "null" | "default";
+    handling?: "strict" | "lenient";
+    timezone?: string;
+    columns?: string[];
+    stripNulls?: boolean;
+    explain?: ExplainOptions;
+    headers?: Record<string, string>;
+    return?: "minimal" | "headers-only" | "representation";
+    tx?: "commit" | "rollback";
+};
+interface BaseAST {
+    from: string;
+    schema?: string;
+    select?: SelectEntry[];
+    $meta?: Meta;
+}
+interface QueryAST extends BaseAST {
+    type: "query";
+    join?: JoinMap;
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    group?: string[];
+}
+interface InsertAST extends BaseAST {
+    type: "insert";
+    values: object | object[];
+}
+interface UpdateAST extends BaseAST {
+    type: "update";
+    values: object;
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+}
+interface DeleteAST extends BaseAST {
+    type: "delete";
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+}
+interface UpsertAST extends BaseAST {
+    type: "upsert" | "put";
+    values: object;
+    onConflict?: string[];
+    ignoreDuplicates?: boolean;
+}
+interface RpcAST extends BaseAST {
+    type: "rpc";
+    function: string;
+    args?: object | unknown[];
+    where?: Where;
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    httpMethod?: "GET" | "POST";
+    paramsType?: "named" | "positional";
+    inputType?: "json" | "text" | "binary" | "xml";
+}
+type AST = QueryAST | InsertAST | UpdateAST | DeleteAST | UpsertAST | RpcAST;
+type AnyAST = {
+    type?: string;
+    from?: string;
+    function?: string;
+    schema?: string;
+    join?: JoinMap;
+    select?: SelectEntry[];
+    where?: Where;
+    values?: object | object[];
+    args?: object | unknown[];
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    group?: string[];
+    onConflict?: string[];
+    ignoreDuplicates?: boolean;
+    httpMethod?: "GET" | "POST";
+    paramsType?: "named" | "positional";
+    inputType?: "json" | "text" | "binary" | "xml";
+    $meta?: Meta;
+};
+type AggregateFunction = "count" | "sum" | "avg" | "min" | "max";
+type RouteResult = {
+    from?: string;
+    function?: string;
+    isRpc: boolean;
+};
+type PreferToken = {
+    key: "count";
+    value: "exact" | "planned" | "estimated";
+} | {
+    key: "resolution";
+    value: "merge-duplicates" | "ignore-duplicates";
+} | {
+    key: "return";
+    value: "minimal" | "headers-only" | "representation";
+} | {
+    key: "tx";
+    value: "commit" | "rollback";
+} | {
+    key: "missing";
+    value: "default" | "null";
+} | {
+    key: "handling";
+    value: "strict" | "lenient";
+} | {
+    key: "max-affected";
+    value: number;
+} | {
+    key: "timezone";
+    value: string;
+} | {
+    key: "params";
+    value: "single-object" | "multiple-objects";
+};
+type HeadersResult = {
+    schema?: string;
+    preferTokens: PreferToken[];
+    accept: string;
+};
+type SelectResult = {
+    select: SelectEntry[];
+    join: JoinMap;
+    embeddedAliases: Set<string>;
+};
+type BodyResult = {
+    values?: object | object[];
+    args?: object;
+    raw?: string;
+};
+type QueryParamsResult = Map<string, string[]>;
+type FiltersResult = {
+    where: Where;
+    embeddedWheres: Record<string, Where>;
+};
+type EmbedTransform = {
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    _nested?: Record<string, {
+        order?: OrderEntry[];
+        limit?: number;
+        offset?: number;
+    }>;
+};
+type TransformsResult = {
+    order?: OrderEntry[];
+    limit?: number;
+    offset?: number;
+    embeddedTransforms: Record<string, EmbedTransform>;
+};
+type RpcResult = {
+    args?: object | unknown[];
+    httpMethod?: "GET" | "POST";
+    paramsType?: "named" | "positional";
+    inputType?: "json" | "text" | "binary" | "xml";
+};
+type UpsertResult = {
+    onConflict?: string[];
+    ignoreDuplicates: boolean;
+};
+type TranslatorConfig = {
+    parseRoute?: (req: Request) => RouteResult;
+    parseHeaders?: (req: Request) => HeadersResult;
+    parseSelect?: (req: Request) => SelectResult;
+    parseBody?: (req: Request) => Promise<BodyResult>;
+    parseQueryParams?: (req: Request) => QueryParamsResult;
+    resolveType?: (route: RouteResult, method: string, headers: HeadersResult) => ASTType;
+    resolveFilters?: (queryParams: QueryParamsResult, embeddedAliases: Set<string>) => FiltersResult;
+    resolveTransforms?: (queryParams: QueryParamsResult, embeddedAliases: Set<string>) => TransformsResult;
+    resolveMeta?: (headers: HeadersResult, queryParams: QueryParamsResult, method: string) => Meta;
+    resolveRpcParams?: (route: RouteResult, method: string, queryParams: QueryParamsResult, body: BodyResult) => RpcResult;
+    resolveUpsertParams?: (queryParams: QueryParamsResult, headers: HeadersResult) => UpsertResult;
+    basePath?: string;
+};
+
+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;
+};
+
+interface TableInfo {
+    name: string;
+    sql: string;
+    schema: string;
+    type: "table" | "view";
+    rows: number;
+    engine: string;
+    collation: string;
+}
+interface ColumnInfo {
+    table: string;
+    name: string;
+    type: string;
+    nullable: boolean;
+    default_value: string | null;
+    is_primary_key: boolean;
+    schema: string;
+    ordinal_position: number;
+    collation: string;
+    character_maximum_length: string | null;
+    precision: {
+        precision: number | null;
+        scale: number | null;
+    } | null;
+    is_identity: boolean;
+    pg_type?: string;
+    is_generated?: boolean;
+}
+interface IndexInfo {
+    table: string;
+    name: string;
+    unique: boolean;
+    columns: string[];
+    schema: string;
+}
+interface ForeignKeyInfo {
+    table: string;
+    column: string;
+    ref_table: string;
+    ref_column: string;
+    on_update: string;
+    on_delete: string;
+    schema: string;
+    ref_schema?: string;
+    foreign_key_name: string;
+    fk_def: string;
+    is_visible?: boolean;
+}
+interface PrimaryKeyInfo {
+    table: string;
+    columns: string[];
+    schema: string;
+    field_count: number;
+}
+interface ViewInfo {
+    name: string;
+    sql: string;
+    schema: string;
+}
+interface CheckConstraintInfo {
+    schema: string;
+    table: string;
+    expression: string;
+    name?: string;
+    column?: string;
+}
+interface UniqueConstraintInfo {
+    schema: string;
+    table: string;
+    name: string;
+    columns: string[];
+}
+interface CommentInfo {
+    schema: string;
+    table: string;
+    column?: string;
+    text: string;
+}
+interface TriggerInfo {
+    table: string;
+    name: string;
+    sql: string;
+    schema: string;
+}
+interface CustomTypesInfo {
+    schema: string;
+    type: string;
+    kind: "enum" | "composite";
+    values?: string[];
+    fields?: {
+        name: string;
+        type: string;
+    }[];
+}
+type IntrospectOptions = {
+    exclude_tables?: string[];
+    name?: string;
+    version?: string;
+};
+interface IntrospectResult {
+    tables: TableInfo[];
+    columns: ColumnInfo[];
+    indexes: IndexInfo[];
+    foreign_keys: ForeignKeyInfo[];
+    primary_keys: PrimaryKeyInfo[];
+    views: ViewInfo[];
+    check_constraints: CheckConstraintInfo[];
+    unique_constraints: UniqueConstraintInfo[];
+    comments: CommentInfo[];
+    custom_types: CustomTypesInfo[];
+    triggers: TriggerInfo[];
+    database_name: string;
+    version: string;
+    ddl_dialect?: "postgres" | "sqlite";
+    schema_separator?: string;
+}
+interface TableDiff {
+    type: "added" | "removed" | "modified";
+    name: string;
+    sql?: string;
+}
+interface ColumnDiff {
+    type: "added" | "removed" | "modified";
+    table: string;
+    name: string;
+    changes?: {
+        type?: {
+            from: string;
+            to: string;
+        };
+        nullable?: {
+            from: boolean;
+            to: boolean;
+        };
+        default_value?: {
+            from: string | null;
+            to: string | null;
+        };
+    };
+    column?: ColumnInfo;
+}
+interface IndexDiff {
+    type: "added" | "removed";
+    table: string;
+    name: string;
+    unique: boolean;
+    columns: string[];
+}
+interface ForeignKeyDiff {
+    type: "added" | "removed";
+    table: string;
+    column: string;
+    ref_table: string;
+    ref_column: string;
+    on_update: string;
+    on_delete: string;
+}
+interface DiffResult {
+    tables: TableDiff[];
+    columns: ColumnDiff[];
+    indexes: IndexDiff[];
+    foreign_keys: ForeignKeyDiff[];
+    has_changes: boolean;
+}
+declare const enum PlanStepType {
+    DISABLE_FOREIGN_KEYS = "disable_foreign_keys",
+    ENABLE_FOREIGN_KEYS = "enable_foreign_keys",
+    BEGIN_TRANSACTION = "begin_transaction",
+    COMMIT_TRANSACTION = "commit_transaction",
+    CREATE_TABLE = "create_table",
+    ADD_COLUMN = "add_column",
+    DROP_COLUMN = "drop_column",
+    ADD_INDEX = "add_index",
+    DROP_INDEX = "drop_index",
+    DROP_TABLE = "drop_table",
+    RENAME_TABLE = "rename_table",
+    COPY_DATA = "copy_data",
+    CREATE_TRIGGER = "create_trigger"
+}
+interface PlanStep {
+    sql: string;
+    description?: string;
+    type?: PlanStepType;
+}
+interface DataLossWarning {
+    table: string;
+    reason: string;
+}
+interface PlanResult {
+    steps: PlanStep[];
+    warnings?: DataLossWarning[];
+    unsafe: boolean;
+}
+declare class DataLossError extends Error {
+    warnings: DataLossWarning[];
+    constructor(warnings: DataLossWarning[]);
+}
+declare class MigrationError extends Error {
+    stepIndex: number;
+    sql: string;
+    cause: Error;
+    constructor(stepIndex: number, sql: string, cause: Error);
+}
+interface SchemaDiffResult {
+    current?: IntrospectResult;
+    desired?: IntrospectResult;
+    diff: DiffResult | string;
+    plan: PlanResult;
+}
+interface ConnectionMigrator {
+    diff(): Promise<SchemaDiffResult>;
+    migrate(opts?: {
+        force?: boolean;
+    }): Promise<SchemaDiffResult>;
+    migratePlan(planResult: PlanResult, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    safeSortPlanSteps(steps: PlanStep[]): PlanStep[];
+}
+
+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 CacheSetOptions {
+    ttl?: number;
+}
+interface CacheDriver {
+    get(key: string): Promise<string | undefined>;
+    set(key: string, value: string, options?: CacheSetOptions): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+
+interface IConnectionConfig extends Partial<KyselyConfig> {
+    url?: string;
+    introspection?: IntrospectOptions;
+    schemaCache?: CacheDriver;
+    /**
+     * Base schema of the connection that is always prepended to any schema operations.
+     * E.g. when migrating to a desired schema, `baseSchema` is always prepended.
+     * This is useful for when auth is enabled, and auth schema must be present.
+     */
+    baseSchema?: string;
+}
+type Dialect = "sqlite" | "postgres";
+type TransactionOptions = {
+    intent?: "migration";
+};
+type ConnectionContextOptions = {
+    forceRollback?: boolean;
+};
+declare class RelationNotFoundError extends Error {
+    readonly schema: string | undefined;
+    readonly relation: string;
+    constructor(schema: string | undefined, relation: string);
+}
+declare abstract class Connection<Driver = unknown, DB = any, Config extends IConnectionConfig = IConnectionConfig> {
+    config: Config;
+    kysely: Kysely<DB>;
+    abstract driver: Driver;
+    abstract dialect: Dialect;
+    protected introspection: IntrospectResult | undefined;
+    protected constructor(config: Config);
+    /**
+     * Connection-level DDL translation, mainly for SQLite connections to override.
+     */
+    translateDdl(ddl: string): Promise<unknown>;
+    clearSchemaCache(): Promise<void>;
+    protected readCachedIntrospection(options?: {
+        useCache?: boolean;
+    }): Promise<IntrospectResult | undefined>;
+    protected writeCachedIntrospection(result: IntrospectResult, options?: {
+        useDriver?: boolean;
+    }): Promise<void>;
+    protected deleteCachedIntrospection(): Promise<void>;
+    protected schemaCacheKey(): string;
+    exec<T = {
+        rows: unknown[];
+    } | void>(query: string, ...parameters: readonly unknown[]): Promise<T>;
+    ping(): Promise<boolean | void>;
+    abstract introspect(options?: {
+        useCache?: boolean;
+    }): Promise<IntrospectResult>;
+    transaction(_statements: string[], _opts?: TransactionOptions): Promise<void>;
+    abstract close(): Promise<void>;
+    createMigrator(_desiredSchema: string): ConnectionMigrator;
+    onPostgrestAST(ast: AnyAST, _vars?: VarsContext): Promise<AnyAST>;
+    /**
+     * Per-row response coercion run after schema-typed deserialization.
+     * Subclasses fix wire-protocol-shape quirks (e.g. JSON-as-text on
+     * Postgres `json_agg`, numeric-as-string from postgres.js). Default = no-op.
+     */
+    deserializeRow(row: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Normalize a database error into a PG-style error object.
+     * Override in subclasses to map dialect-specific error codes.
+     */
+    normalizeDbError(e: unknown): unknown;
+    /**
+     * Wrap PostgREST query execution with connection-specific context.
+     * For Postgres: wraps in a transaction with SET LOCAL role/claims.
+     * Default: pass-through.
+     */
+    withContext<T>(_vars: VarsContext | undefined, fn: (db: Kysely<any>) => Promise<T>, _opts?: ConnectionContextOptions): Promise<T>;
+}
+
+export { type QbDelete as $, type AnyAST as A, type BaseAST as B, Connection as C, DataLossError as D, type EmbedDef as E, type FiltersResult as F, type ForeignKeyInfo as G, type HeadersResult as H, type IntrospectResult as I, type IndexDiff as J, type IndexInfo as K, type InsertAST as L, type IntrospectOptions as M, type JoinDef as N, type JoinMap as O, type PolicyCommand as P, type Meta as Q, MigrationError as R, type OrderEntry as S, type TransactionOptions as T, type PlanResult as U, type VarsContext as V, type PlanStep as W, PlanStepType as X, type PreferToken as Y, type PrimaryKeyInfo as Z, type Qb as _, type IConnectionConfig as a, type QbInsert as a0, type QbSelect as a1, type QbUpdate as a2, type QueryAST as a3, type QueryParamsResult as a4, RelationNotFoundError as a5, type RouteResult as a6, type RpcAST as a7, type RpcResult as a8, type SchemaDiffResult as a9, type SelectEntry as aa, type SelectResult as ab, type TableDiff as ac, type TableInfo as ad, type TextSearchValue as ae, type TransformsResult as af, type TranslatorConfig as ag, type TriggerInfo as ah, type UniqueConstraintInfo as ai, type UpdateAST as aj, type UpsertAST as ak, type UpsertResult as al, type ViewInfo as am, type Where as an, type WhereValue as ao, isRef as ap, translatePostgresDdl as aq, type CacheDriver as b, type CacheSetOptions as c, deparsePostgresDdl as d, type PolicyRole as e, Policy as f, type AST as g, type ASTType as h, type AggregateFunction as i, type BodyResult as j, type CheckConstraintInfo as k, type ColumnDef as l, type ColumnDiff as m, type ColumnInfo as n, type ColumnRef as o, type CommentInfo as p, type ConnectionContextOptions as q, type ConnectionMigrator as r, type CustomTypesInfo as s, type DataLossWarning as t, type DeleteAST as u, type Dialect as v, type DiffResult as w, type EmbedTransform as x, type ExplainOptions as y, type ForeignKeyDiff as z };

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node