@rebasepro/server-core 0.6.1 → 0.8.0

package/dist/init.d.ts

@@ -1,4 +1,4 @@
-import { AuthAdapter, BackendBootstrapper, BackendHooks, BootstrappedAuth, DatabaseAdapter, DataDriver, EntityCollection, HealthCheckResult, RealtimeProvider, SecurityRule } from "@rebasepro/types";
+import { AuthAdapter, BackendBootstrapper, BootstrappedAuth, DatabaseAdapter, DataDriver, DataSourceDefinition, EntityCallbacks, EntityCollection, HealthCheckResult, RealtimeProvider, SecurityRule } from "@rebasepro/types";
 import { BackendCollectionRegistry } from "./collections/BackendCollectionRegistry";
 import { DriverRegistry } from "./services/driver-registry";
 import { Server } from "http";
@@ -35,7 +35,7 @@ export interface RebaseAuthConfig {
      *
      * When a request includes `Authorization: Bearer <serviceKey>`, it is
      * granted admin-level access without JWT verification. This is the
-     * Rebase equivalent of a Firebase Service Account key.
+     * Rebase equivalent of a Service Account key.
      *
      * Generate with: `node -e "logger.info(require('crypto').randomBytes(48).toString('base64'))"`
      *
@@ -97,7 +97,31 @@ export interface RebaseAuthConfig {
         clientSecret: string;
     };
     defaultRole?: string;
-    providers?: OAuthProvider<any>[];
+    /**
+     * Canonical array of OAuth providers.
+     *
+     * This is the primary extension point for **all** OAuth integrations.
+     * Each entry is an `OAuthProvider<unknown>` constructed via one of
+     * the `create*Provider` factories exported from `@rebasepro/server-core`
+     * (e.g. `createGoogleProvider`, `createGitHubProvider`).
+     *
+     * The named convenience fields above (`google`, `github`, etc.) are
+     * automatically resolved into this array at startup. You can mix both
+     * approaches; named fields and explicit entries are merged (named
+     * fields are appended after explicit entries).
+     *
+     * @example
+     * ```ts
+     * import { createGoogleProvider } from "@rebasepro/server-core";
+     *
+     * auth: {
+     *   providers: [
+     *     createGoogleProvider({ clientId: "…", clientSecret: "…" }),
+     *   ],
+     * }
+     * ```
+     */
+    providers?: OAuthProvider<unknown>[];
     /**
      * Override specific parts of the built-in auth implementation.
      *
@@ -116,7 +140,11 @@ export interface RebaseAuthConfig {
      * ```
      */
     hooks?: AuthHooks;
-    [key: string]: unknown;
+    /**
+     * Enable magic link (passwordless email) authentication.
+     * Requires email to be configured.
+     */
+    magicLink?: boolean;
 }
 export interface RebaseBackendConfig {
     collections?: EntityCollection[];
@@ -124,6 +152,15 @@ export interface RebaseBackendConfig {
     server: Server;
     app: Hono<HonoEnv>;
     basePath?: string;
+    /**
+     * Declared data sources, shared with the frontend `<Rebase dataSources>`.
+     *
+     * Used to resolve each collection's engine (capabilities) and transport.
+     * Collections on a `direct`/`custom` transport are client-only: the backend
+     * still owns their schema/registry but does **not** generate server data
+     * routes for them. Server-mediated sources (the default) need no entry.
+     */
+    dataSources?: DataSourceDefinition[];
     /**
      * Database bootstrappers.
      */
@@ -157,11 +194,20 @@ export interface RebaseBackendConfig {
     /**
      * Storage configuration. Accepts:
      *
-     * - A `BackendStorageConfig` object (`{ type: 'local' | 's3', ... }`)
-     * - A `StorageController` instance (for custom providers like GCS, Azure, etc.)
+     * - A `BackendStorageConfig` object (`{ type: 'local' | 's3' | 'gcs', ... }`)
+     * - A `StorageController` instance (for custom providers like Azure, etc.)
      * - A `Record<string, ...>` of either, for multi-backend setups
      */
     storage?: BackendStorageConfig | StorageController | Record<string, BackendStorageConfig | StorageController>;
+    /**
+     * Declared storage sources. Drives the client-side StorageSourceRegistry
+     * and the transport distinction (server vs direct).
+     *
+     * Server-backed sources are auto-derived from the `storage` map — you
+     * only need explicit entries for "direct" transport sources (e.g.
+     * external storage) that the backend does not proxy.
+     */
+    storageSources?: import("@rebasepro/types").StorageSourceDefinition[];
     history?: unknown;
     /**
      * Default security rules applied to any collection that does not define
@@ -211,14 +257,24 @@ export interface RebaseBackendConfig {
         origin: string | string[] | ((origin: string) => boolean);
     };
     /**
-     * Backend-level hooks for intercepting collection entity data
-     * at the REST API boundary. These run server-side after database
-     * operations and before API responses are sent.
+     * Global lifecycle callbacks applied to every collection.
      *
-     * Complement the per-collection `EntityCallbacks` system which
-     * handles collection CRUD operations.
+     * Same type as per-collection `callbacks` — fires on **every** data path
+     * (REST API, WebSocket / realtime, server-side `rebase.data`).
+     *
+     * Execution order: global callbacks → collection callbacks → property callbacks.
+     *
+     * @example
+     * ```ts
+     * callbacks: {
+     *     afterRead({ entity, collection }) {
+     *         console.log(`Read ${collection.slug}/${entity.id}`);
+     *         return entity;
+     *     }
+     * }
+     * ```
      */
-    hooks?: BackendHooks;
+    callbacks?: EntityCallbacks;
 }
 /**
  * Type guard to detect whether the `auth` config is an `AuthAdapter`