@supabase/lite 0.0.1

package/dist/db/postgres/PostgresConnection.js

@@ -0,0 +1,611 @@
+import postgres from 'postgres';
+import { PostgresJSDialect } from 'kysely-postgres-js';
+import { Kysely, sql } from 'kysely';
+import { Connection, invariant, RelationNotFoundError } from '@supabase/lite';
+
+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 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/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);
+          }
+        },
+        // json (OID 114) and jsonb (OID 3802): postgres.js leaves both as text by default.
+        // PostgREST returns them as parsed JSON, including json_agg() in embed aggregates.
+        json: {
+          to: 114,
+          from: [114],
+          serialize: (x) => JSON.stringify(x),
+          parse: (x) => JSON.parse(x)
+        },
+        jsonb: {
+          to: 3802,
+          from: [3802],
+          serialize: (x) => JSON.stringify(x),
+          parse: (x) => JSON.parse(x)
+        },
+        // numeric (OID 1700): postgres.js returns as string for precision safety.
+        // PostgREST returns as JSON number — coerce when round-trip is exact, else keep string.
+        numeric: {
+          to: 1700,
+          from: [1700],
+          serialize: (x) => String(x),
+          parse: (x) => {
+            const n = Number(x);
+            if (Number.isFinite(n) && String(n) === x) return n;
+            return x;
+          }
+        },
+        // Date/time OIDs: keep as raw strings to mirror SQLite, which stores ISO text.
+        // Auth/storage code already uses Date.parse() on these, and the spec timestamp
+        // sentinel only matches strings.
+        date: {
+          to: 1082,
+          from: [1082],
+          serialize: (x) => x,
+          parse: (x) => x
+        },
+        time: {
+          to: 1083,
+          from: [1083],
+          serialize: (x) => x,
+          parse: (x) => x
+        },
+        timestamp: {
+          to: 1114,
+          from: [1114],
+          serialize: (x) => x,
+          parse: (x) => x
+        },
+        timestamptz: {
+          to: 1184,
+          from: [1184],
+          serialize: (x) => x,
+          parse: (x) => x
+        },
+        timetz: {
+          to: 1266,
+          from: [1266],
+          serialize: (x) => x,
+          parse: (x) => 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);
+}
+
+export { PostgresConnection, createPostgresConnection };