@rebasepro/server-core 0.6.1 → 0.7.0

package/dist/auth/rate-limiter.d.ts

@@ -1,50 +0,0 @@
-import { MiddlewareHandler } from "hono";
-import { HonoEnv } from "../api/types";
-interface RateLimiterOptions {
-    /** Time window in milliseconds (default: 15 minutes) */
-    windowMs?: number;
-    /** Maximum requests per window (default: 100) */
-    limit?: number;
-    /** Key generator function. Defaults to IP-based keying. */
-    keyGenerator?: (c: Parameters<MiddlewareHandler<HonoEnv>>[0]) => string;
-    /** Custom message for rate limit responses */
-    message?: string;
-}
-/**
- * Create a rate-limiting middleware.
- *
- * Uses a sliding window algorithm: only timestamps within the last
- * `windowMs` milliseconds are counted. Old entries are garbage-collected
- * every `windowMs` to prevent unbounded memory growth.
- */
-export declare function createRateLimiter(options?: RateLimiterOptions): MiddlewareHandler<HonoEnv>;
-/**
- * Pre-configured rate limiter for general auth endpoints (login, register).
- * 200 requests per 15 minutes per IP.
- */
-export declare const defaultAuthLimiter: MiddlewareHandler<HonoEnv>;
-/**
- * Pre-configured strict rate limiter for sensitive endpoints (password reset, verification).
- * 50 requests per 15 minutes per IP.
- */
-export declare const strictAuthLimiter: MiddlewareHandler<HonoEnv>;
-/**
- * Key generator for API-key-based rate limiting.
- *
- * Uses the API key ID (from `c.get("apiKey")`) as the rate limit key.
- * Falls back to IP-based keying when the request is not authenticated
- * via an API key.
- */
-export declare function apiKeyKeyGenerator(c: Parameters<MiddlewareHandler<HonoEnv>>[0]): string;
-/**
- * Create a rate limiter specifically for API key requests.
- *
- * When a request is authenticated via an API key that has a `rate_limit`
- * configured, this limiter enforces per-key limits using the key's ID
- * as the rate limit bucket.
- *
- * @param defaultLimit - Fallback limit when the key has no `rate_limit` set.
- * @param windowMs     - Time window in milliseconds (default: 15 minutes).
- */
-export declare function createApiKeyRateLimiter(defaultLimit?: number, windowMs?: number): MiddlewareHandler<HonoEnv>;
-export {};

package/dist/auth/reset-password-admin.d.ts

@@ -1,29 +0,0 @@
-/**
- * Standalone admin endpoint for resetting a user's password.
- *
- * Hook resolution order:
- * 1. Collection-level hook (`auth.onResetPassword` on the collection)
- * 2. Backend-level hook (`AuthHooks.onAdminResetPassword`)
- * 3. Built-in default (send reset email, or generate temp password)
- */
-import { Hono } from "hono";
-import type { AuthRepository } from "./interfaces";
-import type { AuthHooks } from "./auth-hooks";
-import type { EmailService, EmailConfig } from "../email";
-import type { HonoEnv } from "../api/types";
-import type { AuthCollectionConfig } from "@rebasepro/types";
-export interface ResetPasswordRouteConfig {
-    authRepo: AuthRepository;
-    emailService?: EmailService;
-    emailConfig?: EmailConfig;
-    serviceKey?: string;
-    authHooks?: AuthHooks;
-    /** The parsed auth config from the collection, if available. */
-    collectionAuthConfig?: AuthCollectionConfig;
-}
-/**
- * Create a standalone admin route for resetting user passwords.
- *
- * Mounts: POST /users/:userId/reset-password
- */
-export declare function createResetPasswordRoute(config: ResetPasswordRouteConfig): Hono<HonoEnv>;

package/dist/auth/rls-scope.d.ts

@@ -1,31 +0,0 @@
-/**
- * Shared RLS (Row-Level Security) scoping helper.
- *
- * DataDrivers may implement a `withAuth()` method that returns a scoped
- * clone of the driver with RLS policies applied for the given user.
- * This is database-specific (e.g. Postgres SET LOCAL ROLE) and is not
- * part of the core DataDriver interface.
- *
- * This module provides the shared duck-typing logic used by the
- * adapter-aware middleware.
- *
- * @module
- */
-import type { DataDriver } from "@rebasepro/types";
-/**
- * Scope a DataDriver via `withAuth()` for RLS.
- *
- * SECURITY: If `withAuth()` is available but fails, the error is re-thrown
- * so the request is **denied** rather than proceeding with unscoped access
- * (fail-closed behavior).
- *
- * If the driver does not support RLS, the original driver is returned.
- *
- * @param driver - The DataDriver to scope.
- * @param user   - The authenticated user identity for RLS.
- * @returns The RLS-scoped DataDriver (or the original if RLS is unsupported).
- */
-export declare function scopeDataDriver(driver: DataDriver, user: {
-    uid: string;
-    roles?: string[];
-}): Promise<DataDriver>;

package/dist/auth/routes.d.ts

@@ -1,33 +0,0 @@
-import { Hono } from "hono";
-import type { AuthRepository, OAuthProvider } from "./interfaces";
-import type { AuthHooks } from "./auth-hooks";
-import { EmailService, EmailConfig } from "../email";
-import { HonoEnv } from "../api/types";
-/**
- * Shared configuration for auth and admin route factories.
- */
-export interface AuthModuleConfig {
-    authRepo: AuthRepository;
-    emailService?: EmailService;
-    emailConfig?: EmailConfig;
-    /** Allow new user registration (default: false). */
-    allowRegistration?: boolean;
-    /** Default role ID to assign to new users (default: none). Must NOT be "admin". */
-    defaultRole?: string;
-    /** Optional array of OAuth providers */
-    oauthProviders?: OAuthProvider<any>[];
-    /** When true, blocks all self-registration regardless of `allowRegistration`. */
-    disableSelfRegistration?: boolean;
-    /**
-     * Auth hooks for customizing password hashing, credential
-     * verification, lifecycle hooks, etc.
-     */
-    authHooks?: AuthHooks;
-    /**
-     * Callback that checks if bootstrap has already been completed.
-     * Used by GET /auth/config to report `needsSetup` status.
-     * When not provided, falls back to checking if any users exist.
-     */
-    isBootstrapCompleted?: () => Promise<boolean>;
-}
-export declare function createAuthRoutes(config: AuthModuleConfig): Hono<HonoEnv>;

package/dist/auth/session-routes.d.ts

@@ -1,25 +0,0 @@
-import { Hono } from "hono";
-import { z } from "zod";
-import { HonoEnv } from "../api/types";
-import type { AuthModuleConfig } from "./routes";
-import { resolveAuthHooks } from "./auth-hooks";
-interface SessionRoutesConfig {
-    router: Hono<HonoEnv>;
-    config: AuthModuleConfig;
-    ops: ReturnType<typeof resolveAuthHooks>;
-    parseBody: <T>(schema: z.ZodSchema<T>, body: unknown) => T;
-    buildAuthResponse: (user: {
-        id: string;
-        email: string;
-        displayName?: string | null;
-        photoUrl?: string | null;
-        metadata?: Record<string, unknown> | null;
-    }, roleIds: string[], accessToken: string, refreshToken: string) => unknown;
-    createSessionAndTokens: (userId: string, userAgent: string, ipAddress: string) => Promise<{
-        roleIds: string[];
-        accessToken: string;
-        refreshToken: string;
-    }>;
-}
-export declare function mountSessionRoutes(opts: SessionRoutesConfig): void;
-export {};

package/dist/auth/slack-oauth.d.ts

@@ -1,12 +0,0 @@
-import type { OAuthProvider } from "./interfaces";
-/**
- * Creates a Slack OAuth Provider integration (OAuth 2.0 / "Sign in with Slack").
- * Uses the OpenID Connect flow with the "openid,email,profile" scopes.
- */
-export declare function createSlackProvider(config: {
-    clientId: string;
-    clientSecret: string;
-}): OAuthProvider<{
-    code: string;
-    redirectUri: string;
-}>;

package/dist/auth/spotify-oauth.d.ts

@@ -1,12 +0,0 @@
-import type { OAuthProvider } from "./interfaces";
-/**
- * Creates a Spotify OAuth Provider integration.
- * Uses the authorization code flow with the "user-read-email" scope.
- */
-export declare function createSpotifyProvider(config: {
-    clientId: string;
-    clientSecret: string;
-}): OAuthProvider<{
-    code: string;
-    redirectUri: string;
-}>;

package/dist/auth/twitter-oauth.d.ts

@@ -1,18 +0,0 @@
-import type { OAuthProvider } from "./interfaces";
-/**
- * Creates a Twitter/X OAuth 2.0 Provider integration.
- *
- * Uses OAuth 2.0 with PKCE (authorization code flow). The frontend must include
- * the PKCE `code_verifier` when sending the authorization code.
- *
- * Twitter API v2 requires the "tweet.read" and "users.read" scopes at minimum,
- * plus "offline.access" if refresh tokens are needed on Twitter's side.
- */
-export declare function createTwitterProvider(config: {
-    clientId: string;
-    clientSecret: string;
-}): OAuthProvider<{
-    code: string;
-    redirectUri: string;
-    codeVerifier: string;
-}>;

package/dist/backend-CIxN4FVm.js

@@ -1,15 +0,0 @@
-import { createRequire as __createRequire } from "module";
-import "process";
-__createRequire(import.meta.url);
-//#region ../types/src/types/backend.ts
-/**
-* Type guard: does this admin support SQL operations?
-* @group Admin
-*/
-function isSQLAdmin(admin) {
-	return !!admin && typeof admin.executeSql === "function";
-}
-//#endregion
-export { isSQLAdmin as t };
-
-//# sourceMappingURL=backend-CIxN4FVm.js.map

package/dist/backend-CIxN4FVm.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"backend-CIxN4FVm.js","names":[],"sources":["../../types/src/types/backend.ts"],"sourcesContent":["import type { Entity } from \"./entities\";\nimport type { EntityCollection, FilterValues, WhereFilterOp } from \"./collections\";\nimport type { AuthAdapter } from \"./auth_adapter\";\n\n// =============================================================================\n// DATABASE CONNECTION INTERFACES\n// =============================================================================\n\n/**\n * Abstract database connection interface.\n * Represents a connection to any database system.\n */\nexport interface DatabaseConnection {\n    /**\n     * Type identifier for this database (e.g., 'postgres', 'mongodb', 'mysql')\n     */\n    readonly type: string;\n\n    /**\n     * Whether the connection is currently active\n     */\n    readonly isConnected?: boolean;\n\n    /**\n     * Close the database connection and release resources.\n     */\n    close?(): Promise<void>;\n}\n\n// =============================================================================\n// QUERY BUILDING INTERFACES\n// =============================================================================\n\n/**\n * A single filter condition for database queries\n */\nexport interface QueryFilter {\n    field: string;\n    operator: WhereFilterOp;\n    value: unknown;\n}\n\n/**\n * Options for fetching a collection of entities\n */\nexport interface FetchCollectionOptions<M extends Record<string, unknown> = Record<string, unknown>> {\n    filter?: FilterValues<Extract<keyof M, string>>;\n    orderBy?: string;\n    order?: \"desc\" | \"asc\";\n    limit?: number;\n    offset?: number;\n    startAfter?: unknown;\n    searchString?: string;\n    databaseId?: string;\n    collection?: EntityCollection;\n}\n\n/**\n * Options for searching entities\n */\nexport interface SearchOptions<M extends Record<string, unknown> = Record<string, unknown>> {\n    filter?: FilterValues<Extract<keyof M, string>>;\n    orderBy?: string;\n    order?: \"desc\" | \"asc\";\n    limit?: number;\n    databaseId?: string;\n    collection?: EntityCollection;\n}\n\n/**\n * Options for counting entities\n */\nexport interface CountOptions<M extends Record<string, unknown> = Record<string, unknown>> {\n    filter?: FilterValues<Extract<keyof M, string>>;\n    searchString?: string;\n    databaseId?: string;\n}\n\n/**\n * Abstract condition builder interface.\n * Implementations translate Rebase filter conditions to database-specific queries.\n *\n * Note: This interface can be implemented as instance methods or as a class with static methods.\n * For static implementations (like DrizzleConditionBuilder), use the ConditionBuilderStatic type.\n *\n * @template T The type of condition returned by the builder (e.g., SQL for PostgreSQL, Filter<Document> for MongoDB)\n */\nexport interface ConditionBuilder<T = unknown> {\n    /**\n     * Build filter conditions from Rebase FilterValues\n     */\n    buildFilterConditions<M extends Record<string, unknown>>(\n        filter: FilterValues<Extract<keyof M, string>>,\n        collectionPath: string,\n        ...args: unknown[]\n    ): T[];\n\n    /**\n     * Build search conditions for text search\n     */\n    buildSearchConditions(\n        searchString: string,\n        properties: Record<string, unknown>,\n        ...args: unknown[]\n    ): T[];\n\n    /**\n     * Combine multiple conditions with AND operator\n     */\n    combineConditionsWithAnd(conditions: T[]): T | undefined;\n\n    /**\n     * Combine multiple conditions with OR operator\n     */\n    combineConditionsWithOr(conditions: T[]): T | undefined;\n}\n\n/**\n * Static condition builder type for implementations using static methods.\n * Use this type when the class provides static methods rather than instance methods.\n *\n * @example\n * // DrizzleConditionBuilder satisfies this type\n * const builder: ConditionBuilderStatic<SQL> = DrizzleConditionBuilder;\n */\nexport type ConditionBuilderStatic<T = unknown> = {\n    buildFilterConditions<M extends Record<string, unknown>>(\n        filter: FilterValues<Extract<keyof M, string>>,\n        ...args: unknown[]\n    ): T[];\n    buildSearchConditions(\n        searchString: string,\n        properties: Record<string, unknown>,\n        ...args: unknown[]\n    ): T[];\n    combineConditionsWithAnd(conditions: T[]): T | undefined;\n    combineConditionsWithOr(conditions: T[]): T | undefined;\n};\n\n// =============================================================================\n// ENTITY REPOSITORY INTERFACES\n// =============================================================================\n\n/**\n * Abstract entity repository interface.\n * Handles all CRUD operations for entities in the database.\n *\n * Implementations should handle:\n * - Entity serialization/deserialization\n * - Relation resolution\n * - ID generation and conversion\n */\nexport interface EntityRepository {\n    /**\n     * Fetch a single entity by ID\n     */\n    fetchEntity<M extends Record<string, unknown>>(\n        collectionPath: string,\n        entityId: string | number,\n        databaseId?: string\n    ): Promise<Entity<M> | undefined>;\n\n    /**\n     * Fetch a collection of entities with optional filtering, ordering, and pagination\n     */\n    fetchCollection<M extends Record<string, unknown>>(\n        collectionPath: string,\n        options?: FetchCollectionOptions<M>\n    ): Promise<Entity<M>[]>;\n\n    /**\n     * Search entities by text\n     */\n    searchEntities<M extends Record<string, unknown>>(\n        collectionPath: string,\n        searchString: string,\n        options?: SearchOptions<M>\n    ): Promise<Entity<M>[]>;\n\n    /**\n     * Count entities in a collection\n     */\n    countEntities<M extends Record<string, unknown>>(\n        collectionPath: string,\n        options?: CountOptions<M>\n    ): Promise<number>;\n\n    /**\n     * Save an entity (create or update)\n     */\n    saveEntity<M extends Record<string, unknown>>(\n        collectionPath: string,\n        values: Partial<M>,\n        entityId?: string | number,\n        databaseId?: string\n    ): Promise<Entity<M>>;\n\n    /**\n     * Delete an entity by ID\n     */\n    deleteEntity(\n        collectionPath: string,\n        entityId: string | number,\n        databaseId?: string\n    ): Promise<void>;\n\n    /**\n     * Check if a field value is unique in a collection\n     */\n    checkUniqueField(\n        collectionPath: string,\n        fieldName: string,\n        value: unknown,\n        excludeEntityId?: string,\n        databaseId?: string\n    ): Promise<boolean>;\n\n}\n\n// =============================================================================\n// REALTIME INTERFACES\n// =============================================================================\n\n/**\n * Configuration for subscribing to a collection\n */\nexport interface CollectionSubscriptionConfig {\n    clientId: string;\n    path: string;\n    filter?: unknown;\n    orderBy?: string;\n    order?: \"desc\" | \"asc\";\n    limit?: number;\n    startAfter?: unknown;\n    databaseId?: string;\n    searchString?: string;\n}\n\n/**\n * Configuration for subscribing to a single entity\n */\nexport interface EntitySubscriptionConfig {\n    clientId: string;\n    path: string;\n    entityId: string | number;\n}\n\n/**\n * Abstract realtime provider interface.\n * Handles real-time subscriptions and notifications for entity changes.\n */\nexport interface RealtimeProvider {\n    /**\n     * Subscribe to collection changes\n     */\n    subscribeToCollection(\n        subscriptionId: string,\n        config: CollectionSubscriptionConfig,\n        callback?: (entities: Entity[]) => void\n    ): void;\n\n    /**\n     * Subscribe to single entity changes\n     */\n    subscribeToEntity(\n        subscriptionId: string,\n        config: EntitySubscriptionConfig,\n        callback?: (entity: Entity | null) => void\n    ): void;\n\n    /**\n     * Unsubscribe from a subscription\n     */\n    unsubscribe(subscriptionId: string): void;\n\n    /**\n     * Notify all relevant subscribers of an entity update\n     */\n    notifyEntityUpdate(\n        path: string,\n        entityId: string,\n        entity: Entity | null,\n        databaseId?: string\n    ): Promise<void>;\n\n    /**\n     * Called when the HTTP server is ready and listening.\n     * Useful for providers that need the server address for callbacks.\n     */\n    onServerReady?(serverInfo: { port: number; hostname?: string }): void;\n\n    /**\n     * Gracefully shut down the realtime provider.\n     * Called during server shutdown to clean up resources.\n     */\n    destroy?(): Promise<void>;\n\n    /**\n     * Stop the internal LISTEN client (e.g., PostgreSQL LISTEN/NOTIFY).\n     * Called during graceful shutdown before closing database connections.\n     */\n    stopListening?(): Promise<void>;\n}\n\n// =============================================================================\n// COLLECTION REGISTRY INTERFACES\n// =============================================================================\n\n/**\n * Abstract collection registry interface.\n * Manages registration and lookup of entity collections.\n */\nexport interface CollectionRegistryInterface {\n    /**\n     * Register a collection\n     */\n    register(collection: EntityCollection): void;\n\n    /**\n     * Get a collection by its path\n     */\n    getCollectionByPath(path: string): EntityCollection | undefined;\n\n    /**\n     * Get all registered collections\n     */\n    getCollections(): EntityCollection[];\n}\n\n// =============================================================================\n// DATA TRANSFORMER INTERFACES\n// =============================================================================\n\n/**\n * Abstract data transformer interface.\n * Handles serialization/deserialization between frontend and database formats.\n */\nexport interface DataTransformer {\n    /**\n     * Transform entity data for storage in the database\n     */\n    serializeToDatabase<M extends Record<string, unknown>>(\n        entity: M,\n        collection: EntityCollection\n    ): Record<string, unknown>;\n\n    /**\n     * Transform database data back to entity format\n     */\n    deserializeFromDatabase<M extends Record<string, unknown>>(\n        data: Record<string, unknown>,\n        collection: EntityCollection\n    ): Promise<M>;\n}\n\n// =============================================================================\n// DATABASE ADMIN — CAPABILITY-SPECIFIC INTERFACES (1.3)\n// =============================================================================\n\n/**\n * Administrative operations for SQL-based databases (PostgreSQL, MySQL, etc.).\n * Used by the SQL Editor, RLS Editor, and schema browser.\n *\n * @group Admin\n */\nexport interface SQLAdmin {\n    /**\n     * Execute raw SQL against the database.\n     */\n    executeSql(sql: string, options?: { database?: string; role?: string }): Promise<Record<string, unknown>[]>;\n\n    /**\n     * Fetch the available databases on the server.\n     */\n    fetchAvailableDatabases?(): Promise<string[]>;\n\n    /**\n     * Fetch the available database roles.\n     */\n    fetchAvailableRoles?(): Promise<string[]>;\n\n    /**\n     * Fetch the current database name.\n     */\n    fetchCurrentDatabase?(): Promise<string | undefined>;\n}\n\n/**\n * Administrative operations for document-based databases (MongoDB, Firestore, etc.).\n * Used by future document administration tools.\n *\n * @group Admin\n */\nexport interface DocumentAdmin {\n    /**\n     * Execute an aggregation pipeline or equivalent query.\n     */\n    executeAggregate?(pipeline: Record<string, unknown>[]): Promise<Record<string, unknown>[]>;\n\n    /**\n     * Fetch statistics for a collection (document count, size, etc.).\n     */\n    fetchCollectionStats?(collectionName: string): Promise<{ count: number; sizeBytes?: number }>;\n}\n\n/**\n * Administrative operations for schema management.\n * Shared across SQL and document databases.\n *\n * @group Admin\n */\nexport interface SchemaAdmin {\n    /**\n     * Fetch database tables/collections not yet mapped to a Rebase collection.\n     */\n    fetchUnmappedTables?(mappedPaths?: string[]): Promise<string[]>;\n\n    /**\n     * Fetch column/field metadata for a single table/collection.\n     * The return type is generic — SQL backends return TableMetadata,\n     * document backends may return a different shape.\n     */\n    fetchTableMetadata?(tableName: string): Promise<unknown>;\n}\n\n/**\n * Metadata for a database branch.\n * @group Admin\n */\nexport interface BranchInfo {\n    /** Branch name (without prefix). */\n    name: string;\n    /** The database this branch was created from. */\n    parentDatabase: string;\n    /** When the branch was created. */\n    createdAt: Date;\n    /** Size in bytes, if available from the server. */\n    sizeBytes?: number;\n}\n\n/**\n * Administrative operations for database branching.\n * Allows creating isolated database copies for development/preview workflows.\n *\n * @group Admin\n */\nexport interface BranchAdmin {\n    /** Create a new branch (database copy) from the current or specified source database. */\n    createBranch(name: string, options?: { source?: string }): Promise<BranchInfo>;\n\n    /** Delete a branch database. Cannot delete the main/default database. */\n    deleteBranch(name: string): Promise<void>;\n\n    /** List all branches (databases that were created via branching). */\n    listBranches(): Promise<BranchInfo[]>;\n\n    /** Get info about a specific branch. */\n    getBranchInfo(name: string): Promise<BranchInfo | undefined>;\n}\n\n/**\n * Union type for all admin capabilities.\n * A backend may implement any combination of these interfaces.\n *\n * Use type guards (`isSQLAdmin`, `isDocumentAdmin`, `isSchemaAdmin`, `isBranchAdmin`)\n * to safely narrow the type before calling methods.\n *\n * @group Admin\n */\nexport type DatabaseAdmin = Partial<SQLAdmin> & Partial<DocumentAdmin> & Partial<SchemaAdmin> & Partial<BranchAdmin>;\n\n/**\n * Type guard: does this admin support SQL operations?\n * @group Admin\n */\nexport function isSQLAdmin(admin: DatabaseAdmin | undefined): admin is SQLAdmin {\n    return !!admin && typeof (admin as SQLAdmin).executeSql === \"function\";\n}\n\n/**\n * Type guard: does this admin support document operations?\n * @group Admin\n */\nexport function isDocumentAdmin(admin: DatabaseAdmin | undefined): admin is DocumentAdmin {\n    return !!admin && (\n        typeof (admin as DocumentAdmin).executeAggregate === \"function\" ||\n        typeof (admin as DocumentAdmin).fetchCollectionStats === \"function\"\n    );\n}\n\n/**\n * Type guard: does this admin support schema management?\n * @group Admin\n */\nexport function isSchemaAdmin(admin: DatabaseAdmin | undefined): admin is SchemaAdmin {\n    return !!admin && (\n        typeof (admin as SchemaAdmin).fetchUnmappedTables === \"function\" ||\n        typeof (admin as SchemaAdmin).fetchTableMetadata === \"function\"\n    );\n}\n\n/**\n * Type guard: does this admin support database branching?\n * @group Admin\n */\nexport function isBranchAdmin(admin: DatabaseAdmin | undefined): admin is BranchAdmin {\n    return !!admin && typeof (admin as BranchAdmin).createBranch === \"function\";\n}\n\n// =============================================================================\n// LIFECYCLE INTERFACES (1.4)\n// =============================================================================\n\n/**\n * Health check result returned by `healthCheck()`.\n * @group Lifecycle\n */\nexport interface HealthCheckResult {\n    /** Whether the backend is healthy and able to serve requests. */\n    healthy: boolean;\n    /** Round-trip latency to the database in milliseconds. */\n    latencyMs: number;\n    /** Optional details (e.g., pool stats, replication lag). */\n    details?: Record<string, unknown>;\n}\n\n/**\n * Lifecycle contract for backend components that hold resources\n * (database connections, WebSocket pools, timers, etc.).\n *\n * All methods are optional — simple backends (e.g., in-memory) can skip them.\n * @group Lifecycle\n */\nexport interface BackendLifecycle {\n    /**\n     * Initialize the backend: open connections, run migrations, seed data.\n     * Called once during startup. Idempotent.\n     */\n    initialize?(): Promise<void>;\n\n    /**\n     * Check whether the backend is healthy and reachable.\n     * Should be fast (< 1 s) and safe to call frequently.\n     */\n    healthCheck?(): Promise<HealthCheckResult>;\n\n    /**\n     * Gracefully shut down: close connections, flush buffers, cancel timers.\n     * After calling `destroy()`, no other methods should be called.\n     */\n    destroy?(): Promise<void>;\n}\n\n// =============================================================================\n// BACKEND FACTORY INTERFACES\n// =============================================================================\n\n/**\n * Configuration for creating a database backend\n */\nexport interface BackendConfig {\n    /**\n     * Type of database backend\n     */\n    type: string;\n\n    /**\n     * Database connection (implementation-specific)\n     */\n    connection: unknown;\n\n    /**\n     * Schema definition (implementation-specific, e.g., Drizzle schema for PostgreSQL)\n     */\n    schema?: unknown;\n}\n\n/**\n * A complete backend instance with all required services.\n *\n * Now includes optional lifecycle management and admin capabilities.\n */\nexport interface BackendInstance extends BackendLifecycle {\n    /**\n     * Entity repository for CRUD operations\n     */\n    entityRepository: EntityRepository;\n\n    /**\n     * Realtime provider for subscriptions\n     */\n    realtimeProvider: RealtimeProvider;\n\n    /**\n     * Collection registry\n     */\n    collectionRegistry: CollectionRegistryInterface;\n\n    /**\n     * The underlying database connection\n     */\n    connection: DatabaseConnection;\n\n    /**\n     * Administrative operations (SQL, schema, documents).\n     * What's available depends on the backend type — use type guards\n     * (`isSQLAdmin`, `isSchemaAdmin`, etc.) to narrow.\n     */\n    admin?: DatabaseAdmin;\n}\n\n/**\n * Factory function type for creating backend instances\n */\nexport type BackendFactory<TConfig extends BackendConfig = BackendConfig> =\n    (config: TConfig) => BackendInstance;\n\n// =============================================================================\n// BACKEND BOOTSTRAPPER (1.2)\n// =============================================================================\n\n/**\n * A `BackendBootstrapper` encapsulates all driver-specific initialization logic.\n *\n * Instead of hard-coding Postgres setup into `initializeRebaseBackend()`,\n * each database backend provides its own bootstrapper that knows how to:\n * - Create the DataDriver from a config object\n * - Optionally initialize auth tables\n * - Optionally create a realtime service\n * - Mount driver-specific API routes\n *\n * The main `initializeRebaseBackend()` becomes a **coordinator** that iterates\n * registered bootstrappers, calls their hooks, and wires the results together.\n *\n * @group Backend\n *\n * @example\n * ```typescript\n * // Third-party MySQL bootstrapper\n * const mysqlBootstrapper: BackendBootstrapper = {\n *   type: \"mysql\",\n *   initializeDriver: async (config) => new MySQLDataDriver(config.connection),\n *   initializeRealtime: async (config) => new MySQLChangeStreamRealtime(config.connection),\n * };\n *\n * initializeRebaseBackend({\n *   ...config,\n *   bootstrappers: [postgresBootstrapper, mysqlBootstrapper]\n * });\n * ```\n */\nexport interface BackendBootstrapper {\n    /**\n     * Which driver type this bootstrapper handles.\n     * Must match the `type` field on the driver config object\n     * (e.g., `\"postgres\"`, `\"mongodb\"`, `\"mysql\"`).\n     */\n    type: string;\n\n    /**\n     * Unique identifier for this bootstrapper instance.\n     * Used to register the driver in the driver registry.\n     * Defaults to `type` if not set.\n     */\n    id?: string;\n\n    /**\n     * Whether this bootstrapper provides the default driver.\n     * When true, the coordinator uses this driver as the primary one.\n     */\n    isDefault?: boolean;\n\n    /**\n     * Run database migrations for this driver.\n     * Called by the coordinator after all drivers are initialized.\n     */\n    runMigrations?(config: unknown, driverResult: InitializedDriver): Promise<void>;\n\n    /**\n     * Create a DataDriver from the given config.\n     * This is the only **required** method.\n     */\n    initializeDriver(config: unknown): Promise<InitializedDriver>;\n\n    /**\n     * Initialize auth tables / services if this driver supports them.\n     * Return undefined if auth is not supported by this backend.\n     */\n    initializeAuth?(config: unknown, driverResult: InitializedDriver): Promise<BootstrappedAuth | undefined>;\n\n    /**\n     * Initialize history tables / services if this driver supports them.\n     * Return undefined if history is not supported by this backend.\n     */\n    initializeHistory?(config: unknown, driverResult: InitializedDriver): Promise<{ historyService: unknown } | undefined>;\n\n    /**\n     * Create a realtime provider for this driver.\n     * Return undefined if the driver does not support realtime.\n     */\n    initializeRealtime?(config: unknown, driverResult: InitializedDriver): Promise<RealtimeProvider | undefined>;\n\n    /**\n     * Mount any driver-specific HTTP routes (e.g., custom admin endpoints).\n     * Called after all drivers are initialized.\n     */\n    mountRoutes?(app: unknown, basePath: string, driverResult: InitializedDriver): void;\n\n    /**\n     * Return admin capabilities for this driver.\n     */\n    getAdmin?(driverResult: InitializedDriver): DatabaseAdmin | undefined;\n\n    /**\n     * Initialize WebSocket server for realtime operations.\n     */\n    initializeWebsockets?(server: unknown, realtimeService: RealtimeProvider, driver: import(\"../controllers/data_driver\").DataDriver, config?: unknown, authAdapter?: AuthAdapter): Promise<void> | void;\n}\n\n/**\n * Result of `BackendBootstrapper.initializeDriver()`.\n * @group Backend\n */\nexport interface InitializedDriver {\n    /** The DataDriver instance, ready for use. */\n    driver: import(\"../controllers/data_driver\").DataDriver;\n\n    /** The realtime service, if the driver created one during init. */\n    realtimeProvider?: RealtimeProvider;\n\n    /** A collection registry to register schema / tables into. */\n    collectionRegistry?: CollectionRegistryInterface;\n\n    /** The underlying database connection (for lifecycle management). */\n    connection?: DatabaseConnection;\n\n    /**\n     * Opaque handle that the bootstrapper can use in subsequent hooks\n     * (e.g., `initializeAuth`, `mountRoutes`) to access driver internals.\n     * Not used by the coordinator.\n     */\n    internals?: unknown;\n}\n\n/**\n * Result of `BackendBootstrapper.initializeAuth()`.\n * @group Backend\n */\nexport interface BootstrappedAuth {\n    /** User management service. */\n    userService: unknown;\n    /** Role management service (optional, roles are now simple strings). */\n    roleService?: unknown;\n    /** Email service (optional). */\n    emailService?: unknown;\n    /** Combined Auth Repository for unified token and user management. */\n    authRepository?: unknown;\n}\n"],"mappings":";;;;;;;;AA2dA,SAAgB,WAAW,OAAqD;CAC5E,OAAO,CAAC,CAAC,SAAS,OAAQ,MAAmB,eAAe;AAChE"}

package/dist/chunk-Dze3rakg.js

@@ -1,42 +0,0 @@
-import { createRequire as __createRequire } from "module";
-import "process";
-const require = __createRequire(import.meta.url);
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
-	if (typeof require !== "undefined") return require.apply(this, arguments);
-	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
-});
-//#endregion
-export { __toCommonJS as a, __require as i, __esmMin as n, __toESM as o, __exportAll as r, __commonJSMin as t };

package/dist/collections/BackendCollectionRegistry.d.ts

@@ -1,13 +0,0 @@
-import { CollectionRegistry } from "@rebasepro/common";
-import { CollectionRegistryInterface } from "../db/interfaces";
-/**
- * Backend-agnostic collection registry.
- * Satisfies CollectionRegistryInterface through inheritance from CollectionRegistry.
- */
-export declare class BackendCollectionRegistry extends CollectionRegistry implements CollectionRegistryInterface {
-    /**
-     * Get the available relation keys for a given collection path.
-     * Maps from the collection's relation property names to the relation names.
-     */
-    getRelationKeysForCollection(collectionPath: string): string[];
-}

package/dist/collections/loader.d.ts

@@ -1,5 +0,0 @@
-import { EntityCollection } from "@rebasepro/types";
-/**
- * Asynchronously load collection files from a directory for backend initialization
- */
-export declare function loadCollectionsFromDirectory(directory: string): Promise<EntityCollection[]>;

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

@@ -1,17 +0,0 @@
-import type { CronJobDefinition } from "@rebasepro/types";
-export interface LoadedCronJob {
-    /** Job ID derived from filename (e.g. "cleanup-sessions"). */
-    id: string;
-    /** The full definition. */
-    definition: CronJobDefinition;
-}
-/**
- * Auto-discover cron job files from a directory.
- *
- * Each file should default-export a `CronJobDefinition`.
- * The filename (without extension) becomes the job ID:
- *   `crons/cleanup-sessions.ts` → id = "cleanup-sessions"
- *
- * Follows the same discovery pattern as `loadFunctionsFromDirectory`.
- */
-export declare function loadCronJobsFromDirectory(directory: string): Promise<LoadedCronJob[]>;

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

@@ -1,14 +0,0 @@
-import { Hono } from "hono";
-import type { HonoEnv } from "../api/types";
-import type { CronScheduler } from "./cron-scheduler";
-/**
- * Create admin REST routes for managing cron jobs.
- *
- * Routes:
- *   GET    /          → list all cron jobs
- *   GET    /:id       → get a single job's status
- *   POST   /:id/trigger → manually trigger a job
- *   GET    /:id/logs  → get execution logs for a job
- *   PUT    /:id       → update job (enable/disable)
- */
-export declare function createCronRoutes(scheduler: CronScheduler): Hono<HonoEnv>;

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

@@ -1,106 +0,0 @@
-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

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

@@ -1,6 +0,0 @@
-export { loadCronJobsFromDirectory } from "./cron-loader";
-export type { LoadedCronJob } from "./cron-loader";
-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

@@ -1,18 +0,0 @@
-/**
- * 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, EntityRepository, CollectionSubscriptionConfig, EntitySubscriptionConfig, 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, EntityRepository, CollectionSubscriptionConfig, EntitySubscriptionConfig, RealtimeProvider, CollectionRegistryInterface, DataTransformer, BackendConfig, BackendInstance, BackendFactory };