@cequrebackends/cequre-ts 0.11.4

package/dist/adapters/bun/index.js

@@ -0,0 +1,547 @@
+// @bun
+import {
+  CequreStreamMedia,
+  UPGRADED,
+  empty,
+  error,
+  file,
+  json,
+  methodNotAllowed,
+  notFound,
+  redirect,
+  routeErrorToResponse,
+  stream,
+  toResponse
+} from "../../index-mfqj7cwr.js";
+import {
+  CequreQueueManager,
+  RedisAdapter,
+  init_bun_redis_cache,
+  init_logger,
+  logger
+} from "../../index-rf1kdn5b.js";
+import {
+  CequreError,
+  ulid
+} from "../../index-17yswtmg.js";
+
+// adapters/bun/bun-server.ts
+class BunServerProvider {
+  server;
+  start(config) {
+    const tls = config.tls;
+    let finalTls = tls;
+    if (tls && tls.cert && tls.key) {
+      finalTls = {
+        cert: Bun.file(tls.cert),
+        key: Bun.file(tls.key),
+        passphrase: tls.passphrase,
+        serverName: tls.serverName
+      };
+    }
+    this.server = Bun.serve({
+      port: config.port ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : 3000),
+      hostname: config.hostname,
+      tls: finalTls,
+      ...config.maxRequestBodySize ? { maxRequestBodySize: config.maxRequestBodySize } : {},
+      ...config.routes ? { routes: config.routes } : {},
+      fetch: config.fetch
+    });
+    console.log(`\uD83D\uDE80 Cequre starting on http://${this.server.hostname}:${this.server.port}`);
+    return this.server;
+  }
+  async stop() {
+    if (this.server) {
+      this.server.stop(true);
+    }
+  }
+}
+// adapters/bun/bun-cron.ts
+init_logger();
+
+class BunCronProvider {
+  localJobs = new Map;
+  useBullMQ = false;
+  constructor() {
+    try {
+      CequreQueueManager.getInstance();
+      this.useBullMQ = true;
+    } catch {
+      this.useBullMQ = false;
+    }
+  }
+  registerJob(name, schedule, handler) {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      qm.registerWorker("cequre_cron", async (job) => {
+        if (job.name === name) {
+          try {
+            await Promise.resolve(handler());
+          } catch (err) {
+            logger.error(err, `[Cequre Cron (BullMQ)] Job "${name}" failed:`);
+            throw new Error(String(err instanceof Error ? err.message : err));
+          }
+        }
+      }).catch((err) => {
+        logger.error(err, `[Cequre Cron (BullMQ)] Failed to register worker for "${name}":`);
+      });
+      qm.addJob("cequre_cron", name, {}, {
+        repeat: { pattern: schedule },
+        jobId: `cron_${name}`,
+        removeOnComplete: true,
+        removeOnFail: 100
+      }).catch((err) => {
+        logger.error(err, `[Cequre Cron (BullMQ)] Failed to register job "${name}":`);
+      });
+    } else {
+      if (this.localJobs.has(name)) {
+        throw CequreError.Conflict(`[Cequre Cron] A cron job with the name "${name}" is already registered.`);
+      }
+      const job = Bun.cron(schedule, async () => {
+        try {
+          await handler();
+        } catch (err) {
+          logger.error(err, `[Cequre Cron] Job "${name}" failed:`);
+        }
+      });
+      this.localJobs.set(name, job);
+    }
+  }
+  async stop(name) {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const repeatableJobs = await queue.getRepeatableJobs();
+      const job = repeatableJobs.find((j) => j.name === name);
+      if (job) {
+        await queue.removeRepeatableByKey(job.key);
+        return true;
+      }
+      return false;
+    } else {
+      const job = this.localJobs.get(name);
+      if (job && typeof job.stop === "function") {
+        job.stop();
+        this.localJobs.delete(name);
+        return true;
+      }
+      return false;
+    }
+  }
+  async stopAll() {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const repeatableJobs = await queue.getRepeatableJobs();
+      for (const job of repeatableJobs) {
+        await queue.removeRepeatableByKey(job.key);
+      }
+    } else {
+      for (const [name, job] of this.localJobs.entries()) {
+        if (typeof job.stop === "function") {
+          try {
+            job.stop();
+          } catch (e) {
+            logger.error(e, `[Cequre Cron] Error stopping job "${name}":`);
+          }
+        }
+      }
+      this.localJobs.clear();
+    }
+  }
+  async list() {
+    if (this.useBullMQ) {
+      const qm = CequreQueueManager.getInstance();
+      const queue = qm.getQueue("cequre_cron");
+      const jobs = await queue.getRepeatableJobs();
+      return jobs.map((j) => j.name);
+    } else {
+      return Array.from(this.localJobs.keys());
+    }
+  }
+  startAll() {}
+}
+// adapters/bun/bun-websocket.ts
+class WebSocketManager {
+  connections = new Map;
+  rooms = new Map;
+  connectionRooms = new Map;
+  metadata = new Map;
+  lastPong = new Map;
+  heartbeatTimer = null;
+  register(ws) {
+    this.connections.set(ws.id, ws);
+    this.connectionRooms.set(ws.id, new Set);
+    this.metadata.set(ws.id, {});
+    this.lastPong.set(ws.id, Date.now());
+  }
+  remove(wsOrId) {
+    const id = typeof wsOrId === "string" ? wsOrId : wsOrId.id;
+    for (const room of this.connectionRooms.get(id) ?? []) {
+      this.leaveRoom(id, room);
+    }
+    this.connections.delete(id);
+    this.connectionRooms.delete(id);
+    this.metadata.delete(id);
+    this.lastPong.delete(id);
+  }
+  pong(id) {
+    if (this.lastPong.has(id))
+      this.lastPong.set(id, Date.now());
+  }
+  startHeartbeat(intervalMs = 30000, timeoutMs = 1e4) {
+    if (this.heartbeatTimer !== null)
+      return;
+    const deadline = intervalMs + timeoutMs;
+    this.heartbeatTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, lastSeen] of this.lastPong) {
+        if (now - lastSeen > deadline)
+          this.remove(id);
+      }
+      for (const ws of this.connections.values()) {
+        ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, intervalMs);
+    if (this.heartbeatTimer.unref)
+      this.heartbeatTimer.unref();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer)
+      clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  joinRoom(id, room) {
+    if (!this.rooms.has(room))
+      this.rooms.set(room, new Set);
+    this.rooms.get(room).add(id);
+    this.connectionRooms.get(id)?.add(room);
+  }
+  leaveRoom(id, room) {
+    this.rooms.get(room)?.delete(id);
+    if (this.rooms.get(room)?.size === 0)
+      this.rooms.delete(room);
+    this.connectionRooms.get(id)?.delete(room);
+  }
+  getRoomMembers(room) {
+    return [...this.rooms.get(room) ?? []];
+  }
+  getConnectionRooms(id) {
+    return [...this.connectionRooms.get(id) ?? []];
+  }
+  listRooms() {
+    return [...this.rooms.keys()];
+  }
+  sendTo(id, payload) {
+    const ws = this.connections.get(id);
+    if (!ws)
+      return false;
+    ws.send(JSON.stringify(payload));
+    return true;
+  }
+  broadcastToRoom(room, payload, { exclude = [] } = {}) {
+    const ids = this.rooms.get(room);
+    if (!ids)
+      return 0;
+    let sent = 0;
+    for (const id of ids) {
+      if (exclude.includes(id))
+        continue;
+      if (this.sendTo(id, payload))
+        sent++;
+    }
+    return sent;
+  }
+  broadcastAll(payload, { exclude = [] } = {}) {
+    let sent = 0;
+    for (const id of this.connections.keys()) {
+      if (exclude.includes(id))
+        continue;
+      if (this.sendTo(id, payload))
+        sent++;
+    }
+    return sent;
+  }
+  setMeta(id, key, value) {
+    const meta = this.metadata.get(id);
+    if (meta)
+      meta[key] = value;
+  }
+  getMeta(id, key) {
+    return this.metadata.get(id)?.[key];
+  }
+  get connectionCount() {
+    return this.connections.size;
+  }
+  get roomCount() {
+    return this.rooms.size;
+  }
+  getStats() {
+    return {
+      connections: this.connectionCount,
+      rooms: Object.fromEntries([...this.rooms.entries()].map(([room, ids]) => [room, ids.size])),
+      heartbeatActive: this.heartbeatTimer !== null
+    };
+  }
+}
+var wsManager = new WebSocketManager;
+function toServerWebSocket(ws) {
+  return {
+    id: ws.data.id,
+    data: ws.data,
+    send: (message, compress) => ws.send(message, compress)
+  };
+}
+function parseMessage(message) {
+  if (typeof message !== "string") {
+    return { type: "binary", payload: message };
+  }
+  try {
+    const parsed = JSON.parse(message);
+    return parsed && typeof parsed === "object" ? parsed : { type: "message", payload: parsed };
+  } catch {
+    return { type: "message", payload: message };
+  }
+}
+function createWebSocketHandler({
+  heartbeat,
+  onJoinRoom
+} = {}) {
+  const startHeartbeat = () => {
+    if (heartbeat === false)
+      return;
+    wsManager.startHeartbeat(heartbeat?.interval, heartbeat?.timeout);
+  };
+  return {
+    open(ws) {
+      const wrapped = toServerWebSocket(ws);
+      wsManager.register(wrapped);
+      startHeartbeat();
+      ws.send(JSON.stringify({ type: "connected", id: wrapped.id }));
+    },
+    async message(ws, rawMessage) {
+      const message = parseMessage(rawMessage);
+      const wrapped = toServerWebSocket(ws);
+      const { id } = wrapped;
+      switch (message.type) {
+        case "join":
+          if (!message.room)
+            return;
+          if (onJoinRoom && !await onJoinRoom(message.room, wrapped)) {
+            ws.send(JSON.stringify({ type: "error", message: `Access denied to room '${message.room}'` }));
+            return;
+          }
+          wsManager.joinRoom(id, message.room);
+          ws.send(JSON.stringify({ type: "joined", room: message.room }));
+          return;
+        case "leave":
+          if (!message.room)
+            return;
+          wsManager.leaveRoom(id, message.room);
+          ws.send(JSON.stringify({ type: "left", room: message.room }));
+          return;
+        case "broadcast":
+          if (message.room) {
+            if (!wsManager.getConnectionRooms(id).includes(message.room)) {
+              ws.send(JSON.stringify({ type: "error", message: "Not in room" }));
+              return;
+            }
+            wsManager.broadcastToRoom(message.room, { type: "message", from: id, payload: message.payload }, { exclude: [id] });
+          }
+          return;
+        case "ping":
+          ws.send(JSON.stringify({ type: "pong" }));
+          return;
+        case "pong":
+          wsManager.pong(id);
+          return;
+        default:
+          ws.send(JSON.stringify({ type: "error", message: `Unknown type: ${message.type}` }));
+      }
+    },
+    close(ws) {
+      wsManager.remove(ws.data.id);
+    }
+  };
+}
+function createBunWebSocketRoute({
+  path = "/ws",
+  heartbeat,
+  onJoinRoom
+} = {}) {
+  const handler = createWebSocketHandler({ heartbeat, onJoinRoom });
+  return async (request, server) => {
+    if (!server)
+      return new Response(JSON.stringify({ message: "WebSocket upgrade requires Bun.serve to pass the server into fetch" }), { status: 500 });
+    const didUpgrade = server.upgrade(request, {
+      data: {
+        id: ulid(),
+        path,
+        handler
+      }
+    });
+    if (didUpgrade) {
+      return;
+    }
+    return new Response(JSON.stringify({ message: "WebSocket upgrade failed" }), { status: 400 });
+  };
+}
+function createBunWebSocketHandlers() {
+  return {
+    open(ws) {
+      return ws.data.handler.open?.(ws);
+    },
+    message(ws, message) {
+      return ws.data.handler.message?.(ws, message);
+    },
+    close(ws, code, reason) {
+      return ws.data.handler.close?.(ws, code, reason);
+    },
+    drain(ws) {
+      return ws.data.handler.drain?.(ws);
+    }
+  };
+}
+
+class CequreWebsocket {
+  static get manager() {
+    return wsManager;
+  }
+  static route(options = {}) {
+    return createBunWebSocketRoute(options);
+  }
+  static handler(options = {}) {
+    return createWebSocketHandler(options);
+  }
+  static handlers() {
+    return createBunWebSocketHandlers();
+  }
+  static register(ws) {
+    return wsManager.register(ws);
+  }
+  static remove(wsOrId) {
+    return wsManager.remove(wsOrId);
+  }
+  static pong(id) {
+    return wsManager.pong(id);
+  }
+  static startHeartbeat(intervalMs, timeoutMs) {
+    return wsManager.startHeartbeat(intervalMs, timeoutMs);
+  }
+  static stopHeartbeat() {
+    return wsManager.stopHeartbeat();
+  }
+  static joinRoom(id, room) {
+    return wsManager.joinRoom(id, room);
+  }
+  static leaveRoom(id, room) {
+    return wsManager.leaveRoom(id, room);
+  }
+  static getRoomMembers(room) {
+    return wsManager.getRoomMembers(room);
+  }
+  static getConnectionRooms(id) {
+    return wsManager.getConnectionRooms(id);
+  }
+  static listRooms() {
+    return wsManager.listRooms();
+  }
+  static sendTo(id, payload) {
+    return wsManager.sendTo(id, payload);
+  }
+  static broadcastToRoom(room, payload, opts) {
+    return wsManager.broadcastToRoom(room, payload, opts);
+  }
+  static broadcastAll(payload, opts) {
+    return wsManager.broadcastAll(payload, opts);
+  }
+  static setMeta(id, key, value) {
+    return wsManager.setMeta(id, key, value);
+  }
+  static getMeta(id, key) {
+    return wsManager.getMeta(id, key);
+  }
+  static get connectionCount() {
+    return wsManager.connectionCount;
+  }
+  static get roomCount() {
+    return wsManager.roomCount;
+  }
+  static getStats() {
+    return wsManager.getStats();
+  }
+}
+// adapters/bun/bun-storage.ts
+import fs from "fs";
+import path from "path";
+class LocalStorageProvider {
+  uploadDir;
+  apiPrefix;
+  constructor(uploadDir = "uploads", apiPrefix = "/api") {
+    this.apiPrefix = apiPrefix;
+    this.uploadDir = path.resolve(process.cwd(), uploadDir);
+    if (!fs.existsSync(this.uploadDir)) {
+      fs.mkdirSync(this.uploadDir, { recursive: true });
+    }
+  }
+  async saveFile(file2, options) {
+    const ext = file2.name ? path.extname(file2.name) : "";
+    const safeName = options?.filename ? options.filename : `${ulid()}${ext}`;
+    const filePath = path.join(this.uploadDir, safeName);
+    await Bun.write(filePath, file2);
+    return {
+      filename: safeName,
+      originalName: file2.name || "upload",
+      mimetype: file2.type || "application/octet-stream",
+      size: file2.size,
+      url: `${this.apiPrefix}/uploads/${safeName}`
+    };
+  }
+  async deleteFile(filename) {
+    const filePath = path.join(this.uploadDir, filename);
+    try {
+      if (fs.existsSync(filePath)) {
+        await fs.promises.unlink(filePath);
+      }
+    } catch (e) {
+      console.error(`Failed to delete file ${filePath}`, e);
+    }
+  }
+}
+
+// adapters/bun/index.ts
+init_bun_redis_cache();
+function withBun(config) {
+  return {
+    ...config,
+    serverProvider: config.serverProvider || new BunServerProvider,
+    cronProvider: config.cronProvider || new BunCronProvider,
+    realtimeProvider: config.realtimeProvider || { websocket: CequreWebsocket },
+    storageProvider: config.storageProvider || new LocalStorageProvider
+  };
+}
+export {
+  wsManager,
+  withBun,
+  toResponse,
+  stream,
+  routeErrorToResponse,
+  redirect,
+  notFound,
+  methodNotAllowed,
+  json,
+  file,
+  error,
+  empty,
+  createWebSocketHandler,
+  createBunWebSocketRoute,
+  createBunWebSocketHandlers,
+  WebSocketManager,
+  UPGRADED,
+  RedisAdapter,
+  LocalStorageProvider,
+  CequreWebsocket,
+  CequreStreamMedia,
+  BunServerProvider,
+  BunCronProvider
+};

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

@@ -0,0 +1,9 @@
+export * from "./node-server";
+export * from "./node-cron";
+export * from "./node-websocket";
+export * from "./node-storage";
+export * from "./node-redis-cache";
+export * from "./node-response";
+export * from "./node-media";
+import type { CequreConfig } from "../../shared/main/runtime";
+export declare function withNode(config: CequreConfig): CequreConfig;