@cequrebackends/cequre-ts 0.12.2 → 0.14.0

package/dist/adapters/bun/index.js

@@ -14,16 +14,20 @@ import {
   toResponse
 } from "../../index-mfqj7cwr.js";
 import {
-  CequreQueueManager,
+  CequreQueueManager
+} from "../../index-7xxm1add.js";
+import {
+  CequreError
+} from "../../index-qzzg2p5r.js";
+import {
   RedisAdapter,
   init_bun_redis_cache,
   init_logger,
   logger
-} from "../../index-rf1kdn5b.js";
+} from "../../index-8bhn0nb4.js";
 import {
-  CequreError,
   ulid
-} from "../../index-17yswtmg.js";
+} from "../../index-cpw1bjf1.js";
 
 // adapters/bun/bun-server.ts
 class BunServerProvider {
@@ -48,7 +52,9 @@ class BunServerProvider {
       websocket: config.websocket,
       fetch: config.fetch
     });
-    console.log(`\uD83D\uDE80 Cequre starting on http://${this.server.hostname}:${this.server.port}`);
+    if (process.env.CEQURE_VITE_MODE !== "1") {
+      console.log(`\uD83D\uDE80 Cequre starting on http://${this.server.hostname}:${this.server.port}`);
+    }
     return this.server;
   }
   async stop() {

package/dist/adapters/node/index.js

@@ -1,15 +1,19 @@
 // @bun
 import {
-  CequreQueueManager,
+  CequreQueueManager
+} from "../../index-7xxm1add.js";
+import {
+  CequreError
+} from "../../index-qzzg2p5r.js";
+import {
   exports_logger,
   init_logger,
   logger
-} from "../../index-rf1kdn5b.js";
+} from "../../index-8bhn0nb4.js";
 import {
-  CequreError,
   __toCommonJS,
   ulid
-} from "../../index-17yswtmg.js";
+} from "../../index-cpw1bjf1.js";
 
 // adapters/node/node-server.ts
 import http from "http";
@@ -34,7 +38,7 @@ class NodeServerProvider {
       }
     }
     const fetchHandler = async (req) => {
-      const url = new URL(req.url);
+      const url = new URL(req.url, "http://localhost");
       let handler = config.routes?.[url.pathname]?.[req.method] || config.routes?.[url.pathname]?.["ALL"];
       if (!handler && routeMatchers.length > 0) {
         for (const matcher of routeMatchers) {
@@ -91,7 +95,9 @@ class NodeServerProvider {
         socket.destroy();
       });
     });
-    console.log(`\uD83D\uDE80 Cequre starting on http://${config.hostname || "localhost"}:${port}`);
+    if (process.env.CEQURE_VITE_MODE !== "1") {
+      console.log(`\uD83D\uDE80 Cequre starting on http://${config.hostname || "localhost"}:${port}`);
+    }
     const serverObj = this.server;
     serverObj.stop = this.stop.bind(this);
     return serverObj;
@@ -567,7 +573,14 @@ function getLog() {
 class RedisAdapter {
   redis;
   constructor(options) {
-    this.redis = new Redis(options?.url || process.env.REDIS_URL || "redis://localhost:6379");
+    this.redis = new Redis(options?.url || process.env.REDIS_URL || "redis://localhost:6379", {
+      maxRetriesPerRequest: 1,
+      retryStrategy(times) {
+        if (times > 3)
+          return null;
+        return Math.min(times * 100, 1000);
+      }
+    });
     getLog().debug("Redis KV adapter initialized (ioredis)");
   }
   async get(key) {

package/dist/adapters/vercel/index.d.ts

@@ -0,0 +1,38 @@
+export * from "./vercel-server";
+export * from "./vercel-cron";
+export * from "./vercel-sse";
+export * from "./vercel-storage";
+export * from "./upstash-kv";
+export * from "./vercel-queue";
+export * from "./vercel-response";
+export * from "./vercel-media";
+export * from "./vercel-websocket";
+import type { CequreConfig } from "../../shared/main/runtime";
+/**
+ * Vercel adapter for Cequre — configures the runtime for Vercel serverless.
+ *
+ * - ServerProvider: Exports fetch handler (no TCP server)
+ * - CronProvider: Webhook-based (Vercel Cron triggers)
+ * - StorageProvider: Vercel Blob (HTTP-based)
+ * - KV: Upstash Redis (HTTP-based, no TCP)
+ * - Realtime: SSE (no WebSocket on serverless)
+ *
+ * @example
+ * ```ts
+ * import { createCequre } from "./cequre/_generated/server";
+ * import { withVercel } from "@cequrebackends/cequre-ts/adapters/vercel";
+ * import { turso } from "@cequrebackends/plugin-turso";
+ *
+ * const app = createCequre(withVercel({
+ *   adapter: turso({ url: process.env.DATABASE_URL!, authToken: process.env.DATABASE_AUTH_TOKEN! }),
+ *   kv: { driver: "upstash" },
+ *   plugins: [defaultSecurity()],
+ * }));
+ *
+ * await app.init();
+ * export default async function handler(req: Request) {
+ *   return app.fetch(req);
+ * }
+ * ```
+ */
+export declare function withVercel(config: CequreConfig): CequreConfig;

package/dist/adapters/vercel/index.js

@@ -0,0 +1,305 @@
+// @bun
+import {
+  UpstashKVAdapter,
+  init_logger,
+  init_upstash_kv,
+  logger
+} from "../../index-8bhn0nb4.js";
+import {
+  ulid
+} from "../../index-cpw1bjf1.js";
+
+// adapters/vercel/vercel-server.ts
+class VercelServerProvider {
+  fetchHandler = null;
+  routeHandlers = {};
+  start(config) {
+    this.fetchHandler = config.fetch;
+    this.routeHandlers = config.routes || {};
+    return {
+      port: config.port || 3000,
+      hostname: config.hostname || "vercel",
+      stop: () => {},
+      stopImmediate: () => {}
+    };
+  }
+  getHandler() {
+    return this.fetchHandler;
+  }
+  async stop() {}
+}
+// adapters/vercel/vercel-cron.ts
+init_logger();
+
+class VercelCronProvider {
+  jobs = new Map;
+  registerJob(name, schedule, handler) {
+    if (this.jobs.has(name)) {
+      logger.warn(`[Cequre Cron (Vercel)] Job "${name}" already registered.`);
+      return;
+    }
+    this.jobs.set(name, { name, schedule, handler });
+    logger.info(`[Cequre Cron (Vercel)] Registered "${name}" with schedule "${schedule}". ` + `Add to vercel.json crons: { "path": "/_cron/${name}", "schedule": "${schedule}" }`);
+  }
+  async execute(name) {
+    const job = this.jobs.get(name);
+    if (!job) {
+      throw new Error(`[Cequre Cron (Vercel)] Job "${name}" not found.`);
+    }
+    try {
+      await job.handler();
+    } catch (err) {
+      logger.error(err, `[Cequre Cron (Vercel)] Job "${name}" failed:`);
+      throw err;
+    }
+  }
+  getCronConfigs() {
+    return Array.from(this.jobs.values()).map((job) => ({
+      path: `/_cron/${job.name}`,
+      schedule: job.schedule
+    }));
+  }
+  startAll() {}
+  stopAll() {
+    this.jobs.clear();
+  }
+  stop(name) {
+    return this.jobs.delete(name);
+  }
+  async list() {
+    return Array.from(this.jobs.keys());
+  }
+}
+// adapters/vercel/vercel-sse.ts
+class VercelSSEProvider {
+  channels = new Map;
+  publish(topic, data) {
+    const listeners = this.channels.get(topic);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch {}
+      }
+    }
+  }
+  broadcast(data) {
+    for (const listeners of this.channels.values()) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch {}
+      }
+    }
+  }
+  subscribe(topic, listener) {
+    if (!this.channels.has(topic)) {
+      this.channels.set(topic, new Set);
+    }
+    this.channels.get(topic).add(listener);
+    return () => {
+      this.channels.get(topic)?.delete(listener);
+    };
+  }
+  createSSEResponse(topic) {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        const unsubscribe = this.subscribe(topic, (data) => {
+          controller.enqueue(`data: ${JSON.stringify(data)}
+
+`);
+        });
+        controller._unsubscribe = unsubscribe;
+      },
+      cancel: (controller) => {
+        if (controller._unsubscribe) {
+          controller._unsubscribe();
+        }
+      }
+    });
+    return new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    });
+  }
+}
+// adapters/vercel/vercel-storage.ts
+class VercelStorageProvider {
+  token;
+  constructor() {
+    this.token = process.env.BLOB_READ_WRITE_TOKEN || "";
+    if (!this.token) {
+      console.warn("[Cequre Storage (Vercel)] BLOB_READ_WRITE_TOKEN not set \u2014 file uploads will fail.");
+    }
+  }
+  async saveFile(file, options) {
+    const ext = file.name ? file.name.substring(file.name.lastIndexOf(".")) : "";
+    const safeName = options?.filename ? options.filename : `${ulid()}${ext}`;
+    const buffer = await file.arrayBuffer();
+    const res = await fetch("https://blob.vercel.com/", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        pathname: safeName,
+        payload: Array.from(new Uint8Array(buffer))
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`Vercel Blob upload failed: ${res.status} ${await res.text()}`);
+    }
+    const blob = await res.json();
+    return {
+      filename: safeName,
+      originalName: file.name || "upload",
+      mimetype: file.type || "application/octet-stream",
+      size: file.size,
+      url: blob.url
+    };
+  }
+  async deleteFile(filename) {
+    const res = await fetch("https://blob.vercel.com/", {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ pathname: filename })
+    });
+    if (!res.ok && res.status !== 404) {
+      console.error(`[Cequre Storage (Vercel)] Failed to delete ${filename}:`, await res.text());
+    }
+  }
+}
+
+// adapters/vercel/index.ts
+init_upstash_kv();
+
+// adapters/vercel/vercel-queue.ts
+init_logger();
+
+class VercelQueueProvider {
+  token;
+  workers = new Map;
+  baseUrl;
+  constructor() {
+    this.token = process.env.QSTASH_TOKEN || "";
+    this.baseUrl = process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : "";
+    if (!this.token) {
+      console.warn("[Cequre Queue (Vercel)] QSTASH_TOKEN not set \u2014 enqueue will fail.");
+    }
+  }
+  async enqueue(queueName, jobName, data, options) {
+    if (!this.token) {
+      throw new Error("[Cequre Queue (Vercel)] QSTASH_TOKEN not configured.");
+    }
+    const callbackUrl = `${this.baseUrl}/_queue/${queueName}`;
+    const res = await fetch("https://qstash.upstash.io/v2/publish/" + encodeURIComponent(callbackUrl), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: jobName,
+        data,
+        ...options
+      })
+    });
+    if (!res.ok) {
+      throw new Error(`QStash enqueue failed: ${res.status} ${await res.text()}`);
+    }
+    const result = await res.json();
+    return result.messageId;
+  }
+  registerWorker(queueName, handler) {
+    this.workers.set(queueName, handler);
+    logger.info(`[Cequre Queue (Vercel)] Worker registered for queue "${queueName}". Route: /_queue/${queueName}`);
+  }
+  async processDelivery(queueName, body) {
+    const handler = this.workers.get(queueName);
+    if (!handler) {
+      throw new Error(`[Cequre Queue (Vercel)] No worker for queue "${queueName}".`);
+    }
+    const job = {
+      id: body.messageId || body.id || "",
+      name: body.name || "default",
+      data: body.data,
+      timestamp: Date.now()
+    };
+    await handler(job);
+  }
+  startWorkers() {}
+}
+// adapters/vercel/vercel-response.ts
+function methodNotAllowed(method) {
+  return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+    status: 405,
+    headers: { "Content-Type": "application/json", Allow: method || "" }
+  });
+}
+function notFound() {
+  return new Response(JSON.stringify({ error: "Not Found" }), {
+    status: 404,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+function toResponse(result) {
+  if (result instanceof Response)
+    return result;
+  if (result === undefined || result === null) {
+    return new Response(null, { status: 204 });
+  }
+  return new Response(JSON.stringify(result), {
+    headers: { "Content-Type": "application/json" }
+  });
+}
+// adapters/vercel/vercel-media.ts
+async function CequreStreamMedia(request, filename, options) {
+  const blobUrl = filename.startsWith("http") ? filename : `https://blob.vercel.com/${filename}`;
+  if (request.headers.get("range")) {
+    const blobRes = await fetch(blobUrl, {
+      headers: { Range: request.headers.get("range") }
+    });
+    return new Response(blobRes.body, {
+      status: blobRes.status,
+      headers: blobRes.headers
+    });
+  }
+  return new Response(null, {
+    status: 302,
+    headers: { Location: blobUrl }
+  });
+}
+// adapters/vercel/vercel-websocket.ts
+var CequreWebsocket = undefined;
+// adapters/vercel/index.ts
+function withVercel(config) {
+  return {
+    ...config,
+    serverProvider: config.serverProvider || new VercelServerProvider,
+    cronProvider: config.cronProvider || new VercelCronProvider,
+    realtimeProvider: config.realtimeProvider || undefined,
+    storageProvider: config.storageProvider || new VercelStorageProvider,
+    kv: config.kv || { driver: "upstash" }
+  };
+}
+export {
+  withVercel,
+  toResponse,
+  notFound,
+  methodNotAllowed,
+  VercelStorageProvider,
+  VercelServerProvider,
+  VercelSSEProvider,
+  VercelQueueProvider,
+  VercelCronProvider,
+  UpstashKVAdapter,
+  CequreWebsocket,
+  CequreStreamMedia
+};

package/dist/adapters/vercel/upstash-kv.d.ts

@@ -0,0 +1,41 @@
+import type { KVAdapter } from "../../shared/utils/kv/types";
+/**
+ * Upstash Redis KV adapter — HTTP-based Redis for serverless.
+ *
+ * Upstash provides a REST API (no TCP connections) which works on
+ * Vercel serverless functions, Cloudflare Workers, and Edge runtime.
+ *
+ * Requires: UPSTASH_REDIS_REST_URL and UPSTASH_REDIS_REST_TOKEN
+ * environment variables (or pass via constructor).
+ *
+ * @example
+ * ```ts
+ * import { CequreKV } from "@cequrebackends/cequre-ts";
+ * const kv = new CequreKV({ driver: "upstash" });
+ * ```
+ */
+export declare class UpstashKVAdapter implements KVAdapter {
+    private url;
+    private token;
+    constructor(options?: {
+        url?: string;
+        token?: string;
+    });
+    private command;
+    get<T = unknown>(key: string): Promise<T | null>;
+    getMany<T = unknown>(keys: string[]): Promise<Map<string, T>>;
+    set(key: string, value: unknown, ttl?: number): Promise<void>;
+    setMany(entries: Array<{
+        key: string;
+        value: unknown;
+        ttl?: number;
+    }>): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<number>;
+    has(key: string): Promise<boolean>;
+    keys(prefix?: string): Promise<string[]>;
+    count(): Promise<number>;
+    clear(): Promise<void>;
+    cleanup(): number;
+    close(): void;
+}

package/dist/adapters/vercel/vercel-cron.d.ts

@@ -0,0 +1,34 @@
+import type { CronProvider } from "../../shared/core/types";
+/**
+ * VercelCronProvider — Vercel Cron triggers are HTTP webhooks.
+ *
+ * registerJob() stores the job metadata. The generated app exposes
+ * a `/_cron/:name` route that Vercel Cron calls on schedule.
+ *
+ * vercel.json declares the cron schedules:
+ *   "crons": [
+ *     { "path": "/_cron/cleanup", "schedule": "0 * * * *" }
+ *   ]
+ *
+ * startAll() is a no-op — Vercel triggers externally.
+ * execute(name) is called by the /_cron/:name route handler.
+ */
+export declare class VercelCronProvider implements CronProvider {
+    private jobs;
+    registerJob(name: string, schedule: string, handler: () => void | Promise<void>): void;
+    /**
+     * Execute a cron job by name. Called by the /_cron/:name route handler.
+     */
+    execute(name: string): Promise<void>;
+    /**
+     * Returns all registered cron jobs for vercel.json generation.
+     */
+    getCronConfigs(): Array<{
+        path: string;
+        schedule: string;
+    }>;
+    startAll(): void;
+    stopAll(): void;
+    stop(name: string): boolean;
+    list(): Promise<string[]>;
+}

package/dist/adapters/vercel/vercel-media.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Vercel media streaming helper.
+ *
+ * On Vercel, media is served from Vercel Blob (CDN-backed).
+ * Range requests are handled by Vercel's CDN layer.
+ */
+export declare function CequreStreamMedia(request: Request, filename: string, options?: {
+    provider?: string;
+    maxChunkSize?: number;
+}): Promise<Response>;

package/dist/adapters/vercel/vercel-queue.d.ts

@@ -0,0 +1,31 @@
+interface QueueJob {
+    id: string;
+    name: string;
+    data: any;
+    timestamp: number;
+}
+/**
+ * VercelQueueProvider — uses Upstash QStash for serverless queues.
+ *
+ * enqueue() sends an HTTP POST to QStash, which retries and calls
+ * the webhook URL on schedule. registerWorker() registers a handler
+ * that QStash calls via HTTP webhook.
+ *
+ * Requires: QSTASH_TOKEN environment variable.
+ *
+ * The generated app exposes `/_queue/:queueName` routes that QStash calls.
+ */
+export declare class VercelQueueProvider {
+    private token;
+    private workers;
+    private baseUrl;
+    constructor();
+    enqueue<T = any>(queueName: string, jobName: string, data: T, options?: any): Promise<string>;
+    registerWorker<T = any>(queueName: string, handler: (job: QueueJob) => Promise<void>): void;
+    /**
+     * Process a QStash webhook delivery. Called by the /_queue/:name route.
+     */
+    processDelivery(queueName: string, body: any): Promise<void>;
+    startWorkers(): void;
+}
+export {};

package/dist/adapters/vercel/vercel-response.d.ts

@@ -0,0 +1,4 @@
+export declare function methodNotAllowed(method?: string): Response;
+export declare function notFound(): Response;
+export declare function toResponse(result: any): Response;
+export type VercelRouteResult = Response | undefined;

package/dist/adapters/vercel/vercel-server.d.ts

@@ -0,0 +1,24 @@
+import type { ServerProvider, CequreServerConfig } from "../../shared/core/types";
+/**
+ * VercelServerProvider — does NOT start a TCP server.
+ * Instead, it stashes the fetch handler for the serverless entry point
+ * to export as `export default function handler(req)`.
+ *
+ * On Vercel, each invocation is a fresh function call. The runtime
+ * must be initialized once at module scope (cold start), then `fetch()`
+ * is called per request.
+ *
+ * The runtime's graceful shutdown hooks call server.stop(), which is a
+ * no-op on serverless — Vercel manages function lifecycle.
+ */
+export declare class VercelServerProvider implements ServerProvider {
+    private fetchHandler;
+    private routeHandlers;
+    start(config: CequreServerConfig): any;
+    /**
+     * Returns the fetch handler for the serverless entry point to export.
+     * Used by the generated index.ts: `export default async function handler(req) { return app.fetch(req) }`
+     */
+    getHandler(): ((req: Request, server?: any) => Promise<Response>) | null;
+    stop(): Promise<void>;
+}

package/dist/adapters/vercel/vercel-sse.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Vercel SSE (Server-Sent Events) realtime provider.
+ *
+ * Vercel serverless does NOT support WebSocket connections.
+ * For two-way realtime, use a third-party service (Pusher, Ably, PartyKit).
+ *
+ * SSE works on Vercel Edge Functions and Node.js serverless.
+ * Clients connect via EventSource: `new EventSource("/_sse/:channel")`.
+ */
+export declare class VercelSSEProvider {
+    private channels;
+    publish(topic: string, data: any): void;
+    broadcast(data: any): void;
+    subscribe(topic: string, listener: (data: any) => void): () => void;
+    /**
+     * Creates an SSE Response for a given channel.
+     * Used by the /_sse/:channel route handler.
+     */
+    createSSEResponse(topic: string): Response;
+}

package/dist/adapters/vercel/vercel-storage.d.ts

@@ -0,0 +1,23 @@
+import type { StorageProvider, UploadedFile } from "../../shared/core/types";
+/**
+ * VercelStorageProvider — uses Vercel Blob for file storage.
+ *
+ * Vercel serverless filesystem is read-only (except ephemeral /tmp).
+ * Vercel Blob provides HTTP-based object storage with CDN.
+ *
+ * Requires: BLOB_READ_WRITE_TOKEN environment variable.
+ *
+ * @example
+ * ```ts
+ * import { VercelStorageProvider } from "@cequrebackends/cequre-ts/adapters/vercel";
+ * const storage = new VercelStorageProvider();
+ * ```
+ */
+export declare class VercelStorageProvider implements StorageProvider {
+    private token;
+    constructor();
+    saveFile(file: File, options?: {
+        filename?: string;
+    }): Promise<UploadedFile>;
+    deleteFile(filename: string): Promise<void>;
+}

package/dist/adapters/vercel/vercel-websocket.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Vercel WebSocket stub.
+ *
+ * Vercel serverless does NOT support WebSocket connections.
+ * The websocket property is set to undefined in withVercel().
+ *
+ * For realtime, use SSE (VercelSSEProvider) or a third-party
+ * service (Pusher, Ably, PartyKit).
+ *
+ * This file exists for adapter file parity (8 files matching Bun/Node).
+ */
+export declare const CequreWebsocket: undefined;

package/dist/{index-kyvy0s1x.js → index-6qbca8zn.js}

@@ -1,10 +1,12 @@
 // @bun
 import {
-  CequreError,
+  CequreError
+} from "./index-qzzg2p5r.js";
+import {
   __esm,
   __export,
   __toCommonJS
-} from "./index-17yswtmg.js";
+} from "./index-cpw1bjf1.js";
 
 // shared/core/openapi.ts
 var exports_openapi = {};