@rebasepro/server-core 0.0.1-canary.09e5ec5

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,129 @@
+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/history/index.ts

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

package/src/index.ts

@@ -0,0 +1,66 @@
+/**
+ * @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/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";
+
+// Backend bootstrappers (pluggable driver initialization)
+