@rebasepro/server-core 0.7.0 → 0.8.0

package/dist/functions/define-function.d.ts

@@ -0,0 +1,50 @@
+import { Hono } from "hono";
+import type { RebaseClient } from "@rebasepro/types";
+import type { HonoEnv } from "../api/types";
+/**
+ * Typed context injected into a function authored with {@link defineFunction}.
+ *
+ * Surfaces the app-scoped Rebase singleton so handlers don't need to reach
+ * for the global `rebase` import. Request-scoped values (the authenticated
+ * `user`, the RLS-scoped `driver`, the `apiKey`, the `requestId`) are typed
+ * on the Hono context via {@link HonoEnv} — read them with `c.get("user")`
+ * / `c.var.driver` inside a handler.
+ */
+export interface RebaseFunctionContext {
+    /**
+     * The server-side Rebase singleton (`data`, `auth`, `storage`, `email`,
+     * `sql`). `rebase.data` runs with **admin privileges** (no RLS) — use the
+     * request `driver` (`c.var.driver`) for user-scoped queries.
+     */
+    rebase: RebaseClient;
+}
+/**
+ * Typed authoring contract for a custom backend function.
+ *
+ * A custom function is a file in the `functionsDir` that default-exports a
+ * Hono app; the loader mounts it at `/<filename>`. `defineFunction` is the
+ * typed opt-in for that contract: it hands you a pre-typed `Hono<HonoEnv>`
+ * app (so `c.var.user` / `c.var.driver` are typed) plus a
+ * {@link RebaseFunctionContext}, and returns exactly the Hono app the loader
+ * already accepts — so it is fully interchangeable with a plain
+ * `export default new Hono()`.
+ *
+ * @example
+ * ```ts
+ * import { defineFunction, requireAuth } from "@rebasepro/server-core";
+ *
+ * export default defineFunction((app, { rebase }) => {
+ *     app.use("/*", requireAuth);
+ *     app.get("/home", async (c) => {
+ *         const [stats] = await rebase.sql!(`SELECT count(*) AS n FROM orders`);
+ *         return c.json({ orders: Number(stats.n) });
+ *     });
+ * });
+ * ```
+ *
+ * @param definition Receives the function's Hono app and the typed context.
+ *   Register routes on the provided `app` and return nothing, or return your
+ *   own `Hono<HonoEnv>` app to use instead.
+ * @returns The Hono app to default-export from the function file.
+ */
+export declare function defineFunction(definition: (app: Hono<HonoEnv>, ctx: RebaseFunctionContext) => void | Hono<HonoEnv>): Hono<HonoEnv>;

package/dist/functions/function-loader.d.ts

@@ -0,0 +1,17 @@
+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 declare function loadFunctionsFromDirectory(directory: string): Promise<LoadedFunction[]>;

package/dist/functions/function-routes.d.ts

@@ -0,0 +1,10 @@
+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 declare function createFunctionRoutes(functions: LoadedFunction[]): Hono<HonoEnv>;

package/dist/functions/index.d.ts

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

package/dist/history/history-routes.d.ts

@@ -0,0 +1,23 @@
+import { Hono } from "hono";
+import { HonoEnv } from "../api/types";
+import { BackendCollectionRegistry } from "../collections/BackendCollectionRegistry";
+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 declare function createHistoryRoutes(params: {
+    historyService: HistoryService;
+    registry: BackendCollectionRegistry;
+    driver: DataDriver;
+}): Hono<HonoEnv>;

package/dist/history/index.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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`.
+ */
+export { initializeRebaseBackend, isAuthAdapter, isDatabaseAdapter } from "./init";
+export type { RebaseBackendConfig, RebaseBackendInstance, RebaseAuthConfig } from "./init";
+export { rebase, _setRebaseMock, _resetRebaseMock } from "./singleton";
+export * from "./db/interfaces";
+export * from "./auth";
+export * from "./api";
+export * from "./email";
+export * from "./storage";
+export { createHistoryRoutes } from "./history";
+export { loadFunctionsFromDirectory, createFunctionRoutes, defineFunction } from "./functions";
+export type { LoadedFunction, RebaseFunctionContext } from "./functions";
+export { loadCronJobsFromDirectory, CronScheduler, validateCronExpression, createCronRoutes, createCronStore } from "./cron";
+export type { LoadedCronJob, CronStore } from "./cron";
+export { authUid, authRoles, authJwt } from "./utils/sql";
+export { logger } from "./utils/logger";
+export type { Logger } from "./utils/logger";
+export { loadEnv } from "./env";
+export type { RebaseEnv } from "./env";
+export * from "./types";
+export * from "./services/driver-registry";
+export { cleanupDevPortFile, listenWithPortRetry } from "./utils/dev-port";
+export { serveSPA } from "./serve-spa";
+export { z } from "zod";