@cequrebackends/cequre-ts 0.11.4

package/dist/index-rf1kdn5b.js

@@ -0,0 +1,732 @@
+// @bun
+import {
+  CequreError,
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./index-17yswtmg.js";
+
+// shared/utils/kv/adapters/memory.ts
+function getLog() {
+  if (!log) {
+    const { createLogger } = (init_logger(), __toCommonJS(exports_logger));
+    log = createLogger("kv-memory");
+  }
+  return log;
+}
+
+class MemoryAdapter {
+  store = new Map;
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return null;
+    if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  getMany(keys) {
+    const result = new Map;
+    const now = Date.now();
+    for (const key of keys) {
+      const entry = this.store.get(key);
+      if (entry) {
+        if (entry.expiresAt !== null && entry.expiresAt <= now) {
+          this.store.delete(key);
+        } else {
+          result.set(key, entry.value);
+        }
+      }
+    }
+    return result;
+  }
+  set(key, value, ttl) {
+    const expiresAt = ttl != null ? Date.now() + ttl * 1000 : null;
+    this.store.set(key, { value, expiresAt });
+  }
+  setMany(entries) {
+    const now = Date.now();
+    for (const { key, value, ttl } of entries) {
+      const expiresAt = ttl != null ? now + ttl * 1000 : null;
+      this.store.set(key, { value, expiresAt });
+    }
+  }
+  delete(key) {
+    return this.store.delete(key);
+  }
+  deleteMany(keys) {
+    let deleted = 0;
+    for (const key of keys) {
+      if (this.store.delete(key))
+        deleted++;
+    }
+    return deleted;
+  }
+  has(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return false;
+    if (entry.expiresAt !== null && entry.expiresAt <= Date.now()) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  keys(prefix) {
+    const now = Date.now();
+    const result = [];
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt === null || entry.expiresAt > now) {
+        if (!prefix || key.startsWith(prefix)) {
+          result.push(key);
+        }
+      }
+    }
+    return result;
+  }
+  count() {
+    const now = Date.now();
+    let count = 0;
+    for (const entry of this.store.values()) {
+      if (entry.expiresAt === null || entry.expiresAt > now) {
+        count++;
+      }
+    }
+    return count;
+  }
+  clear() {
+    this.store.clear();
+  }
+  cleanup() {
+    const now = Date.now();
+    let removed = 0;
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt !== null && entry.expiresAt <= now) {
+        this.store.delete(key);
+        removed++;
+      }
+    }
+    if (removed > 0) {
+      getLog().debug({ removed }, "KV expired entries cleaned up (Memory)");
+    }
+    return removed;
+  }
+  close() {
+    this.store.clear();
+    getLog().debug("Memory KV store closed");
+  }
+}
+var log = null;
+var init_memory = () => {};
+
+// shared/utils/kv/adapters/sqlite.ts
+import { Database } from "bun:sqlite";
+function getLog2() {
+  if (!log2) {
+    const { createLogger } = (init_logger(), __toCommonJS(exports_logger));
+    log2 = createLogger("kv-sqlite");
+  }
+  return log2;
+}
+
+class SQLiteAdapter {
+  db;
+  stmtGet;
+  stmtSet;
+  stmtDel;
+  stmtHas;
+  stmtKeys;
+  stmtKeysPrefix;
+  stmtClear;
+  stmtCleanup;
+  stmtCount;
+  constructor(options) {
+    const dbPath = options?.path ?? "./data/cequre-kv.sqlite";
+    if (dbPath !== ":memory:") {
+      const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
+      if (dir) {
+        try {
+          const { mkdirSync } = __require("fs");
+          mkdirSync(dir, { recursive: true });
+        } catch {}
+      }
+    }
+    this.db = new Database(dbPath);
+    this.db.run("PRAGMA journal_mode = WAL");
+    this.db.run("PRAGMA synchronous = NORMAL");
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS kv (
+        key   TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        expires_at INTEGER
+      )
+    `);
+    this.db.run(`CREATE INDEX IF NOT EXISTS idx_kv_expires ON kv(expires_at) WHERE expires_at IS NOT NULL`);
+    this.stmtGet = this.db.prepare("SELECT value FROM kv WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)");
+    this.stmtSet = this.db.prepare("INSERT OR REPLACE INTO kv (key, value, expires_at) VALUES (?, ?, ?)");
+    this.stmtDel = this.db.prepare("DELETE FROM kv WHERE key = ?");
+    this.stmtHas = this.db.prepare("SELECT 1 FROM kv WHERE key = ? AND (expires_at IS NULL OR expires_at > ?) LIMIT 1");
+    this.stmtKeys = this.db.prepare("SELECT key FROM kv WHERE expires_at IS NULL OR expires_at > ?");
+    this.stmtKeysPrefix = this.db.prepare("SELECT key FROM kv WHERE key LIKE ? AND (expires_at IS NULL OR expires_at > ?)");
+    this.stmtClear = this.db.prepare("DELETE FROM kv");
+    this.stmtCleanup = this.db.prepare("DELETE FROM kv WHERE expires_at IS NOT NULL AND expires_at <= ?");
+    this.stmtCount = this.db.prepare("SELECT COUNT(*) as count FROM kv WHERE expires_at IS NULL OR expires_at > ?");
+    getLog2().debug({ path: dbPath }, "SQLite KV adapter initialized");
+  }
+  async get(key) {
+    const now = Date.now();
+    const row = this.stmtGet.get(key, now);
+    if (!row)
+      return null;
+    try {
+      return JSON.parse(row.value);
+    } catch {
+      return row.value;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    for (const key of keys) {
+      const val = await this.get(key);
+      if (val !== null)
+        result.set(key, val);
+    }
+    return result;
+  }
+  async set(key, value, ttl) {
+    const serialized = JSON.stringify(value);
+    const expiresAt = ttl != null ? Date.now() + ttl * 1000 : null;
+    this.stmtSet.run(key, serialized, expiresAt);
+  }
+  async setMany(entries) {
+    const tx = this.db.transaction(() => {
+      for (const { key, value, ttl } of entries) {
+        const serialized = JSON.stringify(value);
+        const expiresAt = ttl != null ? Date.now() + ttl * 1000 : null;
+        this.stmtSet.run(key, serialized, expiresAt);
+      }
+    });
+    tx();
+  }
+  async delete(key) {
+    const result = this.stmtDel.run(key);
+    return result.changes > 0;
+  }
+  async deleteMany(keys) {
+    let deleted = 0;
+    const tx = this.db.transaction(() => {
+      for (const key of keys) {
+        const result = this.stmtDel.run(key);
+        deleted += result.changes;
+      }
+    });
+    tx();
+    return deleted;
+  }
+  async has(key) {
+    const now = Date.now();
+    return this.stmtHas.get(key, now) !== null;
+  }
+  async keys(prefix) {
+    const now = Date.now();
+    const rows = prefix ? this.stmtKeysPrefix.all(`${prefix}%`, now) : this.stmtKeys.all(now);
+    return rows.map((r) => r.key);
+  }
+  async count() {
+    const now = Date.now();
+    const row = this.stmtCount.get(now);
+    return row.count;
+  }
+  async clear() {
+    this.stmtClear.run();
+  }
+  cleanup() {
+    const now = Date.now();
+    const result = this.stmtCleanup.run(now);
+    if (result.changes > 0) {
+      getLog2().debug({ removed: result.changes }, "KV expired entries cleaned up (SQLite)");
+    }
+    return result.changes;
+  }
+  close() {
+    this.db.close();
+    getLog2().debug("SQLite KV adapter closed");
+  }
+}
+var log2 = null;
+var init_sqlite = () => {};
+
+// adapters/bun/bun-redis-cache.ts
+function getLog3() {
+  if (!_log)
+    _log = (init_logger(), __toCommonJS(exports_logger)).createLogger("kv-redis");
+  return _log;
+}
+
+class RedisAdapter {
+  redis;
+  constructor(options) {
+    this.redis = Bun.redis;
+    if (options?.url) {
+      const parsed = new URL(options.url);
+      const hostname = parsed.hostname;
+      const port = parseInt(parsed.port || "6379", 10);
+      if (hostname !== "localhost" || port !== 6379) {
+        getLog3().warn({ url: options.url }, "Custom Redis URL detected. Set REDIS_URL env var for Bun.redis to connect to non-default host.");
+      }
+    }
+    getLog3().debug("Redis KV adapter initialized (Bun.redis)");
+  }
+  async get(key) {
+    const value = await this.redis.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    if (keys.length === 0)
+      return result;
+    const values = await this.redis.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.redis.setex(key, ttl, serialized);
+    } else {
+      await this.redis.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.redis.del(key);
+    return deleted > 0;
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0)
+      return 0;
+    return await this.redis.del(...keys);
+  }
+  async has(key) {
+    const exists = await this.redis.exists(key);
+    return exists > 0;
+  }
+  async keys(prefix) {
+    if (!prefix) {
+      return await this.redis.keys("*");
+    }
+    return await this.redis.keys(`${prefix}*`);
+  }
+  async count() {
+    return await this.redis.dbsize();
+  }
+  async clear() {
+    await this.redis.flushdb();
+  }
+  cleanup() {
+    return 0;
+  }
+  close() {
+    getLog3().debug("Redis KV adapter closed (Bun.redis singleton \u2014 connection managed by runtime)");
+  }
+}
+var _log = null;
+var init_bun_redis_cache = () => {};
+
+// shared/utils/kv/types.ts
+var init_types = () => {};
+
+// shared/utils/kv/index.ts
+class CequreKV {
+  adapter;
+  cleanupTimer = null;
+  isCleanupNative = false;
+  constructor(options = {}) {
+    const driver = options.driver ?? "sqlite";
+    if (driver === "memory") {
+      this.adapter = new MemoryAdapter;
+      this.isCleanupNative = false;
+    } else if (driver === "redis") {
+      this.adapter = new RedisAdapter(options.redis);
+      this.isCleanupNative = true;
+    } else {
+      this.adapter = new SQLiteAdapter(options.sqlite);
+      this.isCleanupNative = false;
+    }
+    if (!this.isCleanupNative) {
+      const interval = options.cleanupInterval ?? 60000;
+      if (interval > 0) {
+        this.cleanupTimer = setInterval(() => this.cleanup(), interval);
+        if (this.cleanupTimer && typeof this.cleanupTimer === "object" && "unref" in this.cleanupTimer) {
+          this.cleanupTimer.unref();
+        }
+      }
+    }
+  }
+  async get(key) {
+    return this.adapter.get(key);
+  }
+  async getMany(keys) {
+    return this.adapter.getMany(keys);
+  }
+  async set(key, value, ttl) {
+    return this.adapter.set(key, value, ttl);
+  }
+  async setMany(entries) {
+    return this.adapter.setMany(entries);
+  }
+  async delete(key) {
+    return this.adapter.delete(key);
+  }
+  async deleteMany(keys) {
+    return this.adapter.deleteMany(keys);
+  }
+  async has(key) {
+    return this.adapter.has(key);
+  }
+  async keys(prefix) {
+    return this.adapter.keys(prefix);
+  }
+  async count() {
+    return this.adapter.count();
+  }
+  async clear() {
+    return this.adapter.clear();
+  }
+  async cleanup() {
+    return this.adapter.cleanup();
+  }
+  async close() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    return this.adapter.close();
+  }
+}
+var init_kv = __esm(() => {
+  init_memory();
+  init_sqlite();
+  init_bun_redis_cache();
+  init_types();
+});
+
+// shared/utils/logger.ts
+var exports_logger = {};
+__export(exports_logger, {
+  logger: () => logger,
+  createLogger: () => createLogger,
+  CequreErrorLogs: () => CequreErrorLogs
+});
+import pino from "pino";
+import pretty from "pino-pretty";
+function getErrorKV() {
+  if (!kvStore) {
+    kvStore = new CequreKV({ sqlite: { path: "./data/cequre-error-kv.sqlite" } });
+  }
+  return kvStore;
+}
+function createStream() {
+  if (Bun.env.NODE_ENV !== "production" && Bun.env.NODE_ENV !== "test") {
+    return pretty({
+      colorize: true,
+      translateTime: "yyyy-mm-dd HH:MM:ss.l",
+      ignore: "pid,hostname,component,count,output,url",
+      customColors: "info:bgBlue,error:bgRed,warn:bgYellow",
+      messageFormat: (log3, messageKey) => {
+        const msg = log3[messageKey];
+        if (log3.level === 40)
+          return `\x1B[33m${msg}\x1B[0m`;
+        if (log3.level >= 50)
+          return `\x1B[31m${msg}\x1B[0m`;
+        return msg;
+      }
+    });
+  }
+  return;
+}
+function storeErrorToKV(obj, msg) {
+  if (ERROR_LOG_KV) {
+    const err = obj && typeof obj === "object" && "err" in obj ? obj.err : obj;
+    const logData = {
+      level: 50,
+      time: Date.now(),
+      msg,
+      err
+    };
+    const key = `error:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+    getErrorKV().set(key, JSON.stringify(logData)).catch(() => {});
+  }
+}
+
+class CequreErrorLogs {
+  static async get(options = {}) {
+    const { limit = 100, since } = options;
+    const kv = getErrorKV();
+    const allKeys = await kv.keys("error:");
+    const errors = [];
+    for (const key of allKeys.slice(-limit)) {
+      const timestamp = parseInt(key.split(":")[1] || "0", 10);
+      if (since && timestamp < since)
+        continue;
+      const log3 = await kv.get(key);
+      if (log3) {
+        try {
+          const parsed = JSON.parse(log3);
+          errors.push({
+            key,
+            timestamp,
+            level: parsed.level === 50 ? "error" : parsed.level === 60 ? "fatal" : "error",
+            message: parsed.msg || parsed.message || "",
+            error: parsed.err?.message,
+            stack: parsed.err?.stack
+          });
+        } catch {
+          errors.push({ key, timestamp, level: "error", message: log3 });
+        }
+      }
+    }
+    return errors.sort((a, b) => b.timestamp - a.timestamp);
+  }
+  static async count() {
+    const kv = getErrorKV();
+    const keys = await kv.keys("error:");
+    return keys.length;
+  }
+  static async clear() {
+    const kv = getErrorKV();
+    const keys = await kv.keys("error:");
+    await kv.deleteMany(keys);
+  }
+}
+function createLogger(component) {
+  if (!logger) {
+    return new Proxy({}, {
+      get(target, prop) {
+        if (!logger)
+          return () => {};
+        const child = logger.child({ component });
+        const val = child[prop];
+        return typeof val === "function" ? val.bind(child) : val;
+      }
+    });
+  }
+  return logger.child({ component });
+}
+var LOG_LEVEL, ERROR_LOG_KV, kvStore = null, consoleStream, logger;
+var init_logger = __esm(() => {
+  init_kv();
+  LOG_LEVEL = Bun.env.CEQURE_LOG_LEVEL || Bun.env.LOG_LEVEL || (Bun.env.NODE_ENV === "test" ? "silent" : "info");
+  ERROR_LOG_KV = Bun.env.CEQURE_ERROR_LOG_KV === "true";
+  consoleStream = createStream();
+  logger = consoleStream ? pino({ name: "cequre", level: LOG_LEVEL }, consoleStream) : pino({ name: "cequre", level: LOG_LEVEL });
+  if (ERROR_LOG_KV) {
+    const loggerWithErrorStorage = logger;
+    const originalError = loggerWithErrorStorage.error.bind(logger);
+    loggerWithErrorStorage.error = (objOrMsg, msgOrFn, ...args) => {
+      const msg = typeof msgOrFn === "string" ? msgOrFn : typeof objOrMsg === "string" ? objOrMsg : String(objOrMsg);
+      storeErrorToKV(objOrMsg, msg);
+      return originalError(objOrMsg, msgOrFn, ...args);
+    };
+  }
+});
+
+// shared/utils/queue-manager.ts
+import { Queue as BullQueue, Worker as BullWorker, QueueEvents as BullQueueEvents } from "bullmq";
+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()
+    });
+    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) => {
+      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()
+    });
+    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 closeAll = async (items, label) => {
+      await Promise.all(items.map(async (item) => {
+        try {
+          if (item.close)
+            await item.close();
+          else if (item.disconnect)
+            await item.disconnect();
+        } catch (err) {
+          logger.error(err, `[QueueManager] Error closing ${label}`);
+        }
+      }));
+    };
+    await closeAll(Array.from(this.workers.values()), "worker");
+    await closeAll(Array.from(this.queueEvents.values()), "queue events");
+    await closeAll(Array.from(this.queues.values()), "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 };