@rebasepro/server 0.23.0 → 0.24.1-canary.g19596ef

package/dist/init/docs.d.ts

@@ -1,16 +1,41 @@
 import { Hono, type MiddlewareHandler } from "hono";
 import { CollectionConfig } from "@rebasepro/types";
 import { HonoEnv } from "../api/types.js";
+/** The OpenAPI document builder, loaded on demand — see {@link loadOpenApiGenerator}. */
+export type OpenApiGenerator = typeof import("../api/openapi-generator.js").generateOpenApiSpec;
+/**
+ * Load the document builder. Separate from mounting so the mount is
+ * synchronous: a backend loads it once while it is built, and mounts the
+ * routes wherever and as often as the application asks.
+ */
+export declare function loadOpenApiGenerator(): Promise<OpenApiGenerator>;
+export interface OpenApiDocsOptions {
+    enableSwagger: boolean | undefined;
+    /**
+     * The collections the REST routes were generated from — the ones whose
+     * data source has a `"server"` transport — not every active collection. A
+     * direct-transport collection is served by the client against its own
+     * backend; documenting it here publishes a full set of CRUD paths that
+     * 404, with a Try-It button next to each.
+     */
+    serverCollections: CollectionConfig[];
+    requireAuth: boolean;
+    /** The runtime's admin gate — the middlewares every admin surface sits behind — for the spec when it is not public. */
+    adminGate: MiddlewareHandler<HonoEnv>[];
+    /** The document builder. Only read when there are collections to document. */
+    generate: OpenApiGenerator | undefined;
+    /** Whether to log where Swagger UI is. Default `true`. */
+    announce?: boolean;
+    /**
+     * Tables the driver skipped for having row-level security disabled, which
+     * the answer names when there are no collections to document.
+     */
+    unprotectedTables?: readonly {
+        schema: string;
+        table: string;
+    }[];
+}
 /**
  * Serve the OpenAPI document, and Swagger UI outside production.
- *
- * `serverCollections` must be the collections the REST routes were generated
- * from — the ones whose data source has a `"server"` transport — not every
- * active collection. A direct-transport collection is served by the client
- * against its own backend; documenting it here publishes a full set of CRUD
- * paths that 404, with a Try-It button next to each.
- *
- * `adminGate` is the runtime's admin gate — the middlewares every admin surface
- * sits behind — for the spec when it is not public.
  */
-export declare function mountOpenApiDocs(app: Hono<HonoEnv>, basePath: string, enableSwagger: boolean | undefined, serverCollections: CollectionConfig[], requireAuth: boolean, adminGate: MiddlewareHandler<HonoEnv>[]): Promise<void>;
+export declare function mountOpenApiDocs(app: Hono<HonoEnv>, basePath: string, options: OpenApiDocsOptions): void;

package/dist/init/health.d.ts

@@ -1,4 +1,4 @@
-import { AuthSchemaHealth, DataDriver, HealthCheckResult } from "@rebasepro/types";
+import { AuthSchemaHealth, DataDriver, HealthCheckResult, RealtimeProvider } from "@rebasepro/types";
 /**
  * @param defaultDriver     — probed for basic database reachability.
  * @param authSchemaCheck   — optional; asserts the auth schema is one this
@@ -8,4 +8,19 @@ import { AuthSchemaHealth, DataDriver, HealthCheckResult } from "@rebasepro/type
  *   check. Reporting that as healthy is what lets an orchestrator keep routing
  *   traffic to a server that cannot authenticate anyone.
  */
-export declare function createHealthCheck(defaultDriver: DataDriver, authSchemaCheck?: () => Promise<AuthSchemaHealth>): () => Promise<HealthCheckResult>;
+/**
+ * How long a realtime LISTEN connection may be down before `/health` says so.
+ *
+ * A dropped connection is replaced within seconds, and a pod that reports
+ * itself degraded over that would shed traffic for nothing. One still down
+ * after this is not reconnecting: every external and cross-instance change is
+ * being lost while writes through this pod still look live, which is the
+ * failure an orchestrator should route around.
+ */
+export declare const REALTIME_LISTENER_GRACE_MS = 60000;
+/**
+ * @param realtimeProviders — optional; each reports the LISTEN connections it
+ *   depends on. One down past {@link REALTIME_LISTENER_GRACE_MS} makes the
+ *   check unhealthy; one down for less is reported but not failed on.
+ */
+export declare function createHealthCheck(defaultDriver: DataDriver, authSchemaCheck?: () => Promise<AuthSchemaHealth>, realtimeProviders?: RealtimeProvider[]): () => Promise<HealthCheckResult>;

package/dist/init/process-safety.d.ts

@@ -19,7 +19,12 @@
  *
  * Set `REBASE_EXIT_ON_UNHANDLED_REJECTION=1` to restore Node's default.
  *
- * @returns An uninstall function (used by tests), or `undefined` when nothing
- * was installed.
+ * `initializeRebaseBackend` calls it first. A process that builds its backend
+ * with `createRebaseBackend` calls it itself if it wants the same — it is the
+ * process's decision, not a backend's. Idempotent across every copy of this
+ * package in the process.
+ *
+ * @returns An uninstall function, or `undefined` when nothing was installed
+ * (already installed, or switched off by the variable).
  */
 export declare function installUnhandledRejectionHandler(): (() => void) | undefined;

package/dist/init/shutdown.d.ts

@@ -1,7 +1,12 @@
 import { Server } from "http";
 import { RealtimeProvider } from "@rebasepro/types";
 interface ShutdownConfig {
-    server: Server;
+    /**
+     * The HTTP server to drain and close, when the backend was handed one.
+     * Absent, the shutdown stops the backend's own work and leaves the server
+     * to whoever created it.
+     */
+    server?: Server;
     /** Structural, for the same no-circular-imports reason as the backend below. */
     cronScheduler?: {
         stop(timeoutMs?: number): Promise<void> | void;
@@ -14,9 +19,29 @@ interface ShutdownConfig {
     rlsAudit?: {
         stop(): void;
     };
+    /** The expired-token sweep: its timer, and the tick it may have running. */
+    authTokenSweep?: {
+        stop(): Promise<void> | void;
+    };
+    /** The history retention sweep: its timer, and the sweep it may have running. */
+    historyRetentionSweep?: {
+        stop(): Promise<void> | void;
+    };
     /** The stop `MetricsHistory.start()` returned: its interval writes to the pool. */
     stopMetricsSampler?: () => void;
     realtimeServices: Record<string, RealtimeProvider>;
+    /**
+     * End the responses that stay open until their client leaves — the Logs
+     * Explorer's SSE tail. `server.close()` waits for every open connection, so
+     * one of these left open held the shutdown to its force timeout.
+     */
+    closeLongLivedResponses?: () => void;
+    /**
+     * The email service, when one is configured. A pooled SMTP transport keeps
+     * its connections open between sends; one with a `close()` is closed once
+     * nothing else can send, rather than left for its idle timer.
+     */
+    emailService?: object;
 }
 /**
  * Minimal structural view of the backend instance needed by