@framers/sql-storage-adapter 0.7.1 → 0.7.3

package/dist/cjs/adapters/supabase.js

@@ -0,0 +1,401 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var supabase_exports = {};
+__export(supabase_exports, {
+  SupabaseAdapter: () => SupabaseAdapter
+});
+module.exports = __toCommonJS(supabase_exports);
+class SupabaseAdapter {
+  constructor() {
+    this.kind = "supabase-postgres";
+    this.capabilities = /* @__PURE__ */ new Set([
+      "transactions",
+      "persistence",
+      "locks",
+      "streaming",
+      "batch"
+    ]);
+    this.metrics = {
+      totalQueries: 0,
+      totalDuration: 0,
+      averageDuration: 0,
+      slowQueries: [],
+      cacheHits: 0,
+      cacheMisses: 0
+    };
+    this.profilingEnabled = false;
+    this.queryCache = /* @__PURE__ */ new Map();
+    this.cacheEnabled = false;
+    this.maxCacheSize = 100;
+  }
+  async open(options) {
+    this.options = options;
+    const pg = await Promise.resolve().then(() => __toESM(require("pg")));
+    const { Pool } = pg;
+    const getEnv = (key) => {
+      if (typeof process !== "undefined" && process.env) {
+        return process.env[key];
+      }
+      return void 0;
+    };
+    const connectionString = options?.connectionString || getEnv("DATABASE_URL");
+    if (!connectionString) {
+      throw new Error("Supabase connection string required (DATABASE_URL or connectionString option)");
+    }
+    this.pool = new Pool({
+      connectionString,
+      max: options?.poolConfig?.max || 20,
+      min: options?.poolConfig?.min || 2,
+      idleTimeoutMillis: options?.poolConfig?.idleTimeoutMillis || 3e4,
+      connectionTimeoutMillis: options?.poolConfig?.connectionTimeoutMillis || 5e3,
+      ssl: options?.ssl !== false ? { rejectUnauthorized: false } : void 0
+    });
+    try {
+      const client = await this.pool.connect();
+      client.release();
+    } catch (error) {
+      throw new Error(`Failed to connect to Supabase: ${error}`);
+    }
+  }
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = void 0;
+    }
+    this.clearCache();
+  }
+  trackQuery(query, startTime) {
+    if (!this.profilingEnabled)
+      return;
+    const duration = Date.now() - startTime;
+    this.metrics.totalQueries++;
+    this.metrics.totalDuration += duration;
+    this.metrics.averageDuration = this.metrics.totalDuration / this.metrics.totalQueries;
+    if (duration > 100) {
+      if (!this.metrics.slowQueries) {
+        this.metrics.slowQueries = [];
+      }
+      this.metrics.slowQueries.push({
+        query: query.substring(0, 200),
+        duration,
+        timestamp: new Date(Date.now())
+      });
+      if (this.metrics.slowQueries.length > 100) {
+        this.metrics.slowQueries.shift();
+      }
+    }
+  }
+  getCacheKey(query, params) {
+    return `${query}::${JSON.stringify(params || {})}`;
+  }
+  async run(statement, parameters) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    const startTime = Date.now();
+    try {
+      const result = await this.pool.query(statement, Array.isArray(parameters) ? parameters : void 0);
+      this.trackQuery(statement, startTime);
+      return {
+        changes: result.rowCount || 0,
+        lastInsertRowid: result.rows[0]?.id || 0
+      };
+    } catch (error) {
+      throw new Error(`Query failed: ${error}`);
+    }
+  }
+  async get(statement, parameters) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    if (this.cacheEnabled) {
+      const cacheKey = this.getCacheKey(statement, parameters);
+      if (this.queryCache.has(cacheKey)) {
+        if (this.metrics.cacheHits !== void 0) {
+          this.metrics.cacheHits++;
+        }
+        const cached = this.queryCache.get(cacheKey);
+        return cached ?? null;
+      }
+      if (this.metrics.cacheMisses !== void 0) {
+        this.metrics.cacheMisses++;
+      }
+    }
+    const startTime = Date.now();
+    try {
+      const result = await this.pool.query(statement, Array.isArray(parameters) ? parameters : void 0);
+      this.trackQuery(statement, startTime);
+      const value = result.rows[0] || null;
+      if (this.cacheEnabled && value !== null) {
+        const cacheKey = this.getCacheKey(statement, parameters);
+        this.queryCache.set(cacheKey, value);
+        if (this.queryCache.size > this.maxCacheSize) {
+          const firstKey = this.queryCache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.queryCache.delete(firstKey);
+          }
+        }
+      }
+      return value;
+    } catch (error) {
+      throw new Error(`Query failed: ${error}`);
+    }
+  }
+  async all(statement, parameters) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    if (this.cacheEnabled) {
+      const cacheKey = this.getCacheKey(statement, parameters);
+      if (this.queryCache.has(cacheKey)) {
+        if (this.metrics.cacheHits !== void 0) {
+          this.metrics.cacheHits++;
+        }
+        const cached = this.queryCache.get(cacheKey);
+        if (cached) {
+          return cached;
+        }
+      }
+      if (this.metrics.cacheMisses !== void 0) {
+        this.metrics.cacheMisses++;
+      }
+    }
+    const startTime = Date.now();
+    try {
+      const result = await this.pool.query(statement, Array.isArray(parameters) ? parameters : void 0);
+      this.trackQuery(statement, startTime);
+      const rows = result.rows;
+      if (this.cacheEnabled) {
+        const cacheKey = this.getCacheKey(statement, parameters);
+        this.queryCache.set(cacheKey, rows);
+        if (this.queryCache.size > this.maxCacheSize) {
+          const firstKey = this.queryCache.keys().next().value;
+          if (firstKey !== void 0) {
+            this.queryCache.delete(firstKey);
+          }
+        }
+      }
+      return rows;
+    } catch (error) {
+      throw new Error(`Query failed: ${error}`);
+    }
+  }
+  async exec(script) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    const startTime = Date.now();
+    try {
+      await this.pool.query(script);
+      this.trackQuery(script, startTime);
+    } catch (error) {
+      throw new Error(`Script execution failed: ${error}`);
+    }
+  }
+  async transaction(fn) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const trxAdapter = {
+        kind: this.kind,
+        capabilities: this.capabilities,
+        open: async () => {
+        },
+        close: async () => {
+        },
+        run: async (stmt, params) => {
+          const result2 = await client.query(stmt, Array.isArray(params) ? params : void 0);
+          return { changes: result2.rowCount || 0, lastInsertRowid: 0 };
+        },
+        get: async (stmt, params) => {
+          const result2 = await client.query(stmt, Array.isArray(params) ? params : void 0);
+          return result2.rows[0] || null;
+        },
+        all: async (stmt, params) => {
+          const result2 = await client.query(stmt, Array.isArray(params) ? params : void 0);
+          return result2.rows;
+        },
+        exec: async (script) => {
+          await client.query(script);
+        },
+        transaction: async (fn2) => fn2(trxAdapter)
+      };
+      const result = await fn(trxAdapter);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  // Extension methods
+  async *stream(query, parameters, options) {
+    if (!this.pool)
+      throw new Error("Storage adapter not opened");
+    const batchSize = options?.batchSize || 100;
+    let offset = 0;
+    let hasMore = true;
+    while (hasMore) {
+      const paginatedQuery = `${query} LIMIT ${batchSize} OFFSET ${offset}`;
+      const rows = await this.all(paginatedQuery, parameters);
+      if (rows.length < batchSize) {
+        hasMore = false;
+      }
+      for (const row of rows) {
+        yield row;
+      }
+      offset += batchSize;
+    }
+  }
+  async batchWrite(operations) {
+    return this.transaction(async (trx) => {
+      let successful = 0;
+      let failed = 0;
+      const errors = [];
+      for (let index = 0; index < operations.length; index++) {
+        const op = operations[index];
+        try {
+          switch (op.type) {
+            case "insert": {
+              const keys = Object.keys(op.values || {});
+              const values = Object.values(op.values || {});
+              const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
+              const query = `INSERT INTO ${op.table} (${keys.join(", ")}) VALUES (${placeholders})`;
+              await trx.run(query, values);
+              successful++;
+              break;
+            }
+            case "update": {
+              const sets = Object.keys(op.values || {}).map((k, i) => `${k} = $${i + 1}`).join(", ");
+              const whereClause = Object.keys(op.where || {}).map((k, i) => `${k} = $${i + Object.keys(op.values || {}).length + 1}`).join(" AND ");
+              const query = `UPDATE ${op.table} SET ${sets} WHERE ${whereClause}`;
+              const params = [...Object.values(op.values || {}), ...Object.values(op.where || {})];
+              await trx.run(query, params);
+              successful++;
+              break;
+            }
+            case "delete": {
+              const whereClause = Object.keys(op.where || {}).map((k, i) => `${k} = $${i + 1}`).join(" AND ");
+              const query = `DELETE FROM ${op.table} WHERE ${whereClause}`;
+              await trx.run(query, Object.values(op.where || {}));
+              successful++;
+              break;
+            }
+          }
+        } catch (error) {
+          failed++;
+          errors.push({
+            index,
+            error: error instanceof Error ? error : new Error(String(error))
+          });
+        }
+      }
+      return { successful, failed, errors: errors.length > 0 ? errors : void 0 };
+    });
+  }
+  async migrate(migrations) {
+    await this.exec(`
+      CREATE TABLE IF NOT EXISTS _migrations (
+        id TEXT PRIMARY KEY,
+        version INTEGER NOT NULL,
+        applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    const applied = await this.all("SELECT id, version FROM _migrations");
+    const appliedSet = new Set(applied.map((m) => m.id));
+    for (const migration of migrations) {
+      if (!appliedSet.has(migration.id)) {
+        await this.transaction(async (trx) => {
+          await trx.exec(migration.up);
+          await trx.run("INSERT INTO _migrations (id, version) VALUES ($1, $2)", [migration.id, migration.version]);
+        });
+      }
+    }
+  }
+  async getMigrationStatus() {
+    const applied = await this.all("SELECT * FROM _migrations ORDER BY version");
+    return applied.map((m) => ({
+      id: m.id,
+      version: m.version,
+      up: "",
+      down: "",
+      timestamp: new Date(m.applied_at).getTime()
+    }));
+  }
+  async backup(_destination) {
+    throw new Error("Backup not implemented for Supabase adapter. Use Supabase dashboard or pg_dump.");
+  }
+  async restore(_source) {
+    throw new Error("Restore not implemented for Supabase adapter. Use Supabase dashboard or pg_restore.");
+  }
+  enableProfiling() {
+    this.profilingEnabled = true;
+  }
+  disableProfiling() {
+    this.profilingEnabled = false;
+  }
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  clearMetrics() {
+    this.metrics = {
+      totalQueries: 0,
+      totalDuration: 0,
+      averageDuration: 0,
+      slowQueries: [],
+      cacheHits: 0,
+      cacheMisses: 0
+    };
+  }
+  enableCache(maxSize = 100) {
+    this.cacheEnabled = true;
+    this.maxCacheSize = maxSize;
+  }
+  disableCache() {
+    this.cacheEnabled = false;
+    this.clearCache();
+  }
+  clearCache() {
+    this.queryCache.clear();
+  }
+  getPoolStatus() {
+    if (!this.pool) {
+      return { active: 0, idle: 0, waiting: 0, max: 0 };
+    }
+    return {
+      active: this.pool.totalCount,
+      idle: this.pool.idleCount,
+      waiting: this.pool.waitingCount,
+      max: this.pool.options?.max ?? 0
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SupabaseAdapter
+});

package/dist/cjs/codecs/BrowserBlobCodec.d.ts

@@ -0,0 +1,14 @@
+import type { IBlobCodec } from '../core/contracts/blobCodec.js';
+/**
+ * Browser-compatible BLOB codec using typed arrays.
+ *
+ * Encodes number[] vectors as Float32Array binary BLOBs and computes
+ * SHA-256 hashes via `crypto.subtle` (with a Node.js fallback for
+ * test environments where SubtleCrypto may not be available).
+ */
+export declare class BrowserBlobCodec implements IBlobCodec {
+    encode(vec: number[]): Uint8Array;
+    decode(blob: Uint8Array | ArrayBufferLike): number[];
+    sha256(input: string): Promise<string>;
+}
+//# sourceMappingURL=BrowserBlobCodec.d.ts.map

package/dist/cjs/codecs/BrowserBlobCodec.js

@@ -0,0 +1,57 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var BrowserBlobCodec_exports = {};
+__export(BrowserBlobCodec_exports, {
+  BrowserBlobCodec: () => BrowserBlobCodec
+});
+module.exports = __toCommonJS(BrowserBlobCodec_exports);
+class BrowserBlobCodec {
+  encode(vec) {
+    const f32 = new Float32Array(vec);
+    return new Uint8Array(f32.buffer);
+  }
+  decode(blob) {
+    const bytes = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+    const f32 = new Float32Array(bytes.buffer, bytes.byteOffset, bytes.byteLength / 4);
+    return Array.from(f32);
+  }
+  async sha256(input) {
+    if (typeof globalThis.crypto?.subtle?.digest === "function") {
+      const encoded = new TextEncoder().encode(input);
+      const hashBuffer = await globalThis.crypto.subtle.digest("SHA-256", encoded);
+      const hashArray = new Uint8Array(hashBuffer);
+      return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    const { createHash } = await Promise.resolve().then(() => __toESM(require("node:crypto")));
+    return createHash("sha256").update(input, "utf8").digest("hex");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBlobCodec
+});

package/dist/cjs/codecs/NodeBlobCodec.d.ts

@@ -0,0 +1,14 @@
+import type { IBlobCodec } from '../core/contracts/blobCodec.js';
+/**
+ * Node.js Buffer-based BLOB codec.
+ *
+ * Encodes number[] vectors as Float32 little-endian binary BLOBs using
+ * `Buffer.writeFloatLE` / `Buffer.readFloatLE`, and computes SHA-256
+ * hashes using the `node:crypto` module.
+ */
+export declare class NodeBlobCodec implements IBlobCodec {
+    encode(vec: number[]): Uint8Array;
+    decode(blob: Uint8Array | ArrayBufferLike): number[];
+    sha256(input: string): Promise<string>;
+}
+//# sourceMappingURL=NodeBlobCodec.d.ts.map

package/dist/cjs/codecs/NodeBlobCodec.js

@@ -0,0 +1,59 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var NodeBlobCodec_exports = {};
+__export(NodeBlobCodec_exports, {
+  NodeBlobCodec: () => NodeBlobCodec
+});
+module.exports = __toCommonJS(NodeBlobCodec_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+class NodeBlobCodec {
+  encode(vec) {
+    const buf = Buffer.alloc(vec.length * 4);
+    for (let i = 0; i < vec.length; i++) {
+      buf.writeFloatLE(vec[i], i * 4);
+    }
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  decode(blob) {
+    const bytes = blob instanceof Uint8Array ? blob : new Uint8Array(blob);
+    const buf = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const count = buf.length / 4;
+    const vec = new Array(count);
+    for (let i = 0; i < count; i++) {
+      vec[i] = buf.readFloatLE(i * 4);
+    }
+    return vec;
+  }
+  async sha256(input) {
+    return import_node_crypto.default.createHash("sha256").update(input, "utf8").digest("hex");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NodeBlobCodec
+});

package/dist/cjs/core/contracts/blobCodec.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Binary BLOB codec for encoding/decoding vectors and computing hashes.
+ *
+ * Node.js implementations use Buffer.
+ * Browser implementations use Uint8Array + DataView.
+ */
+export interface IBlobCodec {
+    /** Encode a number[] vector to a binary BLOB value (Float32 little-endian). */
+    encode(vec: number[]): Uint8Array;
+    /** Decode a BLOB column value back to number[]. */
+    decode(blob: Uint8Array | ArrayBufferLike): number[];
+    /** SHA-256 hex digest. Async to support crypto.subtle in browsers. */
+    sha256(input: string): Promise<string>;
+}
+//# sourceMappingURL=blobCodec.d.ts.map

package/dist/cjs/core/contracts/blobCodec.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var blobCodec_exports = {};
+module.exports = __toCommonJS(blobCodec_exports);