@supabase/lite 0.0.1-next.1

package/dist/db/postgres/pglite/PgliteConnection.js

@@ -0,0 +1,890 @@
+import { PGlite } from '@electric-sql/pglite';
+export { PGlite } from '@electric-sql/pglite';
+import { Kysely, sql, PostgresQueryCompiler, PostgresIntrospector, PostgresAdapter, CompiledQuery } from 'kysely';
+import { Connection, invariant, RelationNotFoundError, DataLossError } from '@supabase/lite';
+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 {}
+async function ensureDataDirExist(dataDir) {
+  let path;
+  if (typeof dataDir === "string") {
+    path = dataDir;
+  }
+  if (typeof dataDir === "object" && dataDir.dataDir) {
+    path = dataDir.dataDir;
+  }
+  if (path) {
+    const { mkdir } = await import('node:fs');
+    mkdir(path, { recursive: true }, (err) => {
+      if (err) {
+        throw err;
+      }
+    });
+  }
+}
+var PGliteDriver = class {
+  #client;
+  #ownsClient;
+  constructor(client, ownsClient) {
+    this.#client = client;
+    this.#ownsClient = ownsClient;
+  }
+  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() {
+    if (this.#ownsClient) {
+      await this.#client.close();
+    }
+  }
+  async init() {
+  }
+  async releaseConnection(_connection) {
+  }
+};
+var PGliteConnection = class {
+  #client;
+  constructor(client) {
+    this.#client = client;
+  }
+  async executeQuery(compiledQuery) {
+    const result = await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
+    const affected = result.affectedRows;
+    return {
+      rows: result.rows,
+      numAffectedRows: typeof affected === "number" ? BigInt(affected) : void 0
+    };
+  }
+  // biome-ignore lint/correctness/useYield: .
+  async *streamQuery() {
+    throw new Error("PGlite does not support streaming.");
+  }
+};
+var KyselyPglite = class {
+  client;
+  #ownsClient = true;
+  constructor(dataDirOrOptionsOrPGlite, opts) {
+    void ensureDataDirExist(dataDirOrOptionsOrPGlite);
+    let options = { ...opts };
+    if (typeof dataDirOrOptionsOrPGlite === "object" && dataDirOrOptionsOrPGlite instanceof PGlite) {
+      this.client = dataDirOrOptionsOrPGlite;
+      this.#ownsClient = false;
+      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, this.#ownsClient),
+    createIntrospector: (db) => new PostgresIntrospector(db),
+    createQueryCompiler: () => new PostgresQueryCompiler()
+  };
+};
+var ForceRollback = class extends Error {
+  constructor(result) {
+    super("Force rollback");
+    this.result = result;
+  }
+};
+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;
+    const cached = await this.readCachedIntrospection({ useCache });
+    if (cached) return cached;
+    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",
+               cols.udt_name AS "udt_name",
+               CASE WHEN cols.is_generated = 'NEVER' THEN false ELSE true END AS "is_generated"
+            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,
+        pg_type: r.udt_name ?? void 0,
+        is_generated: r.is_generated ?? false
+      }));
+      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 uqResult = await sql`
+            SELECT
+               n.nspname AS "schema",
+               cl.relname AS "table",
+               c.conname AS "name",
+               array_agg(att.attname ORDER BY cols.ord) AS "columns"
+            FROM pg_constraint c
+               JOIN pg_class cl ON cl.oid = c.conrelid
+               JOIN pg_namespace n ON n.oid = cl.relnamespace
+               CROSS JOIN LATERAL unnest(c.conkey) WITH ORDINALITY AS cols(attnum, ord)
+               JOIN pg_attribute att ON att.attrelid = c.conrelid AND att.attnum = cols.attnum
+            WHERE
+               c.contype = 'u'
+               AND n.nspname NOT IN ('information_schema', 'pg_catalog')
+            GROUP BY n.nspname, cl.relname, c.conname, c.oid
+         `.execute(this.kysely);
+      const uniqueConstraints = uqResult.rows.map((r) => ({
+        schema: r.schema,
+        table: r.table,
+        name: r.name,
+        columns: r.columns
+      }));
+      const commentResult = await sql`
+            SELECT
+               n.nspname AS "schema",
+               cl.relname AS "table",
+               att.attname AS "column",
+               d.description AS "text"
+            FROM pg_description d
+               JOIN pg_class cl ON cl.oid = d.objoid
+               JOIN pg_namespace n ON n.oid = cl.relnamespace
+               LEFT JOIN pg_attribute att
+                         ON att.attrelid = cl.oid AND att.attnum = d.objsubid AND d.objsubid > 0
+            WHERE
+               n.nspname NOT IN ('information_schema', 'pg_catalog')
+               AND cl.relkind IN ('r', 'v', 'm', 'f', 'p')
+               AND d.description IS NOT NULL
+         `.execute(this.kysely);
+      const comments = commentResult.rows.map((r) => ({
+        schema: r.schema,
+        table: r.table,
+        column: r.column ?? void 0,
+        text: r.text
+      }));
+      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";
+      const result = {
+        tables,
+        columns,
+        indexes,
+        foreign_keys: fks,
+        primary_keys: pks,
+        views,
+        triggers: [],
+        check_constraints: checkConstraints,
+        unique_constraints: uniqueConstraints,
+        comments,
+        custom_types: customTypes,
+        database_name: dbName,
+        version: ""
+      };
+      await this.writeCachedIntrospection(result, { useDriver: useCache });
+      return result;
+    } catch (e) {
+      console.error("Introspection failed:", e);
+      return {
+        tables: [],
+        columns: [],
+        indexes: [],
+        foreign_keys: [],
+        primary_keys: [],
+        views: [],
+        triggers: [],
+        check_constraints: [],
+        unique_constraints: [],
+        comments: [],
+        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, opts) {
+    const forceRollback = opts?.forceRollback === true;
+    if (!forceRollback && !vars) return fn(this.kysely);
+    const rlsActive = vars ? await this.ensureRlsContext() : false;
+    if (!forceRollback && !rlsActive) return fn(this.kysely);
+    try {
+      return await this.kysely.transaction().execute(async (trx) => {
+        if (vars && rlsActive) {
+          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
+            );
+          }
+        }
+        const result = await fn(trx);
+        if (forceRollback) throw new ForceRollback(result);
+        return result;
+      });
+    } catch (error) {
+      if (error instanceof ForceRollback) return error.result;
+      throw error;
+    }
+  }
+  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") {
+        await this.clearSchemaCache();
+      }
+    }
+  }
+};
+
+// 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, desiredSchema) {
+    this.from = from;
+    this.desiredSchema = desiredSchema;
+  }
+  // Desired schema is immutable for a migrator, so cache its extracted catalog.
+  // This avoids rebuilding a scratch PGlite database on repeated diff() calls.
+  #desiredCatalog;
+  async #getDesiredCatalog(extractCatalog) {
+    if (this.#desiredCatalog) {
+      return this.#desiredCatalog;
+    }
+    const toConnection = new this.from.constructor();
+    try {
+      await toConnection.exec(this.desiredSchema);
+      this.#desiredCatalog = await extractCatalog(pgDeltaQueryable(toConnection));
+      return this.#desiredCatalog;
+    } finally {
+      await toConnection.close();
+    }
+  }
+  async diff() {
+    const { createPlan, extractCatalog } = await loadPgDelta();
+    const from = pgDeltaQueryable(this.from);
+    const toCatalog = await this.#getDesiredCatalog(extractCatalog);
+    const fromCatalog = await extractCatalog(from);
+    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;
+  }
+};
+var PgliteConnection = class extends BasePostgresConnection {
+  driver;
+  dialect = "postgres";
+  #closed = false;
+  constructor(config = {}) {
+    const client = new PGlite({
+      ...config.pgliteOptions,
+      dataDir: config.url ?? void 0,
+      extensions: {
+        ...config.pgliteOptions?.extensions,
+        isn,
+        ltree,
+        file_fdw,
+        pgcrypto
+      },
+      parsers: {
+        // bigint/int8 (OID 20) → JS number when safe, else BigInt. Mirrors PostgresConnection.
+        20: (x) => {
+          const n = Number(x);
+          return Number.isSafeInteger(n) ? n : BigInt(x);
+        },
+        // json (OID 114) and jsonb (OID 3802): pglite leaves both as text by default.
+        // PostgREST returns them as parsed JSON, including json_agg() in embed aggregates.
+        114: (x) => JSON.parse(x),
+        3802: (x) => JSON.parse(x),
+        // numeric (OID 1700): coerce when round-trip exact, else keep string for precision safety.
+        1700: (x) => {
+          const n = Number(x);
+          if (Number.isFinite(n) && String(n) === x) return n;
+          return x;
+        },
+        // Date/time OIDs (1082 date, 1083 time, 1114 timestamp, 1184 timestamptz,
+        // 1266 timetz): keep as raw strings to mirror SQLite. Auth/storage code uses
+        // Date.parse() on these and the spec timestamp sentinel only matches strings.
+        1082: (x) => x,
+        1083: (x) => x,
+        1114: (x) => x,
+        1184: (x) => x,
+        1266: (x) => x,
+        ...config.pgliteOptions?.parsers
+      }
+    });
+    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() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await this.clearSchemaCache();
+    await this.kysely.destroy();
+    await this.driver.close();
+  }
+  createMigrator(desiredSchema) {
+    const migrationSchema = [this.config.baseSchema, desiredSchema].filter(Boolean).join("\n\n");
+    return new PostgresMigrator(this, migrationSchema);
+  }
+};
+async function createPgliteConnection(config = {}) {
+  return new PgliteConnection(config);
+}
+
+export { PgliteConnection, createPgliteConnection };