@rebasepro/server 0.14.1 → 0.14.2-canary.g27a129e

package/dist/logs-routes-CWBLQj2l.js

@@ -0,0 +1,245 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-DSJWtz9O.js";
+import { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+//#region src/api/logs-routes.ts
+var logs_routes_exports = /* @__PURE__ */ __exportAll({
+	addLog: () => addLog,
+	createLogsRoutes: () => createLogsRoutes,
+	default: () => logs_routes_default,
+	logBuffer: () => logBuffer,
+	logMiddleware: () => logMiddleware
+});
+function normalizeFilter(options) {
+	return {
+		...options,
+		search: options.search?.toLowerCase()
+	};
+}
+/**
+* Whether one entry belongs in a filtered view.
+*
+* Shared by the query and the stream on purpose: two copies of this would drift,
+* and the failure that produces is invisible — a tail that quietly shows a
+* different set of lines than the snapshot it started from.
+*/
+function matchesFilter(entry, filter) {
+	if (filter.level && entry.level !== filter.level) return false;
+	if (filter.source && entry.source !== filter.source) return false;
+	if (filter.search && !entry.message.toLowerCase().includes(filter.search)) return false;
+	if (filter.since && entry.timestamp < filter.since) return false;
+	return true;
+}
+var LogRingBuffer = class {
+	buffer = [];
+	maxSize;
+	idCounter = 0;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(maxSize = 1e4) {
+		this.maxSize = maxSize;
+	}
+	push(entry) {
+		const id = `log_${++this.idCounter}`;
+		const stored = {
+			...entry,
+			id
+		};
+		this.buffer.push(stored);
+		if (this.buffer.length > this.maxSize) this.buffer.shift();
+		for (const listener of this.listeners) try {
+			listener(stored);
+		} catch {}
+	}
+	/**
+	* Follow the buffer. Returns the unsubscribe — call it, always: a listener
+	* left behind holds its whole closure, and on this class that closure is a
+	* pending-entry array.
+	*
+	* A listener must not log. It is called from inside `push`, so anything that
+	* reaches `addLog` from here recurses until the stack gives out.
+	*/
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	query(options) {
+		const filter = normalizeFilter(options);
+		const sorted = [...this.buffer.filter((e) => matchesFilter(e, filter))].reverse();
+		const total = sorted.length;
+		const limit = options.limit || 100;
+		const offset = options.offset || 0;
+		return {
+			entries: sorted.slice(offset, offset + limit),
+			total
+		};
+	}
+	getLatest(count = 50) {
+		return this.buffer.slice(-count).reverse();
+	}
+};
+var logBuffer = new LogRingBuffer();
+/** Add a log entry */
+function addLog(level, source, message, metadata) {
+	logBuffer.push({
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		level,
+		source,
+		message,
+		metadata
+	});
+}
+/** Hono middleware to log API requests */
+function logMiddleware(options = {}) {
+	const ignored = new Set(options.ignorePaths ?? []);
+	return async (c, next) => {
+		const start = Date.now();
+		await next();
+		if (ignored.has(c.req.path)) return;
+		const duration = Date.now() - start;
+		const reqId = c.get("requestId");
+		addLog("info", "api", `${c.req.method} ${c.req.path} ${c.res.status} ${duration}ms`, {
+			method: c.req.method,
+			path: c.req.path,
+			status: c.res.status,
+			duration,
+			...reqId && { requestId: reqId }
+		});
+	};
+}
+/**
+* How long entries accumulate before a batch goes out.
+*
+* Not zero, and that is the point. A busy server logs faster than a browser can
+* render, and one SSE frame per line would hand the client a re-render per
+* request served — worse than the 3s poll this replaces, precisely when the logs
+* are worth watching. Coalescing keeps the frame rate bounded by the window
+* rather than by traffic, and 250ms still reads as "live" to a person.
+*/
+var STREAM_FLUSH_MS = 250;
+/**
+* Idle gap after which the stream sends a comment line.
+*
+* A silent SSE connection is indistinguishable from a dead one to everything in
+* between — proxies, load balancers and laptop NICs all reap idle sockets, and a
+* server with nothing to say is the normal state here.
+*/
+var STREAM_HEARTBEAT_MS = 25e3;
+/**
+* Entries a single connection will hold between flushes.
+*
+* This is a *rate* ceiling, not just a memory bound, and that is easy to get
+* wrong: nothing drains `pending` between flushes, so the most a connection can
+* carry losslessly is `maxPending` per `flushMs` — here 2000 per 250ms, or 8000
+* entries a second. Above that the oldest pending entries go and the client is
+* told how many, whatever speed it is reading at.
+*
+* It was 500, which put that ceiling at 2000/s. A healthy reader on a loopback
+* socket lost 85% of a 20k burst to it — the cap fired on the server's own
+* coalescing window rather than on any slowness at the client, which is a drop
+* notice that says nothing true about why. 8000/s is past what one Node process
+* serves, so reaching it now means genuinely more log than a person can be shown.
+*
+* The memory this bounds is the copy a *stalled* reader causes: roughly 2000
+* entries, a few MB, per stuck connection.
+*/
+var STREAM_MAX_PENDING = 2e3;
+function createLogsRoutes(timing = {}) {
+	const flushMs = timing.flushMs ?? STREAM_FLUSH_MS;
+	const heartbeatMs = timing.heartbeatMs ?? STREAM_HEARTBEAT_MS;
+	const maxPending = timing.maxPending ?? STREAM_MAX_PENDING;
+	const app = new Hono();
+	app.get("/", (c) => {
+		const query = c.req.query();
+		const result = logBuffer.query({
+			level: query.level,
+			source: query.source,
+			search: query.search,
+			limit: query.limit ? parseInt(query.limit) : void 0,
+			offset: query.offset ? parseInt(query.offset) : void 0,
+			since: query.since
+		});
+		return c.json(result);
+	});
+	app.get("/latest", (c) => {
+		const count = parseInt(c.req.query("count") || "50");
+		return c.json({ entries: logBuffer.getLatest(count) });
+	});
+	app.get("/stream", (c) => {
+		const query = c.req.query();
+		const filter = normalizeFilter({
+			level: query.level,
+			source: query.source,
+			search: query.search
+		});
+		const limit = query.limit ? parseInt(query.limit) : 200;
+		c.header("X-Accel-Buffering", "no");
+		return streamSSE(c, async (stream) => {
+			let pending = [];
+			let dropped = 0;
+			const unsubscribe = logBuffer.subscribe((entry) => {
+				if (!matchesFilter(entry, filter)) return;
+				if (pending.length >= maxPending) {
+					pending.shift();
+					dropped++;
+				}
+				pending.push(entry);
+			});
+			const snapshot = logBuffer.query({
+				...filter,
+				limit
+			});
+			const abortOnDisconnect = () => {
+				if (!stream.closed) stream.abort();
+			};
+			c.req.raw.signal.addEventListener("abort", abortOnDisconnect, { once: true });
+			if (c.req.raw.signal.aborted) abortOnDisconnect();
+			try {
+				await stream.writeSSE({
+					event: "snapshot",
+					data: JSON.stringify({
+						entries: snapshot.entries.slice().reverse(),
+						total: snapshot.total
+					})
+				});
+				let idleMs = 0;
+				while (!stream.aborted && !stream.closed) {
+					await stream.sleep(flushMs);
+					if (stream.aborted || stream.closed) break;
+					if (pending.length === 0) {
+						idleMs += flushMs;
+						if (idleMs >= heartbeatMs) {
+							await stream.write(": ping\n\n");
+							idleMs = 0;
+						}
+						continue;
+					}
+					const entries = pending;
+					const lost = dropped;
+					pending = [];
+					dropped = 0;
+					idleMs = 0;
+					await stream.writeSSE({
+						event: "append",
+						data: JSON.stringify(lost > 0 ? {
+							entries,
+							dropped: lost
+						} : { entries })
+					});
+				}
+			} finally {
+				unsubscribe();
+				c.req.raw.signal.removeEventListener("abort", abortOnDisconnect);
+			}
+		});
+	});
+	return app;
+}
+var logs_routes_default = createLogsRoutes();
+//#endregion
+export { logs_routes_exports as n, logMiddleware as t };
+
+//# sourceMappingURL=logs-routes-CWBLQj2l.js.map

package/dist/logs-routes-CWBLQj2l.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs-routes-CWBLQj2l.js","names":[],"sources":["../src/api/logs-routes.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport type { MiddlewareHandler } from \"hono\";\nimport { streamSSE } from \"hono/streaming\";\nimport type { HonoEnv } from \"./types\";\n\nexport interface LogEntry {\n    id: string;\n    timestamp: string;\n    level: \"debug\" | \"info\" | \"warn\" | \"error\";\n    source: \"api\" | \"auth\" | \"storage\" | \"realtime\" | \"system\";\n    message: string;\n    metadata?: Record<string, unknown>;\n}\n\n/** What a caller can narrow the log by, in either direction (query or stream). */\nexport interface LogFilterOptions {\n    level?: string;\n    source?: string;\n    search?: string;\n    since?: string;\n}\n\n/**\n * A filter with the search term already lowercased.\n *\n * The distinction matters on the stream path: `query()` lowercases once and then\n * scans, but a subscriber tests one entry at a time and would otherwise redo the\n * same `toLowerCase()` on every request the server handles.\n */\ntype NormalizedFilter = LogFilterOptions;\n\nfunction normalizeFilter(options: LogFilterOptions): NormalizedFilter {\n    return { ...options,\n        search: options.search?.toLowerCase() };\n}\n\n/**\n * Whether one entry belongs in a filtered view.\n *\n * Shared by the query and the stream on purpose: two copies of this would drift,\n * and the failure that produces is invisible — a tail that quietly shows a\n * different set of lines than the snapshot it started from.\n */\nfunction matchesFilter(entry: LogEntry, filter: NormalizedFilter): boolean {\n    if (filter.level && entry.level !== filter.level) return false;\n    if (filter.source && entry.source !== filter.source) return false;\n    if (filter.search && !entry.message.toLowerCase().includes(filter.search)) return false;\n    if (filter.since && entry.timestamp < filter.since) return false;\n    return true;\n}\n\n/** Notified for every entry pushed, in push order. */\nexport type LogListener = (entry: LogEntry) => void;\n\nclass LogRingBuffer {\n    private buffer: LogEntry[] = [];\n    private maxSize: number;\n    private idCounter = 0;\n    private listeners = new Set<LogListener>();\n\n    constructor(maxSize = 10000) {\n        this.maxSize = maxSize;\n    }\n\n    push(entry: Omit<LogEntry, \"id\">): void {\n        const id = `log_${++this.idCounter}`;\n        const stored: LogEntry = { ...entry,\n            id };\n        this.buffer.push(stored);\n        if (this.buffer.length > this.maxSize) {\n            this.buffer.shift();\n        }\n        // This runs on the request hot path, so a listener must never be able to\n        // take the request down with it: a tail that throws loses its own tail,\n        // not the response the log line was describing.\n        for (const listener of this.listeners) {\n            try {\n                listener(stored);\n            } catch {\n                /* a broken tail is not the request's problem */\n            }\n        }\n    }\n\n    /**\n     * Follow the buffer. Returns the unsubscribe — call it, always: a listener\n     * left behind holds its whole closure, and on this class that closure is a\n     * pending-entry array.\n     *\n     * A listener must not log. It is called from inside `push`, so anything that\n     * reaches `addLog` from here recurses until the stack gives out.\n     */\n    subscribe(listener: LogListener): () => void {\n        this.listeners.add(listener);\n        return () => {\n            this.listeners.delete(listener);\n        };\n    }\n\n    query(options: LogFilterOptions & {\n        limit?: number;\n        offset?: number;\n    }): { entries: LogEntry[]; total: number } {\n        const filter = normalizeFilter(options);\n        const filtered = this.buffer.filter(e => matchesFilter(e, filter));\n\n        // Newest first\n        const sorted = [...filtered].reverse();\n        const total = sorted.length;\n        const limit = options.limit || 100;\n        const offset = options.offset || 0;\n\n        return {\n            entries: sorted.slice(offset, offset + limit),\n            total\n        };\n    }\n\n    getLatest(count = 50): LogEntry[] {\n        return this.buffer.slice(-count).reverse();\n    }\n}\n\n// Global singleton\nexport const logBuffer = new LogRingBuffer();\n\n/** Add a log entry */\nexport function addLog(\n    level: LogEntry[\"level\"],\n    source: LogEntry[\"source\"],\n    message: string,\n    metadata?: Record<string, unknown>\n): void {\n    logBuffer.push({\n        timestamp: new Date().toISOString(),\n        level,\n        source,\n        message,\n        metadata\n    });\n}\n\nexport interface LogMiddlewareOptions {\n    /**\n     * Paths this sink ignores, matched exactly against `c.req.path`.\n     *\n     * For requests whose only reason to exist is to read the log. Recording\n     * those makes the reader the loudest thing in its own output, and on a quiet\n     * server it is also the thing evicting real entries out of the ring.\n     */\n    ignorePaths?: string[];\n}\n\n/** Hono middleware to log API requests */\nexport function logMiddleware(options: LogMiddlewareOptions = {}): MiddlewareHandler<HonoEnv> {\n    const ignored = new Set(options.ignorePaths ?? []);\n    return async (c, next) => {\n        const start = Date.now();\n        await next();\n        if (ignored.has(c.req.path)) return;\n        const duration = Date.now() - start;\n        const reqId = c.get(\"requestId\");\n        addLog(\"info\", \"api\", `${c.req.method} ${c.req.path} ${c.res.status} ${duration}ms`, {\n            method: c.req.method,\n            path: c.req.path,\n            status: c.res.status,\n            duration,\n            ...(reqId && { requestId: reqId })\n        });\n    };\n}\n\n/**\n * How long entries accumulate before a batch goes out.\n *\n * Not zero, and that is the point. A busy server logs faster than a browser can\n * render, and one SSE frame per line would hand the client a re-render per\n * request served — worse than the 3s poll this replaces, precisely when the logs\n * are worth watching. Coalescing keeps the frame rate bounded by the window\n * rather than by traffic, and 250ms still reads as \"live\" to a person.\n */\nconst STREAM_FLUSH_MS = 250;\n\n/**\n * Idle gap after which the stream sends a comment line.\n *\n * A silent SSE connection is indistinguishable from a dead one to everything in\n * between — proxies, load balancers and laptop NICs all reap idle sockets, and a\n * server with nothing to say is the normal state here.\n */\nconst STREAM_HEARTBEAT_MS = 25_000;\n\n/**\n * Entries a single connection will hold between flushes.\n *\n * This is a *rate* ceiling, not just a memory bound, and that is easy to get\n * wrong: nothing drains `pending` between flushes, so the most a connection can\n * carry losslessly is `maxPending` per `flushMs` — here 2000 per 250ms, or 8000\n * entries a second. Above that the oldest pending entries go and the client is\n * told how many, whatever speed it is reading at.\n *\n * It was 500, which put that ceiling at 2000/s. A healthy reader on a loopback\n * socket lost 85% of a 20k burst to it — the cap fired on the server's own\n * coalescing window rather than on any slowness at the client, which is a drop\n * notice that says nothing true about why. 8000/s is past what one Node process\n * serves, so reaching it now means genuinely more log than a person can be shown.\n *\n * The memory this bounds is the copy a *stalled* reader causes: roughly 2000\n * entries, a few MB, per stuck connection.\n */\nconst STREAM_MAX_PENDING = 2000;\n\n/**\n * The stream's timings, injectable only so they can be tested.\n *\n * The defaults above are the contract and nothing in production passes this. A\n * heartbeat is a 25-second wait to observe, and a suite that cannot observe it is\n * a suite where the keepalive can rot — which surfaces as \"the tail dies after a\n * few minutes behind the load balancer\", months later, on someone else's cluster.\n */\nexport interface LogStreamTiming {\n    flushMs?: number;\n    heartbeatMs?: number;\n    maxPending?: number;\n}\n\nexport function createLogsRoutes(timing: LogStreamTiming = {}): Hono<HonoEnv> {\n    const flushMs = timing.flushMs ?? STREAM_FLUSH_MS;\n    const heartbeatMs = timing.heartbeatMs ?? STREAM_HEARTBEAT_MS;\n    const maxPending = timing.maxPending ?? STREAM_MAX_PENDING;\n\n    const app = new Hono<HonoEnv>();\n\n    // GET /api/logs — Query logs\n    app.get(\"/\", (c) => {\n        const query = c.req.query();\n        const result = logBuffer.query({\n            level: query.level,\n            source: query.source,\n            search: query.search,\n            limit: query.limit ? parseInt(query.limit) : undefined,\n            offset: query.offset ? parseInt(query.offset) : undefined,\n            since: query.since\n        });\n        return c.json(result);\n    });\n\n    // GET /api/logs/latest — Get latest logs (for real-time)\n    app.get(\"/latest\", (c) => {\n        const count = parseInt(c.req.query(\"count\") || \"50\");\n        return c.json({ entries: logBuffer.getLatest(count) });\n    });\n\n    // GET /api/logs/stream — tail the buffer over SSE.\n    //\n    // The Logs Explorer used to poll this router every 3 seconds, which cost a\n    // request per client per 3s to say \"nothing happened\" and still showed each\n    // line up to 3s late. Here the buffer pushes instead, so an idle server is an\n    // idle socket.\n    //\n    // Events:\n    //   snapshot  {entries, total}   the filtered window, oldest-first, at open\n    //   append    {entries, dropped} entries since the last frame, oldest-first\n    //   `: ping`                     comment, keepalive only\n    //\n    // Snapshot and appends come down the same connection deliberately. A client\n    // that fetched its backlog separately would race the subscription — entries\n    // logged between the two calls belong to neither — and closing that race from\n    // the outside needs an id cursor and dedupe on every frame.\n    app.get(\"/stream\", (c) => {\n        const query = c.req.query();\n        const filter = normalizeFilter({\n            level: query.level,\n            source: query.source,\n            search: query.search\n        });\n        const limit = query.limit ? parseInt(query.limit) : 200;\n\n        // Reverse proxies buffer text responses by default, which turns a live\n        // tail into nothing at all until the buffer fills. nginx (and the ingress\n        // in front of the managed runtime) reads this header; everything else\n        // ignores it. The rest of the SSE headers are set by `streamSSE`.\n        c.header(\"X-Accel-Buffering\", \"no\");\n\n        return streamSSE(c, async (stream) => {\n            let pending: LogEntry[] = [];\n            let dropped = 0;\n\n            // Subscribe *before* reading the backlog, with nothing awaited\n            // between the two. Both are synchronous, so the two halves meet\n            // exactly: an entry logged after the query but before the\n            // subscription would otherwise be in neither, and that gap is the one\n            // thing this route exists to close.\n            const unsubscribe = logBuffer.subscribe(entry => {\n                if (!matchesFilter(entry, filter)) return;\n                if (pending.length >= maxPending) {\n                    pending.shift();\n                    dropped++;\n                }\n                pending.push(entry);\n            });\n            const snapshot = logBuffer.query({ ...filter,\n                limit });\n\n            // A client that goes away has to end this handler, or the\n            // subscription outlives the socket. `streamSSE` only wires the\n            // request signal through on old Bun, so do it here and let\n            // `stream.aborted` be the one condition the loop tests.\n            //\n            // The `aborted` check is not belt-and-braces. A listener added to an\n            // already-aborted signal is never called, so a client that leaves\n            // during the snapshot write — a fast navigation, or a reconnect storm\n            // against a restarting server — would leave this handler with no way\n            // to learn it had gone: a subscriber and a flush loop, per attempt,\n            // for the life of the process.\n            const abortOnDisconnect = () => {\n                if (!stream.closed) stream.abort();\n            };\n            c.req.raw.signal.addEventListener(\"abort\", abortOnDisconnect, { once: true });\n            if (c.req.raw.signal.aborted) abortOnDisconnect();\n\n            try {\n                await stream.writeSSE({\n                    event: \"snapshot\",\n                    // The view tails like a terminal; both frames are oldest-first\n                    // so the client only ever appends.\n                    data: JSON.stringify({\n                        entries: snapshot.entries.slice().reverse(),\n                        total: snapshot.total\n                    })\n                });\n\n                let idleMs = 0;\n                while (!stream.aborted && !stream.closed) {\n                    await stream.sleep(flushMs);\n                    if (stream.aborted || stream.closed) break;\n\n                    if (pending.length === 0) {\n                        idleMs += flushMs;\n                        if (idleMs >= heartbeatMs) {\n                            await stream.write(\": ping\\n\\n\");\n                            idleMs = 0;\n                        }\n                        continue;\n                    }\n\n                    const entries = pending;\n                    const lost = dropped;\n                    pending = [];\n                    dropped = 0;\n                    idleMs = 0;\n                    await stream.writeSSE({\n                        event: \"append\",\n                        data: JSON.stringify(lost > 0 ? { entries,\n                            dropped: lost } : { entries })\n                    });\n                }\n            } finally {\n                unsubscribe();\n                c.req.raw.signal.removeEventListener(\"abort\", abortOnDisconnect);\n            }\n        });\n    });\n\n    return app;\n}\n\nexport default createLogsRoutes();\n"],"mappings":"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"}

package/dist/{openapi-generator-DQeQ_q2f.js → openapi-generator-DLiiGD9X.js}

@@ -1,8 +1,8 @@
 import { createRequire as __createRequire } from "module";
 import "process";
 __createRequire(import.meta.url);
-import { y as resolveCollectionRelations } from "./src-8XDWyDfR.js";
-import "./src-Cz9nMgUR.js";
+import { y as resolveCollectionRelations } from "./src-B-E7RjdN.js";
+import "./src-CrCxd8km.js";
 //#region ../types/src/types/relations.ts
 /** @group Models */
 function isToMany(relation) {
@@ -927,4 +927,4 @@ function toPascalCase(str) {
 //#endregion
 export { generateOpenApiSpec };
 
-//# sourceMappingURL=openapi-generator-DQeQ_q2f.js.map
+//# sourceMappingURL=openapi-generator-DLiiGD9X.js.map