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

package/dist/boot/options.d.ts

@@ -0,0 +1,20 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import type { RebaseAuthConfig } from "../init";
+import type { EmailConfig } from "../email";
+import type { RebaseBootEnv } from "./env";
+/**
+ * Build the email configuration, or `undefined` when no SMTP host is set.
+ *
+ * Without it the auth adapter still works; password-reset and verification mail
+ * simply has nowhere to go, which the auth routes report for themselves.
+ */
+export declare function resolveEmailOptions(env: RebaseBootEnv): EmailConfig | undefined;
+/**
+ * Build the auth configuration from the environment and the bundle's users
+ * collection.
+ *
+ * OAuth providers are included only when both halves of a credential pair are
+ * present. Google is the exception the template already made: a client id alone
+ * is enough, because the ID-token flow needs no secret.
+ */
+export declare function resolveAuthOptions(env: RebaseBootEnv, usersCollection: CollectionConfig | undefined): RebaseAuthConfig;

package/dist/boot/sources.d.ts

@@ -0,0 +1,77 @@
+import { type DataSourceDefinition, type StorageSourceDefinition } from "@rebasepro/types";
+import type { BackendStorageConfig } from "../storage/types";
+/**
+ * Resolving *named* data and storage sources from the environment.
+ *
+ * A project is not required to have one database and one bucket. Collections
+ * already route by `collection.dataSource`, storage properties already route by
+ * `storageSource`, and the backend already registers one driver per source key —
+ * so the only piece missing was a way to *configure* the second, third and fourth
+ * of each without hand-writing an entrypoint.
+ *
+ * The naming rule is mechanical, and deliberately derives the variable name from
+ * the declared key rather than trying to discover keys by scanning the
+ * environment. Scanning would have to guess how `DATABASE_URL_READ_REPLICA` splits
+ * into a key; deriving cannot be ambiguous, and a typo shows up as a missing
+ * source at boot instead of a silently ignored variable.
+ *
+ * ```
+ *   <BASE>            the default source        DATABASE_URL, S3_BUCKET
+ *   <BASE>__<KEY>     a named source            DATABASE_URL__ANALYTICS, S3_BUCKET__MEDIA
+ * ```
+ *
+ * The double underscore matters: single-underscore suffixes collide with real
+ * variable names (`S3_BUCKET_NAME` would parse as bucket "name").
+ */
+/** Environment lookup, injectable so tests need not mutate `process.env`. */
+export type EnvBag = Record<string, string | undefined>;
+/**
+ * Convert a source key into the suffix used in environment variable names.
+ *
+ * The default key maps to no suffix at all, which is what keeps every existing
+ * single-database deployment working untouched.
+ */
+export declare function envSuffixForKey(key: string, defaultKey: string): string;
+/** A data source resolved to everything needed to build a driver for it. */
+export interface ResolvedDataSourceConfig {
+    /** Data-source key — becomes the driver-registry id collections route by. */
+    key: string;
+    engine: string;
+    /** npm package implementing the driver. */
+    driverPackage: string;
+    connectionString: string;
+    adminConnectionString?: string;
+    readConnectionString?: string;
+    isDefault: boolean;
+    poolConfig?: Record<string, number>;
+}
+/**
+ * Resolve every server-transport data source to a connection.
+ *
+ * `direct` and `custom` transports are skipped: the client talks to those
+ * itself, so the backend holds no connection for them and must not demand one.
+ *
+ * A declared source with no connection string is an error rather than a warning.
+ * The alternative — starting without it — means every collection routed to that
+ * source silently falls back to the default database, which is data landing in
+ * the wrong place with a healthy-looking server in front of it.
+ */
+export declare function resolveDataSources(env: EnvBag, definitions: DataSourceDefinition[] | undefined): ResolvedDataSourceConfig[];
+/**
+ * Build one storage configuration from the variables for a single source.
+ *
+ * Returns `undefined` when the source has no configuration at all, so an
+ * optional bucket that was never set does not fail a boot. The production
+ * "local storage is off" rule deliberately does *not* live here — it is enforced
+ * once, in `initializeStorage`, which logs precisely why storage is disabled.
+ * Duplicating it would mean two places to keep in agreement.
+ */
+export declare function resolveStorageBackend(env: EnvBag, key: string, engineHint: string | undefined, defaultBasePath: string): BackendStorageConfig | undefined;
+/**
+ * Resolve every server-transport storage source into a controller config map.
+ *
+ * The returned shape is the `Record<key, config>` the backend already accepts,
+ * so multiple buckets need nothing new downstream — they were always supported,
+ * they just had no way to be configured from the environment.
+ */
+export declare function resolveStorageSources(env: EnvBag, definitions: StorageSourceDefinition[] | undefined, defaultBasePath: string): Record<string, BackendStorageConfig> | undefined;

package/dist/index.d.ts

@@ -36,3 +36,18 @@ export { cleanupDevPortFile, listenWithPortRetry } from "./utils/dev-port";
 export { serveSPA } from "./serve-spa";
 export { installShutdownHandlers } from "./init/shutdown";
 export type { ShutdownHandlerOptions } from "./init/shutdown";
+export { bootFromBundle, runFromBundle } from "./boot/boot";
+export type { BootedRuntime, BootOptions } from "./boot/boot";
+export { BundleError, loadBundle, readBundleManifest, loadBundleConfigExports, createSourceBundle, loadBundleSchema, loadUsersCollection } from "./boot/bundle";
+export type { LoadedBundle, BundleConfigExports } from "./boot/bundle";
+export { loadBootEnv, resolveCorsOrigin, isLocalhostOrigin } from "./boot/env";
+export type { RebaseBootEnv, CorsOriginResolver } from "./boot/env";
+export { resolveAuthOptions, resolveEmailOptions } from "./boot/options";
+export { envSuffixForKey, resolveDataSources, resolveStorageSources, resolveStorageBackend } from "./boot/sources";
+export type { ResolvedDataSourceConfig, EnvBag } from "./boot/sources";
+export { initializeDataSource, initializeDataSources } from "./boot/driver";
+export type { InitializedDataSource, DatabaseConnection, BundleSchema } from "./boot/driver";
+export { MetricsRegistry, createMetricsMiddleware, createMetricsRoutes, classifySurface } from "./metrics";
+export type { MetricSurface, MetricsHandle } from "./metrics";
+export { createContractRoutes } from "./api/contract-routes";
+export type { ContractRoutesConfig } from "./api/contract-routes";