@dvmkit/sdk 0.0.0 → 0.1.0-rc.1

package/dist/chunk-DMNLFNTW.js

@@ -0,0 +1,135 @@
+import {
+  withSdkInitLock
+} from "./chunk-S3XAHZQY.js";
+
+// src/sdk/server/processed-payment-store.ts
+var ProcessedPaymentReplayError = class extends Error {
+  constructor(rail, paymentId) {
+    super(`payment ${paymentId} on rail ${rail} was already processed`);
+    this.rail = rail;
+    this.paymentId = paymentId;
+    this.name = "ProcessedPaymentReplayError";
+  }
+  rail;
+  paymentId;
+};
+var PostgresProcessedPaymentStore = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  async withTx(fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await fn(client);
+      await client.query("COMMIT");
+      return result;
+    } catch (err) {
+      try {
+        await client.query("ROLLBACK");
+      } catch {
+      }
+      throw err;
+    } finally {
+      client.release();
+    }
+  }
+  /** Create the `processed_payments` table if absent. Call once at SDK boot. */
+  async init() {
+    await withSdkInitLock(this.pool, () => this.createTables());
+  }
+  /** The boot DDL itself — always runs under {@link withSdkInitLock} (internal-review). */
+  async createTables() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS processed_payments (
+        dvm_id     TEXT NOT NULL,
+        rail       TEXT NOT NULL,
+        payment_id TEXT NOT NULL,
+        credit_id  TEXT NOT NULL,
+        draw_id    TEXT NOT NULL,
+        job_id     TEXT,
+        created_at BIGINT NOT NULL,
+        PRIMARY KEY (dvm_id, rail, payment_id)
+      );
+    `);
+    await this.pool.query(`UPDATE processed_payments SET rail = 'tempo' WHERE rail = 'mpp'`);
+  }
+  async record(args) {
+    const q = args.tx ?? this.pool;
+    try {
+      await q.query(
+        `INSERT INTO processed_payments (dvm_id, rail, payment_id, credit_id, draw_id, job_id, created_at)
+         VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+        [
+          args.dvmId,
+          args.rail,
+          args.paymentId,
+          args.creditId,
+          args.drawId,
+          args.jobId ?? null,
+          args.nowMs ?? Date.now()
+        ]
+      );
+    } catch (err) {
+      if (isUniqueViolation(err)) {
+        throw new ProcessedPaymentReplayError(args.rail, args.paymentId);
+      }
+      throw err;
+    }
+  }
+  async get(args) {
+    const { rows } = await this.pool.query(
+      `SELECT * FROM processed_payments WHERE dvm_id = $1 AND rail = $2 AND payment_id = $3`,
+      [args.dvmId, args.rail, args.paymentId]
+    );
+    if (rows.length === 0) return void 0;
+    const row = rows[0];
+    return {
+      dvmId: row.dvm_id,
+      rail: row.rail,
+      paymentId: row.payment_id,
+      creditId: row.credit_id,
+      drawId: row.draw_id,
+      jobId: row.job_id,
+      createdAt: Number(row.created_at)
+    };
+  }
+};
+var MemoryProcessedPaymentStore = class {
+  markers = /* @__PURE__ */ new Map();
+  withTx(fn) {
+    return fn(void 0);
+  }
+  record(args) {
+    const key = markerKey(args);
+    if (this.markers.has(key)) {
+      return Promise.reject(new ProcessedPaymentReplayError(args.rail, args.paymentId));
+    }
+    this.markers.set(key, {
+      dvmId: args.dvmId,
+      rail: args.rail,
+      paymentId: args.paymentId,
+      creditId: args.creditId,
+      drawId: args.drawId,
+      jobId: args.jobId ?? null,
+      createdAt: args.nowMs ?? Date.now()
+    });
+    return Promise.resolve();
+  }
+  get(args) {
+    return Promise.resolve(this.markers.get(markerKey(args)));
+  }
+};
+function markerKey(args) {
+  return `${args.dvmId}\0${args.rail}\0${args.paymentId}`;
+}
+function isUniqueViolation(err) {
+  return typeof err === "object" && err !== null && err.code === "23505";
+}
+
+export {
+  ProcessedPaymentReplayError,
+  PostgresProcessedPaymentStore,
+  MemoryProcessedPaymentStore
+};

package/dist/chunk-FROTD5XQ.js

@@ -0,0 +1,70 @@
+import {
+  withSdkInitLock
+} from "./chunk-S3XAHZQY.js";
+
+// src/sdk/server/postgres-kv-store.ts
+var PostgresKVStore = class {
+  pool;
+  constructor(pool) {
+    this.pool = pool;
+  }
+  /** Run the CREATE TABLE migration. Call once at startup. */
+  async init() {
+    await withSdkInitLock(this.pool, () => this.createTables());
+  }
+  /** The boot DDL itself — always runs under {@link withSdkInitLock} (internal-review). */
+  async createTables() {
+    await this.pool.query(`
+      -- Single-tenant KV table aligned with the platform's isolate storage schema.
+      -- The only structural difference is the absence of dvm_id (SDK is single-DVM-per-DB).
+      -- Any column addition should land on both schemas; see M06 / internal-review for the convergence precedent.
+      CREATE TABLE IF NOT EXISTS kv_store (
+        key        TEXT PRIMARY KEY,
+        value      JSONB NOT NULL,
+        expires_at BIGINT
+      );
+      CREATE INDEX IF NOT EXISTS idx_kv_store_expires_at ON kv_store (expires_at)
+        WHERE expires_at IS NOT NULL;
+    `);
+  }
+  async get(key) {
+    const { rows } = await this.pool.query(
+      "SELECT value FROM kv_store WHERE key = $1 AND (expires_at IS NULL OR expires_at > $2)",
+      [key, Date.now()]
+    );
+    if (rows.length === 0) return void 0;
+    return rows[0].value;
+  }
+  async set(key, value, opts) {
+    const expiresAt = opts?.ttl !== void 0 ? Date.now() + opts.ttl * 1e3 : null;
+    await this.pool.query(
+      `INSERT INTO kv_store (key, value, expires_at)
+       VALUES ($1, $2, $3)
+       ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, expires_at = EXCLUDED.expires_at`,
+      [key, JSON.stringify(value), expiresAt]
+    );
+  }
+  async delete(key) {
+    await this.pool.query("DELETE FROM kv_store WHERE key = $1", [key]);
+  }
+  async list(prefix) {
+    const now = Date.now();
+    if (prefix !== void 0) {
+      const escaped = prefix.replace(/%/g, "\\%").replace(/_/g, "\\_");
+      const { rows: rows2 } = await this.pool.query(
+        "SELECT key FROM kv_store WHERE key LIKE $1 AND (expires_at IS NULL OR expires_at > $2)",
+        [`${escaped}%`, now]
+      );
+      return rows2.map((r) => r.key);
+    }
+    const { rows } = await this.pool.query(
+      "SELECT key FROM kv_store WHERE expires_at IS NULL OR expires_at > $1",
+      [now]
+    );
+    return rows.map((r) => r.key);
+  }
+};
+
+export {
+  PostgresKVStore
+};

package/dist/chunk-H25M54MI.js

@@ -0,0 +1,149 @@
+// src/lib/pg-retry.ts
+import { AsyncLocalStorage } from "async_hooks";
+var postgresRecovery = new AsyncLocalStorage();
+function withPostgresRecoveryContext(context, operation) {
+  return postgresRecovery.run(context, operation);
+}
+function isTransportError(err) {
+  if (err === null || typeof err !== "object") return false;
+  const code = err.code;
+  const msg = err.message;
+  if (typeof code === "string" && /^[0-9A-Z]{5}$/.test(code)) return false;
+  return typeof msg === "string" && msg.includes("Connection terminated") || code === "ECONNRESET" || code === "ENOTFOUND";
+}
+var POSTGRES_APPLICATION_NAME_MAX_BYTES = 63;
+function formatPostgresApplicationName(label, machineId = process.env.FLY_MACHINE_ID) {
+  const machineSuffix = machineId ? `@${machineId}` : "";
+  const boundedMachineSuffix = truncateUtf8(machineSuffix, POSTGRES_APPLICATION_NAME_MAX_BYTES);
+  const labelBudget = POSTGRES_APPLICATION_NAME_MAX_BYTES - Buffer.byteLength(boundedMachineSuffix, "utf8");
+  return `${truncateUtf8(label, labelBudget)}${boundedMachineSuffix}`;
+}
+var patchedPools = /* @__PURE__ */ new WeakSet();
+var guardedClients = /* @__PURE__ */ new WeakSet();
+function applyRetryToPool(pool, label = "pg-pool") {
+  if (patchedPools.has(pool)) return;
+  patchedPools.add(pool);
+  pool.options.application_name = formatPostgresApplicationName(label);
+  pool.on("error", (err) => {
+    console.error(`[${label}] idle client error:`, err.message);
+  });
+  const p = pool;
+  const origQuery = p.query.bind(pool);
+  p.query = (...args) => withTransportRecovery(pool, label, "pool.query", () => origQuery(...args));
+  const origConnect = p.connect.bind(pool);
+  p.connect = async (...args) => {
+    const client = await withTransportRecovery(
+      pool,
+      label,
+      "pool.connect",
+      () => origConnect(...args)
+    );
+    guardCheckedOutClient(client, label);
+    return client;
+  };
+}
+function withPostgresTransactionRecovery(pool, label, operation, callback) {
+  return withTransportRecovery(pool, label, operation, async () => {
+    const client = await pool.connect();
+    let releaseError;
+    try {
+      await client.query("BEGIN");
+      const value = await callback(client);
+      await client.query("COMMIT");
+      return value;
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      if (isTransportError(error)) releaseError = asError(error);
+      throw error;
+    } finally {
+      client.release(releaseError);
+    }
+  });
+}
+async function withTransportRecovery(pool, label, operation, callback) {
+  const context = postgresRecovery.getStore();
+  const maxAttempts = context?.drainPool ? hostPoolSize(pool) + 1 : 2;
+  const startedAt = Date.now();
+  let firstError;
+  for (let attempt = 1; ; attempt += 1) {
+    try {
+      const value = await callback();
+      if (firstError) {
+        logTransportRecovery({
+          context,
+          label,
+          operation,
+          attempts: attempt,
+          elapsedMs: Date.now() - startedAt,
+          outcome: "recovered",
+          error: firstError.message
+        });
+      }
+      return value;
+    } catch (error) {
+      if (!isTransportError(error)) throw error;
+      firstError ??= asError(error);
+      const elapsedMs = Date.now() - startedAt;
+      if (attempt >= maxAttempts || context !== void 0 && Date.now() >= context.deadlineMs) {
+        logTransportRecovery({
+          context,
+          label,
+          operation,
+          attempts: attempt,
+          elapsedMs,
+          outcome: "exhausted",
+          error: asError(error).message
+        });
+        throw error;
+      }
+    }
+  }
+}
+function hostPoolSize(pool) {
+  const configured = pool.options.max;
+  return typeof configured === "number" && Number.isSafeInteger(configured) && configured > 0 ? configured : 10;
+}
+function logTransportRecovery(args) {
+  console.warn(
+    JSON.stringify({
+      level: "postgres_transport_recovery",
+      label: args.label,
+      route: args.context?.route,
+      channel_id: args.context?.channelId,
+      operation: args.operation,
+      attempts: args.attempts,
+      elapsed_ms: args.elapsedMs,
+      outcome: args.outcome,
+      error: args.error
+    })
+  );
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+function guardCheckedOutClient(client, label) {
+  if (client === null || typeof client !== "object") return;
+  const emitter = client;
+  if (typeof emitter.on !== "function" || guardedClients.has(client)) return;
+  guardedClients.add(client);
+  emitter.on("error", (err) => {
+    console.error(`[${label}] checked-out client error:`, err.message);
+  });
+}
+function truncateUtf8(value, maxBytes) {
+  if (maxBytes <= 0) return "";
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+  let result = "";
+  for (const character of value) {
+    const next = result + character;
+    if (Buffer.byteLength(next, "utf8") > maxBytes) break;
+    result = next;
+  }
+  return result;
+}
+
+export {
+  withPostgresRecoveryContext,
+  applyRetryToPool,
+  withPostgresTransactionRecovery
+};