@supabase/lite 0.0.1 → 0.2.0

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

@@ -1,13 +1,4 @@
-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 {
+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
     */
@@ -17,112 +8,8 @@ try {
       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 ?? ""}
+async function B(n){let e;if(typeof n=="string"&&(e=n),typeof n=="object"&&n.dataDir&&(e=n.dataDir),e){let{mkdir:a}=await import('node:fs');a(e,{recursive:true},o=>{if(o)throw o});}}var N=class{#e;#t;constructor(e,a){this.#e=e,this.#t=a;}async acquireConnection(){return new _(this.#e)}async beginTransaction(e,a){await e.executeQuery(CompiledQuery.raw("BEGIN"));}async commitTransaction(e){await e.executeQuery(CompiledQuery.raw("COMMIT"));}async rollbackTransaction(e){await e.executeQuery(CompiledQuery.raw("ROLLBACK"));}async destroy(){this.#t&&await this.#e.close();}async init(){}async releaseConnection(e){}},_=class{#e;constructor(e){this.#e=e;}async executeQuery(e){let a=await this.#e.query(e.sql,[...e.parameters]),o=a.affectedRows;return {rows:a.rows,numAffectedRows:typeof o=="number"?BigInt(o):void 0}}async*streamQuery(){throw new Error("PGlite does not support streaming.")}},d=class{client;#e=true;constructor(e,a){B(e);let o={...a};if(typeof e=="object"&&e instanceof PGlite){this.client=e,this.#e=false;return}typeof e=="string"?o={dataDir:e,...o}:o=e??{},this.client=new PGlite(o);}dialect={createAdapter:()=>new PostgresAdapter,createDriver:()=>new N(this.client,this.#e),createIntrospector:e=>new PostgresIntrospector(e),createQueryCompiler:()=>new PostgresQueryCompiler}};var y=class extends Error{constructor(a){super("Force rollback");this.result=a;}},g=class extends Connection{dialect="postgres";constructor(e){super({...e,baseSchema:`
+            ${e.baseSchema??""}
          
             CREATE SCHEMA IF NOT EXISTS auth;
 
@@ -148,16 +35,7 @@ var BasePostgresConnection = class extends Connection {
                 '{}'
               )::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`
+         `});}async introspect(e){invariant(typeof e=="object"||e===void 0,"options must be an object");let a=e?.useCache??false,o=await this.readCachedIntrospection({useCache:a});if(o)return o;try{let i=(await sql`
             SELECT
                tbls.table_name AS "name",
                tbls.table_schema AS "schema",
@@ -170,17 +48,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely)).rows.map(t=>({name:t.name,schema:t.schema,type:"table",rows:Number(t.rows),sql:"",engine:"",collation:""})),m=(await sql`
             SELECT
                cols.table_name AS "table",
                cols.table_schema AS "schema",
@@ -232,25 +100,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,schema:t.schema,name:t.name,type:t.type,nullable:t.nullable,default_value:t.default_value,is_primary_key:!1,ordinal_position:Number(t.ordinal_position),character_maximum_length:t.character_maximum_length??null,precision:t.precision??null,is_identity:t.is_identity,collation:t.collation,pg_type:t.udt_name??void 0,is_generated:t.is_generated??!1})),p=(await sql`
             SELECT
                ns.nspname AS "schema",
                cl.relname AS "table",
@@ -275,19 +125,7 @@ var BasePostgresConnection = class extends Connection {
                '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`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,column:t.column,schema:t.schema,ref_table:t.ref_table,ref_column:t.ref_column,foreign_key_name:t.foreign_key_name,fk_def:t.fk_def,on_update:"",on_delete:""})),u=(await sql`
             SELECT
                ns.nspname AS "schema",
                cl.relname AS "table",
@@ -304,20 +142,7 @@ var BasePostgresConnection = class extends Connection {
                '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`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,columns:t.columns,schema:t.schema,field_count:t.columns.length})),T=new Set(u.flatMap(t=>t.columns.map(v=>`${t.schema}.${t.table}.${v}`)));for(let t of m)t.is_primary_key=T.has(`${t.schema}.${t.table}.${t.name}`);let L=(await sql`
             SELECT
                tnsp.nspname AS "schema",
                cl.relname AS "table",
@@ -338,15 +163,7 @@ var BasePostgresConnection = class extends Connection {
                '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`
+         `.execute(this.kysely)).rows.map(t=>({table:t.table,name:t.name,unique:t.unique,columns:t.columns,schema:t.schema})),C=(await sql`
             SELECT
                views.schemaname AS "schema",
                views.viewname AS "name",
@@ -354,13 +171,7 @@ var BasePostgresConnection = class extends Connection {
             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`
+         `.execute(this.kysely)).rows.map(t=>({name:t.name,schema:t.schema,sql:t.sql??""})),I=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -372,13 +183,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,expression:t.expression??""})),x=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -393,14 +198,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,name:t.name,columns:t.columns})),k=(await sql`
             SELECT
                n.nspname AS "schema",
                cl.relname AS "table",
@@ -415,14 +213,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely)).rows.map(t=>({schema:t.schema,table:t.table,column:t.column??void 0,text:t.text})),D=await sql`
             SELECT
                n.nspname AS "schema",
                t.typname AS "type",
@@ -433,8 +224,7 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely),P=await sql`
             SELECT
                n.nspname AS "schema",
                t.typname AS "type",
@@ -456,76 +246,9 @@ var BasePostgresConnection = class extends Connection {
                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`
+         `.execute(this.kysely),H=[...D.rows.map(t=>({schema:t.schema,type:t.type,kind:"enum",values:t.values})),...P.rows.map(t=>({schema:t.schema,type:t.type,kind:"composite",fields:t.fields}))],F=(await sql`SELECT current_database() AS "name"`.execute(this.kysely)).rows[0]?.name??"postgres",A={tables:i,columns:m,indexes:L,foreign_keys:p,primary_keys:u,views:C,triggers:[],check_constraints:I,unique_constraints:x,comments:k,custom_types:H,database_name:F,version:""};return await this.writeCachedIntrospection(A,{useDriver:a}),A}catch(s){return console.error("Introspection failed:",s),{tables:[],columns:[],indexes:[],foreign_keys:[],primary_keys:[],views:[],triggers:[],check_constraints:[],unique_constraints:[],comments:[],custom_types:[],database_name:"postgres",version:""}}}rlsState="unknown";async ensureRlsContext(){if(this.rlsState!=="unknown")return this.rlsState==="active";let e=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`
+      `.execute(this.kysely);if(!(Number(e.rows[0]?.count??0)>0))return this.rlsState="inactive",false;this.rlsState="active",await sql`
          DO $$ BEGIN
             IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'anon') THEN
                CREATE ROLE anon NOLOGIN;
@@ -534,357 +257,12 @@ var BasePostgresConnection = class extends Connection {
                CREATE ROLE authenticated NOLOGIN;
             END IF;
          END $$
-      `.execute(this.kysely);
-    const schemas = await sql`
+      `.execute(this.kysely);let o=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
-      };
-    }
-  };
-}
+      `.execute(this.kysely);for(let{nspname:s}of o.rows)await sql`GRANT USAGE ON SCHEMA ${sql.ref(s)} TO anon, authenticated`.execute(this.kysely),await sql.raw(`GRANT ALL ON ALL TABLES IN SCHEMA "${s}" TO anon, authenticated`).execute(this.kysely),await sql.raw(`GRANT ALL ON ALL SEQUENCES IN SCHEMA "${s}" TO anon, authenticated`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA "${s}" GRANT ALL ON TABLES TO anon, authenticated`).execute(this.kysely),await sql.raw(`ALTER DEFAULT PRIVILEGES IN SCHEMA "${s}" GRANT ALL ON SEQUENCES TO anon, authenticated`).execute(this.kysely);return  true}async withContext(e,a,o){let s=o?.forceRollback===true;if(!s&&!e)return a(this.kysely);let i=e?await this.ensureRlsContext():false;if(!s&&!i)return a(this.kysely);try{return await this.kysely.transaction().execute(async c=>{if(e&&i){let l=e.auth,p=l?.role||"anon",w=String(l?.uid??""),u=l?.jwt;await sql`SELECT set_config('role', ${p}, true)`.execute(c),await sql`SELECT set_config('request.jwt.claim.sub', ${w}, true)`.execute(c),await sql`SELECT set_config('request.jwt.claim.role', ${p}, true)`.execute(c),u&&typeof u=="object"&&await sql`SELECT set_config('request.jwt.claims', ${JSON.stringify(u)}, true)`.execute(c);}let m=await a(c);if(s)throw new y(m);return m})}catch(c){if(c instanceof y)return c.result;throw c}}async onPostgrestAST(e){if(!e.from)return e;let a=e.schema??"public",o=e.from,s=await this.introspect({useCache:true});if(!s.tables.some(i=>i.name===o&&i.schema===a)&&!s.views.some(i=>i.name===o&&i.schema===a))throw new RelationNotFoundError(a,o);return e}async transaction(e,a){await this.exec("BEGIN");try{for(let o of e)await this.exec(o);await this.exec("COMMIT");}catch(o){throw await this.exec("ROLLBACK"),o}finally{a?.intent==="migration"&&await this.clearSchemaCache();}}};var R=(n,e=a=>a)=>{if(!n||n==="{}")return [];let a=n.slice(1,-1);if(a==="")return [];let o=[],s="",i=false,c=0;for(let m=0;m<a.length;m++){let l=a[m];l==='"'&&a[m-1]!=="\\"?(i=!i,s+=l):l==="{"&&!i?(c++,s+=l):l==="}"&&!i?(c--,s+=l):l===","&&!i&&c===0?(o.push(e(s)),s=""):s+=l;}return s!==""&&o.push(e(s)),o},M=n=>n==="NULL"?null:n.startsWith('"')&&n.endsWith('"')?n.slice(1,-1).replace(/\\(.)/g,"$1"):n,j=n=>n==="NULL"?null:Number.parseInt(n,10);function b(n){return typeof n=="object"&&n!==null&&"text"in n&&"values"in n}function Q(n,e){if(n==null)return n;switch(e){case 20:return typeof n=="bigint"?n:BigInt(n);case 22:return Array.isArray(n)?n:typeof n=="string"?n.split(" ").map(Number).filter(a=>!Number.isNaN(a)):n;case 1002:case 1009:case 1015:return typeof n=="string"?R(n,M):n;case 1005:case 1007:case 1016:return typeof n=="string"?R(n,j):n;default:return n}}function h(n){return {async query(e,a){let o=b(e)?e.text:e,s=b(e)?e.values:a??[],i=await n.driver.query(o,[...s]);return {rows:i.rows.map(m=>Object.fromEntries(i.fields.map(l=>[l.name,Q(m[l.name],l.dataTypeID)])))}}}}async function K(){try{return await import('@supabase/pg-delta')}catch(n){throw new Error("Postgres/PGlite schema diffing now requires a Bun/Node-compatible runtime with pg-delta available.",{cause:n})}}function V(n){let e=/^drop table (.+)$/.exec(n);if(e)return {table:e[1],reason:"drop table"};let a=/^drop column (.+) on (.+)$/.exec(n);if(a)return {table:a[2],reason:`drop column ${a[1]}`};let o=/^drop sequence (.+)$/.exec(n);return o?{table:o[1],reason:"drop sequence"}:{table:"unknown",reason:n}}var E=class{constructor(e,a){this.from=e;this.desiredSchema=a;}#e;async#t(e){if(this.#e)return this.#e;let a=new this.from.constructor;try{return await a.exec(this.desiredSchema),this.#e=await e(h(a)),this.#e}finally{await a.close();}}async diff(){let{createPlan:e,extractCatalog:a}=await K(),o=h(this.from),s=await this.#t(a),i=await a(o),c=await e(i,s);if(!c)return {diff:"",plan:{steps:[],warnings:[],unsafe:false}};let m=c.plan.risk?.level==="data_loss"?c.plan.risk.statements.map(V):[];return {diff:c.plan.statements.join(`
 
-// 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);
-}
+`),plan:{steps:c.plan.statements.map(l=>({sql:l})),warnings:m,unsafe:c.plan.risk?.level==="data_loss"}}}async migratePlan(e,a){if(e.steps.length!==0){if(e.unsafe&&!a?.force)throw new DataLossError(e.warnings??[]);await this.from.transaction(e.steps.map(o=>o.sql),{intent:"migration"});}}async migrate(e){let a=await this.diff();return await this.migratePlan(a.plan,e),a}safeSortPlanSteps(e){return e}};var S=class extends g{driver;dialect="postgres";#e=false;constructor(e={}){let a=new PGlite({...e.pgliteOptions,dataDir:e.url??void 0,extensions:{...e.pgliteOptions?.extensions,isn:isn,ltree:ltree,file_fdw:file_fdw,pgcrypto:pgcrypto},parsers:{20:s=>{let i=Number(s);return Number.isSafeInteger(i)?i:BigInt(s)},114:s=>JSON.parse(s),3802:s=>JSON.parse(s),1700:s=>{let i=Number(s);return Number.isFinite(i)&&String(i)===s?i:s},1082:s=>s,1083:s=>s,1114:s=>s,1184:s=>s,1266:s=>s,...e.pgliteOptions?.parsers}}),{dialect:o}=new d(a);super(e),this.driver=a,this.kysely=new Kysely({dialect:o});}async exec(e,...a){try{if(a.length>0){let{rows:s}=await sql(e,...a??[]).execute(this.kysely);return {rows:s}}return {rows:(await this.driver.exec(e))[0].rows}}catch(o){throw console.error(o),new Error(`Failed to execute query: ${e}`)}}async close(){this.#e||(this.#e=true,await this.clearSchemaCache(),await this.kysely.destroy(),await this.driver.close());}createMigrator(e){let a=[this.config.baseSchema,e].filter(Boolean).join(`
 
-export { PgliteConnection, createPgliteConnection };
+`);return new E(this,a)}};async function Ie(n={}){return new S(n)}export{S as PgliteConnection,Ie as createPgliteConnection};