@supabase/lite 0.0.1 → 0.2.0

package/dist/db/postgres/index.js

@@ -1,802 +0,0 @@
-import postgres from 'postgres';
-import { PostgresJSDialect } from 'kysely-postgres-js';
-import { Kysely, sql, PostgresQueryCompiler, PostgresIntrospector, PostgresAdapter, CompiledQuery } from 'kysely';
-import { Connection, invariant, RelationNotFoundError, DataLossError } from 'lite-supa';
-import { PGlite } from '@electric-sql/pglite';
-import { mkdir } from 'node:fs';
-import { isn } from '@electric-sql/pglite/contrib/isn';
-import { ltree } from '@electric-sql/pglite/contrib/ltree';
-import { file_fdw } from '@electric-sql/pglite/contrib/file_fdw';
-import { pgcrypto } from '@electric-sql/pglite/contrib/pgcrypto';
-
-try {
-   /**
-    * Adding this to avoid warnings from node:sqlite being experimental
-    */
-   const { emitWarning } = process;
-   process.emitWarning = (warning, ...args) => {
-      if (warning.includes("SQLite is an experimental feature")) return;
-      return emitWarning(warning, ...args);
-   };
-} catch {}
-var BasePostgresConnection = class extends Connection {
-  dialect = "postgres";
-  constructor(options) {
-    super({
-      ...options,
-      // @todo: this should be handled by the auth schema
-      baseSchema: `
-            ${options.baseSchema ?? ""}
-         
-            CREATE SCHEMA IF NOT EXISTS auth;
-
-            -- Function to get current user ID (for RLS policies)
-            CREATE OR REPLACE FUNCTION auth.uid() RETURNS UUID AS $$
-              SELECT NULLIF(current_setting('request.jwt.claim.sub', true), '')::uuid;
-            $$ LANGUAGE SQL STABLE;
-            
-            -- Function to get current user role (for RLS policies)
-            CREATE OR REPLACE FUNCTION auth.role() RETURNS TEXT AS $$
-              SELECT NULLIF(current_setting('request.jwt.claim.role', true), '');
-            $$ LANGUAGE SQL STABLE;
-            
-            -- Function to get current user email (for RLS policies)
-            CREATE OR REPLACE FUNCTION auth.email() RETURNS TEXT AS $$
-              SELECT NULLIF(current_setting('request.jwt.claim.email', true), '');
-            $$ LANGUAGE SQL STABLE;
-            
-            -- Function to get JWT claims (for RLS policies)
-            CREATE OR REPLACE FUNCTION auth.jwt() RETURNS JSONB AS $$
-              SELECT COALESCE(
-                NULLIF(current_setting('request.jwt.claims', true), ''),
-                '{}'
-              )::jsonb;
-            $$ LANGUAGE SQL STABLE;
-         `
-    });
-  }
-  async introspect(options) {
-    invariant(typeof options === "object" || options === void 0, "options must be an object");
-    const useCache = options?.useCache ?? false;
-    if (typeof this.introspection === "object" && useCache === true) return this.introspection;
-    try {
-      const tblResult = await sql`
-            SELECT
-               tbls.table_name AS "name",
-               tbls.table_schema AS "schema",
-               tbls.table_type AS "type",
-               COALESCE(s.n_live_tup, 0) AS "rows"
-            FROM information_schema.tables tbls
-               LEFT JOIN pg_stat_user_tables s
-                         ON tbls.table_schema = s.schemaname AND tbls.table_name = s.relname
-            WHERE
-               tbls.table_schema NOT IN ('information_schema', 'pg_catalog')
-               AND tbls.table_type IN ('BASE TABLE', 'FOREIGN TABLE')
-            ORDER BY tbls.table_schema, tbls.table_name
-         `.execute(this.kysely);
-      const tables = tblResult.rows.map((r) => ({
-        name: r.name,
-        schema: r.schema,
-        type: "table",
-        rows: Number(r.rows),
-        sql: "",
-        engine: "",
-        collation: ""
-      }));
-      const colResult = await sql`
-            SELECT
-               cols.table_name AS "table",
-               cols.table_schema AS "schema",
-               cols.column_name AS "name",
-               cols.ordinal_position AS "ordinal_position",
-               CASE
-                  WHEN cols.column_default IS NOT NULL AND cols.column_default LIKE 'nextval(%' THEN
-                     CASE
-                        WHEN LOWER(cols.data_type) = 'smallint' THEN 'smallserial'
-                        WHEN LOWER(cols.data_type) = 'integer' THEN 'serial'
-                        WHEN LOWER(cols.data_type) = 'bigint' THEN 'bigserial'
-                        ELSE LOWER(cols.data_type)
-                        END
-                  WHEN cols.data_type = 'ARRAY' THEN format_type(pt.typelem, NULL)
-                  WHEN LOWER(cols.data_type) = 'user-defined' THEN format_type(pt.oid, NULL)
-                  ELSE LOWER(cols.data_type)
-                  END AS "type",
-               CASE WHEN cols.is_nullable = 'YES' THEN true ELSE false END AS "nullable",
-               CASE
-                  WHEN cols.column_default IS NOT NULL AND cols.column_default LIKE 'nextval(%'
-                     THEN NULL
-                  ELSE cols.column_default
-                  END AS "default_value",
-               cols.character_maximum_length::text AS "character_maximum_length", CASE
-                                                                                     WHEN cols.data_type IN ('numeric', 'decimal')
-                                                                                        THEN
-                                                                                        json_build_object(
-                                                                                           'precision',
-                                                                                           cols.numeric_precision,
-                                                                                           'scale',
-                                                                                           cols.numeric_scale)
-                                                                                     ELSE NULL
-               END AS "precision",
-               CASE
-                  WHEN cols.is_identity = 'YES' THEN true
-                  WHEN cols.column_default IS NOT NULL AND cols.column_default LIKE 'nextval(%'
-                     THEN true
-                  ELSE false
-                  END AS "is_identity",
-               COALESCE(cols.collation_name, '') AS "collation"
-            FROM information_schema.columns cols
-               LEFT JOIN pg_catalog.pg_class c ON c.relname = cols.table_name
-               JOIN pg_catalog.pg_namespace n
-                    ON n.oid = c.relnamespace AND n.nspname = cols.table_schema
-               LEFT JOIN pg_catalog.pg_attribute attr
-                         ON attr.attrelid = c.oid AND attr.attname = cols.column_name
-               LEFT JOIN pg_catalog.pg_type pt ON pt.oid = attr.atttypid
-            WHERE cols.table_schema NOT IN ('information_schema', 'pg_catalog')
-            ORDER BY cols.table_schema, cols.table_name, cols.ordinal_position
-         `.execute(this.kysely);
-      const columns = colResult.rows.map((r) => ({
-        table: r.table,
-        schema: r.schema,
-        name: r.name,
-        type: r.type,
-        nullable: r.nullable,
-        default_value: r.default_value,
-        is_primary_key: false,
-        // filled below
-        ordinal_position: Number(r.ordinal_position),
-        character_maximum_length: r.character_maximum_length ?? null,
-        precision: r.precision ?? null,
-        is_identity: r.is_identity,
-        collation: r.collation
-      }));
-      const fkResult = await sql`
-            SELECT
-               ns.nspname AS "schema",
-               cl.relname AS "table",
-               att.attname AS "column",
-               nr.nspname AS "ref_schema",
-               ref_cl.relname AS "ref_table",
-               ref_att.attname AS "ref_column",
-               con.conname AS "foreign_key_name",
-               pg_get_constraintdef(con.oid) AS "fk_def"
-            FROM pg_constraint con
-               JOIN pg_class cl ON cl.oid = con.conrelid
-               JOIN pg_namespace ns ON ns.oid = cl.relnamespace
-               JOIN pg_class ref_cl ON ref_cl.oid = con.confrelid
-               JOIN pg_namespace nr ON nr.oid = ref_cl.relnamespace
-               CROSS JOIN LATERAL unnest(con.conkey, con.confkey) WITH ORDINALITY AS cols(conkey_num, confkey_num, ord)
-            JOIN pg_attribute att
-            ON att.attrelid = con.conrelid AND att.attnum = cols.conkey_num
-               JOIN pg_attribute ref_att ON ref_att.attrelid = con.confrelid AND ref_att.attnum = cols.confkey_num
-            WHERE
-               con.contype = 'f'
-               AND ns.nspname NOT IN (
-               'information_schema'
-               , 'pg_catalog')
-            ORDER BY ns.nspname, cl.relname, con.conname, cols.ord
-         `.execute(this.kysely);
-      const fks = fkResult.rows.map((r) => ({
-        table: r.table,
-        column: r.column,
-        schema: r.schema,
-        ref_table: r.ref_table,
-        ref_column: r.ref_column,
-        foreign_key_name: r.foreign_key_name,
-        fk_def: r.fk_def,
-        on_update: "",
-        on_delete: ""
-      }));
-      const pkResult = await sql`
-            SELECT
-               ns.nspname AS "schema",
-               cl.relname AS "table",
-               array_agg(att.attname ORDER BY cols.ord) AS "columns"
-            FROM pg_constraint con
-               JOIN pg_class cl ON cl.oid = con.conrelid
-               JOIN pg_namespace ns ON ns.oid = cl.relnamespace
-               CROSS JOIN LATERAL unnest(con.conkey) WITH ORDINALITY AS cols(attnum, ord)
-            JOIN pg_attribute att
-            ON att.attrelid = con.conrelid AND att.attnum = cols.attnum
-            WHERE
-               con.contype = 'p'
-               AND ns.nspname NOT IN (
-               'information_schema'
-               , 'pg_catalog')
-            GROUP BY ns.nspname, cl.relname, con.oid
-         `.execute(this.kysely);
-      const pks = pkResult.rows.map((r) => ({
-        table: r.table,
-        columns: r.columns,
-        schema: r.schema,
-        field_count: r.columns.length
-      }));
-      const pkSet = new Set(
-        pks.flatMap((pk) => pk.columns.map((col) => `${pk.schema}.${pk.table}.${col}`))
-      );
-      for (const col of columns) {
-        col.is_primary_key = pkSet.has(`${col.schema}.${col.table}.${col.name}`);
-      }
-      const idxResult = await sql`
-            SELECT
-               tnsp.nspname AS "schema",
-               cl.relname AS "table",
-               ic.relname AS "name",
-               idx.indisunique AS "unique",
-               array_agg(att.attname ORDER BY a.ord) AS "columns"
-            FROM pg_index idx
-               JOIN pg_class cl ON cl.oid = idx.indrelid
-               JOIN pg_namespace tnsp ON cl.relnamespace = tnsp.oid
-               JOIN pg_class ic ON ic.oid = idx.indexrelid
-               CROSS JOIN LATERAL unnest(idx.indkey) WITH ORDINALITY AS a(attnum, ord)
-            JOIN pg_attribute att
-            ON att.attrelid = cl.oid AND att.attnum = a.attnum
-            WHERE
-               idx.indisunique = true
-               AND NOT idx.indisprimary
-               AND tnsp.nspname NOT IN (
-               'information_schema'
-               , 'pg_catalog')
-            GROUP BY tnsp.nspname, cl.relname, ic.relname, idx.indisunique
-         `.execute(this.kysely);
-      const indexes = idxResult.rows.map((r) => ({
-        table: r.table,
-        name: r.name,
-        unique: r.unique,
-        columns: r.columns,
-        schema: r.schema
-      }));
-      const viewResult = await sql`
-            SELECT
-               views.schemaname AS "schema",
-               views.viewname AS "name",
-               views.definition AS "sql"
-            FROM pg_views views
-            WHERE views.schemaname NOT IN ('information_schema', 'pg_catalog')
-            ORDER BY views.schemaname, views.viewname
-         `.execute(this.kysely);
-      const views = viewResult.rows.map((r) => ({
-        name: r.name,
-        schema: r.schema,
-        sql: r.sql ?? ""
-      }));
-      const chkResult = await sql`
-            SELECT
-               n.nspname AS "schema",
-               cl.relname AS "table",
-               substring(pg_get_constraintdef(c.oid) FROM 'CHECK \\((.*)\\)') AS "expression"
-            FROM pg_constraint c
-               JOIN pg_class cl ON cl.oid = c.conrelid
-               JOIN pg_namespace n ON n.oid = cl.relnamespace
-            WHERE
-               c.contype = 'c'
-               AND n.nspname NOT IN ('information_schema', 'pg_catalog')
-            ORDER BY n.nspname, cl.relname
-         `.execute(this.kysely);
-      const checkConstraints = chkResult.rows.map((r) => ({
-        schema: r.schema,
-        table: r.table,
-        expression: r.expression ?? ""
-      }));
-      const enumResult = await sql`
-            SELECT
-               n.nspname AS "schema",
-               t.typname AS "type",
-               'enum' AS "kind",
-               array_agg(e.enumlabel ORDER BY e.enumsortorder) AS "values"
-            FROM pg_type t
-               JOIN pg_enum e ON t.oid = e.enumtypid
-               JOIN pg_namespace n ON n.oid = t.typnamespace
-            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-            GROUP BY n.nspname, t.typname
-         `.execute(this.kysely);
-      const compositeResult = await sql`
-            SELECT
-               n.nspname AS "schema",
-               t.typname AS "type",
-               'composite' AS "kind",
-               json_agg(json_build_object(
-                  'name',
-                  a.attname,
-                  'type',
-                  format_type(a.atttypid, a.atttypmod)) ORDER BY a.attnum
-               ) AS "fields"
-            FROM pg_type t
-               JOIN pg_namespace n ON n.oid = t.typnamespace
-               JOIN pg_class c ON c.oid = t.typrelid
-               JOIN pg_attribute a ON a.attrelid = c.oid
-            WHERE
-               t.typtype = 'c'
-               AND c.relkind = 'c'
-               AND a.attnum > 0
-               AND NOT a.attisdropped
-               AND n.nspname NOT IN ('pg_catalog', 'information_schema')
-            GROUP BY n.nspname, t.typname
-         `.execute(this.kysely);
-      const customTypes = [
-        ...enumResult.rows.map((r) => ({
-          schema: r.schema,
-          type: r.type,
-          kind: "enum",
-          values: r.values
-        })),
-        ...compositeResult.rows.map((r) => ({
-          schema: r.schema,
-          type: r.type,
-          kind: "composite",
-          fields: r.fields
-        }))
-      ];
-      const dbResult = await sql`SELECT current_database() AS "name"`.execute(this.kysely);
-      const dbName = dbResult.rows[0]?.name ?? "postgres";
-      this.introspection = {
-        tables,
-        columns,
-        indexes,
-        foreign_keys: fks,
-        primary_keys: pks,
-        views,
-        triggers: [],
-        check_constraints: checkConstraints,
-        custom_types: customTypes,
-        database_name: dbName,
-        version: ""
-      };
-      return this.introspection;
-    } catch (e) {
-      console.error("Introspection failed:", e);
-      return {
-        tables: [],
-        columns: [],
-        indexes: [],
-        foreign_keys: [],
-        primary_keys: [],
-        views: [],
-        triggers: [],
-        check_constraints: [],
-        custom_types: [],
-        database_name: "postgres",
-        version: ""
-      };
-    }
-  }
-  rlsState = "unknown";
-  /**
-   * Detect if any table has RLS enabled, and if so ensure anon/authenticated
-   * roles exist with default privileges. Runs once per connection.
-   */
-  async ensureRlsContext() {
-    if (this.rlsState !== "unknown") return this.rlsState === "active";
-    const result = await sql`
-         SELECT count(*) ::text as count FROM pg_class WHERE relrowsecurity = true
-      `.execute(this.kysely);
-    const hasRls = Number(result.rows[0]?.count ?? 0) > 0;
-    if (!hasRls) {
-      this.rlsState = "inactive";
-      return false;
-    }
-    this.rlsState = "active";
-    await sql`
-         DO $$ BEGIN
-            IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'anon') THEN
-               CREATE ROLE anon NOLOGIN;
-            END IF;
-            IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'authenticated') THEN
-               CREATE ROLE authenticated NOLOGIN;
-            END IF;
-         END $$
-      `.execute(this.kysely);
-    const schemas = await sql`
-         SELECT DISTINCT n.nspname FROM pg_class c
-         JOIN pg_namespace n ON n.oid = c.relnamespace
-         WHERE c.relrowsecurity = true
-      `.execute(this.kysely);
-    for (const { nspname } of schemas.rows) {
-      await sql`GRANT USAGE ON SCHEMA ${sql.ref(nspname)} TO anon, authenticated`.execute(
-        this.kysely
-      );
-      await sql.raw(`GRANT ALL ON ALL TABLES IN SCHEMA "${nspname}" TO anon, authenticated`).execute(this.kysely);
-      await sql.raw(`GRANT ALL ON ALL SEQUENCES IN SCHEMA "${nspname}" TO anon, authenticated`).execute(this.kysely);
-      await sql.raw(
-        `ALTER DEFAULT PRIVILEGES IN SCHEMA "${nspname}" GRANT ALL ON TABLES TO anon, authenticated`
-      ).execute(this.kysely);
-      await sql.raw(
-        `ALTER DEFAULT PRIVILEGES IN SCHEMA "${nspname}" GRANT ALL ON SEQUENCES TO anon, authenticated`
-      ).execute(this.kysely);
-    }
-    return true;
-  }
-  async withContext(vars, fn) {
-    if (!vars) return fn(this.kysely);
-    const rlsActive = await this.ensureRlsContext();
-    if (!rlsActive) return fn(this.kysely);
-    return this.kysely.transaction().execute(async (trx) => {
-      const auth = vars.auth;
-      const role = auth?.role || "anon";
-      const uid = String(auth?.uid ?? "");
-      const jwt = auth?.jwt;
-      await sql`SELECT set_config('role', ${role}, true)`.execute(trx);
-      await sql`SELECT set_config('request.jwt.claim.sub', ${uid}, true)`.execute(trx);
-      await sql`SELECT set_config('request.jwt.claim.role', ${role}, true)`.execute(trx);
-      if (jwt && typeof jwt === "object") {
-        await sql`SELECT set_config('request.jwt.claims', ${JSON.stringify(jwt)}, true)`.execute(
-          trx
-        );
-      }
-      return fn(trx);
-    });
-  }
-  async onPostgrestAST(ast) {
-    if (!ast.from) return ast;
-    const schema = ast.schema ?? "public";
-    const relation = ast.from;
-    const introspection = await this.introspect({ useCache: true });
-    if (!introspection.tables.some((t) => t.name === relation && t.schema === schema) && !introspection.views.some((v) => v.name === relation && v.schema === schema)) {
-      throw new RelationNotFoundError(schema, relation);
-    }
-    return ast;
-  }
-  async transaction(statements, opts) {
-    await this.exec("BEGIN");
-    try {
-      for (const statement of statements) {
-        await this.exec(statement);
-      }
-      await this.exec("COMMIT");
-    } catch (error) {
-      await this.exec("ROLLBACK");
-      throw error;
-    } finally {
-      if (opts?.intent === "migration") {
-        this.introspection = void 0;
-      }
-    }
-  }
-};
-
-// src/db/postgres/PostgresConnection.ts
-var PostgresConnection = class extends BasePostgresConnection {
-  driver;
-  dialect = "postgres";
-  constructor(config) {
-    super(config);
-    this.driver = postgres(config.url ?? "", {
-      types: {
-        // Parse bigint/int8 (OID 20) as JS number instead of string
-        bigint: {
-          to: 20,
-          from: [20],
-          serialize: (x) => x.toString(),
-          parse: (x) => {
-            const n = Number(x);
-            if (Number.isSafeInteger(n)) return n;
-            return BigInt(x);
-          }
-        }
-      }
-    });
-    const dialect = new PostgresJSDialect({ postgres: this.driver });
-    this.kysely = new Kysely({ dialect });
-  }
-  async close() {
-    await this.driver.end();
-  }
-};
-function createPostgresConnection(config) {
-  return new PostgresConnection(config);
-}
-function ensureDataDirExist(dataDir) {
-  let path;
-  if (typeof dataDir === "string") {
-    path = dataDir;
-  }
-  if (typeof dataDir === "object" && dataDir.dataDir) {
-    path = dataDir.dataDir;
-  }
-  if (path) {
-    mkdir(path, { recursive: true }, (err) => {
-      if (err) {
-        throw err;
-      }
-    });
-  }
-}
-var PGliteDriver = class {
-  #client;
-  constructor(client) {
-    this.#client = client;
-  }
-  async acquireConnection() {
-    return new PGliteConnection(this.#client);
-  }
-  async beginTransaction(connection, _settings) {
-    await connection.executeQuery(CompiledQuery.raw("BEGIN"));
-  }
-  async commitTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("COMMIT"));
-  }
-  async rollbackTransaction(connection) {
-    await connection.executeQuery(CompiledQuery.raw("ROLLBACK"));
-  }
-  async destroy() {
-    await this.#client.close();
-  }
-  async init() {
-  }
-  async releaseConnection(_connection) {
-  }
-};
-var PGliteConnection = class {
-  #client;
-  constructor(client) {
-    this.#client = client;
-  }
-  async executeQuery(compiledQuery) {
-    return await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
-  }
-  // biome-ignore lint/correctness/useYield: .
-  async *streamQuery() {
-    throw new Error("PGlite does not support streaming.");
-  }
-};
-var KyselyPglite = class {
-  client;
-  constructor(dataDirOrOptionsOrPGlite, opts) {
-    ensureDataDirExist(dataDirOrOptionsOrPGlite);
-    let options = { ...opts };
-    if (typeof dataDirOrOptionsOrPGlite === "object" && dataDirOrOptionsOrPGlite instanceof PGlite) {
-      this.client = dataDirOrOptionsOrPGlite;
-      return;
-    }
-    if (typeof dataDirOrOptionsOrPGlite === "string") {
-      options = {
-        dataDir: dataDirOrOptionsOrPGlite,
-        ...options
-      };
-    } else {
-      options = dataDirOrOptionsOrPGlite ?? {};
-    }
-    this.client = new PGlite(options);
-  }
-  dialect = {
-    createAdapter: () => new PostgresAdapter(),
-    createDriver: () => new PGliteDriver(this.client),
-    createIntrospector: (db) => new PostgresIntrospector(db),
-    createQueryCompiler: () => new PostgresQueryCompiler()
-  };
-};
-
-// src/db/postgres/migration/pgdelta-pglite.ts
-var parseArray = (value, parseElement = (entry) => entry) => {
-  if (!value || value === "{}") return [];
-  const inner = value.slice(1, -1);
-  if (inner === "") return [];
-  const result = [];
-  let current = "";
-  let inQuotes = false;
-  let depth = 0;
-  for (let i = 0; i < inner.length; i++) {
-    const char = inner[i];
-    if (char === '"' && inner[i - 1] !== "\\") {
-      inQuotes = !inQuotes;
-      current += char;
-    } else if (char === "{" && !inQuotes) {
-      depth++;
-      current += char;
-    } else if (char === "}" && !inQuotes) {
-      depth--;
-      current += char;
-    } else if (char === "," && !inQuotes && depth === 0) {
-      result.push(parseElement(current));
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  if (current !== "") {
-    result.push(parseElement(current));
-  }
-  return result;
-};
-var parseStringElement = (value) => {
-  if (value === "NULL") return null;
-  if (value.startsWith('"') && value.endsWith('"')) {
-    return value.slice(1, -1).replace(/\\(.)/g, "$1");
-  }
-  return value;
-};
-var parseIntElement = (value) => {
-  if (value === "NULL") return null;
-  return Number.parseInt(value, 10);
-};
-function isSqlTagLike(value) {
-  return typeof value === "object" && value !== null && "text" in value && "values" in value;
-}
-function normalizeValue(value, dataTypeID) {
-  if (value === null || value === void 0) return value;
-  switch (dataTypeID) {
-    case 20:
-      return typeof value === "bigint" ? value : BigInt(value);
-    case 22:
-      if (Array.isArray(value)) return value;
-      if (typeof value === "string") {
-        return value.split(" ").map(Number).filter((entry) => !Number.isNaN(entry));
-      }
-      return value;
-    case 1002:
-    case 1009:
-    case 1015:
-      return typeof value === "string" ? parseArray(value, parseStringElement) : value;
-    case 1005:
-    case 1007:
-    case 1016:
-      return typeof value === "string" ? parseArray(value, parseIntElement) : value;
-    default:
-      return value;
-  }
-}
-function pgDeltaQueryable(db) {
-  return {
-    async query(input, values) {
-      const sql3 = isSqlTagLike(input) ? input.text : input;
-      const parameters = isSqlTagLike(input) ? input.values : values ?? [];
-      const result = await db.driver.query(sql3, [...parameters]);
-      const rows = result.rows.map(
-        (row) => Object.fromEntries(
-          result.fields.map((field) => [
-            field.name,
-            normalizeValue(row[field.name], field.dataTypeID)
-          ])
-        )
-      );
-      return {
-        rows
-      };
-    }
-  };
-}
-
-// src/db/postgres/migration/PostgresMigrator.ts
-async function loadPgDelta() {
-  try {
-    return await import('@supabase/pg-delta');
-  } catch (error) {
-    throw new Error(
-      "Postgres/PGlite schema diffing now requires a Bun/Node-compatible runtime with pg-delta available.",
-      { cause: error }
-    );
-  }
-}
-function parseRiskWarning(input) {
-  const dropTableMatch = /^drop table (.+)$/.exec(input);
-  if (dropTableMatch) {
-    return {
-      table: dropTableMatch[1],
-      reason: "drop table"
-    };
-  }
-  const dropColumnMatch = /^drop column (.+) on (.+)$/.exec(input);
-  if (dropColumnMatch) {
-    return {
-      table: dropColumnMatch[2],
-      reason: `drop column ${dropColumnMatch[1]}`
-    };
-  }
-  const dropSequenceMatch = /^drop sequence (.+)$/.exec(input);
-  if (dropSequenceMatch) {
-    return {
-      table: dropSequenceMatch[1],
-      reason: "drop sequence"
-    };
-  }
-  return {
-    table: "unknown",
-    reason: input
-  };
-}
-var PostgresMigrator = class {
-  constructor(from, to, desiredSchema) {
-    this.from = from;
-    this.to = to;
-    this.desiredSchema = desiredSchema;
-  }
-  async diff() {
-    const { createPlan, extractCatalog } = await loadPgDelta();
-    const from = pgDeltaQueryable(this.from);
-    const to = pgDeltaQueryable(this.to);
-    await this.to.exec(this.desiredSchema);
-    const [fromCatalog, toCatalog] = await Promise.all([
-      extractCatalog(from),
-      extractCatalog(to)
-    ]);
-    const result = await createPlan(fromCatalog, toCatalog);
-    if (!result) {
-      return {
-        diff: "",
-        plan: {
-          steps: [],
-          warnings: [],
-          unsafe: false
-        }
-      };
-    }
-    const warnings = result.plan.risk?.level === "data_loss" ? result.plan.risk.statements.map(parseRiskWarning) : [];
-    return {
-      diff: result.plan.statements.join("\n\n"),
-      plan: {
-        steps: result.plan.statements.map((sql3) => ({ sql: sql3 })),
-        warnings,
-        unsafe: result.plan.risk?.level === "data_loss"
-      }
-    };
-  }
-  async migratePlan(planResult, opts) {
-    if (planResult.steps.length === 0) {
-      return;
-    }
-    if (planResult.unsafe && !opts?.force) {
-      throw new DataLossError(planResult.warnings ?? []);
-    }
-    await this.from.transaction(
-      planResult.steps.map((step) => step.sql),
-      { intent: "migration" }
-    );
-  }
-  async migrate(opts) {
-    const result = await this.diff();
-    await this.migratePlan(result.plan, opts);
-    return result;
-  }
-  safeSortPlanSteps(steps) {
-    return steps;
-  }
-};
-
-// src/db/postgres/pglite/PgliteConnection.ts
-var PgliteConnection = class _PgliteConnection extends BasePostgresConnection {
-  driver;
-  dialect = "postgres";
-  constructor(config = {}) {
-    const client = new PGlite({
-      ...config.pgliteOptions,
-      dataDir: config.url ?? void 0,
-      extensions: {
-        ...config.pgliteOptions?.extensions,
-        isn,
-        ltree,
-        file_fdw,
-        pgcrypto
-      }
-    });
-    const { dialect } = new KyselyPglite(client);
-    super(config);
-    this.driver = client;
-    this.kysely = new Kysely({ dialect });
-  }
-  async exec(query, ...parameters) {
-    try {
-      if (parameters.length > 0) {
-        const { rows } = await sql(query, ...parameters ?? []).execute(this.kysely);
-        return { rows };
-      }
-      const result = await this.driver.exec(query);
-      return {
-        rows: result[0].rows
-      };
-    } catch (error) {
-      console.error(error);
-      throw new Error(`Failed to execute query: ${query}`);
-    }
-  }
-  async close() {
-    await this.driver.close();
-  }
-  createMigrator(desiredSchema) {
-    const migrationSchema = [this.config.baseSchema, desiredSchema].filter(Boolean).join("\n\n");
-    return new PostgresMigrator(this, new _PgliteConnection(), migrationSchema);
-  }
-};
-async function createPgliteConnection(config = {}) {
-  return new PgliteConnection(config);
-}
-
-export { PgliteConnection, PostgresConnection, createPgliteConnection as createConnection, createPgliteConnection, createPostgresConnection };