@rebasepro/server 0.13.0 → 0.13.1-canary.g06dbe5b

package/dist/functions/function-loader.d.ts

@@ -6,6 +6,18 @@ export interface LoadedFunction {
     /** The Hono sub-app to mount */
     app: Hono<import("hono").Env>;
 }
+/** What a directory of function files produced: what mounted, and what did not. */
+export interface LoadedFunctions {
+    /** The functions that will be served. */
+    functions: LoadedFunction[];
+    /**
+     * One entry per file the loader saw and did **not** mount, each already
+     * phrased as `<name> (<reason>)`. Returned rather than only logged so the
+     * running server can say what is missing — a boot log line is not reachable
+     * from `GET /api/functions`.
+     */
+    problems: string[];
+}
 /**
  * Auto-discover Hono route files from a directory.
  *
@@ -14,5 +26,16 @@ export interface LoadedFunction {
  *   `functions/send-invoice.ts` → mounted at `/send-invoice`
  *
  * This mirrors how `loadCollectionsFromDirectory` works for collections.
+ *
+ * Returns only what loaded. Use {@link loadFunctionsWithDiagnostics} when the
+ * caller also needs to report what did not.
  */
 export declare function loadFunctionsFromDirectory(directory: string, importModule?: ModuleImporter): Promise<LoadedFunction[]>;
+/**
+ * {@link loadFunctionsFromDirectory}, plus the list of files that were skipped.
+ *
+ * Never throws: a single malformed function must not crash server boot. The
+ * caller decides what to do with `problems` — `init.ts` mounts the router
+ * regardless and surfaces the count on the listing endpoint.
+ */
+export declare function loadFunctionsWithDiagnostics(directory: string, importModule?: ModuleImporter): Promise<LoadedFunctions>;

package/dist/functions/function-routes.d.ts

@@ -6,5 +6,11 @@ import { LoadedFunction } from "./function-loader";
  *
  * Each function is mounted at `/<function-name>`, preserving
  * whatever HTTP methods and middleware the Hono sub-app defines.
+ *
+ * @param functions What loaded. May be empty — the router still mounts, so
+ *   "no functions are served" answers 200 with an empty list instead of 404.
+ * @param skipped How many files the loader saw and could not serve. Reported
+ *   as a count and a pointer to the log, not as filenames: the listing is
+ *   reachable anonymously, and the per-file reasons carry import errors.
  */
-export declare function createFunctionRoutes(functions: LoadedFunction[]): Hono<HonoEnv>;
+export declare function createFunctionRoutes(functions: LoadedFunction[], skipped?: number): Hono<HonoEnv>;

package/dist/functions/request-timeout.d.ts

@@ -0,0 +1,34 @@
+import type { MiddlewareHandler } from "hono";
+import type { HonoEnv } from "../api/types";
+/** Default ceiling for a custom function request, in milliseconds. */
+export declare const DEFAULT_FUNCTIONS_TIMEOUT_MS = 30000;
+/**
+ * Resolve the functions request timeout from config, then env, then the default.
+ *
+ * `0` (or any non-positive number) disables the ceiling — for a deployment
+ * whose proxy already imposes one, or a function that legitimately streams for
+ * minutes.
+ */
+export declare function resolveFunctionsTimeoutMs(configured?: number): number;
+/**
+ * A per-request ceiling for the custom functions router.
+ *
+ * Custom functions are the one router that runs code the framework did not
+ * write, and nothing else in the stack bounds how long that code takes: the
+ * Node server is constructed without `requestTimeout`/`headersTimeout`, so a
+ * handler awaiting a promise that never settles — a `fetch` to an unreachable
+ * third party with no `AbortSignal`, a query on a wedged connection — holds its
+ * socket and its request object until the client gives up. On the managed
+ * runtime the process is shared between tenants, so that is not only the slow
+ * caller's problem.
+ *
+ * The handler is **not** cancelled — it cannot be, there is no cancellation
+ * token to hand user code. What is bounded is the client-visible request: after
+ * `ms` the caller gets a 504 and the socket is released, and the handler's
+ * eventual result is dropped. It is a ceiling, not a kill switch, and the exact
+ * number matters far less than its existence.
+ *
+ * Mounted in front of the auth middleware rather than behind it, so a wedged
+ * driver — the failure that also hangs `withAuth()` — is covered too.
+ */
+export declare function createFunctionsRequestTimeout(ms: number): MiddlewareHandler<HonoEnv>;

package/dist/history/history-routes.d.ts

@@ -19,5 +19,11 @@ export interface HistoryService {
 export declare function createHistoryRoutes(params: {
     historyService: HistoryService;
     registry: BackendCollectionRegistry;
+    /**
+     * The unscoped driver, still accepted so the call in `init.ts` and any
+     * embedder's keeps compiling — and deliberately not read. Every read and
+     * write on these routes goes through the request-scoped driver instead;
+     * see {@link authorizeEntityRead}.
+     */
     driver: DataDriver;
 }): Hono<HonoEnv>;

package/dist/index.d.ts

@@ -14,7 +14,7 @@ export { loadCollectionsFromDirectory, applyCollectionDefaults, type CollectionD
 export { assertCollectionConfigs, findCollectionConfigProblems, unknownKeyPolicyFromEnv, type ConfigProblem, type UnknownKeyPolicy, type ValidateCollectionConfigOptions } from "./collections/validate-config";
 export * from "./db/interfaces";
 export * from "./auth/interfaces";
-export { requireAuth, requireAdmin, optionalAuth, queryTokenAuth, fileTokenAuth, extractUserFromToken, hashPassword, verifyPassword, validatePasswordStrength, generateSecurePassword, resolveAuthHooks, createBuiltinAuthAdapter, createCustomAuthAdapter, createGoogleProvider, createLinkedinProvider, createGitHubProvider, createMicrosoftProvider, createAppleProvider, createFacebookProvider, createTwitterProvider, createDiscordProvider, createGitLabProvider, createBitbucketProvider, createSlackProvider, createSpotifyProvider, isApiKeyToken, validateApiKey, httpMethodToOperation, isOperationAllowed, safeCompare } from "./auth";
+export { requireAuth, requireAdmin, optionalAuth, queryTokenAuth, fileTokenAuth, extractUserFromToken, hashPassword, verifyPassword, validatePasswordStrength, generateSecurePassword, resolveAuthHooks, createBuiltinAuthAdapter, createCustomAuthAdapter, createGoogleProvider, createLinkedinProvider, createGitHubProvider, createMicrosoftProvider, createAppleProvider, createFacebookProvider, createTwitterProvider, createDiscordProvider, createGitLabProvider, createBitbucketProvider, createSlackProvider, createSpotifyProvider, oauthCodeFlowSchema, pkceTokenParams, providerVerifiedEmail, verifyOidcIdToken, tryVerifyOidcIdToken, isApiKeyToken, validateApiKey, httpMethodToOperation, isOperationAllowed, safeCompare } from "./auth";
 export type { AccessTokenPayload, PasswordValidationResult, AuthHooks, AuthMethod, ResolvedAuthHooks, BuiltinAuthAdapterConfig, GoogleProviderConfig, AuthMiddlewareOptions, AuthResult, ApiKey, ApiKeyMasked, ApiKeyPermission, ApiKeyWithSecret, CreateApiKeyRequest, UpdateApiKeyRequest, ApiKeyStore, ApiKeyOperation } from "./auth";
 export * from "./api/types";
 export * from "./api/errors";
@@ -35,6 +35,7 @@ export type { RebaseEnv } from "./env";
 export * from "./types";
 export * from "./services/driver-registry";
 export * from "./services/webhook-service";
+export * from "./services/outbound-url-guard";
 export { cleanupDevPortFile, listenWithPortRetry } from "./utils/dev-port";
 export { serveSPA } from "./serve-spa";
 export { installShutdownHandlers } from "./init/shutdown";