@radishbot/sdk 0.3.1 → 0.5.0

package/dist/index.js

@@ -0,0 +1,709 @@
+// src/module_bindings/index.ts
+import {
+  DbConnectionBuilder as __DbConnectionBuilder,
+  DbConnectionImpl as __DbConnectionImpl,
+  SubscriptionBuilderImpl as __SubscriptionBuilderImpl,
+  convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
+  procedures as __procedures,
+  reducerSchema as __reducerSchema,
+  reducers as __reducers,
+  schema as __schema,
+  table as __table
+} from "spacetimedb";
+
+// src/module_bindings/add_log_reducer.ts
+import {
+  t as __t
+} from "spacetimedb";
+var add_log_reducer_default = {
+  keyHash: __t.string(),
+  flowId: __t.u64(),
+  level: __t.string(),
+  message: __t.string(),
+  data: __t.string()
+};
+
+// src/module_bindings/add_logs_batch_reducer.ts
+import {
+  t as __t2
+} from "spacetimedb";
+var add_logs_batch_reducer_default = {
+  keyHash: __t2.string(),
+  flowId: __t2.u64(),
+  entries: __t2.string()
+};
+
+// src/module_bindings/check_timeouts_reducer.ts
+import {
+  t as __t3
+} from "spacetimedb";
+var check_timeouts_reducer_default = {
+  keyHash: __t3.string()
+};
+
+// src/module_bindings/create_root_flow_reducer.ts
+import {
+  t as __t4
+} from "spacetimedb";
+var create_root_flow_reducer_default = {
+  keyHash: __t4.string(),
+  runId: __t4.string(),
+  timeoutSeconds: __t4.u64(),
+  exportToken: __t4.string(),
+  release: __t4.string()
+};
+
+// src/module_bindings/create_sub_flow_reducer.ts
+import {
+  t as __t5
+} from "spacetimedb";
+var create_sub_flow_reducer_default = {
+  keyHash: __t5.string(),
+  parentFlowId: __t5.u64(),
+  name: __t5.string(),
+  timeoutSeconds: __t5.u64(),
+  exportToken: __t5.string()
+};
+
+// src/module_bindings/finish_action_reducer.ts
+import {
+  t as __t6
+} from "spacetimedb";
+var finish_action_reducer_default = {
+  keyHash: __t6.string(),
+  actionId: __t6.u64(),
+  status: __t6.string()
+};
+
+// src/module_bindings/finish_flow_reducer.ts
+import {
+  t as __t7
+} from "spacetimedb";
+var finish_flow_reducer_default = {
+  keyHash: __t7.string(),
+  flowId: __t7.u64(),
+  status: __t7.string(),
+  errorMessage: __t7.string()
+};
+
+// src/module_bindings/register_key_reducer.ts
+import {
+  t as __t8
+} from "spacetimedb";
+var register_key_reducer_default = {
+  keyHash: __t8.string(),
+  label: __t8.string(),
+  retentionDays: __t8.u64()
+};
+
+// src/module_bindings/start_action_reducer.ts
+import {
+  t as __t9
+} from "spacetimedb";
+var start_action_reducer_default = {
+  keyHash: __t9.string(),
+  flowId: __t9.u64(),
+  name: __t9.string()
+};
+
+// src/module_bindings/update_error_group_status_reducer.ts
+import {
+  t as __t10
+} from "spacetimedb";
+var update_error_group_status_reducer_default = {
+  keyHash: __t10.string(),
+  errorGroupId: __t10.u64(),
+  status: __t10.string()
+};
+
+// src/module_bindings/action_table.ts
+import {
+  t as __t11
+} from "spacetimedb";
+var action_table_default = __t11.row({
+  id: __t11.u64().primaryKey(),
+  flowId: __t11.u64().name("flow_id"),
+  name: __t11.string(),
+  status: __t11.string(),
+  createdAt: __t11.timestamp().name("created_at"),
+  finishedAt: __t11.u64().name("finished_at")
+});
+
+// src/module_bindings/api_key_table.ts
+import {
+  t as __t12
+} from "spacetimedb";
+var api_key_table_default = __t12.row({
+  keyHash: __t12.string().primaryKey().name("key_hash"),
+  label: __t12.string(),
+  retentionDays: __t12.u64().name("retention_days"),
+  createdAt: __t12.timestamp().name("created_at")
+});
+
+// src/module_bindings/error_group_table.ts
+import {
+  t as __t13
+} from "spacetimedb";
+var error_group_table_default = __t13.row({
+  id: __t13.u64().primaryKey(),
+  keyHash: __t13.string().name("key_hash"),
+  fingerprint: __t13.string(),
+  message: __t13.string(),
+  path: __t13.string(),
+  release: __t13.string(),
+  count: __t13.u64(),
+  status: __t13.string(),
+  firstSeenAt: __t13.timestamp().name("first_seen_at"),
+  lastSeenAt: __t13.u64().name("last_seen_at"),
+  lastFlowId: __t13.u64().name("last_flow_id")
+});
+
+// src/module_bindings/flow_table.ts
+import {
+  t as __t14
+} from "spacetimedb";
+var flow_table_default = __t14.row({
+  id: __t14.u64().primaryKey(),
+  keyHash: __t14.string().name("key_hash"),
+  runId: __t14.string().name("run_id"),
+  parentFlowId: __t14.u64().name("parent_flow_id"),
+  name: __t14.string(),
+  path: __t14.string(),
+  status: __t14.string(),
+  release: __t14.string(),
+  timeoutSeconds: __t14.u64().name("timeout_seconds"),
+  createdAt: __t14.timestamp().name("created_at"),
+  finishedAt: __t14.u64().name("finished_at"),
+  exportToken: __t14.string().name("export_token")
+});
+
+// src/module_bindings/log_entry_table.ts
+import {
+  t as __t15
+} from "spacetimedb";
+var log_entry_table_default = __t15.row({
+  id: __t15.u64().primaryKey(),
+  flowId: __t15.u64().name("flow_id"),
+  level: __t15.string(),
+  message: __t15.string(),
+  data: __t15.string(),
+  createdAt: __t15.timestamp().name("created_at")
+});
+
+// src/module_bindings/index.ts
+var tablesSchema = __schema({
+  action: __table({
+    name: "action",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "action_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, action_table_default),
+  apiKey: __table({
+    name: "api_key",
+    indexes: [
+      { name: "keyHash", algorithm: "btree", columns: [
+        "keyHash"
+      ] }
+    ],
+    constraints: [
+      { name: "api_key_key_hash_key", constraint: "unique", columns: ["keyHash"] }
+    ]
+  }, api_key_table_default),
+  errorGroup: __table({
+    name: "error_group",
+    indexes: [
+      { name: "fingerprint", algorithm: "btree", columns: [
+        "fingerprint"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "error_group_fingerprint_key", constraint: "unique", columns: ["fingerprint"] },
+      { name: "error_group_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, error_group_table_default),
+  flow: __table({
+    name: "flow",
+    indexes: [
+      { name: "exportToken", algorithm: "btree", columns: [
+        "exportToken"
+      ] },
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "flow_export_token_key", constraint: "unique", columns: ["exportToken"] },
+      { name: "flow_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, flow_table_default),
+  logEntry: __table({
+    name: "log_entry",
+    indexes: [
+      { name: "id", algorithm: "btree", columns: [
+        "id"
+      ] }
+    ],
+    constraints: [
+      { name: "log_entry_id_key", constraint: "unique", columns: ["id"] }
+    ]
+  }, log_entry_table_default)
+});
+var reducersSchema = __reducers(__reducerSchema("add_log", add_log_reducer_default), __reducerSchema("add_logs_batch", add_logs_batch_reducer_default), __reducerSchema("check_timeouts", check_timeouts_reducer_default), __reducerSchema("create_root_flow", create_root_flow_reducer_default), __reducerSchema("create_sub_flow", create_sub_flow_reducer_default), __reducerSchema("finish_action", finish_action_reducer_default), __reducerSchema("finish_flow", finish_flow_reducer_default), __reducerSchema("register_key", register_key_reducer_default), __reducerSchema("start_action", start_action_reducer_default), __reducerSchema("update_error_group_status", update_error_group_status_reducer_default));
+var proceduresSchema = __procedures();
+var REMOTE_MODULE = {
+  versionInfo: {
+    cliVersion: "2.0.3"
+  },
+  tables: tablesSchema.schemaType.tables,
+  reducers: reducersSchema.reducersType.reducers,
+  ...proceduresSchema
+};
+var tables = __makeQueryBuilder(tablesSchema.schemaType);
+var reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);
+
+class SubscriptionBuilder extends __SubscriptionBuilderImpl {
+}
+
+class DbConnectionBuilder extends __DbConnectionBuilder {
+}
+
+class DbConnection extends __DbConnectionImpl {
+  static builder = () => {
+    return new DbConnectionBuilder(REMOTE_MODULE, (config) => new DbConnection(config));
+  };
+  subscriptionBuilder = () => {
+    return new SubscriptionBuilder(this);
+  };
+}
+
+// src/connection.ts
+class SdkConnection {
+  _host;
+  _dbName;
+  _conn = null;
+  _connectPromise = null;
+  _timeoutInterval = null;
+  _keyHash = null;
+  _flowWaiters = new Map;
+  constructor(host, dbName) {
+    this._host = host;
+    this._dbName = dbName;
+  }
+  setKeyHash(keyHash) {
+    this._keyHash = keyHash;
+  }
+  async connect() {
+    if (this._conn)
+      return this._conn;
+    if (this._connectPromise)
+      return this._connectPromise;
+    this._connectPromise = new Promise((resolve, reject) => {
+      const conn = DbConnection.builder().withUri(this._host).withDatabaseName(this._dbName).onConnect((c, _identity, _token) => {
+        this._conn = c;
+        c.subscriptionBuilder().onApplied(() => {
+          resolve(c);
+        }).subscribeToAllTables();
+        this._timeoutInterval = setInterval(() => {
+          if (this._keyHash) {
+            c.reducers.checkTimeouts({ keyHash: this._keyHash });
+          }
+        }, 30000);
+      }).onConnectError((_ctx, err) => {
+        reject(new Error(`SpacetimeDB connection failed: ${err}`));
+      }).build();
+    });
+    return this._connectPromise;
+  }
+  get conn() {
+    if (!this._conn)
+      throw new Error("Not connected");
+    return this._conn;
+  }
+  async createFlowAndResolveId(reducerCall, exportToken) {
+    const conn = this.conn;
+    for (const f of conn.db.flow.iter()) {
+      if (f.exportToken === exportToken)
+        return f.id;
+    }
+    return new Promise((resolve) => {
+      this._flowWaiters.set(exportToken, resolve);
+      reducerCall();
+      const check = () => {
+        for (const f of conn.db.flow.iter()) {
+          if (f.exportToken === exportToken) {
+            this._flowWaiters.delete(exportToken);
+            resolve(f.id);
+            return true;
+          }
+        }
+        return false;
+      };
+      let attempts = 0;
+      const interval = setInterval(() => {
+        if (check() || attempts++ > 100) {
+          clearInterval(interval);
+          if (attempts > 100) {
+            this._flowWaiters.delete(exportToken);
+            throw new Error(`Flow creation timed out for token ${exportToken}`);
+          }
+        }
+      }, 100);
+    });
+  }
+  disconnect() {
+    if (this._timeoutInterval) {
+      clearInterval(this._timeoutInterval);
+      this._timeoutInterval = null;
+    }
+    if (this._conn) {
+      this._conn.disconnect();
+      this._conn = null;
+    }
+  }
+}
+
+// src/index.ts
+var _origConsole = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+var _flowStack = [];
+function _patchConsole() {
+  const capture = (level) => (...args) => {
+    const flow = _flowStack[_flowStack.length - 1];
+    if (flow) {
+      const msg = args.map((a) => {
+        if (typeof a === "string")
+          return a;
+        if (a instanceof Error)
+          return a.message;
+        try {
+          return JSON.stringify(a);
+        } catch {
+          return String(a);
+        }
+      }).join(" ");
+      const data = args.length <= 1 ? undefined : args.length === 2 ? args[1] : args.slice(1);
+      flow.log(msg, data, level);
+    }
+    _origConsole[level === "info" ? "log" : level](...args);
+  };
+  console.log = capture("info");
+  console.info = capture("info");
+  console.warn = capture("warn");
+  console.error = capture("error");
+  console.debug = capture("debug");
+}
+function _restoreConsole() {
+  console.log = _origConsole.log;
+  console.info = _origConsole.info;
+  console.warn = _origConsole.warn;
+  console.error = _origConsole.error;
+  console.debug = _origConsole.debug;
+}
+function serialize(value) {
+  if (value === undefined || value === null)
+    return "{}";
+  if (value instanceof Error)
+    return JSON.stringify({
+      name: value.name,
+      message: value.message,
+      stack: value.stack
+    });
+  try {
+    return JSON.stringify(value, (_key, v) => typeof v === "bigint" ? v.toString() : v);
+  } catch {
+    return JSON.stringify({ value: String(value) });
+  }
+}
+async function hashKey(secretKey) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(secretKey);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateToken() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+class Flow {
+  _sdk;
+  _keyHash;
+  _id = null;
+  _exportToken;
+  _ready;
+  _resolveReady;
+  _pendingLogs = [];
+  _flushScheduled = false;
+  _isReady = false;
+  _finished = false;
+  _parentId;
+  _name;
+  _timeoutSeconds;
+  _release;
+  _runId;
+  constructor(sdk, keyHash, parentId, name, timeoutSeconds, release = "", runId = "") {
+    this._sdk = sdk;
+    this._keyHash = keyHash;
+    this._parentId = parentId;
+    this._name = name;
+    this._timeoutSeconds = !timeoutSeconds || timeoutSeconds === Infinity ? 0n : BigInt(timeoutSeconds);
+    this._release = release;
+    this._runId = runId;
+    this._exportToken = generateToken();
+    this._ready = new Promise((resolve) => {
+      this._resolveReady = resolve;
+    });
+  }
+  async _create() {
+    const conn = this._sdk.conn;
+    const exportToken = this._exportToken;
+    const keyHash = this._keyHash;
+    const timeoutSeconds = this._timeoutSeconds;
+    if (this._parentId === 0n) {
+      const id = await this._sdk.createFlowAndResolveId(() => conn.reducers.createRootFlow({
+        keyHash,
+        runId: this._runId,
+        timeoutSeconds,
+        exportToken,
+        release: this._release
+      }), exportToken);
+      this._id = id;
+    } else {
+      const parentFlowId = this._parentId;
+      const name = this._name;
+      const id = await this._sdk.createFlowAndResolveId(() => conn.reducers.createSubFlow({
+        keyHash,
+        parentFlowId,
+        name,
+        timeoutSeconds,
+        exportToken
+      }), exportToken);
+      this._id = id;
+    }
+    this._isReady = true;
+    this._resolveReady();
+    this._drain();
+  }
+  static MAX_PENDING = 1e4;
+  log(message, data, level = "info") {
+    if (this._finished) {
+      console.warn(`[radish] Cannot log to finished flow`);
+      return this;
+    }
+    if (this._pendingLogs.length >= Flow.MAX_PENDING) {
+      const dropped = this._pendingLogs.length - Flow.MAX_PENDING + 1;
+      this._pendingLogs.splice(0, dropped);
+    }
+    this._pendingLogs.push({
+      level,
+      message,
+      data: data !== undefined ? serialize(data) : "{}"
+    });
+    this._scheduleFlush();
+    return this;
+  }
+  info(message, data) {
+    return this.log(message, data, "info");
+  }
+  warn(message, data) {
+    return this.log(message, data, "warn");
+  }
+  error(message, data) {
+    return this.log(message, data, "error");
+  }
+  debug(message, data) {
+    return this.log(message, data, "debug");
+  }
+  action(name, timeoutSeconds = 100) {
+    const child = new Flow(this._sdk, this._keyHash, 0n, name, timeoutSeconds, this._release, this._runId);
+    this._ready.then(() => {
+      child._parentId = this._id;
+      child._create();
+    });
+    return child;
+  }
+  flow(name, timeoutSeconds = 100) {
+    return this.action(name, timeoutSeconds);
+  }
+  async a(name, fn, timeoutSeconds = 100) {
+    const child = this.action(name, timeoutSeconds);
+    _flowStack.push(child);
+    _patchConsole();
+    try {
+      const result = await fn(child);
+      await child.finish();
+      return result;
+    } catch (e) {
+      await child.finishWithError(e instanceof Error ? e : String(e));
+      throw e;
+    } finally {
+      _flowStack.pop();
+      if (_flowStack.length === 0)
+        _restoreConsole();
+    }
+  }
+  async finish() {
+    await this._ready;
+    this._drain();
+    this._finished = true;
+    this._sdk.conn.reducers.finishFlow({
+      keyHash: this._keyHash,
+      flowId: this._id,
+      status: "finished",
+      errorMessage: ""
+    });
+  }
+  async finishWithError(err) {
+    const errorMessage = err ? typeof err === "string" ? err : err.message : "";
+    if (err) {
+      this.error(errorMessage, err);
+    }
+    await this._ready;
+    this._drain();
+    this._finished = true;
+    this._sdk.conn.reducers.finishFlow({
+      keyHash: this._keyHash,
+      flowId: this._id,
+      status: "error",
+      errorMessage
+    });
+  }
+  get runId() {
+    return this._runId;
+  }
+  async exportID() {
+    await this._ready;
+    return JSON.stringify({
+      flowId: this._id.toString(),
+      exportToken: this._exportToken,
+      keyHash: this._keyHash,
+      runId: this._runId
+    });
+  }
+  async getId() {
+    await this._ready;
+    return this._id;
+  }
+  disconnect() {
+    this._sdk.disconnect();
+  }
+  async finishAndDisconnect() {
+    await this.finish();
+    await new Promise((r) => setTimeout(r, 100));
+    this.disconnect();
+  }
+  _scheduleFlush() {
+    if (this._flushScheduled)
+      return;
+    this._flushScheduled = true;
+    queueMicrotask(() => {
+      this._flushScheduled = false;
+      this._drain();
+    });
+  }
+  _drain() {
+    if (!this._isReady || this._pendingLogs.length === 0)
+      return;
+    const batch = this._pendingLogs.splice(0);
+    const conn = this._sdk.conn;
+    if (batch.length === 1) {
+      const e = batch[0];
+      conn.reducers.addLog({
+        keyHash: this._keyHash,
+        flowId: this._id,
+        level: e.level,
+        message: e.message,
+        data: e.data
+      });
+    } else {
+      conn.reducers.addLogsBatch({
+        keyHash: this._keyHash,
+        flowId: this._id,
+        entries: JSON.stringify(batch)
+      });
+    }
+  }
+}
+function parseRetention(retention) {
+  const match = retention.match(/^(\d+)d$/);
+  if (!match)
+    throw new Error('Invalid retention format. Use e.g. "30d"');
+  return parseInt(match[1], 10);
+}
+async function RL(secretKey, options = {}) {
+  const {
+    host = "wss://maincloud.spacetimedb.com",
+    dbName = "radish-log",
+    label = "",
+    defaultTimeout = 100,
+    release = "",
+    retention = "30d",
+    runId = generateRunId()
+  } = options;
+  const retentionDays = parseRetention(retention);
+  const keyHash = await hashKey(secretKey);
+  const sdk = new SdkConnection(host, dbName);
+  sdk.setKeyHash(keyHash);
+  try {
+    await sdk.connect();
+  } catch (e) {
+    throw new Error(`Failed to connect to Radish (${host}/${dbName}): ${e instanceof Error ? e.message : e}`);
+  }
+  try {
+    sdk.conn.reducers.registerKey({ keyHash, label, retentionDays: BigInt(retentionDays) });
+  } catch {}
+  try {
+    sdk.conn.reducers.checkTimeouts({ keyHash });
+  } catch {}
+  const root = new Flow(sdk, keyHash, 0n, "/", 0, release, runId);
+  root._create();
+  return root;
+}
+async function restoreFlow(secretKey, exportedId, options = {}) {
+  const { host = "wss://maincloud.spacetimedb.com", dbName = "radish-log" } = options;
+  const parsed = JSON.parse(exportedId);
+  const keyHash = await hashKey(secretKey);
+  if (keyHash !== parsed.keyHash) {
+    throw new Error("Secret key does not match the flow owner");
+  }
+  const sdk = new SdkConnection(host, dbName);
+  await sdk.connect();
+  const flow = new Flow(sdk, keyHash, 0n, "restored", 100, "", parsed.runId || "");
+  flow._id = BigInt(parsed.flowId);
+  flow._exportToken = parsed.exportToken;
+  flow._resolveReady();
+  return flow;
+}
+function generateKey() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return "rl_" + Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateRunId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export {
+  restoreFlow,
+  generateRunId,
+  generateKey,
+  RL,
+  Flow
+};

package/dist/module_bindings/action_table.d.ts

@@ -0,0 +1,17 @@
+declare const _default: import("spacetimedb").RowBuilder<{
+    id: import("spacetimedb").U64ColumnBuilder<{
+        isPrimaryKey: true;
+    }>;
+    flowId: import("spacetimedb").U64ColumnBuilder<{
+        name: "flow_id";
+    }>;
+    name: import("spacetimedb").StringBuilder;
+    status: import("spacetimedb").StringBuilder;
+    createdAt: import("spacetimedb").TimestampColumnBuilder<{
+        name: "created_at";
+    }>;
+    finishedAt: import("spacetimedb").U64ColumnBuilder<{
+        name: "finished_at";
+    }>;
+}>;
+export default _default;