@unieojs/unio-supabase-shim 0.1.0

package/src/pglite-database.ts

@@ -0,0 +1,257 @@
+import { PGlite } from "@electric-sql/pglite";
+
+import type {
+  QueryFilter,
+  SelectQuery,
+  ShimRow,
+  ShimValue,
+  SupabaseShimDatabase,
+} from "./types.js";
+
+interface PGliteSnapshot {
+  kind: "pglite-data-dir";
+  compression: "gzip";
+  type: string;
+  data: string;
+}
+
+export class PGliteShimDatabase implements SupabaseShimDatabase {
+  #database: PGlite;
+
+  private constructor(database: PGlite) {
+    this.#database = database;
+  }
+
+  static async create(): Promise<PGliteShimDatabase> {
+    return new PGliteShimDatabase(await PGlite.create());
+  }
+
+  async bootstrap(initSql: string): Promise<void> {
+    await this.#database.exec(initSql);
+  }
+
+  async select(table: string, query: SelectQuery = {}): Promise<ShimRow[]> {
+    const statement = buildSelectStatement(table, query);
+    const result = await this.#database.query<ShimRow>(statement.sql, statement.params);
+    return result.rows;
+  }
+
+  async insert(table: string, rows: ShimRow[], query: SelectQuery = {}): Promise<ShimRow[]> {
+    if (rows.length === 0) {
+      return [];
+    }
+
+    const statement = buildInsertStatement(table, rows, query);
+    const result = await this.#database.query<ShimRow>(statement.sql, statement.params);
+    return result.rows;
+  }
+
+  async delete(table: string, query: SelectQuery = {}): Promise<ShimRow[]> {
+    const statement = buildDeleteStatement(table, query);
+    const result = await this.#database.query<ShimRow>(statement.sql, statement.params);
+    return result.rows;
+  }
+
+  async snapshot(): Promise<string> {
+    const dataDir = await this.#database.dumpDataDir("gzip");
+    const data = encodeBase64(new Uint8Array(await dataDir.arrayBuffer()));
+    return JSON.stringify({
+      kind: "pglite-data-dir",
+      compression: "gzip",
+      type: dataDir.type,
+      data,
+    } satisfies PGliteSnapshot);
+  }
+
+  async restore(snapshot: string): Promise<void> {
+    const parsed = JSON.parse(snapshot) as PGliteSnapshot;
+    if (parsed.kind !== "pglite-data-dir" || parsed.compression !== "gzip") {
+      throw new Error("Unsupported PGlite snapshot format");
+    }
+
+    const dataDir = new Blob([toArrayBuffer(decodeBase64(parsed.data))], {
+      type: parsed.type || "application/gzip",
+    });
+    const next = await PGlite.create({ loadDataDir: dataDir });
+    await this.#database.close();
+    this.#database = next;
+  }
+
+  async close(): Promise<void> {
+    await this.#database.close();
+  }
+}
+
+interface SqlStatement {
+  sql: string;
+  params: ShimValue[];
+}
+
+function buildSelectStatement(table: string, query: SelectQuery): SqlStatement {
+  const params: ShimValue[] = [];
+  const where = buildWhereClause(query.filters ?? [], params);
+  const order = buildOrderClause(query);
+  return {
+    sql: `SELECT ${buildColumnList(query)} FROM ${quoteQualifiedIdentifier(table)}${where}${order}`,
+    params,
+  };
+}
+
+function buildInsertStatement(table: string, rows: ShimRow[], query: SelectQuery): SqlStatement {
+  const params: ShimValue[] = [];
+  const tableName = quoteQualifiedIdentifier(table);
+
+  if (rows.length === 1) {
+    return buildSingleInsertStatement(tableName, rows[0] ?? {}, query, params);
+  }
+
+  const insertCtes = rows.map((row, index) => {
+    const { columnsSql, valuesSql } = buildInsertValues(row, params);
+    return `inserted_${index} AS (INSERT INTO ${tableName}${columnsSql} ${valuesSql} RETURNING *)`;
+  });
+  const insertedSelects = rows
+    .map((_, index) => `SELECT * FROM inserted_${index}`)
+    .join(" UNION ALL ");
+  const where = buildWhereClause(query.filters ?? [], params);
+  const order = buildOrderClause(query);
+
+  return {
+    sql: `WITH ${insertCtes.join(", ")}, inserted AS (${insertedSelects}) SELECT ${buildColumnList(
+      query,
+    )} FROM inserted${where}${order}`,
+    params,
+  };
+}
+
+function buildSingleInsertStatement(
+  tableName: string,
+  row: ShimRow,
+  query: SelectQuery,
+  params: ShimValue[],
+): SqlStatement {
+  const { columnsSql, valuesSql } = buildInsertValues(row, params);
+  const where = buildWhereClause(query.filters ?? [], params);
+  const order = buildOrderClause(query);
+
+  return {
+    sql: `WITH inserted AS (INSERT INTO ${tableName}${columnsSql} ${valuesSql} RETURNING *) SELECT ${buildColumnList(
+      query,
+    )} FROM inserted${where}${order}`,
+    params,
+  };
+}
+
+function buildDeleteStatement(table: string, query: SelectQuery): SqlStatement {
+  const params: ShimValue[] = [];
+  const where = buildWhereClause(query.filters ?? [], params);
+  const order = buildOrderClause(query);
+
+  return {
+    sql: `WITH deleted AS (DELETE FROM ${quoteQualifiedIdentifier(
+      table,
+    )}${where} RETURNING *) SELECT ${buildColumnList(query)} FROM deleted${order}`,
+    params,
+  };
+}
+
+function buildInsertValues(
+  row: ShimRow,
+  params: ShimValue[],
+): { columnsSql: string; valuesSql: string } {
+  const columns = Object.keys(row);
+  if (columns.length === 0) {
+    return { columnsSql: "", valuesSql: "DEFAULT VALUES" };
+  }
+
+  const placeholders = columns.map((column) => {
+    params.push(row[column] ?? null);
+    return `$${params.length}`;
+  });
+
+  return {
+    columnsSql: ` (${columns.map(quoteIdentifier).join(", ")})`,
+    valuesSql: `VALUES (${placeholders.join(", ")})`,
+  };
+}
+
+function buildColumnList(query: SelectQuery): string {
+  const columns = query.columns ?? ["*"];
+  if (columns.includes("*")) {
+    return "*";
+  }
+  return columns.map(quoteIdentifier).join(", ");
+}
+
+function buildWhereClause(filters: QueryFilter[], params: ShimValue[]): string {
+  if (filters.length === 0) {
+    return "";
+  }
+
+  const clauses = filters.map((filter) => {
+    const column = quoteIdentifier(filter.column);
+    if (filter.operator === "eq" && filter.value === null) {
+      return `${column} IS NULL`;
+    }
+
+    params.push(filter.value);
+    return `${column} ${sqlOperatorForFilter(filter)} $${params.length}`;
+  });
+
+  return ` WHERE ${clauses.join(" AND ")}`;
+}
+
+function sqlOperatorForFilter(filter: QueryFilter): string {
+  switch (filter.operator) {
+    case "eq":
+      return "=";
+    case "gte":
+      return ">=";
+    case "lte":
+      return "<=";
+  }
+}
+
+function buildOrderClause(query: SelectQuery): string {
+  if (!query.order) {
+    return "";
+  }
+
+  return ` ORDER BY ${quoteIdentifier(query.order.column)} ${
+    query.order.ascending ? "ASC" : "DESC"
+  }`;
+}
+
+function quoteQualifiedIdentifier(identifier: string): string {
+  return identifier.split(".").map(quoteIdentifier).join(".");
+}
+
+function quoteIdentifier(identifier: string): string {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+    throw new Error(`Unsupported SQL identifier "${identifier}"`);
+  }
+  return `"${identifier}"`;
+}
+
+function encodeBase64(bytes: Uint8Array): string {
+  let binary = "";
+  const chunkSize = 0x8000;
+  for (let index = 0; index < bytes.length; index += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + chunkSize));
+  }
+  return globalThis.btoa(binary);
+}
+
+function decodeBase64(base64: string): Uint8Array {
+  const binary = globalThis.atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+
+function toArrayBuffer(bytes: Uint8Array): ArrayBuffer {
+  const buffer = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(buffer).set(bytes);
+  return buffer;
+}

package/src/query-builder.ts

@@ -0,0 +1,189 @@
+import type {
+  PostgrestResponse,
+  QueryFilter,
+  QueryOrder,
+  ShimRow,
+  ShimValue,
+  SupabaseShimDatabase,
+} from "./types.js";
+
+type QueryAction = "select" | "insert" | "delete";
+
+interface QueryState {
+  action: QueryAction;
+  columns?: string[];
+  filters: QueryFilter[];
+  order?: QueryOrder;
+  rows?: ShimRow[];
+  wantsRows: boolean;
+  single: boolean;
+}
+
+type BuilderData<Single extends boolean> = Single extends true ? ShimRow | null : ShimRow[];
+
+export class SupabasePostgrestBuilder<Single extends boolean = false>
+  implements PromiseLike<PostgrestResponse<BuilderData<Single>>>
+{
+  readonly #database: SupabaseShimDatabase;
+  readonly #table: string;
+  readonly #state: QueryState;
+
+  constructor(database: SupabaseShimDatabase, table: string, state?: Partial<QueryState>) {
+    this.#database = database;
+    this.#table = table;
+    this.#state = {
+      action: state?.action ?? "select",
+      columns: state?.columns,
+      filters: state?.filters ?? [],
+      order: state?.order,
+      rows: state?.rows,
+      wantsRows: state?.wantsRows ?? true,
+      single: state?.single ?? false,
+    };
+  }
+
+  select(columns = "*"): this {
+    this.#state.columns = parseColumns(columns);
+    this.#state.wantsRows = true;
+    return this;
+  }
+
+  insert(rows: ShimRow | ShimRow[]): this {
+    this.#state.action = "insert";
+    this.#state.rows = Array.isArray(rows) ? rows : [rows];
+    this.#state.wantsRows = false;
+    return this;
+  }
+
+  delete(): this {
+    this.#state.action = "delete";
+    this.#state.wantsRows = false;
+    return this;
+  }
+
+  eq(column: string, value: ShimValue): this {
+    this.#state.filters.push({ column, operator: "eq", value });
+    return this;
+  }
+
+  gte(column: string, value: ShimValue): this {
+    this.#state.filters.push({ column, operator: "gte", value });
+    return this;
+  }
+
+  lte(column: string, value: ShimValue): this {
+    this.#state.filters.push({ column, operator: "lte", value });
+    return this;
+  }
+
+  order(column: string, options: { ascending?: boolean } = {}): this {
+    this.#state.order = { column, ascending: options.ascending ?? true };
+    return this;
+  }
+
+  single(): SupabasePostgrestBuilder<true> {
+    this.#state.single = true;
+    return this as unknown as SupabasePostgrestBuilder<true>;
+  }
+
+  then<TResult1 = PostgrestResponse<BuilderData<Single>>, TResult2 = never>(
+    onfulfilled?:
+      | ((value: PostgrestResponse<BuilderData<Single>>) => TResult1 | PromiseLike<TResult1>)
+      | null,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+  ): PromiseLike<TResult1 | TResult2> {
+    return this.#execute().then(onfulfilled, onrejected);
+  }
+
+  catch<TResult = never>(
+    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null,
+  ): Promise<PostgrestResponse<BuilderData<Single>> | TResult> {
+    return this.#execute().catch(onrejected);
+  }
+
+  finally(onfinally?: (() => void) | null): Promise<PostgrestResponse<BuilderData<Single>>> {
+    return this.#execute().finally(onfinally ?? undefined);
+  }
+
+  async #execute(): Promise<PostgrestResponse<BuilderData<Single>>> {
+    try {
+      const rows = await this.#executeRows();
+      if (this.#state.single) {
+        return singleResponse(rows) as PostgrestResponse<BuilderData<Single>>;
+      }
+
+      return {
+        data: rows as BuilderData<Single>,
+        error: null,
+        count: rows.length,
+        status: this.#state.action === "insert" ? 201 : 200,
+      };
+    } catch (error) {
+      return {
+        data: (this.#state.single ? null : []) as BuilderData<Single>,
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          status: 500,
+        },
+        count: null,
+        status: 500,
+      };
+    }
+  }
+
+  async #executeRows(): Promise<ShimRow[]> {
+    if (this.#state.action === "insert") {
+      if (!this.#state.wantsRows) {
+        await this.#database.insert(this.#table, this.#state.rows ?? []);
+        return [];
+      }
+      return this.#database.insert(this.#table, this.#state.rows ?? [], {
+        columns: this.#state.columns,
+        filters: this.#state.filters,
+        order: this.#state.order,
+      });
+    }
+
+    if (this.#state.action === "delete") {
+      if (!this.#state.wantsRows) {
+        await this.#database.delete(this.#table, { filters: this.#state.filters });
+        return [];
+      }
+      return this.#database.delete(this.#table, {
+        columns: this.#state.columns,
+        filters: this.#state.filters,
+        order: this.#state.order,
+      });
+    }
+
+    return this.#database.select(this.#table, {
+      columns: this.#state.columns,
+      filters: this.#state.filters,
+      order: this.#state.order,
+    });
+  }
+}
+
+function singleResponse(rows: ShimRow[]): PostgrestResponse<ShimRow | null> {
+  if (rows.length === 1) {
+    return { data: rows[0], error: null, count: 1, status: 200 };
+  }
+
+  return {
+    data: null,
+    error: {
+      code: "PGRST116",
+      message: "JSON object requested, multiple (or no) rows returned",
+      status: 406,
+    },
+    count: rows.length,
+    status: 406,
+  };
+}
+
+function parseColumns(columns: string): string[] {
+  return columns
+    .split(",")
+    .map((column) => column.trim())
+    .filter(Boolean);
+}

package/src/snapshot.ts

@@ -0,0 +1,13 @@
+import type { SnapshotStorage } from "./types.js";
+
+export class InMemorySnapshotStorage implements SnapshotStorage {
+  readonly #snapshots = new Map<string, string>();
+
+  get(key: string): string | null {
+    return this.#snapshots.get(key) ?? null;
+  }
+
+  set(key: string, snapshot: string): void {
+    this.#snapshots.set(key, snapshot);
+  }
+}

package/src/types.ts

@@ -0,0 +1,66 @@
+export type ShimValue = string | number | boolean | null;
+
+export type ShimRow = Record<string, ShimValue>;
+
+export type AuthChangeEvent = "SIGNED_UP" | "SIGNED_IN" | "SIGNED_OUT";
+
+export interface ShimUser {
+  id: string;
+  email: string;
+}
+
+export interface ShimSession {
+  access_token: string;
+  token_type: "bearer";
+  user: ShimUser;
+}
+
+export interface SupabaseShimError {
+  code?: string;
+  message: string;
+  status?: number;
+}
+
+export interface SupabaseAuthResponse<T> {
+  data: T;
+  error: SupabaseShimError | null;
+}
+
+export interface PostgrestResponse<T> {
+  data: T;
+  error: SupabaseShimError | null;
+  count: number | null;
+  status: number;
+}
+
+export interface QueryFilter {
+  column: string;
+  operator: "eq" | "gte" | "lte";
+  value: ShimValue;
+}
+
+export interface QueryOrder {
+  column: string;
+  ascending: boolean;
+}
+
+export interface SelectQuery {
+  columns?: string[];
+  filters?: QueryFilter[];
+  order?: QueryOrder;
+}
+
+export interface SupabaseShimDatabase {
+  bootstrap(initSql: string): Promise<void>;
+  select(table: string, query?: SelectQuery): Promise<ShimRow[]>;
+  insert(table: string, rows: ShimRow[], query?: SelectQuery): Promise<ShimRow[]>;
+  delete(table: string, query?: SelectQuery): Promise<ShimRow[]>;
+  snapshot(): Promise<string>;
+  restore(snapshot: string): Promise<void>;
+  close?(): Promise<void>;
+}
+
+export interface SnapshotStorage {
+  get(key: string): Promise<string | null> | string | null;
+  set(key: string, snapshot: string): Promise<void> | void;
+}