@stacksjs/bun-router 0.0.15 → 0.0.17

package/dist/router/fluent-router.d.ts

@@ -1,315 +0,0 @@
-/**
- * Fluent Routing Extensions
- *
- * Implements fluent routing patterns with full TypeScript support
- */
-import type { EnhancedRequest, MiddlewareHandler, Route, RouteHandler } from '../types';
-import type { Router } from './router';
-/**
- * Controller class interface
- */
-export interface ControllerClass {
-    new (): Controller;
-}
-/**
- * Base controller interface
- */
-export interface Controller {
-    [key: string]: RouteHandler | unknown;
-}
-/**
- * Resource controller methods
- */
-export type ResourceMethod = 'index' | 'create' | 'store' | 'show' | 'edit' | 'update' | 'destroy';
-/**
- * API resource methods (no create/edit views)
- */
-export type ApiResourceMethod = 'index' | 'store' | 'show' | 'update' | 'destroy';
-/**
- * Singleton resource methods
- */
-export type SingletonMethod = 'show' | 'edit' | 'update';
-/**
- * Resource configuration
- */
-export interface ResourceOptions {
-    only?: ResourceMethod[];
-    except?: ResourceMethod[];
-    middleware?: (string | MiddlewareHandler)[];
-    names?: Partial<Record<ResourceMethod, string>>;
-    parameters?: Record<string, string>;
-    shallow?: boolean;
-}
-/**
- * Route builder for fluent API
- */
-export interface FluentRoute {
-    name: (name: string) => FluentRoute;
-    middleware: (...middleware: (string | MiddlewareHandler)[]) => FluentRoute;
-    withoutMiddleware: (...middleware: string[]) => FluentRoute;
-    where: (param: string, pattern: string | RegExp) => FluentRoute;
-    whereNumber: (param: string) => FluentRoute;
-    whereAlpha: (param: string) => FluentRoute;
-    whereAlphaNumeric: (param: string) => FluentRoute;
-    whereUuid: (param: string) => FluentRoute;
-    whereSlug: (param: string) => FluentRoute;
-    can: (ability: string, model?: string) => FluentRoute;
-    missing: (handler: (req: EnhancedRequest) => Response) => FluentRoute;
-    withTrashed: () => FluentRoute;
-    scopeBindings: () => FluentRoute;
-}
-/**
- * Group builder for fluent API
- */
-export interface GroupBuilder {
-    prefix: (prefix: string) => GroupBuilder;
-    name: (name: string) => GroupBuilder;
-    middleware: (...middleware: (string | MiddlewareHandler)[]) => GroupBuilder;
-    domain: (domain: string) => GroupBuilder;
-    controller: (controller: ControllerClass) => GroupBuilder;
-    routes: (callback: (router: FluentRouter) => void) => void;
-}
-/**
- * Fluent router with chainable API
- */
-export declare class FluentRouter {
-    private router;
-    private currentPrefix;
-    private currentNamePrefix;
-    private currentMiddleware;
-    private currentDomain;
-    private currentController;
-    private excludedMiddleware;
-    constructor(router: Router);
-    /**
-     * Register a GET route
-     */
-    get(path: string, handler: RouteHandler | string | Response): FluentRouteBuilder;
-    /**
-     * Register a POST route
-     */
-    post(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a PUT route
-     */
-    put(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a PATCH route
-     */
-    patch(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a DELETE route
-     */
-    delete(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register an OPTIONS route
-     */
-    options(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a route for any HTTP method
-     */
-    any(path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a route for multiple HTTP methods
-     */
-    match(methods: string[], path: string, handler: RouteHandler | string): FluentRouteBuilder;
-    /**
-     * Register a resource controller
-     */
-    resource(name: string, Controller: ControllerClass, options?: ResourceOptions): this;
-    /**
-     * Register an API resource controller (no create/edit views)
-     */
-    apiResource(name: string, controller: ControllerClass, options?: ResourceOptions): this;
-    /**
-     * Register a singleton resource (no index, create, store, destroy)
-     */
-    singleton(name: string, Controller: ControllerClass, options?: ResourceOptions): this;
-    /**
-     * Create a route group with prefix
-     */
-    prefix(prefix: string): GroupBuilderImpl;
-    /**
-     * Create a route group with name prefix
-     */
-    name(namePrefix: string): GroupBuilderImpl;
-    /**
-     * Create a route group with middleware
-     */
-    middleware(...middleware: (string | MiddlewareHandler)[]): GroupBuilderImpl;
-    /**
-     * Create a route group for a domain
-     */
-    domain(domain: string): GroupBuilderImpl;
-    /**
-     * Create a route group with a controller
-     */
-    controller(controller: ControllerClass): GroupBuilderImpl;
-    /**
-     * Create a route group
-     */
-    group(options: GroupOptions, callback: (router: FluentRouter) => void): this;
-    /**
-     * Check if a named route exists
-     */
-    has(name: string): boolean;
-    /**
-     * Get the current route (from request context)
-     */
-    current(): Route | null;
-    /**
-     * Get the current route name
-     */
-    currentRouteName(): string | null;
-    /**
-     * Get URL for a named route
-     */
-    route(name: string, params?: Record<string, string | number>): string;
-    /**
-     * Register a fallback route
-     */
-    fallback(handler: RouteHandler): this;
-    private addRoute;
-    /**
-     * Create a pattern object for route matching
-     */
-    private createPattern;
-    private buildPath;
-    private buildMiddleware;
-    private resolveHandler;
-    private resolveMiddleware;
-    private getResourceMethods;
-    private getResourceRoute;
-    private getSingletonRoute;
-}
-/**
- * Fluent route builder for chaining route configuration
- */
-export declare class FluentRouteBuilder implements FluentRoute {
-    private router;
-    private path;
-    private method;
-    private routeName;
-    private routeMiddleware;
-    private excludedMiddleware;
-    private constraints;
-    private missingHandler;
-    private includeTrashed;
-    private scopeBindingsEnabled;
-    private ability;
-    private abilityModel;
-    constructor(router: Router, path: string, method: string);
-    /**
-     * Set the route name
-     */
-    name(name: string): this;
-    /**
-     * Add middleware to the route
-     */
-    middleware(...middleware: (string | MiddlewareHandler)[]): this;
-    /**
-     * Exclude middleware from the route
-     */
-    withoutMiddleware(...middleware: string[]): this;
-    /**
-     * Add a parameter constraint
-     */
-    where(param: string, pattern: string | RegExp): this;
-    /**
-     * Constrain parameter to numbers
-     */
-    whereNumber(param: string): this;
-    /**
-     * Constrain parameter to letters
-     */
-    whereAlpha(param: string): this;
-    /**
-     * Constrain parameter to alphanumeric
-     */
-    whereAlphaNumeric(param: string): this;
-    /**
-     * Constrain parameter to UUID
-     */
-    whereUuid(param: string): this;
-    /**
-     * Constrain parameter to slug format
-     */
-    whereSlug(param: string): this;
-    /**
-     * Add authorization check
-     */
-    can(ability: string, model?: string): this;
-    /**
-     * Handle missing model binding
-     */
-    missing(handler: (req: EnhancedRequest) => Response): this;
-    /**
-     * Include soft-deleted models
-     */
-    withTrashed(): this;
-    /**
-     * Enable scoped bindings
-     */
-    scopeBindings(): this;
-    private findRoute;
-}
-interface GroupOptions {
-    prefix?: string;
-    as?: string;
-    middleware?: (string | MiddlewareHandler)[];
-    domain?: string;
-    controller?: ControllerClass;
-}
-declare class GroupBuilderImpl implements GroupBuilder {
-    private fluentRouter;
-    private options;
-    constructor(router: FluentRouter);
-    prefix(prefix: string): this;
-    name(name: string): this;
-    middleware(...middleware: (string | MiddlewareHandler)[]): this;
-    domain(domain: string): this;
-    controller(controller: ControllerClass): this;
-    routes(callback: (router: FluentRouter) => void): void;
-}
-/**
- * Extend Router with fluent routing methods
- */
-export declare function registerFluentRouting(RouterClass: typeof import('./router').Router): void;
-declare module './router' {
-    interface Router {
-        /**
-         * Get fluent router instance
-         */
-        fluent: () => FluentRouter;
-        /**
-         * Register a controller-based resource
-         * Note: Use `resourceController` to avoid conflict with existing `resource` method
-         */
-        resourceController: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router;
-        /**
-         * Register an API resource controller (no create/edit views)
-         */
-        apiResourceController: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router;
-        /**
-         * Register a singleton resource
-         */
-        singletonResource: (name: string, controller: ControllerClass, options?: ResourceOptions) => Router;
-        /**
-         * Check if a named route exists
-         */
-        hasRoute: (name: string) => boolean;
-        /**
-         * Get the current route
-         */
-        currentRoute: () => Route | null;
-        /**
-         * Get the current route name
-         */
-        currentRouteName: () => string | null;
-        /**
-         * Get URL for a named route
-         */
-        routeUrl: (name: string, params?: Record<string, string | number>) => string;
-    }
-}
-export {};