@spfn/core/dist/auto-loader-JFaZ9gON.d.ts

SPFN Framework Core - File-based routing, transactions, repository pattern

import { MiddlewareHandler, Hono } from 'hono';

declare module 'hono' {
    interface ContextVariableMap {
        _skipMiddlewares?: string[];
    }
}
/**
 * AutoRouteLoader: Simplified File-based Routing System
 *
 * Features:
 * - Auto-discovery: Scans routes directory and auto-registers
 * - Dynamic routes: [id] → :id, [...slug] → *
 * - Statistics: Route registration stats for dashboard
 * - Grouping: Natural grouping by directory structure
 */
type RouteInfo = {
    path: string;
    file: string;
    meta?: {
        description?: string;
        tags?: string[];
        auth?: boolean;
        [key: string]: unknown;
    };
    priority: number;
};
type RouteStats = {
    total: number;
    byPriority: {
        static: number;
        dynamic: number;
        catchAll: number;
    };
    byTag: Record<string, number>;
    routes: RouteInfo[];
};
declare class AutoRouteLoader {
    private routesDir;
    private routes;
    private readonly debug;
    private readonly middlewares;
    constructor(routesDir: string, debug?: boolean, middlewares?: Array<{
        name: string;
        handler: MiddlewareHandler;
    }>);
    load(app: Hono): Promise<RouteStats>;
    /**
     * Load routes from an external directory (e.g., from SPFN function packages)
     * Reads package.json spfn.prefix and mounts routes under that prefix
     *
     * @param app - Hono app instance
     * @param routesDir - Directory containing route handlers
     * @param packageName - Name of the package (for logging)
     * @param prefix - Optional prefix to mount routes under (from package.json spfn.prefix)
     * @returns Route statistics
     */
    loadExternalRoutes(app: Hono, routesDir: string, packageName: string, prefix?: string): Promise<RouteStats>;
    getStats(): RouteStats;
    private scanFiles;
    private isValidRouteFile;
    private loadRoute;
    private extractContractPaths;
    private calculateContractPriority;
    private validateModule;
    private registerContractBasedMiddlewares;
    private categorizeAndLogError;
    private logStats;
}
declare function loadRoutes(app: Hono, options?: {
    routesDir?: string;
    debug?: boolean;
    middlewares?: Array<{
        name: string;
        handler: MiddlewareHandler;
    }>;
    includeFunctionRoutes?: boolean;
}): Promise<RouteStats>;

export { AutoRouteLoader as A, type RouteInfo as R, type RouteStats as a, loadRoutes as l };