@rebasepro/server 0.24.0 → 0.24.1-canary.g19596ef

package/dist/functions/index.js

@@ -96,13 +96,15 @@ var INSTANCE_SLOT = Symbol.for("@rebasepro/server:singleton-instance");
 * A *function* that answers "which client is this call for", for hosts where
 * one answer per process is the wrong shape.
 *
-* A Node server boots once and serves every request from the same client, so
-* {@link INSTANCE_SLOT} is the whole story. An isolate-based host is different
-* in a way that matters: the environment arrives attached to the **request**,
-* not to the module, so there is nothing to publish at import time, and an
-* isolate can be reused across requests that must not share state. Such a host
-* registers a resolver — typically reading an `AsyncLocalStorage` populated per
-* request — and it is consulted first.
+* {@link INSTANCE_SLOT} is one answer per process: the default backend's. A
+* Node process can hold several backends, and the code each one runs — a
+* function, a cron job, a hook — must see that one, so the server registers a
+* resolver reading the backend scope it enters per request (an
+* `AsyncLocalStorage`, host-side, in `backend/scope.ts`). An isolate-based
+* host is different in the same way: the environment arrives attached to the
+* **request**, not to the module, so there is nothing to publish at import
+* time, and an isolate can be reused across requests that must not share
+* state. The resolver is consulted first.
 *
 * This exists now, before there is a host that needs it, because of what it
 * protects: `rebase` is a lazy Proxy, so every property access already goes
@@ -123,10 +125,13 @@ function getInstance() {
 	return global[INSTANCE_SLOT] ?? null;
 }
 /**
-* The server-side Rebase singleton.
+* The server-side Rebase client, as a module-level handle.
 *
-* Initialized automatically during server startup. Provides access to all
-* app-scoped services: **data**, **auth**, **storage**, and **email**.
+* Inside a request, cron run or job a backend serves, it is that backend's
+* client (`backend.rebase`) — so with two backends in one process, each one's
+* functions see their own. Anywhere else it is the process default's, which
+* `initializeRebaseBackend` (or `setDefaultBackend`) installs. Provides access
+* to all app-scoped services: **data**, **auth**, **storage**, and **email**.
 *
 * **Admin data plane** (`rebase.dataAsAdmin`):
 * Backed by the native DataDriver — calls go directly to the database without
@@ -185,12 +190,25 @@ var rebase = new Proxy({}, {
 		return instance[prop];
 	},
 	set(_, prop) {
-		throw new Error(`Cannot set rebase.${String(prop)} directly. The singleton is read-only. Use _initRebase() during server startup.`);
+		throw new Error(`Cannot set rebase.${String(prop)} directly. The singleton is read-only. Install a backend with setDefaultBackend(backend), or use backend.rebase.`);
 	}
 });
 //#endregion
 //#region src/functions/define-function.ts
 /**
+* The `rebase` handle, seen through the `Database` a function names.
+*
+* One object serves every function; `DB` only describes it. It resolves, per
+* call, to the backend serving the request — the same answer the imported
+* `rebase` gives. Each collection accessor on `dataAsAdmin` is resolved by
+* name at call time, so a generated `Database` adds compile-time checks and
+* changes nothing the object does — the same reason the browser client's
+* `createRebaseClient<Database>()` is one implementation for every `Database`.
+*/
+function typedSingleton() {
+	return rebase;
+}
+/**
 * Typed authoring contract for a custom backend function.
 *
 * A custom function is a file in the `functionsDir` that default-exports a
@@ -227,7 +245,7 @@ var rebase = new Proxy({}, {
 */
 function defineFunction(definition) {
 	const app = new Hono();
-	const returned = definition(app, { rebase });
+	const returned = definition(app, { rebase: typedSingleton() });
 	return returned instanceof Hono ? returned : app;
 }
 //#endregion
@@ -393,6 +411,17 @@ function getRequestId(c) {
 	return read(c, "requestId");
 }
 /**
+* The signal aborted when this request outlasts the functions timeout and is
+* answered `504 FUNCTION_TIMEOUT`. Pass it to `fetch` and anything else that
+* takes one, so the work stops with the request instead of running on after
+* the caller was told it failed.
+*
+* Never aborts when the timeout is off, or outside the functions router.
+*/
+function getSignal(c) {
+	return read(c, "functionSignal") ?? new AbortController().signal;
+}
+/**
 * Whether a Rebase auth middleware has run on this request.
 *
 * Both middlewares populate `driver` for *every* outcome, anonymous included,
@@ -686,6 +715,8 @@ function isProduction() {
 * not be undone, because the originals were gone.
 */
 var configuredLevel;
+/** Every line to stderr, when a command's stdout is its result. See {@link setLogOutput}. */
+var everyLineToStderr = false;
 function getMinLevel() {
 	if (configuredLevel) return configuredLevel;
 	const env = (hostEnv().LOG_LEVEL || "info").trim().toLowerCase();
@@ -907,13 +938,13 @@ function createLogger(rawDefaultFields = {}) {
 				...merged
 			};
 			const line = JSON.stringify(entry);
-			if (level === "error") writeLine("err", line);
+			if (level === "error" || everyLineToStderr) writeLine("err", line);
 			else writeLine("out", line);
 		} else {
 			const prefix = level === "error" ? "❌" : level === "warn" ? "⚠️" : level === "info" ? "ℹ️" : "🐛";
 			const extra = Object.keys(merged).length > 0 ? ` ${JSON.stringify(merged)}` : "";
 			const out = `${prefix} [${level.toUpperCase()}] ${safeMessage}${extra}`;
-			if (level === "error") console.error(out);
+			if (level === "error" || everyLineToStderr) console.error(out);
 			else if (level === "warn") console.warn(out);
 			else console.log(out);
 		}
@@ -1004,6 +1035,8 @@ function logBackgroundFailure(c, error) {
 }
 //#endregion
 //#region src/api/errors.ts
+/** What a caller is told when the database cannot be reached. Retryable, and not about them. */
+var DATABASE_UNAVAILABLE_MESSAGE = "The database could not be reached, so this request was not served. Retry shortly; if it keeps happening, the server's database is down or unreachable from it.";
 /**
 * Standardized API error class.
 * Throw this from any route handler — the errorHandler middleware
@@ -1076,8 +1109,19 @@ var ApiError = class ApiError extends Error {
 	static serviceUnavailable(message, code = "SERVICE_UNAVAILABLE") {
 		return new ApiError(503, code, message);
 	}
+	/**
+	* `503 DATABASE_UNAVAILABLE`: the database could not be reached. What
+	* every door answers then — the data API, sign-in, the admin routes and
+	* the realtime socket — so a client sees one retryable answer, sent with
+	* `Retry-After`, rather than a permission failure or a crash.
+	*
+	* @see isDatabaseUnreachable
+	*/
+	static databaseUnavailable(message = DATABASE_UNAVAILABLE_MESSAGE) {
+		return new ApiError(503, "DATABASE_UNAVAILABLE", message);
+	}
 };
 //#endregion
-export { ApiError, defineFunction, env, getApiKey, getDriver, getEnv, getRequestId, getRoles, getScopes, getUser, getUserId, hasRole, hasScope, identityResolved, isAdmin, isAuthenticated, isNodeRuntime, lazyResource, rebase, requireAdmin, requireAuth, requireDriver, requireEnv, requireRole, requireScope, runtimeKey, waitUntil };
+export { ApiError, defineFunction, env, getApiKey, getDriver, getEnv, getRequestId, getRoles, getScopes, getSignal, getUser, getUserId, hasRole, hasScope, identityResolved, isAdmin, isAuthenticated, isNodeRuntime, lazyResource, rebase, requireAdmin, requireAuth, requireDriver, requireEnv, requireRole, requireScope, runtimeKey, waitUntil };
 
 //# sourceMappingURL=index.js.map