@rebasepro/server 0.0.1-canary.4829d6e

package/dist/cron/cron-scheduler.d.ts

@@ -0,0 +1,106 @@
+import type { CronJobStatus, CronJobLogEntry } from "@rebasepro/types";
+import type { RebaseClient } from "@rebasepro/types";
+import type { LoadedCronJob } from "./cron-loader";
+import type { CronStore } from "./cron-store";
+/**
+ * Validates a standard 5-field cron expression structurally and semantically.
+ * Returns `{ valid: true }` or `{ valid: false, reason: string }`.
+ */
+export declare function validateCronExpression(schedule: string): {
+    valid: true;
+} | {
+    valid: false;
+    reason: string;
+};
+export declare class CronScheduler {
+    private jobs;
+    private started;
+    private store?;
+    private client?;
+    /**
+     * Set the RebaseClient instance to make it available to cron job handlers.
+     */
+    setClient(client: RebaseClient): void;
+    /**
+     * Attach a persistence store for cron logs.
+     * When set, execution logs are written to the database after each run,
+     * and counters are seeded from the database on start.
+     */
+    setStore(store: CronStore): void;
+    /**
+     * Register a batch of loaded cron jobs.
+     *
+     * If the scheduler is already started, newly registered jobs are
+     * automatically scheduled (so late-registered jobs don't sit idle).
+     *
+     * Validates the cron schedule on registration — invalid schedules
+     * are rejected with a warning and the job is NOT registered.
+     */
+    registerJobs(loadedJobs: LoadedCronJob[]): void;
+    /**
+     * Start the scheduler — begins ticking all enabled jobs.
+     */
+    start(): void;
+    /**
+     * Stop the scheduler and clear all timers.
+     *
+     * Currently-executing handlers run to completion (they are async),
+     * but no further scheduling occurs after stop.
+     */
+    stop(): void;
+    /**
+     * List all registered jobs with their current status.
+     */
+    listJobs(): CronJobStatus[];
+    /**
+     * Get a single job status by ID.
+     */
+    getJob(id: string): CronJobStatus | undefined;
+    /**
+     * Get log entries for a job.
+     */
+    getJobLogs(id: string, limit?: number): CronJobLogEntry[];
+    /**
+     * Get log entries for a job from the database (if store is available).
+     * Falls back to in-memory logs if no store is configured.
+     */
+    getJobLogsFromDb(id: string, limit?: number): Promise<CronJobLogEntry[]>;
+    /**
+     * Enable or disable a job at runtime.
+     */
+    setJobEnabled(id: string, enabled: boolean): CronJobStatus | undefined;
+    /**
+     * Manually trigger a job execution immediately.
+     *
+     * Returns `undefined` if the job doesn't exist.
+     * If the job is currently executing, returns the log entry with
+     * a `skipped: true` result rather than running concurrently.
+     */
+    triggerJob(id: string): Promise<CronJobLogEntry | undefined>;
+    /**
+     * Schedule the next execution for a job.
+     *
+     * Safety guarantees:
+     * 1. Clears any existing timer first (prevents leaked/duplicate timers)
+     * 2. Enforces a minimum delay to prevent tight loops from jitter
+     * 3. Unref's the timer so it doesn't prevent process exit
+     * 4. Re-checks enabled & started state before executing
+     * 5. Concurrency guard prevents overlapping handler executions
+     */
+    private scheduleNext;
+    /**
+     * Stop a single job's timer and clear its next run state.
+     */
+    private stopJob;
+    /**
+     * Execute a job's handler with full isolation and safety.
+     *
+     * - Sets a concurrency flag to prevent overlapping runs
+     * - Wraps handler in a timeout race
+     * - Captures all logs, errors, and results
+     * - Persists to store (non-blocking) if available
+     * - Always restores state even on catastrophic errors
+     */
+    private executeJob;
+    private toStatus;
+}

package/dist/cron/cron-store.d.ts

@@ -0,0 +1,32 @@
+import type { CronJobLogEntry } from "@rebasepro/types";
+import type { DataDriver } from "@rebasepro/types";
+/**
+ * Persistence layer for cron job execution logs.
+ *
+ * Uses the DataDriver's `admin.executeSql` capability to store logs in a
+ * `rebase.cron_logs` table. Falls back gracefully if the driver doesn't
+ * support SQL (e.g. MongoDB) — in that case, no persistence occurs.
+ */
+export interface CronStore {
+    /** Ensure the backing table exists. Called once on startup. */
+    ensureTable(): Promise<void>;
+    /** Persist a single log entry after execution. */
+    insertLog(entry: CronJobLogEntry): Promise<void>;
+    /**
+     * Fetch the most recent logs for a job.
+     * @param jobId  The job identifier
+     * @param limit  Max entries to return (default 50)
+     * @returns Logs sorted newest-first
+     */
+    fetchLogs(jobId: string, limit?: number): Promise<CronJobLogEntry[]>;
+    /**
+     * Fetch aggregate stats for all jobs (totalRuns, totalFailures, lastRunAt).
+     * Used to seed in-memory counters on startup.
+     */
+    fetchJobStats(): Promise<Map<string, {
+        totalRuns: number;
+        totalFailures: number;
+        lastRunAt?: string;
+    }>>;
+}
+export declare function createCronStore(driver: DataDriver): CronStore | undefined;

package/dist/cron/define-cron.d.ts

@@ -0,0 +1,28 @@
+import type { CronJobDefinition } from "@rebasepro/types";
+/**
+ * Typed authoring helper for a cron job file. Identity at runtime —
+ * a plain default-exported {@link CronJobDefinition} works identically;
+ * this adds type inference and autocomplete.
+ *
+ * @see {@link defineFunction} for the equivalent custom-functions helper.
+ *
+ * @example
+ * ```ts
+ * import { defineCron } from "@rebasepro/server";
+ *
+ * export default defineCron({
+ *     name: "Nightly cleanup",
+ *     schedule: "0 3 * * *",
+ *     async handler({ client, log }) {
+ *         const { data: expired } = await client.data.sessions.find({
+ *             where: { expired: ["==", true] },
+ *         });
+ *         for (const session of expired) {
+ *             await client.data.sessions.delete(session.id);
+ *         }
+ *         log(`Deleted ${expired.length} expired sessions`);
+ *     },
+ * });
+ * ```
+ */
+export declare function defineCron(definition: CronJobDefinition): CronJobDefinition;

package/dist/cron/index.d.ts

@@ -0,0 +1,7 @@
+export { loadCronJobsFromDirectory } from "./cron-loader";
+export type { LoadedCronJob } from "./cron-loader";
+export { defineCron } from "./define-cron";
+export { CronScheduler, validateCronExpression } from "./cron-scheduler";
+export { createCronRoutes } from "./cron-routes";
+export { createCronStore } from "./cron-store";
+export type { CronStore } from "./cron-store";

package/dist/db/interfaces.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Database Abstraction Interfaces
+ *
+ * These interfaces define the contracts that any database backend must implement
+ * to be used with Rebase. This allows for pluggable database backends like
+ * PostgreSQL, MongoDB, MySQL, etc.
+ */
+import { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, DataRepository, CollectionSubscriptionConfig, SingleSubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory } from "@rebasepro/types";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+import { PgTransaction } from "drizzle-orm/pg-core";
+/**
+ * Type representing either a direct database connection or a transaction.
+ * Used to allow services to operate within a transaction context.
+ * Note: `any` is intentional here — it represents a Drizzle client with
+ * a dynamic schema, enabling `db.query[tableName]` access without casts.
+ */
+export type DrizzleClient = NodePgDatabase<Record<string, unknown>> | PgTransaction<any, any, any>;
+export type { DatabaseConnection, QueryFilter, FetchCollectionOptions, SearchOptions, CountOptions, ConditionBuilder, ConditionBuilderStatic, DataRepository, CollectionSubscriptionConfig, SingleSubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory };

package/dist/dynamic-import-Dvh-K5fl.js

@@ -0,0 +1,22 @@
+import { createRequire as __createRequire } from "module";
+import "process";
+__createRequire(import.meta.url);
+//#region src/utils/dynamic-import.ts
+/**
+* Native ESM dynamic import.
+*
+* Wrapped in `new Function` so TypeScript / bundlers don't down-compile the
+* `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`
+* files at runtime using the host's real ESM loader. This is the production
+* default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.
+*
+* @internal
+*/
+var nativeDynamicImport = (() => {
+	const doImport = new Function("url", "return import(url)");
+	return (url) => doImport(url);
+})();
+//#endregion
+export { nativeDynamicImport as t };
+
+//# sourceMappingURL=dynamic-import-Dvh-K5fl.js.map

package/dist/dynamic-import-Dvh-K5fl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-import-Dvh-K5fl.js","names":[],"sources":["../src/utils/dynamic-import.ts"],"sourcesContent":["/**\n * Shape returned by a dynamic module import: an object whose `default`\n * property holds the module's default export (CJS `module.exports` is exposed\n * as `default` by Node's ESM interop).\n */\nexport interface ImportedModule {\n    default?: unknown;\n    [key: string]: unknown;\n}\n\n/**\n * Imports a module by file URL. Injected into the directory loaders so tests\n * can supply a deterministic importer.\n */\nexport type ModuleImporter = (url: string) => Promise<ImportedModule>;\n\n/**\n * Native ESM dynamic import.\n *\n * Wrapped in `new Function` so TypeScript / bundlers don't down-compile the\n * `import()` to `require()` — the loaders must import user-authored `.ts`/`.js`\n * files at runtime using the host's real ESM loader. This is the production\n * default for {@link loadFunctionsFromDirectory} / {@link loadCronJobsFromDirectory}.\n *\n * @internal\n */\nexport const nativeDynamicImport: ModuleImporter = (() => {\n    const doImport = new Function(\"url\", \"return import(url)\") as (url: string) => Promise<ImportedModule>;\n    return (url: string) => doImport(url);\n})();\n"],"mappings":";;;;;;;;;;;;;;AA0BA,IAAa,6BAA6C;CACtD,MAAM,WAAW,IAAI,SAAS,OAAO,oBAAoB;CACzD,QAAQ,QAAgB,SAAS,GAAG;AACxC,GAAG"}

package/dist/email/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Email module exports
+ */
+export type { EmailService, EmailSendOptions, SMTPConfig, EmailConfig, PasswordResetTemplateFunction, EmailVerificationTemplateFunction, UserInvitationTemplateFunction, WelcomeEmailTemplateFunction, MagicLinkTemplateFunction } from "./types";
+export { SMTPEmailService, createEmailService } from "./smtp-email-service";
+export { getPasswordResetTemplate, getEmailVerificationTemplate, getUserInvitationTemplate, getWelcomeEmailTemplate, getMagicLinkTemplate } from "./templates";

package/dist/email/smtp-email-service.d.ts

@@ -0,0 +1,30 @@
+import { EmailConfig, EmailSendOptions, EmailService } from "./types";
+/**
+ * SMTP Email Service implementation using Nodemailer
+ */
+export declare class SMTPEmailService implements EmailService {
+    private transporter;
+    private config;
+    private _initialized;
+    constructor(config: EmailConfig);
+    /**
+     * Lazily initialize the SMTP transporter on first use
+     */
+    private ensureTransporter;
+    /**
+     * Check if the email service is properly configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Send an email using SMTP or custom send function
+     */
+    send(options: EmailSendOptions): Promise<void>;
+    /**
+     * Verify SMTP connection (useful for startup checks)
+     */
+    verifyConnection(): Promise<boolean>;
+}
+/**
+ * Create an email service from configuration
+ */
+export declare function createEmailService(config: EmailConfig): EmailService;

package/dist/email/templates.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Default email templates for authentication emails
+ */
+interface TemplateUser {
+    email: string;
+    displayName?: string | null;
+}
+/**
+ * Default password reset email template
+ */
+export declare function getPasswordResetTemplate(resetUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default email verification template
+ */
+export declare function getEmailVerificationTemplate(verifyUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default user invitation email template
+ * Sent when an admin creates a new user account
+ */
+export declare function getUserInvitationTemplate(setPasswordUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default welcome email template
+ * Sent automatically when a new user registers
+ */
+export declare function getWelcomeEmailTemplate(user: TemplateUser, appName?: string, loginUrl?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+/**
+ * Default magic link email template
+ */
+export declare function getMagicLinkTemplate(magicLinkUrl: string, user: TemplateUser, appName?: string): {
+    subject: string;
+    html: string;
+    text: string;
+};
+export {};

package/dist/email/types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Email service types and interfaces.
+ *
+ * The canonical `EmailService` and `EmailSendOptions` live in `@rebasepro/types`
+ * so they can be used on the `RebaseClient` interface without pulling in nodemailer.
+ * This file re-exports them for backward compatibility and adds server-specific
+ * config types (SMTP, template functions, etc.).
+ */
+import type { EmailService, EmailSendOptions } from "@rebasepro/types";
+export type { EmailService, EmailSendOptions };
+/**
+ * SMTP server configuration
+ */
+export interface SMTPConfig {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth?: {
+        user: string;
+        pass: string;
+    };
+    name?: string;
+}
+/**
+ * Template function for password reset emails
+ */
+export type PasswordResetTemplateFunction = (resetUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
+/**
+ * Template function for email verification emails
+ */
+export type EmailVerificationTemplateFunction = (verifyUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
+/**
+ * Template function for user invitation emails
+ */
+export type UserInvitationTemplateFunction = (setPasswordUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
+/**
+ * Template function for welcome emails sent after registration
+ */
+export type WelcomeEmailTemplateFunction = (user: {
+    email: string;
+    displayName?: string | null;
+}, appName: string) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
+/**
+ * Template function for magic link emails
+ */
+export type MagicLinkTemplateFunction = (magicLinkUrl: string, user: {
+    email: string;
+    displayName?: string | null;
+}) => {
+    subject: string;
+    html: string;
+    text?: string;
+};
+/**
+ * Complete email configuration
+ */
+export interface EmailConfig {
+    /**
+     * From address for all emails (e.g., "noreply@example.com" or "MyApp <noreply@example.com>")
+     */
+    from: string;
+    /**
+     * SMTP configuration for sending emails via SMTP server
+     */
+    smtp?: SMTPConfig;
+    /**
+     * Alternative: custom function to send emails
+     * Use this for custom email providers (AWS SES SDK, Resend, etc.)
+     */
+    sendEmail?: (options: EmailSendOptions) => Promise<void>;
+    /**
+     * Base URL for password reset links (e.g., "https://myapp.com")
+     * The reset link will be: {baseUrl}/reset-password?token={token}
+     */
+    resetPasswordUrl?: string;
+    /**
+     * Base URL for email verification links (e.g., "https://myapp.com")
+     * The verification link will be: {baseUrl}/verify-email?token={token}
+     */
+    verifyEmailUrl?: string;
+    /**
+     * Base URL for magic link login (e.g., "https://myapp.com")
+     * The magic link will be: {baseUrl}/auth/magic-link?token={token}
+     * Falls back to `resetPasswordUrl` if not set.
+     */
+    magicLinkUrl?: string;
+    /**
+     * Application name to use in email templates
+     */
+    appName?: string;
+    /**
+     * Custom email templates (optional - defaults are provided)
+     */
+    templates?: {
+        passwordReset?: PasswordResetTemplateFunction;
+        emailVerification?: EmailVerificationTemplateFunction;
+        userInvitation?: UserInvitationTemplateFunction;
+        welcomeEmail?: WelcomeEmailTemplateFunction;
+        magicLink?: MagicLinkTemplateFunction;
+    };
+}

package/dist/env.d.ts

@@ -0,0 +1,102 @@
+import { z } from "zod";
+/**
+ * The full set of environment variables recognized by a Rebase backend.
+ */
+declare const rebaseEnvSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<{
+        production: "production";
+        development: "development";
+        test: "test";
+    }>>;
+    PORT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DATABASE_URL: z.ZodString;
+    ADMIN_CONNECTION_STRING: z.ZodOptional<z.ZodString>;
+    JWT_SECRET: z.ZodString;
+    JWT_ACCESS_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    JWT_REFRESH_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    GOOGLE_CLIENT_ID: z.ZodOptional<z.ZodString>;
+    GOOGLE_CLIENT_SECRET: z.ZodOptional<z.ZodString>;
+    REBASE_SERVICE_KEY: z.ZodOptional<z.ZodString>;
+    ALLOW_REGISTRATION: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false">>;
+    ALLOW_LOCALHOST_IN_PRODUCTION: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+    CORS_ORIGINS: z.ZodOptional<z.ZodString>;
+    FRONTEND_URL: z.ZodOptional<z.ZodString>;
+    DB_POOL_MAX: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DB_POOL_IDLE_TIMEOUT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DB_POOL_CONNECT_TIMEOUT: z.ZodPipe<z.ZodDefault<z.ZodString>, z.ZodTransform<number, string>>;
+    DATABASE_DIRECT_URL: z.ZodOptional<z.ZodString>;
+    DATABASE_READ_URL: z.ZodOptional<z.ZodString>;
+    FORCE_LOCAL_STORAGE: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+    STORAGE_TYPE: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        s3: "s3";
+    }>>;
+    STORAGE_PATH: z.ZodOptional<z.ZodString>;
+    S3_BUCKET: z.ZodOptional<z.ZodString>;
+    S3_REGION: z.ZodOptional<z.ZodString>;
+    S3_ACCESS_KEY_ID: z.ZodOptional<z.ZodString>;
+    S3_SECRET_ACCESS_KEY: z.ZodOptional<z.ZodString>;
+    S3_ENDPOINT: z.ZodOptional<z.ZodString>;
+    S3_FORCE_PATH_STYLE: z.ZodPipe<z.ZodOptional<z.ZodEnum<{
+        "": "";
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "" | "true" | "false" | undefined>>;
+}, z.core.$strip>;
+/** Inferred type of the validated environment. */
+export type RebaseEnv = z.infer<typeof rebaseEnvSchema>;
+/**
+ * Load and validate the Rebase environment configuration from `process.env`.
+ *
+ * Call this **after** your `.env` file has been loaded (via `dotenv`, `--env-file`,
+ * container injection, etc.). This function does not load `.env` files itself —
+ * that is a deployment concern, not a framework concern.
+ *
+ * Behavior:
+ * - Auto-generates ephemeral `JWT_SECRET` and `REBASE_SERVICE_KEY` in
+ *   non-production mode so developers can start without manual setup.
+ * - Blocks auto-generated secrets in production.
+ * - Returns a fully typed, validated env object.
+ *
+ * Use `extend` to add your own typed env variables on top of the base Rebase schema:
+ *
+ * @example
+ * ```ts
+ * import dotenv from "dotenv";
+ * import { z } from "zod";
+ * import { loadEnv } from "@rebasepro/server";
+ *
+ * dotenv.config({ path: "../../.env" });
+ *
+ * // Basic — just Rebase env vars:
+ * export const env = loadEnv();
+ *
+ * // Extended — add your own typed vars:
+ * export const env = loadEnv({
+ *     extend: z.object({
+ *         SMTP_HOST: z.string().optional(),
+ *         SMTP_PORT: z.string().default("587").transform(Number),
+ *         STRIPE_SECRET_KEY: z.string(),
+ *     })
+ * });
+ * // env.SMTP_HOST  → string | undefined  (fully typed)
+ * // env.STRIPE_SECRET_KEY → string        (validated, required)
+ * ```
+ */
+export declare function loadEnv(): RebaseEnv;
+export declare function loadEnv<E extends z.ZodObject<z.ZodRawShape>>(options: {
+    extend: E;
+}): RebaseEnv & z.infer<E>;
+export {};

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

@@ -0,0 +1,55 @@
+import { Hono } from "hono";
+import type { RebaseServerClient } 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 (`dataAsAdmin`, `auth`, `storage`,
+     * `email`, `sql`).
+     *
+     * `rebase.dataAsAdmin` runs with **admin privileges and bypasses RLS** — use
+     * it only for trusted admin work. For user-scoped queries inside a handler,
+     * use the request `driver` (`c.var.driver`), which carries the caller's
+     * identity so RLS applies. (`rebase.data` is a deprecated alias for
+     * `rebase.dataAsAdmin`.)
+     */
+    rebase: RebaseServerClient;
+}
+/**
+ * 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";
+ *
+ * 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,18 @@
+import { Hono } from "hono";
+import { type ModuleImporter } from "../utils/dynamic-import.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 declare function loadFunctionsFromDirectory(directory: string, importModule?: ModuleImporter): 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/:id/history`.
+ */
+export interface HistoryService {
+    fetchHistory(tableName: string, id: 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";