@rebasepro/server-core 0.7.0 → 0.9.0

package/src/serve-spa.ts

@@ -1,89 +0,0 @@
-import { Hono } from "hono";
-import { serveStatic } from "@hono/node-server/serve-static";
-import * as path from "path";
-import * as fs from "fs";
-import fsp from "node:fs/promises";
-import { logger } from "./utils/logger.js";
-
-/**
- * Configuration for serving a Single Page Application
- */
-export interface ServeSPAConfig {
-    /**
-     * Absolute path to the frontend build directory
-     * @example path.join(__dirname, "../../frontend/dist")
-     */
-    frontendPath: string;
-
-    /**
-     * Base path for API routes (default: "/api")
-     * Requests to this path will be passed through to API handlers
-     */
-    apiBasePath?: string;
-
-    /**
-     * Additional paths to exclude from SPA handling
-     * These paths will be passed through to other handlers
-     * @example ["/health", "/ws", "/metrics"]
-     */
-    excludePaths?: string[];
-
-    /**
-     * Index file to serve for SPA routes (default: "index.html")
-     */
-    indexFile?: string;
-}
-
-/**
- * Serve a Single Page Application from an Hono app.
- */
-export function serveSPA<E extends import("hono").Env>(app: Hono<E>, config: ServeSPAConfig): void {
-    const {
-        frontendPath,
-        apiBasePath = "/api",
-        excludePaths = [],
-        indexFile = "index.html"
-    } = config;
-
-    // Validate frontend path exists
-    if (!fs.existsSync(frontendPath)) {
-        logger.warn(`⚠️ Frontend build path does not exist: ${frontendPath}`);
-        logger.warn("   SPA serving is disabled. Build your frontend first.");
-        return;
-    }
-
-    // Serve static files from frontend build
-    app.use("/*", serveStatic({
-        root: path.relative(process.cwd(), frontendPath)
-    }));
-
-    // Build list of paths to exclude from SPA handling
-    const allExcludePaths = [apiBasePath, ...excludePaths];
-
-    // Cache the index.html content to avoid re-reading from disk on every navigation request.
-    let cachedHtml: string | null = null;
-
-    // SPA fallback - serve index.html for all non-excluded routes
-    app.get("*", async (c, next) => {
-        // Skip excluded paths (API, health checks, etc.)
-        if (allExcludePaths.some(p => c.req.path.startsWith(p))) {
-            return next();
-        }
-
-        const indexPath = path.join(frontendPath, indexFile);
-
-        if (!cachedHtml) {
-            try {
-                cachedHtml = await fsp.readFile(indexPath, "utf-8");
-            } catch {
-                logger.warn(`⚠️ Index file not found: ${indexPath}`);
-                return next();
-            }
-        }
-
-        return c.html(cachedHtml);
-    });
-
-    logger.info(`✅ SPA serving enabled from: ${frontendPath}`);
-}
-

package/src/services/driver-registry.ts

@@ -1,183 +0,0 @@
-/**
- * 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";
-import { logger } from "../utils/logger";
-
-/**
- * The default driver identifier used when:
- * - A single driver is provided (not a map)
- * - A collection doesn't specify a databaseId
- */
-export 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 class DefaultDriverRegistry implements DriverRegistry {
-    private delegates = new Map<string, DataDriver>();
-
-    /**
-     * 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 {
-        const registry = new DefaultDriverRegistry();
-
-        if (isDataDriverDelegate(input)) {
-            // Single delegate → register as "(default)"
-            registry.register(DEFAULT_DRIVER_ID, input);
-        } else {
-            // Map of delegates → register each
-            for (const [id, delegate] of Object.entries(input)) {
-                registry.register(id, delegate);
-            }
-            // Ensure there's a default if not explicitly provided
-            if (!registry.has(DEFAULT_DRIVER_ID) && registry.size() > 0) {
-                // If no explicit "(default)", use the first one as default
-                const firstId = Object.keys(input)[0];
-                logger.warn(
-                    `[DriverRegistry] No "${DEFAULT_DRIVER_ID}" driver provided. ` +
-                    `Using "${firstId}" as the default.`
-                );
-                registry.register(DEFAULT_DRIVER_ID, input[firstId]);
-            }
-        }
-
-        return registry;
-    }
-
-    register(id: string, delegate: DataDriver): void {
-        if (this.delegates.has(id)) {
-            logger.warn(`[DriverRegistry] Overwriting driver with id "${id}"`);
-        }
-        this.delegates.set(id, delegate);
-    }
-
-    getDefault(): DataDriver {
-        const delegate = this.delegates.get(DEFAULT_DRIVER_ID);
-        if (!delegate) {
-            throw new Error(
-                "[DriverRegistry] No default driver registered. " +
-                `Register one with id "${DEFAULT_DRIVER_ID}" or pass a single DataDriver.`
-            );
-        }
-        return delegate;
-    }
-
-    get(id: string | undefined | null): DataDriver | undefined {
-        if (id === undefined || id === null) {
-            return this.delegates.get(DEFAULT_DRIVER_ID);
-        }
-        return this.delegates.get(id);
-    }
-
-    getOrDefault(id: string | undefined | null): DataDriver {
-        // If no ID specified, return default
-        if (id === undefined || id === null) {
-            return this.getDefault();
-        }
-
-        // Try to get by ID
-        const delegate = this.delegates.get(id);
-        if (delegate) {
-            return delegate;
-        }
-
-        // Fallback to default with warning
-        logger.warn(
-            `[DriverRegistry] Driver "${id}" not found, falling back to "${DEFAULT_DRIVER_ID}"`
-        );
-        return this.getDefault();
-    }
-
-    has(id: string): boolean {
-        return this.delegates.has(id);
-    }
-
-    list(): string[] {
-        return Array.from(this.delegates.keys());
-    }
-
-    size(): number {
-        return this.delegates.size;
-    }
-}
-
-/**
- * Type guard to check if an object is a DataDriver
- */
-function isDataDriverDelegate(obj: unknown): obj is DataDriver {
-    if (typeof obj !== "object" || obj === null) {
-        return false;
-    }
-    const delegate = obj as DataDriver;
-    // Check for required DataDriver properties
-    return (
-        typeof delegate.key === "string" &&
-        typeof delegate.fetchCollection === "function" &&
-        typeof delegate.fetchEntity === "function" &&
-        typeof delegate.saveEntity === "function" &&
-        typeof delegate.deleteEntity === "function"
-    );
-}

package/src/services/routed-realtime-service.ts

@@ -1,113 +0,0 @@
-import { RealtimeProvider, Entity } 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;
-}
-
-/** Channel/presence/broadcast messages are engine-agnostic pub/sub. */
-const CHANNEL_MESSAGE_TYPES = new Set([
-    "join_channel", "leave_channel", "broadcast",
-    "presence_track", "presence_untrack", "presence_state"
-]);
-
-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 function createRoutedRealtimeService(opts: RoutedRealtimeOptions): WsRealtimeService {
-    const { providers, defaultKey, resolveKey } = opts;
-
-    const asWs = (p: RealtimeProvider): WsRealtimeService => p as unknown as WsRealtimeService;
-    const all = (): WsRealtimeService[] => Object.values(providers).map(asWs);
-    const fallback = (): WsRealtimeService => asWs(providers[defaultKey] ?? Object.values(providers)[0]);
-    const forPath = (path?: string): WsRealtimeService => {
-        if (!path) return fallback();
-        const key = resolveKey(path);
-        return asWs(providers[key] ?? providers[defaultKey] ?? Object.values(providers)[0]);
-    };
-
-    return {
-        addClient(clientId, ws) {
-            for (const p of all()) p.addClient?.(clientId, ws);
-        },
-
-        async handleClientMessage(clientId, message, authContext) {
-            const { type } = message;
-            if (type === "subscribe_collection" || type === "subscribe_entity") {
-                await forPath(message.payload?.path as string | undefined)
-                    .handleClientMessage(clientId, message, authContext);
-                return;
-            }
-            if (type === "unsubscribe") {
-                // The owning provider acts; others no-op on an unknown id.
-                await Promise.all(all().map((p) => p.handleClientMessage(clientId, message, authContext)));
-                return;
-            }
-            // Channels/presence/broadcast (and anything else) → default provider.
-            await fallback().handleClientMessage(clientId, message, authContext);
-        },
-
-        subscribeToCollection(subscriptionId, config, callback) {
-            forPath((config as { path?: string }).path).subscribeToCollection(subscriptionId, config, callback);
-        },
-
-        subscribeToEntity(subscriptionId, config, callback) {
-            forPath((config as { path?: string }).path).subscribeToEntity(subscriptionId, config, callback);
-        },
-
-        unsubscribe(subscriptionId) {
-            for (const p of all()) p.unsubscribe(subscriptionId);
-        },
-
-        async notifyEntityUpdate(path: string, entityId: string, entity: Entity | null, databaseId?: string) {
-            await forPath(path).notifyEntityUpdate(path, entityId, entity, databaseId);
-        },
-
-        onServerReady(serverInfo) {
-            for (const p of all()) p.onServerReady?.(serverInfo);
-        },
-
-        async destroy() {
-            await Promise.all(all().map((p) => p.destroy?.()));
-        },
-
-        async stopListening() {
-            await Promise.all(all().map((p) => p.stopListening?.()));
-        }
-    };
-}

package/src/services/webhook-service.ts

@@ -1,155 +0,0 @@
-import { createHmac, randomUUID } from "crypto";
-
-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 class WebhookDispatcher {
-    private webhooks: WebhookConfig[] = [];
-    private maxRetries = 3;
-    private retryDelays = [1000, 5000, 15000]; // Exponential backoff
-
-    /** Register webhooks to watch */
-    setWebhooks(webhooks: WebhookConfig[]): void {
-        this.webhooks = webhooks.filter(w => w.enabled);
-    }
-
-    /** Called when an entity changes — checks if any webhook matches */
-    async onEntityChange(
-        table: string,
-        event: "INSERT" | "UPDATE" | "DELETE",
-        entityId: string,
-        entity: Record<string, unknown> | null,
-        previousEntity?: Record<string, unknown> | null
-    ): Promise<WebhookDeliveryResult[]> {
-        const matchingWebhooks = this.webhooks.filter(
-            w => w.table === table && w.events.includes(event)
-        );
-
-        if (matchingWebhooks.length === 0) return [];
-
-        const results: WebhookDeliveryResult[] = [];
-
-        for (const webhook of matchingWebhooks) {
-            const payload: Record<string, unknown> = {
-                type: event,
-                table,
-                record: entity,
-                old_record: event === "UPDATE" ? previousEntity : undefined,
-                schema: "public",
-                timestamp: new Date().toISOString()
-            };
-
-            const result = await this.deliverWithRetry(webhook, event, payload);
-            results.push(result);
-        }
-
-        return results;
-    }
-
-    private async deliverWithRetry(
-        webhook: WebhookConfig,
-        event: string,
-        payload: Record<string, unknown>
-    ): Promise<WebhookDeliveryResult> {
-        for (let attempt = 1; attempt <= this.maxRetries; attempt++) {
-            const result = await this.deliver(webhook, event, payload, attempt);
-            if (result.success) return result;
-
-            if (attempt < this.maxRetries) {
-                await new Promise(r => setTimeout(r, this.retryDelays[attempt - 1]));
-            } else {
-                return result; // Final failure
-            }
-        }
-
-        // Should never reach here, but satisfies TypeScript
-        return {
-            webhookId: webhook.id,
-            event,
-            payload,
-            statusCode: 0,
-            responseBody: "Max retries exceeded",
-            success: false,
-            attemptNumber: this.maxRetries
-        };
-    }
-
-    private async deliver(
-        webhook: WebhookConfig,
-        event: string,
-        payload: Record<string, unknown>,
-        attemptNumber: number
-    ): Promise<WebhookDeliveryResult> {
-        const body = JSON.stringify(payload);
-
-        const headers: Record<string, string> = {
-            "Content-Type": "application/json",
-            "X-Webhook-Id": webhook.id,
-            "X-Webhook-Event": event,
-            "X-Webhook-Delivery": randomUUID(),
-            "X-Webhook-Attempt": String(attemptNumber),
-            ...(webhook.headers || {})
-        };
-
-        // HMAC signature
-        if (webhook.secret) {
-            const signature = createHmac("sha256", webhook.secret).update(body).digest("hex");
-            headers["X-Webhook-Signature"] = `sha256=${signature}`;
-        }
-
-        try {
-            const controller = new AbortController();
-            const timeout = setTimeout(() => controller.abort(), 10000); // 10s timeout
-
-            const response = await fetch(webhook.url, {
-                method: "POST",
-                headers,
-                body,
-                signal: controller.signal
-            });
-
-            clearTimeout(timeout);
-
-            const responseBody = await response.text().catch(() => "");
-            const success = response.status >= 200 && response.status < 300;
-
-            return {
-                webhookId: webhook.id,
-                event,
-                payload,
-                statusCode: response.status,
-                responseBody: responseBody.slice(0, 1000), // Truncate
-                success,
-                attemptNumber
-            };
-        } catch (error: unknown) {
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                webhookId: webhook.id,
-                event,
-                payload,
-                statusCode: 0,
-                responseBody: message.slice(0, 1000),
-                success: false,
-                attemptNumber
-            };
-        }
-    }
-}

package/src/singleton.ts

@@ -1,70 +0,0 @@
-import type { RebaseClient } from "@rebasepro/types";
-
-let _instance: RebaseClient | null = null;
-
-/**
- * @internal Called once during server initialization to set the backing instance.
- * This is invoked by `initializeRebaseBackend()` — never call it manually.
- */
-export function _initRebase(client: RebaseClient): void {
-    _instance = client;
-}
-
-/**
- * @internal Allows overriding the underlying instance for unit testing.
- * Throws an error if used in a non-test environment to prevent production abuse.
- */
-export function _setRebaseMock(mockInstance: Partial<RebaseClient>): void {
-    if (process.env.NODE_ENV !== "test") {
-        throw new Error("_setRebaseMock can only be called in a test environment (NODE_ENV=test).");
-    }
-    _instance = { ...(_instance || {} as RebaseClient),
-...mockInstance } as RebaseClient;
-}
-
-/**
- * @internal Resets the singleton instance, useful for afterEach() in test suites.
- */
-export function _resetRebaseMock(): void {
-    if (process.env.NODE_ENV !== "test") {
-        throw new Error("_resetRebaseMock can only be called in a test environment.");
-    }
-    _instance = null;
-}
-
-/**
- * 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 const rebase: RebaseClient = new Proxy({} as RebaseClient, {
-    get(_, prop) {
-        if (!_instance) {
-            throw new Error(
-                `rebase.${String(prop)}: server not initialized yet. ` +
-                "The singleton is available after Rebase starts — don't call it at import time."
-            );
-        }
-        return _instance[prop as keyof RebaseClient];
-    },
-    set(_, prop) {
-        throw new Error(
-            `Cannot set rebase.${String(prop)} directly. ` +
-            "The singleton is read-only. Use _initRebase() during server startup."
-        );
-    }
-});