hybridq 0.1.1

package/dist/server/index.cjs

@@ -0,0 +1,604 @@
+'use strict';
+
+var crypto = require('crypto');
+
+// src/storage/memory.ts
+var MemoryAdapter = class {
+  constructor(opts = {}) {
+    this.queues = /* @__PURE__ */ new Map();
+    this.cipher = opts.cipher ?? null;
+  }
+  bucket(queue) {
+    let b = this.queues.get(queue);
+    if (!b) this.queues.set(queue, b = []);
+    return b;
+  }
+  seal(job) {
+    if (!this.cipher) return { ...job };
+    const enc = this.cipher.encrypt(JSON.stringify(job.payload));
+    return { ...job, payload: null, _enc: enc };
+  }
+  open(stored) {
+    if (!this.cipher || !stored._enc) {
+      const { _enc: _enc2, ...job2 } = stored;
+      return job2;
+    }
+    const payload = JSON.parse(this.cipher.decrypt(stored._enc));
+    const { _enc, ...job } = stored;
+    return { ...job, payload };
+  }
+  async push(job) {
+    this.bucket(job.queue).push(this.seal(job));
+  }
+  async shiftBatch(queue, count, leaseMs) {
+    const now = Date.now();
+    const bucket = this.bucket(queue);
+    const claimed = [];
+    for (const stored of bucket) {
+      if (claimed.length >= count) break;
+      const eligible = (stored.status === "pending" || stored.status === "delayed") && stored.runAt <= now;
+      const lapsed = stored.status === "active" && stored.leaseUntil !== void 0 && stored.leaseUntil <= now;
+      if (!eligible && !lapsed) continue;
+      stored.status = "active";
+      stored.attempts += 1;
+      stored.leaseUntil = now + leaseMs;
+      claimed.push(this.open(stored));
+    }
+    return claimed;
+  }
+  async complete(queue, jobId) {
+    const bucket = this.bucket(queue);
+    const i = bucket.findIndex((j) => j.id === jobId);
+    if (i !== -1) bucket.splice(i, 1);
+  }
+  async fail(queue, jobId, error, retry, backoffMs) {
+    const job = this.bucket(queue).find((j) => j.id === jobId);
+    if (!job) return;
+    job.lastError = error;
+    job.leaseUntil = void 0;
+    if (retry && job.attempts < job.maxAttempts) {
+      job.status = "pending";
+      job.runAt = Date.now() + backoffMs;
+    } else {
+      job.status = "failed";
+    }
+  }
+  async release(queue, jobId) {
+    const job = this.bucket(queue).find((j) => j.id === jobId);
+    if (!job || job.status !== "active") return;
+    job.status = "pending";
+    job.leaseUntil = void 0;
+    job.attempts = Math.max(0, job.attempts - 1);
+  }
+  async size(queue) {
+    const now = Date.now();
+    return this.bucket(queue).filter(
+      (j) => (j.status === "pending" || j.status === "delayed") && j.runAt <= now
+    ).length;
+  }
+};
+
+// src/storage/redis.ts
+var CLAIM_LUA = `
+local pending = KEYS[1]
+local delayed = KEYS[2]
+local active  = KEYS[3]
+local jobs    = KEYS[4]
+local now   = tonumber(ARGV[1])
+local count = tonumber(ARGV[2])
+local lease = tonumber(ARGV[3])
+
+local due = redis.call('ZRANGEBYSCORE', delayed, '-inf', now)
+for _, id in ipairs(due) do
+  redis.call('RPUSH', pending, id)
+  redis.call('ZREM', delayed, id)
+end
+
+local lapsed = redis.call('ZRANGEBYSCORE', active, '-inf', now)
+for _, id in ipairs(lapsed) do
+  redis.call('RPUSH', pending, id)
+  redis.call('ZREM', active, id)
+end
+
+local out = {}
+for i = 1, count do
+  local id = redis.call('LPOP', pending)
+  if not id then break end
+  local raw = redis.call('HGET', jobs, id)
+  if raw then
+    local env = cjson.decode(raw)
+    env.status = 'active'
+    env.attempts = (env.attempts or 0) + 1
+    env.leaseUntil = now + lease
+    local enc = cjson.encode(env)
+    redis.call('HSET', jobs, id, enc)
+    redis.call('ZADD', active, env.leaseUntil, id)
+    table.insert(out, enc)
+  end
+end
+return out
+`;
+var RedisAdapter = class {
+  constructor(redis, opts = {}) {
+    this.redis = redis;
+    this.ns = opts.namespace ?? "hq";
+    this.cipher = opts.cipher ?? null;
+  }
+  k(queue, suffix) {
+    return `${this.ns}:${queue}:${suffix}`;
+  }
+  toEnvelope(job) {
+    const plain = JSON.stringify(job.payload ?? null);
+    const enc = !!this.cipher;
+    return {
+      id: job.id,
+      queue: job.queue,
+      status: job.status,
+      attempts: job.attempts,
+      maxAttempts: job.maxAttempts,
+      runAt: job.runAt,
+      createdAt: job.createdAt,
+      leaseUntil: job.leaseUntil,
+      lastError: job.lastError,
+      payloadJson: enc ? this.cipher.encrypt(plain) : plain,
+      enc
+    };
+  }
+  fromEnvelope(env) {
+    const plain = env.enc ? this.cipher ? this.cipher.decrypt(env.payloadJson) : (() => {
+      throw new Error(
+        "hybridq: job is encrypted but no cipher is configured"
+      );
+    })() : env.payloadJson;
+    return {
+      id: env.id,
+      queue: env.queue,
+      payload: JSON.parse(plain),
+      status: env.status,
+      attempts: env.attempts,
+      maxAttempts: env.maxAttempts,
+      runAt: env.runAt,
+      createdAt: env.createdAt,
+      leaseUntil: env.leaseUntil,
+      lastError: env.lastError
+    };
+  }
+  async push(job) {
+    const env = this.toEnvelope(job);
+    const raw = JSON.stringify(env);
+    await this.redis.hset(this.k(job.queue, "jobs"), job.id, raw);
+    if (job.runAt > Date.now()) {
+      await this.redis.zadd(this.k(job.queue, "delayed"), job.runAt, job.id);
+    } else {
+      await this.redis.rpush(this.k(job.queue, "pending"), job.id);
+    }
+  }
+  async shiftBatch(queue, count, leaseMs) {
+    const res = await this.redis.eval(
+      CLAIM_LUA,
+      [
+        this.k(queue, "pending"),
+        this.k(queue, "delayed"),
+        this.k(queue, "active"),
+        this.k(queue, "jobs")
+      ],
+      [Date.now(), count, leaseMs]
+    );
+    if (!res || res.length === 0) return [];
+    return res.map((raw) => this.fromEnvelope(JSON.parse(raw)));
+  }
+  async complete(queue, jobId) {
+    await this.redis.zrem(this.k(queue, "active"), jobId);
+    await this.redis.hdel(this.k(queue, "jobs"), jobId);
+  }
+  async fail(queue, jobId, error, retry, backoffMs) {
+    const raw = await this.redis.hget(this.k(queue, "jobs"), jobId);
+    if (!raw) return;
+    const env = JSON.parse(raw);
+    env.lastError = error;
+    env.leaseUntil = void 0;
+    await this.redis.zrem(this.k(queue, "active"), jobId);
+    if (retry && env.attempts < env.maxAttempts) {
+      env.status = "pending";
+      env.runAt = Date.now() + backoffMs;
+      await this.redis.hset(this.k(queue, "jobs"), jobId, JSON.stringify(env));
+      if (backoffMs > 0) {
+        await this.redis.zadd(this.k(queue, "delayed"), env.runAt, jobId);
+      } else {
+        await this.redis.rpush(this.k(queue, "pending"), jobId);
+      }
+    } else {
+      env.status = "failed";
+      await this.redis.hset(this.k(queue, "jobs"), jobId, JSON.stringify(env));
+    }
+  }
+  async release(queue, jobId) {
+    const raw = await this.redis.hget(this.k(queue, "jobs"), jobId);
+    if (!raw) return;
+    const env = JSON.parse(raw);
+    if (env.status !== "active") return;
+    env.status = "pending";
+    env.leaseUntil = void 0;
+    env.attempts = Math.max(0, env.attempts - 1);
+    await this.redis.zrem(this.k(queue, "active"), jobId);
+    await this.redis.hset(this.k(queue, "jobs"), jobId, JSON.stringify(env));
+    await this.redis.rpush(this.k(queue, "pending"), jobId);
+  }
+  async size(queue) {
+    return this.redis.llen(this.k(queue, "pending"));
+  }
+};
+function fromUpstash(client) {
+  return {
+    eval: (script, keys, args) => client.eval(script, keys, args),
+    hget: (k, f) => client.hget(k, f),
+    hset: (k, f, v) => client.hset(k, { [f]: v }),
+    hdel: (k, f) => client.hdel(k, f),
+    rpush: (k, v) => client.rpush(k, v),
+    zadd: (k, score, member) => client.zadd(k, { score, member }),
+    zrem: (k, m) => client.zrem(k, m),
+    llen: (k) => client.llen(k)
+  };
+}
+function fromIORedis(client) {
+  return {
+    eval: (script, keys, args) => client.eval(script, keys.length, ...keys, ...args),
+    hget: (k, f) => client.hget(k, f),
+    hset: (k, f, v) => client.hset(k, f, v),
+    hdel: (k, f) => client.hdel(k, f),
+    rpush: (k, v) => client.rpush(k, v),
+    zadd: (k, score, member) => client.zadd(k, score, member),
+    zrem: (k, m) => client.zrem(k, m),
+    llen: (k) => client.llen(k)
+  };
+}
+function getSharedIORedis(factory, key = "__hybridq_ioredis__") {
+  const g = globalThis;
+  if (!g[key]) g[key] = factory();
+  return g[key];
+}
+
+// src/engine/processor.ts
+var defaultBackoff = (attempt) => Math.min(3e4, 1e3 * 2 ** Math.max(0, attempt - 1));
+function cpuSampler() {
+  const proc = globalThis.process;
+  if (!proc?.cpuUsage) return () => 0;
+  const startCpu = proc.cpuUsage();
+  const startWall = Date.now();
+  return () => {
+    const d = proc.cpuUsage(startCpu);
+    const wallUs = Math.max(1, (Date.now() - startWall) * 1e3);
+    return (d.user + d.system) / wallUs * 100;
+  };
+}
+async function drain(opts) {
+  const {
+    queue,
+    adapter,
+    handler,
+    budget,
+    lock,
+    batchSize = 10,
+    leaseMs = budget.maxExecutionTimeMs,
+    backoff = defaultBackoff,
+    onError
+  } = opts;
+  const startedAt = Date.now();
+  const elapsed = () => Date.now() - startedAt;
+  const sampleCpu = cpuSampler();
+  let processed = 0;
+  let failed = 0;
+  let released = 0;
+  let stoppedBy = "drained";
+  const lockKey = `${queue}:drain-lock`;
+  let lockToken = null;
+  if (lock) {
+    lockToken = await lock.acquire(lockKey, budget.maxExecutionTimeMs + 2e3);
+    if (!lockToken) {
+      return { processed, failed, released, stoppedBy: "lockBusy", elapsedMs: 0 };
+    }
+  }
+  const done = () => processed + failed;
+  const budgetExhausted = () => {
+    if (done() >= budget.maxJobsPerTrigger) return "jobCap";
+    if (elapsed() >= budget.maxExecutionTimeMs) return "timeBudget";
+    if (budget.maxCpuBudgetPct !== void 0 && sampleCpu() >= budget.maxCpuBudgetPct) {
+      return "cpuBudget";
+    }
+    return null;
+  };
+  try {
+    outer: while (true) {
+      const hit = budgetExhausted();
+      if (hit) {
+        stoppedBy = hit;
+        break;
+      }
+      const remainingByCount = budget.maxJobsPerTrigger - done();
+      const claimCount = Math.max(1, Math.min(batchSize, remainingByCount));
+      const batch = await adapter.shiftBatch(queue, claimCount, leaseMs);
+      if (batch.length === 0) {
+        stoppedBy = "drained";
+        break;
+      }
+      for (let i = 0; i < batch.length; i++) {
+        const job = batch[i];
+        const hit2 = budgetExhausted();
+        if (hit2) {
+          for (let j = i; j < batch.length; j++) {
+            await adapter.release(queue, batch[j].id);
+            released++;
+          }
+          stoppedBy = hit2;
+          break outer;
+        }
+        try {
+          await handler(job);
+          await adapter.complete(queue, job.id);
+          processed++;
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          onError?.(err, job);
+          await adapter.fail(
+            queue,
+            job.id,
+            message,
+            /* retry */
+            true,
+            backoff(job.attempts)
+          );
+          failed++;
+        }
+      }
+    }
+  } finally {
+    if (lock && lockToken) await lock.release(lockKey, lockToken);
+  }
+  return { processed, failed, released, stoppedBy, elapsedMs: elapsed() };
+}
+
+// src/util/id.ts
+function newId(prefix = "job") {
+  const g = globalThis;
+  const uuid = g.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+  return `${prefix}_${uuid}`;
+}
+
+// src/engine/lock.ts
+var ACQUIRE_LUA = `return redis.call('SET', KEYS[1], ARGV[1], 'NX', 'PX', ARGV[2])`;
+var RELEASE_LUA = `
+if redis.call('GET', KEYS[1]) == ARGV[1] then
+  return redis.call('DEL', KEYS[1])
+end
+return 0`;
+var RedisLock = class {
+  constructor(redis) {
+    this.redis = redis;
+  }
+  async acquire(key, ttlMs) {
+    const token = newId("lock");
+    const res = await this.redis.eval(ACQUIRE_LUA, [key], [token, ttlMs]);
+    return res === "OK" || res === true ? token : null;
+  }
+  async release(key, token) {
+    await this.redis.eval(RELEASE_LUA, [key], [token]);
+  }
+};
+var MemoryLock = class {
+  constructor() {
+    this.held = /* @__PURE__ */ new Map();
+  }
+  async acquire(key, ttlMs) {
+    const now = Date.now();
+    const cur = this.held.get(key);
+    if (cur && cur.until > now) return null;
+    const token = newId("lock");
+    this.held.set(key, { token, until: now + ttlMs });
+    return token;
+  }
+  async release(key, token) {
+    const cur = this.held.get(key);
+    if (cur && cur.token === token) this.held.delete(key);
+  }
+};
+
+// src/server/queue.ts
+var DEFAULT_BUDGET = {
+  maxJobsPerTrigger: 25,
+  maxExecutionTimeMs: 8e3
+  // safe under a 10s serverless limit
+};
+var Queue = class {
+  constructor(config) {
+    this.config = config;
+    this.budget = { ...DEFAULT_BUDGET, ...config.budget };
+  }
+  get name() {
+    return this.config.name;
+  }
+  /** Producer side: push a unit of work. Returns the created job. */
+  async enqueue(payload, opts = {}) {
+    const now = Date.now();
+    const job = {
+      id: opts.id ?? newId("job"),
+      queue: this.config.name,
+      payload,
+      status: opts.delayMs && opts.delayMs > 0 ? "delayed" : "pending",
+      attempts: 0,
+      maxAttempts: opts.maxAttempts ?? this.config.defaultMaxAttempts ?? 3,
+      runAt: now + (opts.delayMs ?? 0),
+      createdAt: now
+    };
+    await this.config.adapter.push(job);
+    return job;
+  }
+  /** How many jobs are currently claimable. Handy for trigger gating. */
+  size() {
+    return this.config.adapter.size(this.config.name);
+  }
+  /**
+   * Consumer side: drain a budgeted batch with the given handler. Safe to call
+   * from many concurrent requests — the lock ensures only one actually runs.
+   */
+  process(handler, budgetOverride) {
+    return drain({
+      queue: this.config.name,
+      adapter: this.config.adapter,
+      handler,
+      budget: { ...this.budget, ...budgetOverride },
+      lock: this.config.lock,
+      batchSize: this.config.batchSize,
+      backoff: this.config.backoff
+    });
+  }
+};
+function defineQueue(config) {
+  return new Queue(config);
+}
+var ALGO = "aes-256-gcm";
+var IV_BYTES = 12;
+var ENVELOPE_PREFIX = "hqv1";
+function deriveKey(secret) {
+  return crypto.createHmac("sha256", "hybridq:payload-key").update(secret).digest();
+}
+function createPayloadCipher(secret) {
+  if (!secret) return null;
+  const key = deriveKey(secret);
+  return {
+    encrypt(plaintext) {
+      const iv = crypto.randomBytes(IV_BYTES);
+      const cipher = crypto.createCipheriv(ALGO, key, iv);
+      const ct = Buffer.concat([
+        cipher.update(plaintext, "utf8"),
+        cipher.final()
+      ]);
+      const tag = cipher.getAuthTag();
+      return [
+        ENVELOPE_PREFIX,
+        iv.toString("base64url"),
+        tag.toString("base64url"),
+        ct.toString("base64url")
+      ].join(".");
+    },
+    decrypt(envelope) {
+      const parts = envelope.split(".");
+      if (parts.length !== 4 || parts[0] !== ENVELOPE_PREFIX) {
+        throw new Error("hybridq: malformed encrypted payload envelope");
+      }
+      const [, ivB64, tagB64, ctB64] = parts;
+      const iv = Buffer.from(ivB64, "base64url");
+      const tag = Buffer.from(tagB64, "base64url");
+      const ct = Buffer.from(ctB64, "base64url");
+      const decipher = crypto.createDecipheriv(ALGO, key, iv);
+      decipher.setAuthTag(tag);
+      return Buffer.concat([decipher.update(ct), decipher.final()]).toString(
+        "utf8"
+      );
+    }
+  };
+}
+function safeEqual(a, b) {
+  const ab = Buffer.from(a);
+  const bb = Buffer.from(b);
+  if (ab.length !== bb.length) return false;
+  return crypto.timingSafeEqual(ab, bb);
+}
+function signTrigger(secret, path, ts = Date.now()) {
+  const sig = crypto.createHmac("sha256", secret).update(`${ts}.${path}`).digest("base64url");
+  return `t=${ts},v=${sig}`;
+}
+function verifyTrigger(secret, path, token, maxSkewMs = 5 * 6e4) {
+  const m = /^t=(\d+),v=([A-Za-z0-9_-]+)$/.exec(token.trim());
+  if (!m) return false;
+  const ts = Number(m[1]);
+  const sig = m[2];
+  if (!Number.isFinite(ts) || Math.abs(Date.now() - ts) > maxSkewMs) {
+    return false;
+  }
+  const expected = crypto.createHmac("sha256", secret).update(`${ts}.${path}`).digest("base64url");
+  return safeEqual(sig, expected);
+}
+
+// src/server/middleware.ts
+var TRIGGER_SECRET_HEADER = "x-worker-trigger-secret";
+var TRIGGER_TOKEN_HEADER = "x-worker-trigger-token";
+function authorizeTrigger(req, auth) {
+  let configured = false;
+  if (auth.secret) {
+    configured = true;
+    const provided = req.headers.get(TRIGGER_SECRET_HEADER);
+    if (provided && safeEqual(provided, auth.secret)) return true;
+  }
+  if (auth.hmacSecret) {
+    configured = true;
+    const token = req.headers.get(TRIGGER_TOKEN_HEADER);
+    const path = auth.path ?? new URL(req.url).pathname;
+    if (token && verifyTrigger(auth.hmacSecret, path, token)) return true;
+  }
+  return configured ? false : false;
+}
+function deferDrain(run, ctx) {
+  const p = run().catch(() => {
+  });
+  if (ctx?.waitUntil) ctx.waitUntil(p);
+}
+function withTrigger(route, opts) {
+  return async (req) => {
+    const res = await route(req);
+    deferDrain(async () => {
+      if (opts.skipIfEmpty && await opts.queue.size() === 0) {
+        return {
+          processed: 0,
+          failed: 0,
+          released: 0,
+          stoppedBy: "drained",
+          elapsedMs: 0
+        };
+      }
+      return opts.queue.process(opts.handler, opts.budget);
+    }, opts.ctx);
+    return res;
+  };
+}
+function createTriggerEndpoint(opts) {
+  const background = opts.background ?? true;
+  return async (req) => {
+    if (!authorizeTrigger(req, opts.auth)) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    if (background) {
+      deferDrain(() => opts.queue.process(opts.handler, opts.budget), opts.ctx);
+      return new Response(JSON.stringify({ accepted: true }), {
+        status: 202,
+        headers: { "content-type": "application/json" }
+      });
+    }
+    const report = await opts.queue.process(opts.handler, opts.budget);
+    return new Response(JSON.stringify(report), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  };
+}
+
+exports.MemoryAdapter = MemoryAdapter;
+exports.MemoryLock = MemoryLock;
+exports.Queue = Queue;
+exports.RedisAdapter = RedisAdapter;
+exports.RedisLock = RedisLock;
+exports.TRIGGER_SECRET_HEADER = TRIGGER_SECRET_HEADER;
+exports.TRIGGER_TOKEN_HEADER = TRIGGER_TOKEN_HEADER;
+exports.authorizeTrigger = authorizeTrigger;
+exports.createPayloadCipher = createPayloadCipher;
+exports.createTriggerEndpoint = createTriggerEndpoint;
+exports.defineQueue = defineQueue;
+exports.drain = drain;
+exports.fromIORedis = fromIORedis;
+exports.fromUpstash = fromUpstash;
+exports.getSharedIORedis = getSharedIORedis;
+exports.newId = newId;
+exports.signTrigger = signTrigger;
+exports.verifyTrigger = verifyTrigger;
+exports.withTrigger = withTrigger;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map