@workglow/supabase 0.2.28

package/dist/storage/browser.js

@@ -0,0 +1,590 @@
+// src/storage/SupabaseKvStorage.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+
+// src/storage/SupabaseTabularStorage.ts
+import { createServiceToken } from "@workglow/util";
+import {
+  BaseSqlTabularStorage,
+  isSearchCondition,
+  pickCoveringIndex,
+  StorageValidationError
+} from "@workglow/storage";
+var SUPABASE_TABULAR_REPOSITORY = createServiceToken("storage.tabularRepository.supabase");
+
+class SupabaseTabularStorage extends BaseSqlTabularStorage {
+  client;
+  realtimeChannel = null;
+  constructor(client, table = "tabular_store", schema, primaryKeyNames, indexes = [], clientProvidedKeys = "if-missing") {
+    super(table, schema, primaryKeyNames, indexes, clientProvidedKeys);
+    this.client = client;
+  }
+  async setupDatabase() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS "${this.table}" (
+        ${this.constructPrimaryKeyColumns('"')} ${this.constructValueColumns('"')},
+        PRIMARY KEY (${this.primaryKeyColumnList()}) 
+      )
+    `;
+    const { error } = await this.client.rpc("exec_sql", { query: sql });
+    if (error && !error.message.includes("already exists")) {
+      throw error;
+    }
+    const pkColumns = this.primaryKeyColumns();
+    const createdIndexes = new Set;
+    for (const columns of this.indexes) {
+      if (columns.length <= pkColumns.length) {
+        const isPkPrefix = columns.every((col, idx) => col === pkColumns[idx]);
+        if (isPkPrefix)
+          continue;
+      }
+      const indexName = `${this.table}_${columns.join("_")}`;
+      const columnList = columns.map((col) => `"${String(col)}"`).join(", ");
+      const columnKey = columns.join(",");
+      if (createdIndexes.has(columnKey))
+        continue;
+      const isRedundant = Array.from(createdIndexes).some((existing) => {
+        const existingCols = existing.split(",");
+        return existingCols.length >= columns.length && columns.every((col, idx) => col === existingCols[idx]);
+      });
+      if (!isRedundant) {
+        const indexSql = `CREATE INDEX IF NOT EXISTS "${indexName}" ON "${this.table}" (${columnList})`;
+        const { error: indexError } = await this.client.rpc("exec_sql", { query: indexSql });
+        if (indexError && !indexError.message.includes("already exists")) {
+          console.warn(`Failed to create index ${indexName}:`, indexError);
+        }
+        createdIndexes.add(columnKey);
+      }
+    }
+  }
+  mapTypeToSQL(typeDef) {
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return "TEXT /* boolean schema */";
+    }
+    if (actualType.contentEncoding === "blob")
+      return "BYTEA";
+    switch (actualType.type) {
+      case "string":
+        if (actualType.format === "date-time")
+          return "TIMESTAMP";
+        if (actualType.format === "date")
+          return "DATE";
+        if (actualType.format === "email")
+          return "VARCHAR(255)";
+        if (actualType.format === "uri")
+          return "VARCHAR(2048)";
+        if (actualType.format === "uuid")
+          return "UUID";
+        if (typeof actualType.maxLength === "number") {
+          return `VARCHAR(${actualType.maxLength})`;
+        }
+        return "TEXT";
+      case "number":
+      case "integer":
+        if (actualType.multipleOf === 1 || actualType.type === "integer") {
+          if (typeof actualType.minimum === "number") {
+            if (actualType.minimum >= 0) {
+              if (typeof actualType.maximum === "number") {
+                if (actualType.maximum <= 32767)
+                  return "SMALLINT";
+                if (actualType.maximum <= 2147483647)
+                  return "INTEGER";
+              }
+              return "BIGINT";
+            }
+          }
+          return "INTEGER";
+        }
+        if (actualType.format === "float")
+          return "REAL";
+        if (actualType.format === "double")
+          return "DOUBLE PRECISION";
+        if (typeof actualType.multipleOf === "number") {
+          const decimalPlaces = String(actualType.multipleOf).split(".")[1]?.length || 0;
+          if (decimalPlaces > 0) {
+            return `NUMERIC(38, ${decimalPlaces})`;
+          }
+        }
+        return "NUMERIC";
+      case "boolean":
+        return "BOOLEAN";
+      case "array":
+        if (actualType.items && typeof actualType.items === "object" && !Array.isArray(actualType.items)) {
+          const itemType = this.mapTypeToSQL(actualType.items);
+          const supportedArrayElementTypes = [
+            "TEXT",
+            "VARCHAR",
+            "CHAR",
+            "INTEGER",
+            "SMALLINT",
+            "BIGINT",
+            "REAL",
+            "DOUBLE PRECISION",
+            "NUMERIC",
+            "BOOLEAN",
+            "UUID",
+            "DATE",
+            "TIMESTAMP"
+          ];
+          const isSupported = supportedArrayElementTypes.some((type) => itemType === type || itemType.startsWith(type + "(") && type !== "VARCHAR");
+          if (isSupported) {
+            return `${itemType}[]`;
+          } else {
+            return "JSONB /* complex array */";
+          }
+        }
+        return "JSONB /* generic array */";
+      case "object":
+        return "JSONB /* object */";
+      default:
+        return "TEXT /* unknown type */";
+    }
+  }
+  constructPrimaryKeyColumns($delimiter = "") {
+    const cols = Object.entries(this.primaryKeySchema.properties).map(([key, typeDef]) => {
+      if (this.isAutoGeneratedKey(key)) {
+        if (this.autoGeneratedKeyStrategy === "autoincrement") {
+          const sqlType2 = this.mapTypeToSQL(typeDef);
+          const isSmallInt = sqlType2.includes("SMALLINT");
+          const isBigInt = sqlType2.includes("BIGINT");
+          const serialType = isBigInt ? "BIGSERIAL" : isSmallInt ? "SMALLSERIAL" : "SERIAL";
+          return `${$delimiter}${key}${$delimiter} ${serialType}`;
+        } else if (this.autoGeneratedKeyStrategy === "uuid") {
+          return `${$delimiter}${key}${$delimiter} UUID DEFAULT gen_random_uuid()`;
+        }
+      }
+      const sqlType = this.mapTypeToSQL(typeDef);
+      let constraints = "NOT NULL";
+      if (this.shouldBeUnsigned(typeDef)) {
+        constraints += ` CHECK (${$delimiter}${key}${$delimiter} >= 0)`;
+      }
+      return `${$delimiter}${key}${$delimiter} ${sqlType} ${constraints}`;
+    }).join(", ");
+    return cols;
+  }
+  constructValueColumns($delimiter = "") {
+    const delimiter = $delimiter || '"';
+    const requiredSet = new Set(this.valueSchema.required ?? []);
+    const cols = Object.entries(this.valueSchema.properties).map(([key, typeDef]) => {
+      const sqlType = this.mapTypeToSQL(typeDef);
+      const isRequired = requiredSet.has(key);
+      const nullable = !isRequired || this.isNullable(typeDef);
+      let constraints = nullable ? "NULL" : "NOT NULL";
+      if (this.shouldBeUnsigned(typeDef)) {
+        constraints += ` CHECK (${delimiter}${key}${delimiter} >= 0)`;
+      }
+      return `${delimiter}${key}${delimiter} ${sqlType} ${constraints}`;
+    }).join(", ");
+    if (cols.length > 0) {
+      return `, ${cols}`;
+    } else {
+      return "";
+    }
+  }
+  sqlToJsValue(column, value) {
+    const typeDef = this.schema.properties[column];
+    if (typeDef) {
+      if (value === null && this.isNullable(typeDef)) {
+        return null;
+      }
+      const actualType = this.getNonNullType(typeDef);
+      if (typeof actualType !== "boolean" && (actualType.type === "number" || actualType.type === "integer")) {
+        if (typeof value === "number")
+          return value;
+        if (typeof value === "string") {
+          const parsed = Number(value);
+          if (!isNaN(parsed))
+            return parsed;
+        }
+      }
+    }
+    return super.sqlToJsValue(column, value);
+  }
+  shouldBeUnsigned(typeDef) {
+    const actualType = this.getNonNullType(typeDef);
+    if (typeof actualType === "boolean") {
+      return false;
+    }
+    if ((actualType.type === "number" || actualType.type === "integer") && typeof actualType.minimum === "number" && actualType.minimum >= 0) {
+      return true;
+    }
+    return false;
+  }
+  async put(entity) {
+    let entityToInsert = { ...entity };
+    if (this.hasAutoGeneratedKey() && this.autoGeneratedKeyName) {
+      const keyName = String(this.autoGeneratedKeyName);
+      const entityRecord = entity;
+      const clientProvidedValue = entityRecord[keyName];
+      const hasClientValue = clientProvidedValue !== undefined && clientProvidedValue !== null;
+      let shouldOmitKey = false;
+      if (this.clientProvidedKeys === "never") {
+        shouldOmitKey = true;
+      } else if (this.clientProvidedKeys === "always") {
+        if (!hasClientValue) {
+          throw new Error(`Auto-generated key "${keyName}" is required when clientProvidedKeys is "always"`);
+        }
+        shouldOmitKey = false;
+      } else {
+        shouldOmitKey = !hasClientValue;
+      }
+      if (shouldOmitKey) {
+        delete entityToInsert[keyName];
+      }
+    }
+    const normalizedEntity = { ...entityToInsert };
+    const requiredSet = new Set(this.valueSchema.required ?? []);
+    for (const key in this.valueSchema.properties) {
+      if (!(key in normalizedEntity) || normalizedEntity[key] === undefined) {
+        if (!requiredSet.has(key)) {
+          normalizedEntity[key] = null;
+        }
+      }
+    }
+    const { data, error } = await this.client.from(this.table).upsert(normalizedEntity, { onConflict: this.primaryKeyColumnList() }).select().single();
+    if (error)
+      throw error;
+    const updatedEntity = data;
+    const updatedRecord = updatedEntity;
+    for (const key in this.schema.properties) {
+      updatedRecord[key] = this.sqlToJsValue(key, updatedRecord[key]);
+    }
+    this.events.emit("put", updatedEntity);
+    return updatedEntity;
+  }
+  async putBulk(entities) {
+    if (entities.length === 0)
+      return [];
+    return await Promise.all(entities.map((entity) => this.put(entity)));
+  }
+  async get(key) {
+    let query = this.client.from(this.table).select("*");
+    const keyRecord = key;
+    for (const pkName of this.primaryKeyNames) {
+      query = query.eq(String(pkName), keyRecord[String(pkName)]);
+    }
+    const { data, error } = await query.single();
+    if (error) {
+      if (error.code === "PGRST116") {
+        this.events.emit("get", key, undefined);
+        return;
+      }
+      throw error;
+    }
+    const val = data;
+    if (val) {
+      const valRecord = val;
+      for (const key2 in this.schema.properties) {
+        valRecord[key2] = this.sqlToJsValue(key2, valRecord[key2]);
+      }
+    }
+    this.events.emit("get", key, val);
+    return val;
+  }
+  async delete(value) {
+    const { key } = this.separateKeyValueFromCombined(value);
+    let query = this.client.from(this.table).delete();
+    const deleteKeyRecord = key;
+    for (const pkName of this.primaryKeyNames) {
+      query = query.eq(String(pkName), deleteKeyRecord[String(pkName)]);
+    }
+    const { error } = await query;
+    if (error)
+      throw error;
+    this.events.emit("delete", key);
+  }
+  async getAll(options) {
+    this.validateGetAllOptions(options);
+    let query = this.client.from(this.table).select("*");
+    if (options?.orderBy) {
+      for (const { column, direction } of options.orderBy) {
+        query = query.order(String(column), { ascending: direction === "ASC" });
+      }
+    }
+    if (options?.offset !== undefined || options?.limit !== undefined) {
+      const start = options?.offset ?? 0;
+      if (options?.limit !== undefined) {
+        query = query.range(start, start + options.limit - 1);
+      } else if (options?.offset !== undefined) {
+        query = query.range(start, start + 999999);
+      }
+    }
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    if (data && data.length) {
+      for (const row of data) {
+        const record = row;
+        for (const key in this.schema.properties) {
+          record[key] = this.sqlToJsValue(key, record[key]);
+        }
+      }
+      return data;
+    }
+    return;
+  }
+  async deleteAll() {
+    const firstPkColumn = this.primaryKeyNames[0];
+    const { error } = await this.client.from(this.table).delete().neq(String(firstPkColumn), null);
+    if (error)
+      throw error;
+    this.events.emit("clearall");
+  }
+  async size() {
+    const { count, error } = await this.client.from(this.table).select("*", { count: "exact", head: true });
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async getBulk(offset, limit) {
+    let query = this.client.from(this.table).select("*");
+    for (const pkName of this.primaryKeyNames) {
+      query = query.order(String(pkName));
+    }
+    const { data, error } = await query.range(offset, offset + limit - 1);
+    if (error)
+      throw error;
+    if (!data || data.length === 0) {
+      return;
+    }
+    for (const row of data) {
+      const record = row;
+      for (const key in this.schema.properties) {
+        record[key] = this.sqlToJsValue(key, record[key]);
+      }
+    }
+    return data;
+  }
+  applyCriteriaToFilter(query, criteria) {
+    let q = query;
+    for (const column of Object.keys(criteria)) {
+      const criterion = criteria[column];
+      let operator = "=";
+      let value;
+      if (isSearchCondition(criterion)) {
+        operator = criterion.operator;
+        value = criterion.value;
+      } else {
+        value = criterion;
+      }
+      switch (operator) {
+        case "=":
+          q = q.eq(String(column), value);
+          break;
+        case "<":
+          q = q.lt(String(column), value);
+          break;
+        case "<=":
+          q = q.lte(String(column), value);
+          break;
+        case ">":
+          q = q.gt(String(column), value);
+          break;
+        case ">=":
+          q = q.gte(String(column), value);
+          break;
+      }
+    }
+    return q;
+  }
+  async count(criteria) {
+    if (!criteria || Object.keys(criteria).length === 0) {
+      return await this.size();
+    }
+    this.validateQueryParams(criteria);
+    const query = this.applyCriteriaToFilter(this.client.from(this.table).select("*", { count: "exact", head: true }), criteria);
+    const { count, error } = await query;
+    if (error)
+      throw error;
+    return count ?? 0;
+  }
+  async deleteSearch(criteria) {
+    const criteriaKeys = Object.keys(criteria);
+    if (criteriaKeys.length === 0) {
+      return;
+    }
+    let query = this.client.from(this.table).delete();
+    for (const column of criteriaKeys) {
+      if (!(column in this.schema.properties)) {
+        throw new Error(`Schema must have a ${String(column)} field to use deleteSearch`);
+      }
+      const criterion = criteria[column];
+      let operator = "=";
+      let value;
+      if (isSearchCondition(criterion)) {
+        operator = criterion.operator;
+        value = criterion.value;
+      } else {
+        value = criterion;
+      }
+      switch (operator) {
+        case "=":
+          query = query.eq(String(column), value);
+          break;
+        case "<":
+          query = query.lt(String(column), value);
+          break;
+        case "<=":
+          query = query.lte(String(column), value);
+          break;
+        case ">":
+          query = query.gt(String(column), value);
+          break;
+        case ">=":
+          query = query.gte(String(column), value);
+          break;
+      }
+    }
+    const { error } = await query;
+    if (error)
+      throw error;
+    this.events.emit("delete", criteriaKeys[0]);
+  }
+  async query(criteria, options) {
+    this.validateQueryParams(criteria, options);
+    let query = this.applyCriteriaToFilter(this.client.from(this.table).select("*"), criteria);
+    if (options?.orderBy) {
+      for (const { column, direction } of options.orderBy) {
+        query = query.order(String(column), { ascending: direction === "ASC" });
+      }
+    }
+    if (options?.offset !== undefined || options?.limit !== undefined) {
+      const start = options?.offset ?? 0;
+      if (options?.limit !== undefined) {
+        query = query.range(start, start + options.limit - 1);
+      } else if (options?.offset !== undefined) {
+        query = query.range(start, start + 999999);
+      }
+    } else if (options?.limit !== undefined) {
+      query = query.limit(options.limit);
+    }
+    const { data, error } = await query;
+    if (error)
+      throw error;
+    if (data && data.length > 0) {
+      for (const row of data) {
+        const record = row;
+        for (const key in this.schema.properties) {
+          record[key] = this.sqlToJsValue(key, record[key]);
+        }
+      }
+      this.events.emit("query", criteria, data);
+      return data;
+    }
+    this.events.emit("query", criteria, undefined);
+    return;
+  }
+  async queryIndex(criteria, options) {
+    this.validateSelect(options);
+    this.validateQueryParams(criteria, options);
+    const registered = this.indexes.map((cols, i) => {
+      const cs = Array.isArray(cols) ? cols : [cols];
+      return { name: `idx_${i}`, keyPath: cs };
+    });
+    pickCoveringIndex({
+      table: this.table,
+      indexes: registered,
+      criteriaColumns: Object.keys(criteria),
+      orderByColumns: (options.orderBy ?? []).map((o) => ({
+        column: String(o.column),
+        direction: o.direction
+      })),
+      selectColumns: options.select.map(String),
+      primaryKeyColumns: this.primaryKeyNames.map(String)
+    });
+    const colList = options.select.map(String).join(",");
+    let q = this.applyCriteriaToFilter(this.client.from(this.table).select(colList), criteria);
+    if (options.orderBy) {
+      for (const { column, direction } of options.orderBy) {
+        q = q.order(String(column), { ascending: direction === "ASC" });
+      }
+    }
+    if (options.offset !== undefined && options.limit === undefined) {
+      throw new StorageValidationError("queryIndex with offset requires limit (no implicit cap)");
+    }
+    if (options.offset !== undefined || options.limit !== undefined) {
+      const start = options.offset ?? 0;
+      if (options.limit !== undefined) {
+        q = q.range(start, start + options.limit - 1);
+      }
+    }
+    const { data, error } = await q;
+    if (error)
+      throw error;
+    if (!data)
+      return [];
+    const rows = data;
+    const sel = new Set(options.select.map(String));
+    for (const row of rows) {
+      for (const key of Object.keys(row)) {
+        if (sel.has(key)) {
+          row[key] = this.sqlToJsValue(key, row[key]);
+        }
+      }
+    }
+    return rows;
+  }
+  convertRealtimeRow(row) {
+    const entity = { ...row };
+    const record = entity;
+    for (const key in this.schema.properties) {
+      record[key] = this.sqlToJsValue(key, row[key]);
+    }
+    return entity;
+  }
+  subscribeToChanges(callback, options) {
+    const channelName = `tabular-${this.table}-${Date.now()}`;
+    this.realtimeChannel = this.client.channel(channelName).on("postgres_changes", {
+      event: "*",
+      schema: "public",
+      table: this.table
+    }, (payload) => {
+      const change = {
+        type: payload.eventType.toUpperCase(),
+        old: payload.old && Object.keys(payload.old).length > 0 ? this.convertRealtimeRow(payload.old) : undefined,
+        new: payload.new && Object.keys(payload.new).length > 0 ? this.convertRealtimeRow(payload.new) : undefined
+      };
+      callback(change);
+    }).subscribe();
+    return () => {
+      if (this.realtimeChannel) {
+        this.client.removeChannel(this.realtimeChannel);
+        this.realtimeChannel = null;
+      }
+    };
+  }
+  destroy() {
+    if (this.realtimeChannel) {
+      this.client.removeChannel(this.realtimeChannel);
+      this.realtimeChannel = null;
+    }
+  }
+}
+
+// src/storage/SupabaseKvStorage.ts
+import {
+  DefaultKeyValueKey,
+  DefaultKeyValueSchema,
+  KvViaTabularStorage
+} from "@workglow/storage";
+var SUPABASE_KV_REPOSITORY = createServiceToken2("storage.kvRepository.supabase");
+
+class SupabaseKvStorage extends KvViaTabularStorage {
+  client;
+  tableName;
+  tabularRepository;
+  constructor(client, tableName, keySchema = { type: "string" }, valueSchema = {}, tabularRepository) {
+    super(keySchema, valueSchema);
+    this.client = client;
+    this.tableName = tableName;
+    this.tabularRepository = tabularRepository ?? new SupabaseTabularStorage(client, tableName, DefaultKeyValueSchema, DefaultKeyValueKey);
+  }
+}
+export {
+  SupabaseTabularStorage,
+  SupabaseKvStorage,
+  SUPABASE_TABULAR_REPOSITORY,
+  SUPABASE_KV_REPOSITORY
+};
+
+//# debugId=B85032AFACA2DABD64756E2164756E21