@cequrebackends/cequre-ts 0.13.0 → 0.14.0

package/dist/index-7xxm1add.js

@@ -0,0 +1,203 @@
+// @bun
+import {
+  CequreError
+} from "./index-qzzg2p5r.js";
+import {
+  init_logger,
+  logger
+} from "./index-8bhn0nb4.js";
+
+// shared/utils/queue-manager.ts
+import { Queue as BullQueue, Worker as BullWorker, QueueEvents as BullQueueEvents } from "bullmq";
+import { Effect } from "effect";
+init_logger();
+
+class BullMQQueueAdapter {
+  queue;
+  constructor(queue) {
+    this.queue = queue;
+  }
+  async add(name, data, opts) {
+    return this.queue.add(name, data, opts);
+  }
+  async addBulk(jobs) {
+    const bulkJobs = jobs.map((job) => ({
+      name: job.name,
+      data: job.data,
+      opts: job.opts
+    }));
+    return this.queue.addBulk(bulkJobs);
+  }
+  async getRepeatableJobs() {
+    return this.queue.getRepeatableJobs();
+  }
+  async removeRepeatableByKey(key) {
+    return this.queue.removeRepeatableByKey(key);
+  }
+  async disconnect() {
+    await this.queue.close();
+  }
+}
+
+class CequreQueueManager {
+  static instance;
+  queues = new Map;
+  workers = new Map;
+  queueEvents = new Map;
+  config;
+  closing = false;
+  constructor(config) {
+    this.config = config;
+    if (!this.config.bullmq?.connection) {
+      throw CequreError.NotConfigured('CequreQueueManager: bullmq provider requires "bullmq.connection"');
+    }
+  }
+  getBullMQBaseOptions() {
+    return {
+      ...this.config.bullmq.prefix ? { prefix: this.config.bullmq.prefix } : {},
+      connection: {
+        ...this.config.bullmq.connection,
+        maxRetriesPerRequest: null
+      }
+    };
+  }
+  static initialize(config) {
+    if (!CequreQueueManager.instance) {
+      CequreQueueManager.instance = new CequreQueueManager(config);
+    }
+    return CequreQueueManager.instance;
+  }
+  static getInstance() {
+    if (!CequreQueueManager.instance) {
+      throw CequreError.NotConfigured("CequreQueueManager not initialized. Call initialize() first.");
+    }
+    return CequreQueueManager.instance;
+  }
+  getQueue(name) {
+    const existing = this.queues.get(name);
+    if (existing)
+      return existing;
+    const queue = new BullQueue(name, {
+      ...this.config.defaultQueueOptions ?? {},
+      ...this.getBullMQBaseOptions()
+    });
+    queue.on("error", (err) => {
+      if (err?.message?.includes("Connection is closed"))
+        return;
+      logger.error(err, `[ ${name.toUpperCase()} QUEUE ] Error`);
+    });
+    const wrapped = new BullMQQueueAdapter(queue);
+    this.queues.set(name, wrapped);
+    return wrapped;
+  }
+  async addJob(queueName, jobName, data, opts) {
+    const queue = this.getQueue(queueName);
+    return queue.add(jobName, data, opts);
+  }
+  async addBulk(queueName, jobs) {
+    const queue = this.getQueue(queueName);
+    return queue.addBulk(jobs);
+  }
+  async registerWorker(queueName, handler, options) {
+    const existing = this.workers.get(queueName);
+    const queueNameForLogs = `[ ${queueName?.toUpperCase()} WORKER ]`;
+    if (existing) {
+      logger.warn(`${queueNameForLogs} Replacing existing worker for queue "${queueName}"`);
+      try {
+        await existing.close();
+      } catch (err) {
+        logger.error(err, `${queueNameForLogs} Error closing old worker for "${queueName}"`);
+      }
+      this.workers.delete(queueName);
+    }
+    const worker = new BullWorker(queueName, async (job) => await handler(job), {
+      ...this.config.defaultWorkerOptions ?? {},
+      ...options ?? {},
+      ...this.getBullMQBaseOptions()
+    });
+    worker.on("completed", (job) => {
+      logger.info(`${queueNameForLogs} Job ${job.id} completed`);
+    });
+    worker.on("failed", (job, err) => {
+      logger.error(err, `${queueNameForLogs} Job ${job?.id ?? "unknown"} failed`);
+    });
+    worker.on("error", (err) => {
+      if (err?.message?.includes("Connection is closed"))
+        return;
+      logger.error(err, `${queueNameForLogs} Worker error`);
+    });
+    await worker.waitUntilReady();
+    logger.info(`${queueNameForLogs} Worker is ready and listening . . .`);
+    const wrapped = {
+      close: async () => {
+        await worker.close();
+      },
+      waitUntilReady: async () => {
+        await worker.waitUntilReady();
+      }
+    };
+    this.workers.set(queueName, wrapped);
+    return wrapped;
+  }
+  getQueueEvents(name) {
+    const existing = this.queueEvents.get(name);
+    if (existing)
+      return existing;
+    const events = new BullQueueEvents(name, {
+      ...this.getBullMQBaseOptions()
+    });
+    events.on("error", (err) => {
+      if (err?.message?.includes("Connection is closed"))
+        return;
+      logger.error(err, `[ ${name.toUpperCase()} QUEUE EVENTS ] Error`);
+    });
+    const wrapped = {
+      disconnect: async () => {
+        await events.close();
+      }
+    };
+    this.queueEvents.set(name, wrapped);
+    return wrapped;
+  }
+  static _reset() {
+    CequreQueueManager.instance = undefined;
+  }
+  static async _resetAndClose() {
+    const existing = CequreQueueManager.instance;
+    CequreQueueManager.instance = undefined;
+    if (existing) {
+      await existing.close();
+    }
+  }
+  async close() {
+    if (this.closing)
+      return;
+    this.closing = true;
+    const closeItemEffect = (item, label) => Effect.tryPromise({
+      try: async () => {
+        if (item.close)
+          await item.close();
+        else if (item.disconnect)
+          await item.disconnect();
+      },
+      catch: (err) => err
+    }).pipe(Effect.catchAll((err) => Effect.sync(() => {
+      logger.error(err, `[QueueManager] Error closing ${label}`);
+    })));
+    const closeGroupEffect = (items, label) => Effect.all(items.map((item) => closeItemEffect(item, label)), { concurrency: "unbounded" });
+    const workers = Array.from(this.workers.values());
+    const queueEvents = Array.from(this.queueEvents.values());
+    const queues = Array.from(this.queues.values());
+    await Effect.runPromise(Effect.gen(function* () {
+      yield* closeGroupEffect(workers, "worker");
+      yield* closeGroupEffect(queueEvents, "queue events");
+      yield* closeGroupEffect(queues, "queue");
+    }));
+    this.workers.clear();
+    this.queueEvents.clear();
+    this.queues.clear();
+    this.closing = false;
+  }
+}
+
+export { CequreQueueManager };

package/dist/{index-c3vh32en.js → index-8bhn0nb4.js}

@@ -1,11 +1,10 @@
 // @bun
 import {
-  CequreError,
   __esm,
   __export,
   __require,
   __toCommonJS
-} from "./index-17yswtmg.js";
+} from "./index-cpw1bjf1.js";
 
 // shared/utils/kv/adapters/memory.ts
 function getLog() {
@@ -356,6 +355,105 @@ class RedisAdapter {
 var _log = null;
 var init_bun_redis_cache = () => {};
 
+// adapters/vercel/upstash-kv.ts
+class UpstashKVAdapter {
+  url;
+  token;
+  constructor(options) {
+    this.url = options?.url || process.env.UPSTASH_REDIS_REST_URL || "";
+    this.token = options?.token || process.env.UPSTASH_REDIS_REST_TOKEN || "";
+    if (!this.url || !this.token) {
+      console.warn("[Cequre KV (Upstash)] UPSTASH_REDIS_REST_URL or UPSTASH_REDIS_REST_TOKEN not set \u2014 KV operations will fail.");
+    }
+  }
+  async command(args) {
+    const res = await fetch(this.url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(args)
+    });
+    if (!res.ok) {
+      throw new Error(`Upstash Redis error: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    return data.result;
+  }
+  async get(key) {
+    const result = await this.command(["GET", key]);
+    if (result === null)
+      return null;
+    try {
+      return JSON.parse(result);
+    } catch {
+      return result;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    if (keys.length === 0)
+      return result;
+    const values = await this.command(["MGET", ...keys]);
+    for (let i = 0;i < keys.length; i++) {
+      const key = keys[i];
+      if (key === undefined)
+        continue;
+      const value = values[i];
+      if (value !== null && value !== undefined) {
+        try {
+          result.set(key, JSON.parse(value));
+        } catch {
+          result.set(key, value);
+        }
+      }
+    }
+    return result;
+  }
+  async set(key, value, ttl) {
+    const serialized = JSON.stringify(value);
+    if (ttl != null && ttl > 0) {
+      await this.command(["SET", key, serialized, "EX", String(ttl)]);
+    } else {
+      await this.command(["SET", key, serialized]);
+    }
+  }
+  async setMany(entries) {
+    await Promise.all(entries.map(({ key, value, ttl }) => this.set(key, value, ttl)));
+  }
+  async delete(key) {
+    const deleted = await this.command(["DEL", key]);
+    return deleted > 0;
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0)
+      return 0;
+    return await this.command(["DEL", ...keys]);
+  }
+  async has(key) {
+    const exists = await this.command(["EXISTS", key]);
+    return exists > 0;
+  }
+  async keys(prefix) {
+    if (!prefix) {
+      return await this.command(["KEYS", "*"]);
+    }
+    return await this.command(["KEYS", `${prefix}*`]);
+  }
+  async count() {
+    return await this.command(["DBSIZE"]);
+  }
+  async clear() {
+    await this.command(["FLUSHDB"]);
+  }
+  cleanup() {
+    return 0;
+  }
+  close() {}
+}
+var init_upstash_kv = () => {};
+
 // shared/utils/kv/types.ts
 var init_types = () => {};
 
@@ -372,6 +470,9 @@ class CequreKV {
     } else if (driver === "redis") {
       this.adapter = new RedisAdapter(options.redis);
       this.isCleanupNative = true;
+    } else if (driver === "upstash") {
+      this.adapter = new UpstashKVAdapter(options.upstash);
+      this.isCleanupNative = true;
     } else {
       this.adapter = new SQLiteAdapter(options.sqlite);
       this.isCleanupNative = false;
@@ -431,6 +532,7 @@ var init_kv = __esm(() => {
   init_memory();
   init_sqlite();
   init_bun_redis_cache();
+  init_upstash_kv();
   init_types();
 });
 
@@ -554,197 +656,4 @@ var init_logger = __esm(() => {
   }
 });
 
-// shared/utils/queue-manager.ts
-import { Queue as BullQueue, Worker as BullWorker, QueueEvents as BullQueueEvents } from "bullmq";
-import { Effect } from "effect";
-init_logger();
-
-class BullMQQueueAdapter {
-  queue;
-  constructor(queue) {
-    this.queue = queue;
-  }
-  async add(name, data, opts) {
-    return this.queue.add(name, data, opts);
-  }
-  async addBulk(jobs) {
-    const bulkJobs = jobs.map((job) => ({
-      name: job.name,
-      data: job.data,
-      opts: job.opts
-    }));
-    return this.queue.addBulk(bulkJobs);
-  }
-  async getRepeatableJobs() {
-    return this.queue.getRepeatableJobs();
-  }
-  async removeRepeatableByKey(key) {
-    return this.queue.removeRepeatableByKey(key);
-  }
-  async disconnect() {
-    await this.queue.close();
-  }
-}
-
-class CequreQueueManager {
-  static instance;
-  queues = new Map;
-  workers = new Map;
-  queueEvents = new Map;
-  config;
-  closing = false;
-  constructor(config) {
-    this.config = config;
-    if (!this.config.bullmq?.connection) {
-      throw CequreError.NotConfigured('CequreQueueManager: bullmq provider requires "bullmq.connection"');
-    }
-  }
-  getBullMQBaseOptions() {
-    return {
-      ...this.config.bullmq.prefix ? { prefix: this.config.bullmq.prefix } : {},
-      connection: {
-        ...this.config.bullmq.connection,
-        maxRetriesPerRequest: null
-      }
-    };
-  }
-  static initialize(config) {
-    if (!CequreQueueManager.instance) {
-      CequreQueueManager.instance = new CequreQueueManager(config);
-    }
-    return CequreQueueManager.instance;
-  }
-  static getInstance() {
-    if (!CequreQueueManager.instance) {
-      throw CequreError.NotConfigured("CequreQueueManager not initialized. Call initialize() first.");
-    }
-    return CequreQueueManager.instance;
-  }
-  getQueue(name) {
-    const existing = this.queues.get(name);
-    if (existing)
-      return existing;
-    const queue = new BullQueue(name, {
-      ...this.config.defaultQueueOptions ?? {},
-      ...this.getBullMQBaseOptions()
-    });
-    queue.on("error", (err) => {
-      if (err?.message?.includes("Connection is closed"))
-        return;
-      logger.error(err, `[ ${name.toUpperCase()} QUEUE ] Error`);
-    });
-    const wrapped = new BullMQQueueAdapter(queue);
-    this.queues.set(name, wrapped);
-    return wrapped;
-  }
-  async addJob(queueName, jobName, data, opts) {
-    const queue = this.getQueue(queueName);
-    return queue.add(jobName, data, opts);
-  }
-  async addBulk(queueName, jobs) {
-    const queue = this.getQueue(queueName);
-    return queue.addBulk(jobs);
-  }
-  async registerWorker(queueName, handler, options) {
-    const existing = this.workers.get(queueName);
-    const queueNameForLogs = `[ ${queueName?.toUpperCase()} WORKER ]`;
-    if (existing) {
-      logger.warn(`${queueNameForLogs} Replacing existing worker for queue "${queueName}"`);
-      try {
-        await existing.close();
-      } catch (err) {
-        logger.error(err, `${queueNameForLogs} Error closing old worker for "${queueName}"`);
-      }
-      this.workers.delete(queueName);
-    }
-    const worker = new BullWorker(queueName, async (job) => await handler(job), {
-      ...this.config.defaultWorkerOptions ?? {},
-      ...options ?? {},
-      ...this.getBullMQBaseOptions()
-    });
-    worker.on("completed", (job) => {
-      logger.info(`${queueNameForLogs} Job ${job.id} completed`);
-    });
-    worker.on("failed", (job, err) => {
-      logger.error(err, `${queueNameForLogs} Job ${job?.id ?? "unknown"} failed`);
-    });
-    worker.on("error", (err) => {
-      if (err?.message?.includes("Connection is closed"))
-        return;
-      logger.error(err, `${queueNameForLogs} Worker error`);
-    });
-    await worker.waitUntilReady();
-    logger.info(`${queueNameForLogs} Worker is ready and listening . . .`);
-    const wrapped = {
-      close: async () => {
-        await worker.close();
-      },
-      waitUntilReady: async () => {
-        await worker.waitUntilReady();
-      }
-    };
-    this.workers.set(queueName, wrapped);
-    return wrapped;
-  }
-  getQueueEvents(name) {
-    const existing = this.queueEvents.get(name);
-    if (existing)
-      return existing;
-    const events = new BullQueueEvents(name, {
-      ...this.getBullMQBaseOptions()
-    });
-    events.on("error", (err) => {
-      if (err?.message?.includes("Connection is closed"))
-        return;
-      logger.error(err, `[ ${name.toUpperCase()} QUEUE EVENTS ] Error`);
-    });
-    const wrapped = {
-      disconnect: async () => {
-        await events.close();
-      }
-    };
-    this.queueEvents.set(name, wrapped);
-    return wrapped;
-  }
-  static _reset() {
-    CequreQueueManager.instance = undefined;
-  }
-  static async _resetAndClose() {
-    const existing = CequreQueueManager.instance;
-    CequreQueueManager.instance = undefined;
-    if (existing) {
-      await existing.close();
-    }
-  }
-  async close() {
-    if (this.closing)
-      return;
-    this.closing = true;
-    const closeItemEffect = (item, label) => Effect.tryPromise({
-      try: async () => {
-        if (item.close)
-          await item.close();
-        else if (item.disconnect)
-          await item.disconnect();
-      },
-      catch: (err) => err
-    }).pipe(Effect.catchAll((err) => Effect.sync(() => {
-      logger.error(err, `[QueueManager] Error closing ${label}`);
-    })));
-    const closeGroupEffect = (items, label) => Effect.all(items.map((item) => closeItemEffect(item, label)), { concurrency: "unbounded" });
-    const workers = Array.from(this.workers.values());
-    const queueEvents = Array.from(this.queueEvents.values());
-    const queues = Array.from(this.queues.values());
-    await Effect.runPromise(Effect.gen(function* () {
-      yield* closeGroupEffect(workers, "worker");
-      yield* closeGroupEffect(queueEvents, "queue events");
-      yield* closeGroupEffect(queues, "queue");
-    }));
-    this.workers.clear();
-    this.queueEvents.clear();
-    this.queues.clear();
-    this.closing = false;
-  }
-}
-
-export { logger, CequreErrorLogs, createLogger, exports_logger, init_logger, RedisAdapter, init_bun_redis_cache, CequreKV, init_kv, CequreQueueManager };
+export { logger, CequreErrorLogs, createLogger, exports_logger, init_logger, RedisAdapter, init_bun_redis_cache, UpstashKVAdapter, init_upstash_kv, CequreKV, init_kv };

package/dist/index-cpw1bjf1.js

@@ -0,0 +1,62 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// shared/core/ulid.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function ulid(seedTime = Date.now()) {
+  let str = "";
+  let now = seedTime;
+  for (let len = TIME_LEN;len > 0; len--) {
+    const mod = now % 32;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / 32;
+  }
+  const randomBytes = new Uint8Array(RANDOM_LEN);
+  crypto.getRandomValues(randomBytes);
+  for (let i = 0;i < RANDOM_LEN; i++) {
+    str += ENCODING.charAt(randomBytes[i] & 31);
+  }
+  return str;
+}
+
+export { __toCommonJS, __export, __esm, __require, ulid };

package/dist/{index-17yswtmg.js → index-qzzg2p5r.js}

@@ -1,64 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = import.meta.require;
-
-// shared/core/ulid.ts
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var TIME_LEN = 10;
-var RANDOM_LEN = 16;
-function ulid(seedTime = Date.now()) {
-  let str = "";
-  let now = seedTime;
-  for (let len = TIME_LEN;len > 0; len--) {
-    const mod = now % 32;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / 32;
-  }
-  const randomBytes = new Uint8Array(RANDOM_LEN);
-  crypto.getRandomValues(randomBytes);
-  for (let i = 0;i < RANDOM_LEN; i++) {
-    str += ENCODING.charAt(randomBytes[i] & 31);
-  }
-  return str;
-}
-
 // shared/utils/url.ts
 function extractPathname(url) {
   const protocolIndex = url.indexOf("://");
@@ -172,4 +112,4 @@ function toErrorResponse(error, request, adapter) {
   });
 }
 
-export { __toCommonJS, __export, __esm, __require, ulid, extractPathname, CequreError, parseConstraintError, getConstraintErrorMessage, getConstraintErrorStatus, buildErrorResponse, toErrorResponse };
+export { extractPathname, CequreError, parseConstraintError, getConstraintErrorMessage, getConstraintErrorStatus, buildErrorResponse, toErrorResponse };