@rebasepro/server 0.10.0 → 0.10.1-canary.14e53ae

package/dist/metrics/index.d.ts

@@ -0,0 +1,83 @@
+import { Hono } from "hono";
+import type { MiddlewareHandler } from "hono";
+import type { HonoEnv } from "../api/types";
+/**
+ * Runtime metrics, in Prometheus text format.
+ *
+ * The point of emitting these from the runtime rather than scraping the
+ * container is that only the runtime knows what a request *was*. A pod-level CPU
+ * graph cannot tell you that auth is slow while data is fine, or that one app is
+ * generating all the traffic. Surface by surface is the difference between a
+ * chart that looks like observability and one you can act on.
+ *
+ * Self-hosters get the same endpoint — this is a plain Prometheus target, not a
+ * hook into a hosted platform.
+ */
+/** Which part of the API served a request. */
+export type MetricSurface = "data" | "auth" | "storage" | "functions" | "admin" | "meta" | "other";
+export declare class MetricsRegistry {
+    private requests;
+    private latency;
+    private gauges;
+    private counters;
+    readonly startedAt: number;
+    private static labelKey;
+    private static parseLabels;
+    /**
+     * Key a named series.
+     *
+     * Concatenating a name and its labels without a separator would let metric
+     * `rebase_x` with label `y=1` collide with a metric literally named
+     * `rebase_xy=1`.
+     */
+    private static namedKey;
+    private static splitNamedKey;
+    recordRequest(labels: Record<string, string>, durationMs: number): void;
+    incrementCounter(name: string, labels?: Record<string, string>, by?: number): void;
+    setGauge(name: string, value: number, labels?: Record<string, string>): void;
+    /** Prometheus escaping: backslash, quote and newline, in that order. */
+    private static formatLabels;
+    /** Group `name -> [[labelKey, value]]` for one-HELP-per-metric rendering. */
+    private static group;
+    render(): string;
+}
+/**
+ * Classify a path into the surface that served it.
+ *
+ * Path *shape*, never the full path: a label per entity id would create an
+ * unbounded set of time series, which is the classic way to take down a
+ * Prometheus. Collection slugs are bounded by the schema, so those are safe and
+ * genuinely useful.
+ */
+export declare function classifySurface(pathname: string, basePath?: string): {
+    surface: MetricSurface;
+    collection?: string;
+};
+export interface MetricsHandle {
+    registry: MetricsRegistry;
+    middleware: MiddlewareHandler<HonoEnv>;
+    /**
+     * Restrict the `collection` label to names that actually exist.
+     *
+     * Called once the collections are known — the middleware has to be installed
+     * before them, since it must wrap every request. Until it is called, and for
+     * any name not in the set, the label is dropped: a path segment is attacker-
+     * controlled, and one series per value invented is unbounded memory.
+     */
+    setKnownCollections(slugs: Iterable<string>): void;
+}
+/**
+ * Build the request-timing middleware and the registry it feeds.
+ *
+ * Timing wraps `next()` in a `finally`, so a request that throws is still
+ * counted — an endpoint that only ever fails would otherwise be invisible in
+ * exactly the situation the metrics exist for.
+ */
+export declare function createMetricsMiddleware(basePath?: string): MetricsHandle;
+/**
+ * Mount the scrape endpoint.
+ *
+ * When a token is configured it is required, and compared in constant time — a
+ * timing oracle on a metrics token is a small thing, but it is free to avoid.
+ */
+export declare function createMetricsRoutes(registry: MetricsRegistry, token?: string): Hono<HonoEnv>;

package/dist/{src-CsHhSKbi.js → src-BITicbgD.js}

@@ -490,6 +490,176 @@ function getDataSourceCapabilities(engine) {
 */
 var DEFAULT_STORAGE_SOURCE_KEY = "(default)";
 //#endregion
-export { RebaseApiError as _, policy as a, isPostgresCollectionConfig as c, REST_TO_CANONICAL as d, toCanonicalOp as f, Vector as g, GeoPoint as h, isSQLAdmin as i, CANONICAL_TO_REST as l, EntityRelation as m, DEFAULT_DATA_SOURCE_KEY as n, getCollectionDataPath as o, EntityReference as p, getDataSourceCapabilities as r, getDeclaredSubcollections as s, DEFAULT_STORAGE_SOURCE_KEY as t, NULL_OPS as u, RebaseClientError as v };
+//#region ../types/src/types/project_manifest.ts
+/** Header carrying the schema version an SDK was generated from. */
+var SCHEMA_VERSION_HEADER = "x-rebase-schema";
+//#endregion
+//#region ../types/src/types/collection_contract.ts
+/** Depth limit for the walk — deep enough for real configs, finite for cyclic ones. */
+var MAX_DEPTH = 64;
+/**
+* Resolve whatever a `target` thunk returns down to a collection.
+*
+* A target may be the collection, a module namespace (when the authoring file
+* used `import * as`), or a default-export wrapper. All three appear in real
+* projects, and the SDK generator already unwraps them the same way.
+*/
+function unwrapTarget(value) {
+	if (!value || typeof value !== "object") return void 0;
+	const candidate = value;
+	if (candidate.default || candidate.__esModule) {
+		const inner = candidate.default;
+		if (inner && typeof inner === "object") return inner;
+	}
+	if (candidate.properties) return value;
+}
+/** The identity a serialized reference uses. Slug first — it is the routing key. */
+function refFor(collection) {
+	if (!collection) return void 0;
+	const withPath = collection;
+	return collection.slug || withPath.path || collection.name;
+}
+function toSerializable(value, seen, depth, state, key) {
+	if (depth > MAX_DEPTH) {
+		state.truncations++;
+		return;
+	}
+	if (typeof value === "function") {
+		if (key === "target") try {
+			const ref = refFor(unwrapTarget(value()));
+			return ref ? { __collectionRef: ref } : void 0;
+		} catch {
+			return;
+		}
+		return;
+	}
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return value.toISOString();
+	if (value instanceof RegExp) return value.source;
+	if (seen.has(value)) {
+		state.truncations++;
+		return;
+	}
+	const cached = state.memo.get(value);
+	if (cached !== void 0) return cached;
+	seen.add(value);
+	const truncationsBefore = state.truncations;
+	const memoize = (result) => {
+		if (result !== void 0 && state.truncations === truncationsBefore) state.memo.set(value, result);
+		return result;
+	};
+	try {
+		if (Array.isArray(value)) {
+			const items = value.map((item) => toSerializable(item, seen, depth + 1, state)).filter((item) => item !== void 0);
+			return memoize(value.length > 0 && items.length === 0 ? void 0 : items);
+		}
+		if ("$$typeof" in value) return void 0;
+		const entries = Object.entries(value);
+		const out = {};
+		for (const [k, v] of entries) {
+			const converted = toSerializable(v, seen, depth + 1, state, k);
+			if (converted !== void 0) out[k] = converted;
+		}
+		if (entries.length > 0 && Object.keys(out).length === 0) return void 0;
+		return memoize(out);
+	} finally {
+		seen.delete(value);
+	}
+}
+/**
+* Serialize collections for transport over the contract endpoint.
+*
+* Sorted by slug so the output — and therefore the schema hash computed from it
+* — does not depend on filesystem ordering.
+*/
+function serializeCollections(collections) {
+	return [...collections].sort((a, b) => String(a.slug ?? "").localeCompare(String(b.slug ?? ""))).map((collection) => toSerializable(collection, /* @__PURE__ */ new WeakSet(), 0, {
+		memo: /* @__PURE__ */ new WeakMap(),
+		truncations: 0
+	})).filter((c) => c !== void 0);
+}
+//#endregion
+//#region ../types/src/types/schema_version.ts
+/**
+* The schema version stamp.
+*
+* One function, used in three places that must agree or the whole drift-detection
+* story is noise: `rebase build` writes it into a bundle manifest, the runtime
+* serves it from the contract endpoint, and a generated SDK records the value it
+* was built from. If any two of those computed it differently, every client would
+* look permanently out of date.
+*
+* It covers **collections only** — the client's contract is the shape of the
+* data, so editing a hook or a server function must not invalidate every SDK in
+* every repository. That is a deliberate narrowing, not an oversight.
+*/
+/** Stable stringify: object keys sorted at every level, so key order cannot alter the hash. */
+function canonicalize(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(canonicalize).join(",")}]`;
+	return `{${Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonicalize(v)}`).join(",")}}`;
+}
+/**
+* Reduce a collection to the parts a generated client is actually built from.
+*
+* The version answers one question — "is this SDK stale?" — so it must change
+* exactly when the generated types could change, and never otherwise. Hashing a
+* whole collection fails both halves of that:
+*
+* - Security rules, callbacks, icons, groups and UI settings do not appear in a
+*   generated client, so including them reports perfectly current SDKs as stale.
+* - Worse, they are not stable *inputs*. The runtime applies default security
+*   rules when it loads collections, so the same source hashed before and after
+*   loading produced two different answers — a build-time stamp that could never
+*   match the server that served it.
+*
+* Codegen reads the slug (for the `Database` key and type names), the properties,
+* and the relations. That is the projection.
+*/
+function projectForCodegen(collection) {
+	const source = collection;
+	return {
+		slug: collection.slug ?? source.path,
+		properties: collection.properties,
+		relations: source.relations,
+		engine: source.engine,
+		dataSource: source.dataSource,
+		subcollections: source.subcollections?.map(projectForCodegen)
+	};
+}
+/**
+* Compute the canonical string a schema version hashes.
+*
+* Exposed separately so the hashing itself can differ by environment: Node has
+* `crypto`, and callers without it can still compare canonical forms directly.
+*/
+function canonicalSchemaPayload(collections) {
+	return canonicalize(serializeCollections(collections).map((collection) => projectForCodegen(collection)));
+}
+/**
+* A short, non-cryptographic digest of the canonical payload.
+*
+* FNV-1a style, 64 bits, as two 32-bit halves. This is an identity, not a
+* security boundary: nothing trusts a schema version to prove anything, it only
+* answers "is this the same schema as before". A hand-rolled hash keeps this
+* module free of `node:crypto`, so the identical function runs in the browser,
+* in the CLI, and in the runtime — which is the property that actually matters.
+*/
+function computeSchemaVersion(collections) {
+	const payload = canonicalSchemaPayload(collections);
+	let h1 = 2166136261;
+	let h2 = 16777619;
+	for (let i = 0; i < payload.length; i++) {
+		const code = payload.charCodeAt(i);
+		h1 ^= code;
+		h1 = h1 + ((h1 << 1) + (h1 << 4) + (h1 << 7) + (h1 << 8) + (h1 << 24)) >>> 0;
+		h2 ^= code + i;
+		h2 = h2 + ((h2 << 1) + (h2 << 5) + (h2 << 9) + (h2 << 15) + (h2 << 24)) >>> 0;
+	}
+	const hex = (n) => n.toString(16).padStart(8, "0");
+	return `v1:${hex(h1)}${hex(h2)}`;
+}
+//#endregion
+export { EntityRelation as _, DEFAULT_DATA_SOURCE_KEY as a, RebaseApiError as b, policy as c, isPostgresCollectionConfig as d, CANONICAL_TO_REST as f, EntityReference as g, toCanonicalOp as h, DEFAULT_STORAGE_SOURCE_KEY as i, getCollectionDataPath as l, REST_TO_CANONICAL as m, serializeCollections as n, getDataSourceCapabilities as o, NULL_OPS as p, SCHEMA_VERSION_HEADER as r, isSQLAdmin as s, computeSchemaVersion as t, getDeclaredSubcollections as u, GeoPoint as v, RebaseClientError as x, Vector as y };
 
-//# sourceMappingURL=src-CsHhSKbi.js.map
+//# sourceMappingURL=src-BITicbgD.js.map