@cequrebackends/cequre-ts 0.11.4

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

@@ -0,0 +1,20 @@
+import type { CronProvider } from "../../shared/core/types";
+export declare class BunCronProvider implements CronProvider {
+    private localJobs;
+    private useBullMQ;
+    constructor();
+    registerJob(name: string, schedule: string, handler: () => void | Promise<void>): void;
+    /**
+     * Stops a specific cron job by name
+     */
+    stop(name: string): Promise<boolean>;
+    /**
+     * Safely stops all running cron jobs
+     */
+    stopAll(): Promise<void>;
+    /**
+     * Returns a list of all currently running cron job names
+     */
+    list(): Promise<string[]>;
+    startAll(): void;
+}

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

@@ -0,0 +1,9 @@
+export interface CequreStreamMediaOptions {
+    provider?: "local" | "s3";
+    maxChunkSize?: number;
+    s3Config?: {
+        bucket?: string;
+        expiresIn?: number;
+    };
+}
+export declare function CequreStreamMedia(request: Request, absolutePathOrUrl: string, options?: CequreStreamMediaOptions): Response;

package/dist/adapters/bun/bun-redis-cache.d.ts

@@ -0,0 +1,33 @@
+import type { KVAdapter } from "../../shared/utils/kv/types";
+/**
+ * Redis KV adapter using Bun's built-in `Bun.redis` client.
+ * No external dependencies required — Bun ships with native Redis support.
+ *
+ * @example
+ * ```ts
+ * import { CequreKV } from "@cequrebackends/cequre-ts";
+ * const kv = new CequreKV({ driver: "redis", redis: { url: "redis://localhost:6379" } });
+ * ```
+ */
+export declare class RedisAdapter implements KVAdapter {
+    private redis;
+    constructor(options?: {
+        url?: string;
+    });
+    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/bun/bun-response.d.ts

@@ -0,0 +1,13 @@
+export type SerializableResponseBody = string | number | boolean | null | undefined | Record<string, unknown> | unknown[];
+export declare const UPGRADED: unique symbol;
+export type BunRouteResult<T = SerializableResponseBody> = Response | T | typeof UPGRADED;
+export declare function json(data: unknown, init?: ResponseInit): Response;
+export declare function empty(status?: number, init?: ResponseInit): Response;
+export declare function redirect(location: string, status?: number, init?: ResponseInit): Response;
+export declare function error(message: string, status?: number, code?: string, init?: ResponseInit): Response;
+export declare function notFound(message?: string): Response;
+export declare function methodNotAllowed(allowedMethods: string[]): Response;
+export declare function file(file: Blob | ArrayBuffer | Uint8Array | string, init?: ResponseInit): Response;
+export declare function stream(data: ReadableStream | AsyncIterable<unknown> | Iterable<unknown>, init?: ResponseInit): Response;
+export declare function toResponse(result: BunRouteResult): Response | undefined;
+export declare function routeErrorToResponse(errorValue: unknown, request?: Request): Response;

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

@@ -0,0 +1,6 @@
+import type { ServerProvider, CequreServerConfig } from "../../shared/core/types";
+export declare class BunServerProvider implements ServerProvider {
+    private server;
+    start(config: CequreServerConfig): any;
+    stop(): Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import type { StorageProvider, UploadedFile } from '../../shared/core/types';
+export declare class LocalStorageProvider implements StorageProvider {
+    private readonly uploadDir;
+    private readonly apiPrefix;
+    constructor(uploadDir?: string, apiPrefix?: string);
+    saveFile(file: File, options?: {
+        filename?: string;
+    }): Promise<UploadedFile>;
+    deleteFile(filename: string): Promise<void>;
+}

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

@@ -0,0 +1,104 @@
+export interface CequreServerWebSocket {
+    id: string;
+    data: Record<string, unknown>;
+    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
+}
+export interface CequreWebSocketData {
+    id: string;
+    path: string;
+    handler: CequreWebSocketHandler;
+}
+type BroadcastOptions = {
+    exclude?: string[];
+};
+type MaybePromise<T> = T | Promise<T>;
+export interface CequreWebSocketHandler {
+    open?(ws: Bun.ServerWebSocket<CequreWebSocketData>): void | Promise<void>;
+    message?(ws: Bun.ServerWebSocket<CequreWebSocketData>, message: string | Buffer): void | Promise<void>;
+    close?(ws: Bun.ServerWebSocket<CequreWebSocketData>, code: number, reason: string): void | Promise<void>;
+    drain?(ws: Bun.ServerWebSocket<CequreWebSocketData>): void | Promise<void>;
+}
+export declare class WebSocketManager {
+    private connections;
+    private rooms;
+    private connectionRooms;
+    private metadata;
+    private lastPong;
+    private heartbeatTimer;
+    register(ws: CequreServerWebSocket): void;
+    remove(wsOrId: CequreServerWebSocket | string): void;
+    pong(id: string): void;
+    startHeartbeat(intervalMs?: number, timeoutMs?: number): void;
+    stopHeartbeat(): void;
+    joinRoom(id: string, room: string): void;
+    leaveRoom(id: string, room: string): void;
+    getRoomMembers(room: string): string[];
+    getConnectionRooms(id: string): string[];
+    listRooms(): string[];
+    sendTo(id: string, payload: unknown): boolean;
+    broadcastToRoom(room: string, payload: unknown, { exclude }?: BroadcastOptions): number;
+    broadcastAll(payload: unknown, { exclude }?: BroadcastOptions): number;
+    setMeta(id: string, key: string, value: unknown): void;
+    getMeta(id: string, key: string): unknown;
+    get connectionCount(): number;
+    get roomCount(): number;
+    getStats(): {
+        connections: number;
+        rooms: {
+            [k: string]: number;
+        };
+        heartbeatActive: boolean;
+    };
+}
+export declare const wsManager: WebSocketManager;
+export declare function createWebSocketHandler({ heartbeat, onJoinRoom, }?: {
+    heartbeat?: {
+        interval?: number;
+        timeout?: number;
+    } | false;
+    onJoinRoom?: (room: string, ws: CequreServerWebSocket) => MaybePromise<boolean>;
+}): CequreWebSocketHandler;
+export declare function createBunWebSocketRoute({ path, heartbeat, onJoinRoom, }?: {
+    path?: string;
+    heartbeat?: {
+        interval?: number;
+        timeout?: number;
+    } | false;
+    onJoinRoom?: (room: string, ws: CequreServerWebSocket) => MaybePromise<boolean>;
+}): (request: Request, server: any) => Promise<Response>;
+export declare function createBunWebSocketHandlers(): Bun.WebSocketHandler<CequreWebSocketData>;
+export declare class CequreWebsocket {
+    static get manager(): WebSocketManager;
+    static route(options?: Parameters<typeof createBunWebSocketRoute>[0]): (request: Request, server: any) => Promise<Response>;
+    static handler(options?: Parameters<typeof createWebSocketHandler>[0]): CequreWebSocketHandler;
+    static handlers(): Bun.WebSocketHandler<CequreWebSocketData>;
+    static register(ws: CequreServerWebSocket): void;
+    static remove(wsOrId: CequreServerWebSocket | string): void;
+    static pong(id: string): void;
+    static startHeartbeat(intervalMs?: number, timeoutMs?: number): void;
+    static stopHeartbeat(): void;
+    static joinRoom(id: string, room: string): void;
+    static leaveRoom(id: string, room: string): void;
+    static getRoomMembers(room: string): string[];
+    static getConnectionRooms(id: string): string[];
+    static listRooms(): string[];
+    static sendTo(id: string, payload: unknown): boolean;
+    static broadcastToRoom(room: string, payload: unknown, opts?: {
+        exclude?: string[];
+    }): number;
+    static broadcastAll(payload: unknown, opts?: {
+        exclude?: string[];
+    }): number;
+    static setMeta(id: string, key: string, value: unknown): void;
+    static getMeta(id: string, key: string): unknown;
+    static get connectionCount(): number;
+    static get roomCount(): number;
+    static getStats(): {
+        connections: number;
+        rooms: {
+            [k: string]: number;
+        };
+        heartbeatActive: boolean;
+    };
+}
+export {};

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

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