@cequrebackends/cequre-ts 0.13.0 → 0.15.0

package/dist/index-z2xccrdm.js

@@ -0,0 +1,203 @@
+// @bun
+import {
+  CequreError
+} from "./index-qzzg2p5r.js";
+import {
+  init_logger,
+  logger
+} from "./index-6vf0r9nh.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.js

@@ -22,34 +22,38 @@ import {
   sqlLiteral,
   validateCreate,
   validateUpdate
-} from "./index-kyvy0s1x.js";
+} from "./index-6qbca8zn.js";
 import {
   CequreStreamMedia,
   methodNotAllowed,
   notFound,
   toResponse
 } from "./index-mfqj7cwr.js";
+import {
+  CequreQueueManager
+} from "./index-z2xccrdm.js";
+import {
+  CequreError,
+  buildErrorResponse,
+  extractPathname,
+  getConstraintErrorMessage,
+  getConstraintErrorStatus,
+  parseConstraintError,
+  toErrorResponse
+} from "./index-qzzg2p5r.js";
 import {
   CequreErrorLogs,
   CequreKV,
-  CequreQueueManager,
   createLogger,
   init_kv,
   init_logger,
   logger
-} from "./index-c3vh32en.js";
+} from "./index-6vf0r9nh.js";
 import {
-  CequreError,
   __require,
   __toCommonJS,
-  buildErrorResponse,
-  extractPathname,
-  getConstraintErrorMessage,
-  getConstraintErrorStatus,
-  parseConstraintError,
-  toErrorResponse,
   ulid
-} from "./index-17yswtmg.js";
+} from "./index-cpw1bjf1.js";
 
 // shared/main/sse.ts
 var encoder = new TextEncoder;
@@ -2836,8 +2840,7 @@ class CequreRuntime {
       return toErrorResponse(err, req, this.adapter);
     }
   }
-  async start(options = {}) {
-    if (false) {}
+  async init() {
     for (const plugin of this.plugins) {
       if (plugin.onInit) {
         await plugin.onInit(this);
@@ -2862,6 +2865,10 @@ class CequreRuntime {
     }
     await this.syncDatabaseSchema();
     await this.buildRoutes();
+  }
+  async start(options = {}) {
+    if (false) {}
+    await this.init();
     this.queue.startWorker();
     if (process.env.CEQURE_CLI_GENERATE) {
       const { generateTypeScriptClientSDK: generateTypeScriptClientSDK2 } = (init_sdk(), __toCommonJS(exports_sdk));
@@ -3076,7 +3083,7 @@ ${r}${b}                |_|               ${reset}
 `;
     if (!process.env.CEQURE_DEV) {
       console.log(banner);
-    } else {
+    } else if (process.env.CEQURE_VITE_MODE !== "1") {
       const p = server ? server.port : options.port;
       console.log(`\uD83D\uDE80 Cequre API Framework started gracefully on port ${p}`);
     }

package/dist/shared/core/index.js

@@ -19,10 +19,11 @@ import {
   sqlLiteral,
   validateCreate,
   validateUpdate
-} from "../../index-kyvy0s1x.js";
+} from "../../index-6qbca8zn.js";
+import"../../index-qzzg2p5r.js";
 import {
   ulid
-} from "../../index-17yswtmg.js";
+} from "../../index-cpw1bjf1.js";
 export {
   validateUpdate,
   validateCreate,

package/dist/shared/main/runtime.d.ts

@@ -24,9 +24,9 @@ export interface CequreConfig {
     plugins?: CequrePlugin[];
     email?: import("../core/types").EmailConfig;
     streamStore?: DurableStreamStore;
-    /** KV store config for rate limiter. Defaults to memory (single-instance). Use redis for multi-instance. */
+    /** KV store config for rate limiter. Defaults to memory (single-instance). Use redis for multi-instance. Use upstash for serverless. */
     kv?: {
-        driver: "memory" | "sqlite" | "redis";
+        driver: "memory" | "sqlite" | "redis" | "upstash";
         redis?: {
             host?: string;
             port?: number;
@@ -35,13 +35,17 @@ export interface CequreConfig {
         sqlite?: {
             path?: string;
         };
+        upstash?: {
+            url?: string;
+            token?: string;
+        };
     };
     serverProvider?: import("../core/types").ServerProvider;
     cronProvider?: import("../core/types").CronProvider;
     realtimeProvider?: import("../core/types").RealtimeProvider;
 }
 import { CequreDurableQueue } from "../utils/durable-queue";
-export declare class CequreRuntime<TCollections extends Record<string, any> = Record<string, any>> {
+export declare class CequreRuntime<TCollections extends Record<string, any> = Record<string, any>, TUser = AuthUser> {
     schema: CequreAST;
     adapter: CequreAdapter;
     router: CequreRouter<TCollections>;
@@ -181,6 +185,15 @@ export declare class CequreRuntime<TCollections extends Record<string, any> = Re
      */
     cron(name: string, schedule: string, handler: (app: CequreRuntime<TCollections>) => unknown): void;
     fetch(req: Request): Promise<Response>;
+    /**
+     * Initialize the runtime without starting a server. Used by serverless
+     * platforms (Vercel, Cloudflare) where the platform handles invocation.
+     * Runs: plugin init → adapter connect → schema sync → route building.
+     * Does NOT start: server, queue worker, cron scheduler, graceful shutdown.
+     *
+     * After init(), call `fetch(req)` to handle individual requests.
+     */
+    init(): Promise<void>;
     start(options?: {
         port?: number;
         drainTimeoutMs?: number;

package/dist/shared/utils/kv/types.d.ts

@@ -1,4 +1,4 @@
-export type KVDriverType = "memory" | "sqlite" | "redis";
+export type KVDriverType = "memory" | "sqlite" | "redis" | "upstash";
 export interface KVOptions {
     /** The storage driver to use. Default: "sqlite" */
     driver?: KVDriverType;
@@ -17,6 +17,13 @@ export interface KVOptions {
         /** Redis connection URL. Default: "redis://localhost:6379" */
         url?: string;
     };
+    /** Configuration for the Upstash Redis driver (HTTP-based, serverless) */
+    upstash?: {
+        /** Upstash Redis REST URL */
+        url?: string;
+        /** Upstash Redis REST token */
+        token?: string;
+    };
 }
 export interface KVAdapter {
     get<T>(key: string): Promise<T | null> | T | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cequrebackends/cequre-ts",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "The Cequre Universal Runtime Engine",
   "type": "module",
   "main": "./dist/index.js",
@@ -26,6 +26,11 @@
       "types": "./dist/adapters/node/index.d.ts",
       "import": "./dist/adapters/node/index.js",
       "default": "./dist/adapters/node/index.js"
+    },
+    "./adapters/vercel": {
+      "types": "./dist/adapters/vercel/index.d.ts",
+      "import": "./dist/adapters/vercel/index.js",
+      "default": "./dist/adapters/vercel/index.js"
     }
   },
   "files": [
@@ -40,24 +45,24 @@
     "url": "https://github.com/cequrebackends/cequre.git"
   },
   "scripts": {
-    "build": "rm -rf dist && bun build ./index.ts ./shared/core/index.ts ./adapters/bun/index.ts ./adapters/node/index.ts --outdir ./dist --target bun --packages external --splitting --format esm && tsc --emitDeclarationOnly"
+    "build": "rm -rf dist && bun build ./index.ts ./shared/core/index.ts ./adapters/bun/index.ts ./adapters/node/index.ts ./adapters/vercel/index.ts --outdir ./dist --target bun --packages external --splitting --format esm && tsc --emitDeclarationOnly"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.49",
-    "bullmq": "^5.79.2",
-    "effect": "^3.21.4",
-    "ioredis": "^5.4.1",
-    "jose": "^6.2.3",
-    "node-cron": "^3.0.3",
+    "@sinclair/typebox": "^0.34.52",
+    "bullmq": "^5.81.2",
+    "effect": "^3.22.0",
+    "ioredis": "^5.11.1",
+    "jose": "^6.2.4",
+    "node-cron": "^4.6.0",
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
-    "ws": "^8.18.0"
+    "ws": "^8.21.1"
   },
   "devDependencies": {
-    "@types/node": "^20.12.0",
+    "@types/node": "^26.1.1",
     "@types/node-cron": "^3.0.11",
-    "@types/ws": "^8.5.12",
+    "@types/ws": "^8.18.1",
     "openapi-typescript": "^7.13.0",
-    "typescript": "^6.0.3"
+    "typescript": "^7.0.2"
   }
 }