@cequrebackends/cequre-ts 0.11.4

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

@@ -0,0 +1,20 @@
+import type { CronProvider } from "../../shared/core/types";
+export declare class NodeCronProvider 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/node/node-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/node/node-redis-cache.d.ts

@@ -0,0 +1,32 @@
+import type { KVAdapter } from "../../shared/utils/kv/types";
+/**
+ * Redis KV adapter using `ioredis`.
+ *
+ * @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/node/node-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/node/node-server.d.ts

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

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

@@ -0,0 +1,10 @@
+import type { StorageProvider, UploadedFile } from '../../shared/core/types';
+export declare class NodeLocalStorageProvider 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/node/node-websocket.d.ts

@@ -0,0 +1,102 @@
+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: CequreServerWebSocket): void | Promise<void>;
+    message?(ws: CequreServerWebSocket, message: string | Buffer): void | Promise<void>;
+    close?(ws: CequreServerWebSocket, code: number, reason: string): void | Promise<void>;
+    drain?(ws: CequreServerWebSocket): void | Promise<void>;
+}
+export declare class NodeWebSocketManager {
+    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: NodeWebSocketManager;
+export declare function createWebSocketHandler({ heartbeat, onJoinRoom, }?: {
+    heartbeat?: {
+        interval?: number;
+        timeout?: number;
+    } | false;
+    onJoinRoom?: (room: string, ws: CequreServerWebSocket) => MaybePromise<boolean>;
+}): CequreWebSocketHandler;
+export declare function createNodeWebSocketRoute({ 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 class CequreWebsocket {
+    static get manager(): NodeWebSocketManager;
+    static route(options?: Parameters<typeof createNodeWebSocketRoute>[0]): (request: Request, server: any) => Promise<Response>;
+    static handler(options?: Parameters<typeof createWebSocketHandler>[0]): CequreWebSocketHandler;
+    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/index-17yswtmg.js

@@ -0,0 +1,175 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// shared/core/ulid.ts
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function ulid(seedTime = Date.now()) {
+  let str = "";
+  let now = seedTime;
+  for (let len = TIME_LEN;len > 0; len--) {
+    const mod = now % 32;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / 32;
+  }
+  const randomBytes = new Uint8Array(RANDOM_LEN);
+  crypto.getRandomValues(randomBytes);
+  for (let i = 0;i < RANDOM_LEN; i++) {
+    str += ENCODING.charAt(randomBytes[i] & 31);
+  }
+  return str;
+}
+
+// shared/utils/url.ts
+function extractPathname(url) {
+  const protocolIndex = url.indexOf("://");
+  const pathStart = protocolIndex === -1 ? 0 : url.indexOf("/", protocolIndex + 3);
+  if (pathStart === -1)
+    return "/";
+  const queryStart = url.indexOf("?", pathStart);
+  return queryStart === -1 ? url.slice(pathStart) : url.slice(pathStart, queryStart);
+}
+
+// shared/utils/error.ts
+class CequreError extends Error {
+  code;
+  status;
+  constructor(message, code = "INTERNAL_ERROR", status = 500) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.status = status;
+  }
+  toJSON() {
+    return {
+      error: this.code,
+      message: this.message
+    };
+  }
+  static BadRequest = (message = "Bad request") => new CequreError(message, "BAD_REQUEST", 400);
+  static Unauthorized = (message = "Unauthorized") => new CequreError(message, "UNAUTHORIZED", 401);
+  static NotImplemented = (message = "Not implemented") => new CequreError(message, "NOT_IMPLEMENTED", 501);
+  static NotConfigured = (message = "Not configured") => new CequreError(message, "NOT_CONFIGURED", 428);
+  static Forbidden = (message = "Forbidden") => new CequreError(message, "FORBIDDEN", 403);
+  static NotFound = (message = "Not found") => new CequreError(message, "NOT_FOUND", 404);
+  static Conflict = (message = "Conflict") => new CequreError(message, "CONFLICT", 409);
+  static TooManyRequests = (message = "Too many requests") => new CequreError(message, "TOO_MANY_REQUESTS", 429);
+  static SubscriptionRequired = (message = "Subscription required") => new CequreError(message, "SUBSCRIPTION_REQUIRED", 402);
+  static Internal = (message = "An unexpected error occurred. Please try again later.") => new CequreError(message, "INTERNAL_ERROR", 500);
+}
+function parseConstraintError(error, adapter) {
+  if (adapter?.parseConstraintError) {
+    return adapter.parseConstraintError(error);
+  }
+  return null;
+}
+function getConstraintErrorMessage(parsed) {
+  switch (parsed.type) {
+    case "foreign_key":
+      if (parsed.referencedTable) {
+        return `The value "${parsed.column}" references a non-existent record in "${parsed.referencedTable}". Please ensure the referenced record exists.`;
+      }
+      return "This operation violates a foreign key constraint. The referenced record does not exist.";
+    case "unique":
+      if (parsed.column) {
+        return `A record with this "${parsed.column}" value already exists. Please use a different value.`;
+      }
+      return "A record with this value already exists. Please use a different value.";
+    case "not_null":
+      return `The field "${parsed.column}" is required and cannot be empty.`;
+    case "check":
+      return `The value violates a validation rule (constraint: ${parsed.constraint}).`;
+    case "exclusion":
+      return "This value conflicts with an existing record.";
+    default:
+      return parsed.rawMessage;
+  }
+}
+function getConstraintErrorStatus(type) {
+  switch (type) {
+    case "foreign_key":
+    case "unique":
+    case "check":
+    case "exclusion":
+      return 409;
+    case "not_null":
+      return 400;
+    default:
+      return 500;
+  }
+}
+function buildErrorResponse(error, request, adapter) {
+  const timestamp = new Date().toISOString();
+  const path = request ? extractPathname(request.url) : undefined;
+  let statusCode = 500;
+  let code = "INTERNAL_ERROR";
+  let message = "An unexpected error occurred. Please try again later.";
+  if (error instanceof CequreError) {
+    statusCode = error.status;
+    code = error.code;
+    message = error.message;
+  } else if (error instanceof Error) {
+    const parsedConstraint = adapter ? parseConstraintError(error, adapter) : null;
+    if (parsedConstraint) {
+      statusCode = getConstraintErrorStatus(parsedConstraint.type);
+      code = `CONSTRAINT_${parsedConstraint.type.toUpperCase()}`;
+      message = getConstraintErrorMessage(parsedConstraint);
+      if (true) {
+        message += ` (${parsedConstraint.rawMessage})`;
+      }
+    } else {
+      if (true) {
+        message = error.message;
+      }
+    }
+  }
+  return { code, message, statusCode, timestamp, ...path ? { path } : {} };
+}
+function toErrorResponse(error, request, adapter) {
+  const body = buildErrorResponse(error, request, adapter);
+  return new Response(JSON.stringify(body), {
+    status: body.statusCode,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+
+export { __toCommonJS, __export, __esm, __require, ulid, extractPathname, CequreError, parseConstraintError, getConstraintErrorMessage, getConstraintErrorStatus, buildErrorResponse, toErrorResponse };