@lastshotlabs/bunshot 0.0.27 → 0.0.28

package/dist/lib/wsMessages.js

@@ -1,330 +0,0 @@
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// State
-// ---------------------------------------------------------------------------
-const DEFAULT_MAX_COUNT = 100;
-const DEFAULT_TTL_SECONDS = 86_400; // 24 hours
-let _store = "memory";
-let _defaults = { maxCount: DEFAULT_MAX_COUNT, ttlSeconds: DEFAULT_TTL_SECONDS };
-const _roomConfigs = new Map();
-// Memory store
-const _memoryMessages = new Map();
-// SQLite trim counters — tracks inserts since last trim per room.
-// Resets on server restart; rooms may temporarily exceed maxCount by up to trimInterval rows.
-// This is a soft cap by design to avoid a DELETE on every INSERT under high throughput.
-const _sqliteTrimCounters = new Map();
-// ---------------------------------------------------------------------------
-// Configuration
-// ---------------------------------------------------------------------------
-export const setWsMessageStore = (store) => { _store = store; };
-export const setWsMessageDefaults = (defaults) => {
-    _defaults = {
-        maxCount: defaults.maxCount ?? DEFAULT_MAX_COUNT,
-        ttlSeconds: defaults.ttlSeconds ?? DEFAULT_TTL_SECONDS,
-    };
-};
-/** Opt a room into message persistence. */
-export const configureRoom = (room, options) => {
-    if (!options.persist) {
-        _roomConfigs.delete(room);
-        return;
-    }
-    _roomConfigs.set(room, {
-        maxCount: options.maxCount ?? _defaults.maxCount,
-        ttlSeconds: options.ttlSeconds ?? _defaults.ttlSeconds,
-    });
-};
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/**
- * Persist a message to a room. Returns null if room is not configured for persistence.
- * On store errors, logs a warning and returns null (non-blocking).
- */
-export const persistMessage = async (room, data) => {
-    const config = _roomConfigs.get(room);
-    if (!config)
-        return null;
-    const message = {
-        id: crypto.randomUUID(),
-        room,
-        senderId: data.senderId ?? null,
-        payload: data.payload,
-        createdAt: Date.now(),
-    };
-    try {
-        switch (_store) {
-            case "memory":
-                return memoryPersist(message, config);
-            case "redis":
-                return await redisPersist(message, config);
-            case "mongo":
-                return await mongoPersist(message, config);
-            case "sqlite":
-                return sqlitePersist(message, config);
-        }
-    }
-    catch (err) {
-        console.warn(`[wsMessages] failed to persist message to ${room}:`, err);
-        return null;
-    }
-};
-/**
- * Get message history for a room.
- * Cursor-based pagination using message `id` as cursor.
- */
-export const getMessageHistory = async (room, opts) => {
-    const limit = opts?.limit ?? 50;
-    switch (_store) {
-        case "memory":
-            return memoryGetHistory(room, limit, opts?.before, opts?.after);
-        case "redis":
-            return await redisGetHistory(room, limit, opts?.before, opts?.after);
-        case "mongo":
-            return await mongoGetHistory(room, limit, opts?.before, opts?.after);
-        case "sqlite":
-            return sqliteGetHistory(room, limit, opts?.before, opts?.after);
-    }
-};
-/** Reset memory store. Useful for test isolation. */
-export const clearWsMessageMemoryStore = () => {
-    _memoryMessages.clear();
-    _roomConfigs.clear();
-    _sqliteTrimCounters.clear();
-};
-// ---------------------------------------------------------------------------
-// Memory backend
-// ---------------------------------------------------------------------------
-function memoryPersist(msg, config) {
-    if (!_memoryMessages.has(msg.room))
-        _memoryMessages.set(msg.room, []);
-    const msgs = _memoryMessages.get(msg.room);
-    msgs.push(msg);
-    // Trim to maxCount
-    if (msgs.length > config.maxCount) {
-        msgs.splice(0, msgs.length - config.maxCount);
-    }
-    return msg;
-}
-function memoryGetHistory(room, limit, before, after) {
-    const msgs = _memoryMessages.get(room) ?? [];
-    const now = Date.now();
-    const config = _roomConfigs.get(room);
-    const ttlMs = (config?.ttlSeconds ?? _defaults.ttlSeconds) * 1000;
-    // Filter expired
-    let filtered = msgs.filter((m) => now - m.createdAt < ttlMs);
-    if (before) {
-        const cursorIdx = filtered.findIndex((m) => m.id === before);
-        if (cursorIdx > 0)
-            filtered = filtered.slice(0, cursorIdx);
-    }
-    else if (after) {
-        const cursorIdx = filtered.findIndex((m) => m.id === after);
-        if (cursorIdx >= 0)
-            filtered = filtered.slice(cursorIdx + 1);
-    }
-    // Return last N messages (most recent)
-    return filtered.slice(-limit);
-}
-// ---------------------------------------------------------------------------
-// Redis backend
-// ---------------------------------------------------------------------------
-async function redisPersist(msg, config) {
-    const { getRedis } = await import("./redis");
-    const redis = getRedis();
-    const key = `wsmsg:${msg.room}`;
-    const serialized = JSON.stringify(msg);
-    await redis.lpush(key, serialized);
-    await redis.ltrim(key, 0, config.maxCount - 1);
-    await redis.expire(key, config.ttlSeconds);
-    return msg;
-}
-async function redisGetHistory(room, limit, before, after) {
-    const { getRedis } = await import("./redis");
-    const redis = getRedis();
-    const key = `wsmsg:${room}`;
-    // Redis list is newest-first (LPUSH)
-    const raw = await redis.lrange(key, 0, -1);
-    let msgs = raw.map((s) => JSON.parse(s)).reverse(); // oldest-first
-    if (before) {
-        const idx = msgs.findIndex((m) => m.id === before);
-        if (idx > 0)
-            msgs = msgs.slice(0, idx);
-    }
-    else if (after) {
-        const idx = msgs.findIndex((m) => m.id === after);
-        if (idx >= 0)
-            msgs = msgs.slice(idx + 1);
-    }
-    return msgs.slice(-limit);
-}
-// ---------------------------------------------------------------------------
-// MongoDB backend
-// ---------------------------------------------------------------------------
-let _mongoModel = null;
-async function getWsMessageModel() {
-    if (_mongoModel)
-        return _mongoModel;
-    const { authConnection } = await import("./mongo");
-    const { default: mongoose } = await import("mongoose");
-    const schema = new mongoose.Schema({
-        _id: { type: String, default: () => crypto.randomUUID() },
-        room: { type: String, required: true, index: true },
-        senderId: { type: String, default: null },
-        payload: { type: mongoose.Schema.Types.Mixed },
-        createdAt: { type: Number, required: true, index: true },
-    }, { collection: "ws_messages" });
-    schema.index({ room: 1, createdAt: 1, _id: 1 });
-    // TTL index — Mongo's TTL monitor runs ~every 60s, so messages may briefly
-    // outlive their TTL. Acceptable for chat history.
-    schema.index({ createdAt: 1 }, { expireAfterSeconds: DEFAULT_TTL_SECONDS });
-    _mongoModel = authConnection.model("WsMessage", schema);
-    return _mongoModel;
-}
-async function mongoPersist(msg, config) {
-    const Model = await getWsMessageModel();
-    await Model.create({
-        _id: msg.id,
-        room: msg.room,
-        senderId: msg.senderId,
-        payload: msg.payload,
-        createdAt: msg.createdAt,
-    });
-    // Trim to maxCount
-    const count = await Model.countDocuments({ room: msg.room });
-    if (count > config.maxCount) {
-        const oldest = await Model.find({ room: msg.room })
-            .sort({ createdAt: 1, _id: 1 })
-            .limit(count - config.maxCount)
-            .select("_id");
-        if (oldest.length > 0) {
-            await Model.deleteMany({ _id: { $in: oldest.map((d) => d._id) } });
-        }
-    }
-    return msg;
-}
-async function mongoGetHistory(room, limit, before, after) {
-    const Model = await getWsMessageModel();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const filter = { room };
-    if (before) {
-        const cursor = await Model.findById(before).lean();
-        if (cursor) {
-            filter.$or = [
-                { createdAt: { $lt: cursor.createdAt } },
-                { createdAt: cursor.createdAt, _id: { $lt: before } },
-            ];
-        }
-    }
-    else if (after) {
-        const cursor = await Model.findById(after).lean();
-        if (cursor) {
-            filter.$or = [
-                { createdAt: { $gt: cursor.createdAt } },
-                { createdAt: cursor.createdAt, _id: { $gt: after } },
-            ];
-        }
-    }
-    const docs = await Model.find(filter)
-        .sort({ createdAt: -1, _id: -1 })
-        .limit(limit)
-        .lean();
-    return docs.reverse().map((d) => ({
-        id: d._id,
-        room: d.room,
-        senderId: d.senderId,
-        payload: d.payload,
-        createdAt: d.createdAt,
-    }));
-}
-// ---------------------------------------------------------------------------
-// SQLite backend
-// ---------------------------------------------------------------------------
-function getSqliteDb() {
-    // Re-use the sqlite DB set via setSqliteDb
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { getSqliteDatabase } = require("../adapters/sqliteAuth");
-    return getSqliteDatabase();
-}
-let _sqliteInitialized = false;
-function ensureSqliteTable() {
-    if (_sqliteInitialized)
-        return;
-    const db = getSqliteDb();
-    db.run(`
-    CREATE TABLE IF NOT EXISTS ws_messages (
-      id TEXT PRIMARY KEY,
-      room TEXT NOT NULL,
-      sender_id TEXT,
-      payload TEXT,
-      created_at INTEGER NOT NULL
-    )
-  `);
-    db.run(`CREATE INDEX IF NOT EXISTS idx_ws_messages_room_created ON ws_messages (room, created_at, id)`);
-    _sqliteInitialized = true;
-}
-function sqlitePersist(msg, config) {
-    ensureSqliteTable();
-    const db = getSqliteDb();
-    db.run(`INSERT INTO ws_messages (id, room, sender_id, payload, created_at) VALUES (?, ?, ?, ?, ?)`, [msg.id, msg.room, msg.senderId, JSON.stringify(msg.payload), msg.createdAt]);
-    // Modulo-based trimming to avoid DELETE on every INSERT.
-    const counter = (_sqliteTrimCounters.get(msg.room) ?? 0) + 1;
-    const trimInterval = Math.max(10, Math.floor(config.maxCount * 0.1));
-    _sqliteTrimCounters.set(msg.room, counter);
-    if (counter >= trimInterval) {
-        _sqliteTrimCounters.set(msg.room, 0);
-        // Delete oldest beyond maxCount
-        db.run(`DELETE FROM ws_messages WHERE room = ? AND id NOT IN (
-        SELECT id FROM ws_messages WHERE room = ? ORDER BY created_at DESC, id DESC LIMIT ?
-      )`, [msg.room, msg.room, config.maxCount]);
-        // TTL cleanup
-        const ttlMs = config.ttlSeconds * 1000;
-        db.run(`DELETE FROM ws_messages WHERE room = ? AND created_at < ?`, [msg.room, Date.now() - ttlMs]);
-    }
-    return msg;
-}
-function sqliteGetHistory(room, limit, before, after) {
-    ensureSqliteTable();
-    const db = getSqliteDb();
-    let sql;
-    let params;
-    if (before) {
-        sql = `
-      SELECT * FROM ws_messages
-      WHERE room = ? AND (created_at, id) < (
-        (SELECT created_at FROM ws_messages WHERE id = ?),
-        ?
-      )
-      ORDER BY created_at DESC, id DESC LIMIT ?
-    `;
-        params = [room, before, before, limit];
-    }
-    else if (after) {
-        sql = `
-      SELECT * FROM ws_messages
-      WHERE room = ? AND (created_at, id) > (
-        (SELECT created_at FROM ws_messages WHERE id = ?),
-        ?
-      )
-      ORDER BY created_at ASC, id ASC LIMIT ?
-    `;
-        params = [room, after, after, limit];
-    }
-    else {
-        sql = `SELECT * FROM ws_messages WHERE room = ? ORDER BY created_at DESC, id DESC LIMIT ?`;
-        params = [room, limit];
-    }
-    const rows = db.query(sql).all(...params);
-    // Normalize to oldest-first
-    if (!after)
-        rows.reverse();
-    return rows.map((r) => ({
-        id: r.id,
-        room: r.room,
-        senderId: r.sender_id,
-        payload: JSON.parse(r.payload),
-        createdAt: r.created_at,
-    }));
-}

package/dist/lib/wsPresence.d.ts

@@ -1,25 +0,0 @@
-/** Track an authenticated socket. Skips if userId is null/undefined. */
-export declare const trackSocket: (socketId: string, userId: string | null) => void;
-/** Untrack a socket on disconnect. */
-export declare const untrackSocket: (socketId: string) => void;
-/** Called when a socket subscribes to a room. Returns join info or null if unauthenticated. */
-export declare const addPresence: (socketId: string, room: string) => {
-    userId: string;
-    isNewUser: boolean;
-} | null;
-/** Called when a socket unsubscribes from a room. Returns leave info or null if unauthenticated. */
-export declare const removePresence: (socketId: string, room: string) => {
-    userId: string;
-    isLastSocket: boolean;
-} | null;
-/** Called on disconnect — cleans up all rooms for a socket. Returns rooms where user fully departed. */
-export declare const cleanupPresence: (socketId: string, rooms: Set<string>) => Array<{
-    room: string;
-    userId: string;
-}>;
-/** Deduplicated userIds present in a room. */
-export declare const getRoomPresence: (room: string) => string[];
-/** Rooms where a user is present. */
-export declare const getUserPresence: (userId: string) => string[];
-/** Reset all presence state. Useful for test isolation. */
-export declare const clearPresenceStore: () => void;

package/dist/lib/wsPresence.js

@@ -1,99 +0,0 @@
-// ---------------------------------------------------------------------------
-// State (in-memory only)
-// ---------------------------------------------------------------------------
-/** socketId → userId (authenticated sockets only) */
-const _socketUsers = new Map();
-/** room → userId → Set<socketId> (multi-tab aware) */
-const _roomPresence = new Map();
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-/** Track an authenticated socket. Skips if userId is null/undefined. */
-export const trackSocket = (socketId, userId) => {
-    if (!userId)
-        return;
-    _socketUsers.set(socketId, userId);
-};
-/** Untrack a socket on disconnect. */
-export const untrackSocket = (socketId) => {
-    _socketUsers.delete(socketId);
-};
-/** Called when a socket subscribes to a room. Returns join info or null if unauthenticated. */
-export const addPresence = (socketId, room) => {
-    const userId = _socketUsers.get(socketId);
-    if (!userId)
-        return null;
-    if (!_roomPresence.has(room))
-        _roomPresence.set(room, new Map());
-    const roomMap = _roomPresence.get(room);
-    const isNewUser = !roomMap.has(userId) || roomMap.get(userId).size === 0;
-    if (!roomMap.has(userId))
-        roomMap.set(userId, new Set());
-    roomMap.get(userId).add(socketId);
-    return { userId, isNewUser };
-};
-/** Called when a socket unsubscribes from a room. Returns leave info or null if unauthenticated. */
-export const removePresence = (socketId, room) => {
-    const userId = _socketUsers.get(socketId);
-    if (!userId)
-        return null;
-    const roomMap = _roomPresence.get(room);
-    if (!roomMap)
-        return null;
-    const sockets = roomMap.get(userId);
-    if (!sockets)
-        return null;
-    sockets.delete(socketId);
-    const isLastSocket = sockets.size === 0;
-    if (isLastSocket) {
-        roomMap.delete(userId);
-        if (roomMap.size === 0)
-            _roomPresence.delete(room);
-    }
-    return { userId, isLastSocket };
-};
-/** Called on disconnect — cleans up all rooms for a socket. Returns rooms where user fully departed. */
-export const cleanupPresence = (socketId, rooms) => {
-    const userId = _socketUsers.get(socketId);
-    if (!userId)
-        return [];
-    const departed = [];
-    for (const room of rooms) {
-        const roomMap = _roomPresence.get(room);
-        if (!roomMap)
-            continue;
-        const sockets = roomMap.get(userId);
-        if (!sockets)
-            continue;
-        sockets.delete(socketId);
-        if (sockets.size === 0) {
-            roomMap.delete(userId);
-            if (roomMap.size === 0)
-                _roomPresence.delete(room);
-            departed.push({ room, userId });
-        }
-    }
-    return departed;
-};
-/** Deduplicated userIds present in a room. */
-export const getRoomPresence = (room) => {
-    const roomMap = _roomPresence.get(room);
-    if (!roomMap)
-        return [];
-    return [...roomMap.keys()];
-};
-/** Rooms where a user is present. */
-export const getUserPresence = (userId) => {
-    const rooms = [];
-    for (const [room, roomMap] of _roomPresence) {
-        const sockets = roomMap.get(userId);
-        if (sockets && sockets.size > 0)
-            rooms.push(room);
-    }
-    return rooms;
-};
-/** Reset all presence state. Useful for test isolation. */
-export const clearPresenceStore = () => {
-    _socketUsers.clear();
-    _roomPresence.clear();
-};

package/dist/middleware/auditLog.js

@@ -1,39 +0,0 @@
-import { getClientIp } from "../lib/clientIp";
-import { logAuditEntry } from "../lib/auditLog";
-export const auditLog = (options) => async (c, next) => {
-    await next();
-    // Exclusion checks run after next() intentionally — c.res.status is only available
-    // after the route handler runs. The route still executes; we're only skipping the log write.
-    if (options.exclude?.methods?.includes(c.req.method))
-        return;
-    // Note: if exclude.paths grows large, regex evaluation on every request adds up.
-    // For high-traffic exclusions, prefer string matching over regex.
-    const path = c.req.path;
-    if (options.exclude?.paths?.some(p => typeof p === "string" ? p === path : p.test(path)))
-        return;
-    let entry = {
-        id: crypto.randomUUID(),
-        requestId: c.get("requestId") ?? undefined,
-        userId: c.get("authUserId") ?? null,
-        sessionId: c.get("sessionId") ?? null,
-        tenantId: c.get("tenantId") ?? null,
-        method: c.req.method,
-        path,
-        status: c.res.status,
-        ip: getClientIp(c),
-        userAgent: c.req.header("user-agent") ?? null,
-        createdAt: new Date().toISOString(),
-    };
-    if (options.onEntry) {
-        try {
-            entry = await options.onEntry(entry, c);
-        }
-        catch (err) {
-            console.error("[auditLog] onEntry hook threw:", err);
-        }
-    }
-    // Fire-and-forget — never block the response; logAuditEntry also swallows errors internally
-    logAuditEntry(entry, options).catch(err => {
-        console.error("[auditLog] write failed:", err);
-    });
-};

package/dist/middleware/bearerAuth.d.ts

@@ -1,2 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-export declare const bearerAuth: MiddlewareHandler;

package/dist/middleware/bearerAuth.js

@@ -1,11 +0,0 @@
-import { timingSafeEqual } from "../lib/crypto";
-export const bearerAuth = async (c, next) => {
-    const isProd = process.env.NODE_ENV === "production";
-    const validToken = (isProd ? process.env.BEARER_TOKEN_PROD : process.env.BEARER_TOKEN_DEV) ?? undefined;
-    const header = c.req.header("Authorization");
-    const token = header?.startsWith("Bearer ") ? header.slice(7) : null;
-    if (!token || !validToken || !timingSafeEqual(token, validToken)) {
-        return c.json({ error: "Unauthorized" }, 401);
-    }
-    await next();
-};

package/dist/middleware/cacheResponse.d.ts

@@ -1,15 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-import type { AppEnv } from "../lib/context";
-export declare function getCacheModel(): import("mongoose").Model<any, {}, {}, {}, any, any, any>;
-type CacheStore = "redis" | "mongo" | "sqlite" | "memory";
-export declare const setCacheStore: (store: CacheStore) => void;
-export declare const bustCache: (key: string) => Promise<void>;
-export declare const bustCachePattern: (pattern: string) => Promise<void>;
-type KeyFn = (c: Parameters<MiddlewareHandler<any>>[0]) => string;
-interface CacheOptions {
-    ttl?: number;
-    key: string | KeyFn;
-    store?: CacheStore;
-}
-export declare const cacheResponse: ({ ttl, key, store }: CacheOptions) => MiddlewareHandler<AppEnv>;
-export {};