@rebasepro/server-core 0.0.1-canary.4d4fb3e

package/src/functions/function-loader.ts

@@ -0,0 +1,91 @@
+import * as fs from "fs";
+import * as path from "path";
+import { pathToFileURL } from "url";
+import { Hono } from "hono";
+
+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) {
+                    console.warn(
+                        `[functions] ${file}: no default export. Skipping.`
+                    );
+                    continue;
+                }
+
+                // Accept a Hono instance directly
+                if (exported instanceof Hono) {
+                    const name = path.basename(file, path.extname(file));
+                    functions.push({ name, app: exported });
+                    console.log(`⚡ Loaded function route: ${name}`);
+                    continue;
+                }
+
+                // Also accept a factory function that returns a Hono instance
+                if (typeof exported === "function") {
+                    const result = exported();
+                    if (result instanceof Hono) {
+                        const name = path.basename(file, path.extname(file));
+                        functions.push({ name, app: result });
+                        console.log(`⚡ Loaded function route: ${name}`);
+                        continue;
+                    }
+                }
+
+                console.warn(
+                    `[functions] ${file}: default export is not a Hono app or factory. Skipping.`
+                );
+            } catch (err: unknown) {
+                const message =
+                    err instanceof Error ? err.message : String(err);
+                console.error(
+                    `[functions] Failed to load ${file}: ${message}`
+                );
+            }
+        }
+    }
+
+    return functions;
+}

package/src/functions/function-routes.ts

@@ -0,0 +1,31 @@
+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/functions/index.ts

@@ -0,0 +1,3 @@
+export { loadFunctionsFromDirectory } from "./function-loader";
+export type { LoadedFunction } from "./function-loader";
+export { createFunctionRoutes } from "./function-routes";

package/src/history/history-routes.ts

@@ -0,0 +1,128 @@
+import { Hono } from "hono";
+import { HonoEnv } from "../api/types";
+import { BackendCollectionRegistry } from "../collections/BackendCollectionRegistry";
+import { ApiError } 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: any[], total: number }>;
+    fetchHistoryEntry(historyId: string): Promise<any>;
+}
+
+export function createHistoryRoutes(params: {
+    historyService: HistoryService;
+    registry: BackendCollectionRegistry;
+    driver: DataDriver;
+}): Hono<HonoEnv> {
+    const { historyService, registry, driver } = params;
+    const router = new Hono<HonoEnv>();
+
+    /**
+     * 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/history/index.ts

@@ -0,0 +1,2 @@
+
+export { createHistoryRoutes } from "./history-routes";

package/src/index.ts

@@ -0,0 +1,56 @@
+/**
+ * @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";
+
+// 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/sql";
+
+// Entity history
+export * from "./history";
+
+// Custom Functions (auto-discovered Hono routes)
+export * from "./functions";
+
+
+
+// SPA serving helper
+export * from "./serve-spa";
+
+// Backend bootstrappers (pluggable driver initialization)
+

package/src/init.ts

@@ -0,0 +1,309 @@
+import { DataDriver, EntityCollection, BackendBootstrapper, BootstrappedAuth, RealtimeProvider } from "@rebasepro/types";
+import { BackendCollectionRegistry } from "./collections/BackendCollectionRegistry";
+import { loadCollectionsFromDirectory } from "./collections/loader";
+import { DriverRegistry, DEFAULT_DRIVER_ID, DefaultDriverRegistry } from "./services/driver-registry";
+import { Server } from "http";
+
+import { RestApiGenerator } from "./api/rest/api-generator";
+import { createAuthMiddleware } from "./auth/middleware";
+import { errorHandler } from "./api/errors";
+import { Hono } from "hono";
+import { HonoEnv } from "./api/types";
+import { configureLogLevel } from "./utils/logging";
+import { createAdminRoutes, createAuthRoutes, requireAuth, requireAdmin, configureJwt } from "./auth";
+import { createStorageController, createStorageRoutes, DEFAULT_STORAGE_ID, DefaultStorageRegistry, BackendStorageConfig, StorageController, StorageRegistry } from "./storage";
+import { createHistoryRoutes } from "./history";
+import { EmailConfig } from "./email";
+
+export interface RebaseAuthConfig {
+    jwtSecret?: string;
+    accessExpiresIn?: string;
+    refreshExpiresIn?: string;
+    requireAuth?: boolean;
+    allowRegistration?: boolean;
+    email?: EmailConfig;
+    google?: { clientId: string };
+    defaultRole?: string;
+    [key: string]: unknown;
+}
+
+export interface RebaseBackendConfig {
+    collections?: EntityCollection[];
+    collectionsDir?: string;
+    server: Server;
+    app: Hono<HonoEnv>;
+    basePath?: string;
+    bootstrappers: BackendBootstrapper[];
+    logging?: {
+        level?: "error" | "warn" | "info" | "debug";
+    };
+    auth?: RebaseAuthConfig;
+    storage?: BackendStorageConfig | Record<string, BackendStorageConfig>;
+    history?: unknown;
+    enableSwagger?: boolean;
+    functionsDir?: string;
+}
+
+export interface RebaseBackendInstance {
+    driverRegistry: DriverRegistry;
+    driver: DataDriver;
+    realtimeServices: Record<string, RealtimeProvider>;
+    realtimeService: RealtimeProvider;
+    auth?: BootstrappedAuth;
+    history?: unknown;
+    storageRegistry?: StorageRegistry;
+    storageController?: StorageController;
+    collectionRegistry: BackendCollectionRegistry;
+}
+
+export async function initializeRebaseBackend(config: RebaseBackendConfig): Promise<RebaseBackendInstance> {
+    try {
+        return await _initializeRebaseBackend(config);
+    } catch (error: unknown) {
+        console.error("❌ Critical error during Rebase Backend initialization:", error);
+
+        const basePath = config.basePath || "/api";
+        config.app.use(`${basePath}/*`, async (c) => {
+            return c.json({
+                error: {
+                    message: "Backend initialization failed. Please check the backend server logs.",
+                    code: "backend-init-failed"
+                }
+            }, 503);
+        });
+
+        return {
+            __failed: true,
+            driverRegistry: DefaultDriverRegistry.create({}),
+            driver: {} as unknown as DataDriver,
+            realtimeServices: {},
+            realtimeService: {} as unknown as RealtimeProvider,
+        } as unknown as RebaseBackendInstance;
+    }
+}
+
+async function _initializeRebaseBackend(config: RebaseBackendConfig): Promise<RebaseBackendInstance> {
+    if (config.logging?.level) {
+        configureLogLevel(config.logging.level);
+    } else {
+        configureLogLevel();
+    }
+
+    console.log("🔥 Initializing Rebase Backend (Bootstrapper Protocol V2)");
+
+    const collectionRegistry = new BackendCollectionRegistry();
+    let activeCollections = config.collections || [];
+    if (config.collectionsDir && activeCollections.length === 0) {
+        activeCollections = await loadCollectionsFromDirectory(config.collectionsDir);
+        console.log(`📁 Auto-discovered ${activeCollections.length} collections from ${config.collectionsDir}`);
+    }
+
+    const realtimeServices: Record<string, RealtimeProvider> = {};
+    const delegates: Record<string, DataDriver> = {};
+    const bootstrappers = config.bootstrappers || [];
+
+    if (bootstrappers.length === 0) {
+        throw new Error("No bootstrappers provided. Cannot initialize database drivers.");
+    }
+
+    let defaultDriverId = DEFAULT_DRIVER_ID;
+
+    let defaultDriverResult: import("@rebasepro/types").InitializedDriver | undefined = undefined;
+
+    // 1. Initialize all drivers
+    for (const bootstrapper of bootstrappers) {
+        const b = bootstrapper as BackendBootstrapper & { id?: string; isDefault?: boolean };
+        console.log(`📦 Running bootstrapper for driver: "${b.id || bootstrapper.type}"`);
+        if (b.isDefault) {
+            defaultDriverId = b.id || bootstrapper.type;
+        }
+
+        const driverResult = await bootstrapper.initializeDriver({ collections: activeCollections, collectionRegistry });
+        delegates[b.id || bootstrapper.type] = driverResult.driver;
+        
+        if ((b.id || bootstrapper.type) === defaultDriverId || !defaultDriverResult) {
+            defaultDriverResult = driverResult;
+        }
+
+        if (bootstrapper.initializeRealtime) {
+            const realtime = await bootstrapper.initializeRealtime({}, driverResult);
+            realtimeServices[b.id || bootstrapper.type] = realtime as RealtimeProvider;
+        }
+    }
+
+    const driverRegistry = DefaultDriverRegistry.create(delegates);
+    activeCollections.forEach(collection => collectionRegistry.register(collection));
+
+    const defaultDriver = driverRegistry.getOrDefault(defaultDriverId);
+    if (!defaultDriver || !defaultDriverResult) {
+        throw new Error("Default driver not initialized by bootstrappers");
+    }
+    const defaultBootstrapper = bootstrappers.find(b => (b as BackendBootstrapper & { id?: string }).id === defaultDriverId || b.type === defaultDriverId) || bootstrappers[0];
+    const defaultRealtimeService = defaultDriverResult.realtimeProvider;
+
+    // 2. Initialize Auth & History via the default driver's bootstrapper
+    let authConfigResult: BootstrappedAuth | undefined = undefined;
+    if (config.auth) {
+        // Secure JWT setup proactively within core package memory to eliminate dual-package hazards
+        const safeAuthConfig = config.auth;
+        if (safeAuthConfig.jwtSecret) {
+            configureJwt({
+                secret: safeAuthConfig.jwtSecret,
+                accessExpiresIn: safeAuthConfig.accessExpiresIn || "1h",
+                refreshExpiresIn: safeAuthConfig.refreshExpiresIn || "30d"
+            });
+        }
+
+        if (defaultBootstrapper.initializeAuth) {
+            console.log("🔐 Bootstrapping authentication via driver protocol...");
+            authConfigResult = await defaultBootstrapper.initializeAuth(config.auth, defaultDriverResult);
+            console.log("✅ Authentication initialized");
+        } else {
+            console.warn("⚠️ Auth requested but default bootstrapper does not support initializeAuth");
+        }
+    }
+
+    let historyConfigResult: Record<string, unknown> | undefined = undefined;
+    if (config.history) {
+        if (defaultBootstrapper.initializeHistory) {
+            console.log("📜 Bootstrapping entity history via driver protocol...");
+            historyConfigResult = await defaultBootstrapper.initializeHistory(config.history, defaultDriverResult);
+            console.log("✅ Entity history initialized");
+        } else {
+            console.warn("⚠️ History requested but default bootstrapper does not support initializeHistory");
+        }
+    }
+
+    // 3. Initialize Storage
+    let storageRegistry: StorageRegistry | undefined;
+    let storageController: StorageController | undefined;
+
+    if (config.storage) {
+        console.log("📁 Configuring storage...");
+        const controllers: Record<string, StorageController> = {};
+
+        if (typeof config.storage === "object" && "type" in config.storage) {
+            const controller = createStorageController(config.storage as BackendStorageConfig);
+            controllers[DEFAULT_STORAGE_ID] = controller;
+        } else {
+            for (const [storageId, storageConfig] of Object.entries(config.storage as Record<string, BackendStorageConfig>)) {
+                controllers[storageId] = createStorageController(storageConfig);
+            }
+        }
+
+        if (Object.keys(controllers).length > 0) {
+            storageRegistry = DefaultStorageRegistry.create(controllers);
+            storageController = storageRegistry.getDefault();
+            console.log(`✅ Initialized ${Object.keys(controllers).length} storage backend(s)`);
+        }
+    }
+
+    const basePath = config.basePath || "/api";
+
+    // 4. Mount API Routes
+    if (config.auth && authConfigResult) {
+        const authRoutes = createAuthRoutes({
+            authRepo: authConfigResult.authRepository as import("./auth/interfaces").AuthRepository ?? authConfigResult.userService as import("./auth/interfaces").AuthRepository,
+            emailService: authConfigResult.emailService as import("./email").EmailService,
+            emailConfig: config.auth.email,
+            allowRegistration: config.auth.allowRegistration ?? false,
+            defaultRole: config.auth.defaultRole
+        });
+        config.app.route(`${basePath}/auth`, authRoutes);
+
+        const adminRoutes = createAdminRoutes({ 
+            authRepo: authConfigResult.authRepository as import("./auth/interfaces").AuthRepository ?? authConfigResult.userService as import("./auth/interfaces").AuthRepository,
+            emailService: authConfigResult.emailService as import("./email").EmailService,
+            emailConfig: config.auth.email,
+        });
+        config.app.route(`${basePath}/admin`, adminRoutes);
+    }
+
+    if (config.collectionsDir) {
+        if (process.env.NODE_ENV !== "production") {
+            const { createSchemaEditorRoutes } = await import("./api/schema-editor-routes");
+            const schemaEditorRoutes = createSchemaEditorRoutes(config.collectionsDir);
+            
+            if (config.auth?.requireAuth !== false && !!config.auth?.jwtSecret) {
+                schemaEditorRoutes.use("/*", requireAuth, requireAdmin);
+            }
+            
+            config.app.route(`${basePath}/schema-editor`, schemaEditorRoutes);
+            console.log(`✅ Schema Editor mounted at ${basePath}/schema-editor`);
+        }
+    }
+
+    if (storageController) {
+        const storageRoutes = createStorageRoutes({
+            controller: storageController,
+            requireAuth: config.auth?.requireAuth ?? true
+        });
+        config.app.route(`${basePath}/storage`, storageRoutes);
+    }
+
+    if (activeCollections.length > 0) {
+        const dataRouter = new Hono<HonoEnv>();
+
+        dataRouter.use("/*", createAuthMiddleware({
+            driver: defaultDriver,
+            requireAuth: false // true BaaS — delegate completely to Postgres RLS
+        }));
+
+        // Mount history routes BEFORE the REST API subcollection catch-all so
+        // that /:slug/:entityId/history is matched by the dedicated handler first.
+        if (historyConfigResult && historyConfigResult.historyService) {
+            const historyRoutes = createHistoryRoutes({
+                historyService: historyConfigResult.historyService as import("./history/history-routes").HistoryService,
+                registry: collectionRegistry,
+                driver: defaultDriver
+            });
+            dataRouter.route("/", historyRoutes);
+        }
+
+        const restGenerator = new RestApiGenerator(activeCollections, defaultDriver);
+        dataRouter.route("/", restGenerator.generateRoutes());
+
+        config.app.route(`${basePath}/data`, dataRouter);
+    }
+
+    // 5. Mount Custom Functions
+    if (config.functionsDir) {
+        const { loadFunctionsFromDirectory } = await import("./functions/function-loader");
+        const { createFunctionRoutes } = await import("./functions/function-routes");
+
+        const loadedFunctions = await loadFunctionsFromDirectory(config.functionsDir);
+
+        if (loadedFunctions.length > 0) {
+            const functionsRouter = new Hono<HonoEnv>();
+
+            // Apply auth middleware — delegates to RLS, per-route auth is up to the function
+            functionsRouter.use("/*", createAuthMiddleware({
+                driver: defaultDriver,
+                requireAuth: false
+            }));
+
+            const fnRoutes = createFunctionRoutes(loadedFunctions);
+            functionsRouter.route("/", fnRoutes);
+            config.app.route(`${basePath}/functions`, functionsRouter);
+            console.log(`⚡ Mounted ${loadedFunctions.length} custom function(s) at ${basePath}/functions`);
+        }
+    }
+
+    if ((defaultBootstrapper as BackendBootstrapper & { initializeWebsockets?: (...args: unknown[]) => unknown }).initializeWebsockets) {
+        await (defaultBootstrapper as BackendBootstrapper & { initializeWebsockets: (...args: unknown[]) => unknown }).initializeWebsockets(config.server, defaultRealtimeService, defaultDriver, config.auth);
+    }
+
+    console.log("✅ Rebase Backend Initialized");
+
+    return {
+        driverRegistry,
+        driver: defaultDriver,
+        realtimeServices,
+        realtimeService: defaultRealtimeService as RealtimeProvider,
+        auth: authConfigResult,
+        history: historyConfigResult,
+        storageRegistry,
+        storageController,
+        collectionRegistry
+    };
+}