@rebasepro/server-core 0.7.0 → 0.8.0

package/dist/services/driver-registry.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Driver Registry
+ *
+ * Manages multiple driver delegates for Rebase backend.
+ * Allows different databases for different collections.
+ *
+ * Usage:
+ * - Single DB: Pass a single DataDriver → maps to "(default)"
+ * - Multiple DBs: Pass a map of { dbId: DataDriver }
+ * - Collections use `databaseId` property to specify which driver to use
+ * - Collections without `databaseId` fallback to "(default)"
+ */
+import { DataDriver } from "@rebasepro/types";
+/**
+ * The default driver identifier used when:
+ * - A single driver is provided (not a map)
+ * - A collection doesn't specify a databaseId
+ */
+export declare const DEFAULT_DRIVER_ID = "(default)";
+/**
+ * Registry for managing multiple driver delegates
+ */
+export interface DriverRegistry {
+    /**
+     * Register a driver delegate with an ID
+     * @param id - Unique identifier for this driver (e.g., "analytics", "users")
+     * @param delegate - The DataDriver instance
+     */
+    register(id: string, delegate: DataDriver): void;
+    /**
+     * Get the default driver delegate (id = "(default)")
+     * @throws Error if no default driver is registered
+     */
+    getDefault(): DataDriver;
+    /**
+     * Get a driver delegate by ID
+     * @param id - Driver identifier, or undefined/null for default
+     * @returns The DataDriver, or undefined if not found
+     */
+    get(id: string | undefined | null): DataDriver | undefined;
+    /**
+     * Get a driver delegate by ID, with fallback to default
+     * @param id - Driver identifier, or undefined/null for default
+     * @returns The DataDriver (falls back to default if id not found)
+     * @throws Error if neither the specified nor default driver exists
+     */
+    getOrDefault(id: string | undefined | null): DataDriver;
+    /**
+     * Check if a driver with the given ID exists
+     */
+    has(id: string): boolean;
+    /**
+     * List all registered driver IDs
+     */
+    list(): string[];
+    /**
+     * Get the number of registered drivers
+     */
+    size(): number;
+}
+/**
+ * Default implementation of DriverRegistry
+ */
+export declare class DefaultDriverRegistry implements DriverRegistry {
+    private delegates;
+    /**
+     * Create a DriverRegistry from either a single delegate or a map
+     * @param input - Single DataDriver (maps to "(default)") or Record<string, DataDriver>
+     */
+    static create(input: DataDriver | Record<string, DataDriver>): DefaultDriverRegistry;
+    register(id: string, delegate: DataDriver): void;
+    getDefault(): DataDriver;
+    get(id: string | undefined | null): DataDriver | undefined;
+    getOrDefault(id: string | undefined | null): DataDriver;
+    has(id: string): boolean;
+    list(): string[];
+    size(): number;
+}

package/dist/services/routed-realtime-service.d.ts

@@ -0,0 +1,43 @@
+import { RealtimeProvider } from "@rebasepro/types";
+/**
+ * A realtime client message as forwarded by the WebSocket server.
+ */
+interface ClientMessage {
+    type: string;
+    payload?: Record<string, unknown>;
+    subscriptionId?: string;
+}
+/**
+ * The concrete realtime service surface the WebSocket server drives — the
+ * typed {@link RealtimeProvider} plus the client-connection methods that
+ * every engine's realtime service implements.
+ */
+export interface WsRealtimeService extends RealtimeProvider {
+    addClient(clientId: string, ws: unknown): void;
+    handleClientMessage(clientId: string, message: ClientMessage, authContext?: unknown): Promise<void> | void;
+}
+export interface RoutedRealtimeOptions {
+    /** Per-engine realtime providers, keyed by data-source key. */
+    providers: Record<string, RealtimeProvider>;
+    /** Key of the default provider (handles channels/presence/broadcast). */
+    defaultKey: string;
+    /** Resolve a collection path to its data-source key. */
+    resolveKey: (collectionPath: string) => string;
+}
+/**
+ * Compose multiple per-engine {@link RealtimeProvider}s into one that routes
+ * each subscription to the provider owning the subscribed collection — the
+ * realtime counterpart of `buildRoutedRebaseData`.
+ *
+ * The WebSocket server stays single and engine-agnostic; this composite is
+ * passed in its place. Routing rules:
+ * - `subscribe_collection` / `subscribe_entity` → the provider for the
+ *   collection's data source (by `payload.path`).
+ * - `unsubscribe` → forwarded to all providers (a no-op on non-owners).
+ * - channel / presence / broadcast → the default provider (these are global
+ *   pub/sub, not bound to an engine).
+ * - `addClient` and lifecycle (`onServerReady`/`destroy`/`stopListening`) →
+ *   all providers (each registers its own ws close handler for cleanup).
+ */
+export declare function createRoutedRealtimeService(opts: RoutedRealtimeOptions): WsRealtimeService;
+export {};

package/dist/services/webhook-service.d.ts

@@ -0,0 +1,29 @@
+export interface WebhookConfig {
+    id: string;
+    url: string;
+    secret?: string;
+    headers?: Record<string, string>;
+    events: string[];
+    table: string;
+    enabled: boolean;
+}
+export interface WebhookDeliveryResult {
+    webhookId: string;
+    event: string;
+    payload: Record<string, unknown>;
+    statusCode: number;
+    responseBody: string;
+    success: boolean;
+    attemptNumber: number;
+}
+export declare class WebhookDispatcher {
+    private webhooks;
+    private maxRetries;
+    private retryDelays;
+    /** Register webhooks to watch */
+    setWebhooks(webhooks: WebhookConfig[]): void;
+    /** Called when an entity changes — checks if any webhook matches */
+    onEntityChange(table: string, event: "INSERT" | "UPDATE" | "DELETE", entityId: string, entity: Record<string, unknown> | null, previousEntity?: Record<string, unknown> | null): Promise<WebhookDeliveryResult[]>;
+    private deliverWithRetry;
+    private deliver;
+}

package/dist/singleton.d.ts

@@ -0,0 +1,35 @@
+import type { RebaseClient } from "@rebasepro/types";
+/**
+ * @internal Called once during server initialization to set the backing instance.
+ * This is invoked by `initializeRebaseBackend()` — never call it manually.
+ */
+export declare function _initRebase(client: RebaseClient): void;
+/**
+ * @internal Allows overriding the underlying instance for unit testing.
+ * Throws an error if used in a non-test environment to prevent production abuse.
+ */
+export declare function _setRebaseMock(mockInstance: Partial<RebaseClient>): void;
+/**
+ * @internal Resets the singleton instance, useful for afterEach() in test suites.
+ */
+export declare function _resetRebaseMock(): void;
+/**
+ * The server-side Rebase singleton.
+ *
+ * Initialized automatically during server startup. Provides access to all
+ * app-scoped services: **data**, **auth**, **storage**, and **email**.
+ *
+ * `rebase.data` runs with **admin privileges** (no RLS). For user-scoped
+ * queries inside request handlers, continue using the handler's context
+ * or the RLS-scoped driver.
+ *
+ * @example
+ * ```typescript
+ * import { rebase } from "@rebasepro/server-core";
+ *
+ * // In a Hono handler, cron job, hook, or service file:
+ * await rebase.email?.send({ to: "admin@co.com", subject: "Alert", html: "<p>Hi</p>" });
+ * const jobs = await rebase.data.jobs.find({ limit: 10 });
+ * ```
+ */
+export declare const rebase: RebaseClient;