@rebasepro/server-core 0.7.0 → 0.9.0

package/src/functions/function-loader.ts

@@ -1,116 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-import { pathToFileURL } from "url";
-import { Hono } from "hono";
-import { logger } from "../utils/logger.js";
-
-export interface LoadedFunction {
-    /** Endpoint name derived from filename (e.g., "send-invoice") */
-    name: string;
-    /** The Hono sub-app to mount */
-    app: Hono<import("hono").Env>;
-}
-
-/**
- * Auto-discover Hono route files from a directory.
- *
- * Each file should default-export a Hono app (or router).
- * The filename (without extension) becomes the mount path:
- *   `functions/send-invoice.ts` → mounted at `/send-invoice`
- *
- * This mirrors how `loadCollectionsFromDirectory` works for collections.
- */
-export async function loadFunctionsFromDirectory(
-    directory: string
-): Promise<LoadedFunction[]> {
-    const functions: LoadedFunction[] = [];
-
-    if (!fs.existsSync(directory)) {
-        return functions;
-    }
-
-    const files = fs.readdirSync(directory);
-    for (const file of files) {
-        if (
-            (file.endsWith(".ts") || file.endsWith(".js")) &&
-            !file.includes(".test.") &&
-            !file.endsWith(".d.ts") &&
-            file !== "index.ts" &&
-            file !== "index.js"
-        ) {
-            const filePath = path.join(directory, file);
-            try {
-                const fileUrl = pathToFileURL(filePath).href;
-
-                // Use new Function to compile dynamic import natively and bypass
-                // tsc converting import() to require() — same pattern as collection loader
-                const dynamicImport = new Function("url", "return import(url)");
-                const mod = await dynamicImport(fileUrl);
-
-                const exported = mod.default;
-
-                if (!exported) {
-                    logger.warn(`[functions] ${file}: no default export. Skipping.`);
-                    continue;
-                }
-
-                // Accept a Hono instance — use duck-typing to handle different
-                // Hono versions which may not share the same prototype.
-                if (isHonoLike(exported)) {
-                    const name = path.basename(file, path.extname(file));
-                    functions.push({ name,
-app: exported as Hono });
-                    logger.info(`⚡ Loaded function route: ${name}`);
-                    continue;
-                }
-
-                // Also accept a factory function that returns a Hono instance
-                if (typeof exported === "function") {
-                    const result = exported();
-                    if (isHonoLike(result)) {
-                        const name = path.basename(file, path.extname(file));
-                        functions.push({ name,
-app: result as Hono });
-                        logger.info(`⚡ Loaded function route: ${name}`);
-                        continue;
-                    }
-                }
-
-                // Provide actionable diagnostics
-                const exportType = typeof exported;
-                const keys = exported && typeof exported === "object"
-                    ? Object.getOwnPropertyNames(Object.getPrototypeOf(exported)).slice(0, 10).join(", ")
-                    : "N/A";
-                logger.warn(
-                    `[functions] ${file}: default export is not a Hono app or factory. Skipping.\n` +
-                    `  export type: ${exportType}${exported?.constructor?.name ? ` (${exported.constructor.name})` : ""}\n` +
-                    `  prototype methods: ${keys}\n` +
-                    "  Hint: ensure the function exports a Hono app created with the same hono version as the server.\n" +
-                    "  The loader checks for .fetch() and .routes — any Hono-compatible app will work."
-                );
-            } catch (err: unknown) {
-                const message =
-                    err instanceof Error ? err.message : String(err);
-                logger.error(`[functions] Failed to load ${file}: ${message}`);
-            }
-        }
-    }
-
-    return functions;
-}
-
-/**
- * Duck-type check for Hono apps.
- * We avoid `instanceof Hono` because different Hono versions
- * installed in the user's project vs. our dependencies will
- * not share the same prototype, causing false negatives.
- */
-function isHonoLike(obj: unknown): boolean {
-    if (!obj || typeof obj !== "object") return false;
-    // Hono instances always have .fetch() and .routes
-    const record = obj as Record<string, unknown>;
-    return (
-        typeof record.fetch === "function" &&
-        Array.isArray(record.routes)
-    );
-}

package/src/functions/function-routes.ts

@@ -1,31 +0,0 @@
-import { Hono } from "hono";
-import { HonoEnv } from "../api/types";
-import { LoadedFunction } from "./function-loader";
-
-/**
- * Mount all loaded function routes under a single Hono router.
- *
- * Each function is mounted at `/<function-name>`, preserving
- * whatever HTTP methods and middleware the Hono sub-app defines.
- */
-export function createFunctionRoutes(
-    functions: LoadedFunction[]
-): Hono<HonoEnv> {
-    const router = new Hono<HonoEnv>();
-
-    // Listing endpoint: GET / → list available functions
-    router.get("/", (c) => {
-        return c.json({
-            functions: functions.map((fn) => ({
-                name: fn.name,
-                endpoint: `/functions/${fn.name}`
-            }))
-        });
-    });
-
-    for (const fn of functions) {
-        router.route(`/${fn.name}`, fn.app);
-    }
-
-    return router;
-}

package/src/history/history-routes.ts

@@ -1,129 +0,0 @@
-import { Hono } from "hono";
-import { HonoEnv } from "../api/types";
-import { BackendCollectionRegistry } from "../collections/BackendCollectionRegistry";
-import { ApiError, errorHandler } from "../api/errors";
-import { DataDriver } from "@rebasepro/types";
-/**
- * Create Hono routes for entity history.
- * Mounted at `{basePath}/data/:slug/:entityId/history`.
- */
-export interface HistoryService {
-    fetchHistory(tableName: string, entityId: string, options: { limit: number, offset: number }): Promise<{ data: Record<string, unknown>[], total: number }>;
-    fetchHistoryEntry(historyId: string): Promise<Record<string, unknown> | null>;
-}
-
-export function createHistoryRoutes(params: {
-    historyService: HistoryService;
-    registry: BackendCollectionRegistry;
-    driver: DataDriver;
-}): Hono<HonoEnv> {
-    const { historyService, registry, driver } = params;
-    const router = new Hono<HonoEnv>();
-    router.onError(errorHandler);
-
-    /**
-     * GET /:slug/:entityId/history - List history entries for an entity
-     *
-     * Query params:
-     *   limit  (default 20)
-     *   offset (default 0)
-     */
-    router.get("/:slug/:entityId/history", async (c) => {
-        const slug = c.req.param("slug");
-        const entityId = c.req.param("entityId");
-        const parsedLimit = parseInt(c.req.query("limit") ?? "20", 10);
-        const parsedOffset = parseInt(c.req.query("offset") ?? "0", 10);
-        const limit = Number.isNaN(parsedLimit) ? 20 : parsedLimit;
-        const offset = Number.isNaN(parsedOffset) ? 0 : parsedOffset;
-
-        // Resolve the collection to get the actual table name
-        const collection = registry.getCollections().find(
-            col => col.slug === slug || false
-        );
-
-        if (!collection) {
-            throw ApiError.notFound(`Collection '${slug}' not found`);
-        }
-
-        if (!collection.history) {
-            throw ApiError.badRequest(`History is not enabled for collection '${slug}'`);
-        }
-
-        const tableName = collection.slug;
-
-        const result = await historyService.fetchHistory(tableName, entityId, {
-            limit: Math.min(limit, 100),
-            offset: Math.max(offset, 0)
-        });
-
-        return c.json({
-            data: result.data,
-            meta: {
-                total: result.total,
-                limit,
-                offset,
-                hasMore: offset + result.data.length < result.total
-            }
-        });
-    });
-
-    /**
-     * POST /:slug/:entityId/history/:historyId/revert - Revert entity to a historical version
-     *
-     * This goes through the normal save path, so it creates its own history entry.
-     */
-    router.post("/:slug/:entityId/history/:historyId/revert", async (c) => {
-        const slug = c.req.param("slug");
-        const entityId = c.req.param("entityId");
-        const historyId = c.req.param("historyId");
-
-        const collection = registry.getCollections().find(
-            col => col.slug === slug || false
-        );
-
-        if (!collection) {
-            throw ApiError.notFound(`Collection '${slug}' not found`);
-        }
-
-        if (!collection.history) {
-            throw ApiError.badRequest(`History is not enabled for collection '${slug}'`);
-        }
-
-        // Fetch the history entry
-        const historyEntry = await historyService.fetchHistoryEntry(historyId);
-
-        if (!historyEntry) {
-            throw ApiError.notFound(`History entry '${historyId}' not found`);
-        }
-
-        // Verify the history entry belongs to this entity (prevent cross-entity revert)
-        const tableName = collection.slug;
-        if (historyEntry.entity_id !== String(entityId) || historyEntry.table_name !== tableName) {
-            throw ApiError.badRequest("History entry does not belong to this entity");
-        }
-
-        if (!historyEntry.values) {
-            throw ApiError.badRequest("Cannot revert: history entry has no stored values");
-        }
-
-        // Revert by saving through the normal driver path — this will
-        // itself create another history entry, giving a full audit trail.
-        const authDriver = c.get("driver") || driver;
-        const path = collection.slug;
-
-        const savedEntity = await authDriver.saveEntity({
-            path,
-            entityId: String(entityId),
-            values: historyEntry.values,
-            collection,
-            status: "existing"
-        });
-
-        return c.json({
-            data: savedEntity,
-            meta: { reverted_from: historyId }
-        });
-    });
-
-    return router;
-}

package/src/index.ts

@@ -1,70 +0,0 @@
-/**
- * @rebasepro/server-core
- *
- * Database-Agnostic Backend Core for Rebase.
- * This package provides the core backend services, generic driver routing,
- * and API layers. Database implementations (e.g., PostgreSQL) are provided
- * by specialized driver packages like `@rebasepro/server-postgresql`.
- */
-
-// =============================================================================
-// Abstract Interfaces (for database abstraction)
-// =============================================================================
-export * from "./db/interfaces";
-export * from "./auth/interfaces";
-
-// Core functionality
-export * from "./init";
-
-// Server-side singleton (import { rebase } from "@rebasepro/server-core")
-export { rebase, _setRebaseMock, _resetRebaseMock } from "./singleton";
-
-// Services
-export * from "./services/driver-registry";
-
-// API types (HonoEnv, ApiConfig, etc.)
-export * from "./api/types";
-
-// API Generation
-export * from "./api";
-
-// Types
-export * from "./types";
-export * from "./types/index";
-
-// Auth module
-export * from "./auth";
-
-// Email module
-export * from "./email";
-
-// Storage module
-export * from "./storage";
-
-export * from "./utils/logging";
-export * from "./utils/logger";
-export * from "./utils/request-logger";
-export * from "./utils/request-id";
-export * from "./utils/sql";
-
-// Entity history
-export * from "./history";
-
-// Custom Functions (auto-discovered Hono routes)
-export * from "./functions";
-
-// Cron Jobs (auto-discovered scheduled tasks)
-export * from "./cron";
-
-
-// SPA serving helper
-export * from "./serve-spa";
-
-// Dev-mode port resolution (retry on EADDRINUSE)
-export * from "./utils/dev-port";
-
-// Environment validation
-export { loadEnv } from "./env";
-export type { RebaseEnv } from "./env";
-export { z } from "zod";
-

package/src/init/docs.ts

@@ -1,47 +0,0 @@
-import { Hono } from "hono";
-import { EntityCollection } from "@rebasepro/types";
-import { HonoEnv } from "../api/types";
-import { logger } from "../utils/logger";
-
-export async function mountOpenApiDocs(
-    app: Hono<HonoEnv>,
-    basePath: string,
-    enableSwagger: boolean | undefined,
-    activeCollections: EntityCollection[],
-    requireAuth: boolean
-): Promise<void> {
-    if (enableSwagger === false || activeCollections.length === 0) {
-        return;
-    }
-
-    const { generateOpenApiSpec } = await import("../api/openapi-generator");
-
-    app.get(`${basePath}/docs`, (c) => {
-        const spec = generateOpenApiSpec(activeCollections, {
-            basePath,
-            requireAuth
-        });
-        return c.json(spec);
-    });
-
-    if (process.env.NODE_ENV !== "production") {
-        app.get(`${basePath}/swagger`, (c) => {
-            return c.html(`<!DOCTYPE html>
-<html>
-<head>
-    <title>Rebase API Documentation</title>
-    <meta charset="utf-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1"/>
-    <link rel="stylesheet" type="text/css" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css"/>
-    <style>body{margin:0;padding:0;}</style>
-</head>
-<body>
-    <div id="swagger-ui"></div>
-    <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
-    <script>SwaggerUIBundle({ url: '${basePath}/docs', dom_id: '#swagger-ui' });</script>
-</body>
-</html>`);
-        });
-        logger.info("Swagger UI available", { path: `${basePath}/swagger` });
-    }
-}

package/src/init/health.ts

@@ -1,37 +0,0 @@
-import { DataDriver, HealthCheckResult, isSQLAdmin } from "@rebasepro/types";
-import { logger } from "../utils/logger";
-
-export function createHealthCheck(defaultDriver: DataDriver): () => Promise<HealthCheckResult> {
-    return async (): Promise<HealthCheckResult> => {
-        const start = performance.now();
-        try {
-            const admin = defaultDriver.admin;
-            if (isSQLAdmin(admin)) {
-                await admin.executeSql("SELECT 1");
-            } else {
-                await defaultDriver.fetchCollection({
-                    path: "__health_check_nonexistent__",
-                    limit: 1
-                });
-            }
-            const latencyMs = Math.round(performance.now() - start);
-            return {
-                healthy: true,
-                latencyMs
-            };
-        } catch (error: unknown) {
-            const latencyMs = Math.round(performance.now() - start);
-            logger.error("Health check failed", {
-                error: error instanceof Error ? error : new Error(String(error)),
-                latencyMs
-            });
-            return {
-                healthy: false,
-                latencyMs,
-                details: {
-                    error: error instanceof Error ? error.message : String(error)
-                }
-            };
-        }
-    };
-}

package/src/init/middlewares.ts

@@ -1,61 +0,0 @@
-import { Hono } from "hono";
-import { bodyLimit } from "hono/body-limit";
-import { csrf } from "hono/csrf";
-import { HonoEnv } from "../api/types";
-import { requestId } from "../utils/request-id";
-import { requestLogger } from "../utils/request-logger";
-import { logger } from "../utils/logger";
-
-interface MiddlewareConfig {
-    maxBodySize?: number;
-    csrf?: {
-        origin: string | string[] | ((origin: string) => boolean);
-    };
-}
-
-export function configureMiddlewares(
-    app: Hono<HonoEnv>,
-    basePath: string,
-    isProduction: boolean,
-    config: MiddlewareConfig
-): void {
-    // Request ID (correlation)
-    app.use(`${basePath}/*`, requestId());
-
-    // Request Body Size Limit
-    const maxBodySize = config.maxBodySize ?? 10 * 1024 * 1024; // 10MB default
-    if (maxBodySize > 0) {
-        app.use(`${basePath}/*`, bodyLimit({
-            maxSize: maxBodySize,
-            onError: (c) => {
-                return c.json({
-                    error: {
-                        message: `Request body too large. Maximum size is ${Math.round(maxBodySize / 1024 / 1024)}MB.`,
-                        code: "PAYLOAD_TOO_LARGE"
-                    }
-                }, 413);
-            }
-        }));
-        logger.info("Request body limit configured", { maxSizeMB: Math.round(maxBodySize / 1024 / 1024) });
-    }
-
-    // CSRF Protection (opt-in)
-    if (config.csrf?.origin) {
-        app.use(`${basePath}/*`, csrf({
-            origin: config.csrf.origin
-        }));
-        logger.info("CSRF protection enabled");
-    }
-
-    // CORS Warning
-    if (!isProduction && !process.env.CORS_ORIGINS && !process.env.FRONTEND_URL) {
-        logger.warn(
-            "No CORS configuration detected (CORS_ORIGINS / FRONTEND_URL not set). " +
-            "The API will accept requests from any origin. " +
-            "Set CORS_ORIGINS in your .env file to restrict access."
-        );
-    }
-
-    // Request Logging
-    app.use(`${basePath}/*`, requestLogger());
-}

package/src/init/shutdown.ts

@@ -1,56 +0,0 @@
-import { Server } from "http";
-import { RealtimeProvider } from "@rebasepro/types";
-import { logger } from "../utils/logger";
-
-interface ShutdownConfig {
-    server: Server;
-    cronScheduler?: { stop(): void };
-    realtimeServices: Record<string, RealtimeProvider>;
-}
-
-export function createShutdown(config: ShutdownConfig): (timeoutMs?: number) => Promise<void> {
-    return (timeoutMs = 15_000): Promise<void> => {
-        return new Promise<void>((resolve) => {
-            (async () => {
-                logger.info("Shutting down Rebase Backend...");
-
-                // 1. Stop cron scheduler
-                if (config.cronScheduler) {
-                    config.cronScheduler.stop();
-                    logger.info("Cron scheduler stopped");
-                }
-
-                // 2. Tear down realtime services (LISTEN clients, debounce timers,
-                //    subscriptions). Must happen BEFORE pool.end() so that pending
-                //    timer callbacks don't fire against a closed pool.
-                for (const [key, rt] of Object.entries(config.realtimeServices)) {
-                    try {
-                        if (typeof rt.destroy === "function") {
-                            await rt.destroy();
-                            logger.info(`Realtime service "${key}" destroyed`);
-                        } else if (typeof rt.stopListening === "function") {
-                            await rt.stopListening();
-                            logger.info(`Realtime service "${key}" LISTEN client stopped`);
-                        }
-                    } catch (err) {
-                        logger.warn(`Error destroying realtime service "${key}":`, { error: err });
-                    }
-                }
-
-                // 3. Close the HTTP server (stop accepting, drain in-flight)
-                config.server.close(() => {
-                    logger.info("HTTP server closed");
-                    resolve();
-                });
-
-                // 4. Force-resolve after timeout (unless disabled with 0)
-                if (timeoutMs > 0) {
-                    setTimeout(() => {
-                        logger.warn(`Forced shutdown after ${timeoutMs / 1000}s timeout`);
-                        resolve();
-                    }, timeoutMs).unref();
-                }
-            })();
-        });
-    };
-}

package/src/init/storage.ts

@@ -1,57 +0,0 @@
-import {
-    BackendStorageConfig,
-    createStorageController,
-    DEFAULT_STORAGE_ID,
-    DefaultStorageRegistry,
-    StorageController,
-    StorageRegistry
-} from "../storage";
-import { logger } from "../utils/logger";
-
-export function initializeStorage(
-    storageConfig: BackendStorageConfig | StorageController | Record<string, BackendStorageConfig | StorageController> | undefined,
-    isProduction: boolean
-): { storageRegistry?: StorageRegistry; storageController?: StorageController } {
-    if (!storageConfig) return {};
-
-    logger.info("Configuring storage");
-    const controllers: Record<string, StorageController> = {};
-
-    const toController = (entry: BackendStorageConfig | StorageController, label: string): StorageController => {
-        if (typeof (entry as StorageController).putObject === "function") {
-            return entry as StorageController;
-        }
-        const conf = entry as BackendStorageConfig;
-        if (isProduction && conf.type === "local") {
-            logger.warn(`Storage backend "${label}" uses local filesystem in production. ` +
-                "Files will be lost on container restart. " +
-                "Configure S3-compatible storage or a custom StorageController.");
-        }
-        return createStorageController(conf);
-    };
-
-    if (
-        typeof storageConfig === "object" &&
-        ("type" in storageConfig || typeof (storageConfig as StorageController).putObject === "function")
-    ) {
-        controllers[DEFAULT_STORAGE_ID] = toController(
-            storageConfig as BackendStorageConfig | StorageController,
-            DEFAULT_STORAGE_ID
-        );
-    } else {
-        for (const [storageId, entry] of Object.entries(
-            storageConfig as Record<string, BackendStorageConfig | StorageController>
-        )) {
-            controllers[storageId] = toController(entry, storageId);
-        }
-    }
-
-    if (Object.keys(controllers).length > 0) {
-        const storageRegistry = DefaultStorageRegistry.create(controllers);
-        const storageController = storageRegistry.getDefault();
-        logger.info("Initialized storage backends", { count: Object.keys(controllers).length });
-        return { storageRegistry, storageController };
-    }
-
-    return {};
-}