shokupan 0.0.1

package/dist/plugins/security-headers.d.ts

@@ -0,0 +1,36 @@
+import { Middleware } from '../types';
+export interface SecurityHeadersOptions {
+    contentSecurityPolicy?: boolean | Record<string, any>;
+    crossOriginEmbedderPolicy?: boolean;
+    crossOriginOpenerPolicy?: boolean;
+    crossOriginResourcePolicy?: boolean;
+    dnsPrefetchControl?: boolean | {
+        allow: boolean;
+    };
+    expectCt?: boolean | {
+        maxAge?: number;
+        enforce?: boolean;
+        reportUri?: string;
+    };
+    frameguard?: boolean | {
+        action: 'deny' | 'sameorigin' | 'allow-from';
+        domain?: string;
+    };
+    hidePoweredBy?: boolean;
+    hsts?: boolean | {
+        maxAge?: number;
+        includeSubDomains?: boolean;
+        preload?: boolean;
+    };
+    ieNoOpen?: boolean;
+    noSniff?: boolean;
+    originAgentCluster?: boolean;
+    permittedCrossDomainPolicies?: boolean | {
+        permittedPolicies: 'none' | 'master-only' | 'by-content-type' | 'all';
+    };
+    referrerPolicy?: boolean | {
+        policy: string | string[];
+    };
+    xssFilter?: boolean;
+}
+export declare function SecurityHeaders(options?: SecurityHeadersOptions): Middleware;

package/dist/plugins/session.d.ts

@@ -0,0 +1,87 @@
+import { EventEmitter } from 'events';
+import { ShokupanContext } from '../context';
+import { Middleware } from '../types';
+export interface SessionData {
+    cookie: Cookie;
+    [key: string]: any;
+}
+export interface SessionCookieOptions {
+    maxAge?: number;
+    signed?: boolean;
+    expires?: Date;
+    httpOnly?: boolean;
+    path?: string;
+    domain?: string;
+    secure?: boolean | 'auto';
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+    priority?: 'low' | 'medium' | 'high';
+}
+export interface SessionOptions {
+    secret: string | string[];
+    name?: string;
+    store?: Store;
+    cookie?: SessionCookieOptions;
+    genid?: (ctx: ShokupanContext) => string;
+    resave?: boolean;
+    saveUninitialized?: boolean;
+    rolling?: boolean;
+    unset?: 'destroy' | 'keep';
+}
+export interface Store extends EventEmitter {
+    get(sid: string, callback: (err: any, session?: SessionData | null) => void): void;
+    set(sid: string, session: SessionData, callback?: (err?: any) => void): void;
+    destroy(sid: string, callback?: (err?: any) => void): void;
+    touch?(sid: string, session: SessionData, callback?: (err?: any) => void): void;
+    all?(callback: (err: any, obj?: {
+        [sid: string]: SessionData;
+    } | null) => void): void;
+    length?(callback: (err: any, length?: number) => void): void;
+    clear?(callback?: (err?: any) => void): void;
+    load?(sid: string, fn: (err: any, session?: SessionData | null) => void): void;
+    createSession?(req: any, session: SessionData): SessionData;
+}
+declare class Cookie implements SessionCookieOptions {
+    maxAge?: number;
+    signed?: boolean;
+    expires?: Date;
+    httpOnly?: boolean;
+    path?: string;
+    domain?: string;
+    secure?: boolean | 'auto';
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+    originalMaxAge: number | undefined;
+    constructor(options?: SessionCookieOptions);
+    serialize(name: string, val: string): string;
+}
+export declare class MemoryStore extends EventEmitter implements Store {
+    private sessions;
+    get(sid: string, cb: (err: any, session?: SessionData | null) => void): void;
+    set(sid: string, sess: SessionData, cb?: (err?: any) => void): void;
+    destroy(sid: string, cb?: (err?: any) => void): void;
+    touch(sid: string, sess: SessionData, cb?: (err?: any) => void): void;
+    all(cb: (err: any, obj?: {
+        [sid: string]: SessionData;
+    } | null) => void): void;
+    clear(cb?: (err?: any) => void): void;
+}
+export interface SessionContext {
+    session: SessionData & {
+        id: string;
+        regenerate(callback: (err: any) => void): void;
+        destroy(callback: (err: any) => void): void;
+        reload(callback: (err: any) => void): void;
+        save(callback: (err: any) => void): void;
+        touch(): void;
+    };
+    sessionID: string;
+    sessionStore: Store;
+}
+declare module "../context" {
+    interface ShokupanContext {
+        session: SessionContext['session'];
+        sessionID: string;
+        sessionStore: Store;
+    }
+}
+export declare function Session(options: SessionOptions): Middleware;
+export {};

package/dist/plugins/validation.d.ts

@@ -0,0 +1,18 @@
+import { Middleware } from '../types';
+export interface ValidationConfig {
+    body?: any;
+    query?: any;
+    params?: any;
+    headers?: any;
+}
+export declare class ValidationError extends Error {
+    errors: any[];
+    status: number;
+    constructor(errors: any[]);
+}
+export declare const valibot: (schema: any, parser: Function) => {
+    _valibot: boolean;
+    schema: any;
+    parser: Function;
+};
+export declare function validate(config: ValidationConfig): Middleware;

package/dist/request.d.ts

@@ -0,0 +1,34 @@
+import { Method } from './types';
+export type ShokupanRequestProps = {
+    method: Method;
+    url: string;
+    headers: Headers;
+    body: any;
+};
+/**
+ * This class is used to create a request object.
+ * It is used to make requests to the router.
+ */
+declare class ShokupanRequestBase {
+    method: Method;
+    url: string;
+    headers: Headers;
+    body: any;
+    json(): Promise<any>;
+    text(): Promise<string>;
+    formData(): Promise<FormData>;
+    constructor(props: ShokupanRequestProps);
+}
+/**
+ * This type is used to add properties to the request object.
+ */
+export type ShokupanRequest<T> = ShokupanRequestBase & T;
+interface ShokupanConstructor {
+    new <T extends Record<string, any>>(props: ShokupanRequestProps): ShokupanRequest<T>;
+}
+/**
+ * This class is used to create a request object.
+ * It is used to make requests to the router.
+ */
+export declare const ShokupanRequest: ShokupanConstructor;
+export {};

package/dist/response.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Custom response class to handle response state (headers, status)
+ * before the actual Response object is created.
+ */
+export declare class ShokupanResponse {
+    private _headers;
+    private _status;
+    /**
+     * Get the current headers
+     */
+    get headers(): Headers;
+    /**
+     * Get the current status code
+     */
+    get status(): number;
+    /**
+     * Set the status code
+     */
+    set status(code: number);
+    /**
+     * Set a response header
+     * @param key Header name
+     * @param value Header value
+     */
+    set(key: string, value: string): this;
+    /**
+     * Append to a response header
+     * @param key Header name
+     * @param value Header value
+     */
+    append(key: string, value: string): this;
+    /**
+     * Get a response header value
+     * @param key Header name
+     */
+    get(key: string): string;
+    /**
+     * Check if a header exists
+     * @param key Header name
+     */
+    has(key: string): boolean;
+}

package/dist/router.d.ts

@@ -0,0 +1,237 @@
+import { OpenAPI } from '@scalar/openapi-types';
+import { Shokupan } from './shokupan';
+import { $appRoot, $childControllers, $childRouters, $isApplication, $isMounted, $isRouter, $mountPath, $parent } from './symbol';
+import { GuardAPISpec, MethodAPISpec, OpenAPIOptions, ProcessResult, RequestOptions, ShokupanRouteConfig, StaticServeOptions, Method, ShokupanController, ShokupanHandler } from './types';
+type HeadersInit = Headers | Record<string, string> | [string, string][];
+export declare const RouterRegistry: Map<string, ShokupanRouter<any>>;
+export declare const ShokupanApplicationTree: {};
+export declare class ShokupanRouter<T extends Record<string, any> = Record<string, any>> {
+    private readonly config?;
+    private [$isApplication];
+    private [$isMounted];
+    private [$isRouter];
+    private [$appRoot];
+    private [$mountPath];
+    private [$parent];
+    [$childRouters]: ShokupanRouter<T>[];
+    [$childControllers]: ShokupanController[];
+    get rootConfig(): {
+        [x: string]: any;
+        port?: number;
+        hostname?: string;
+        development?: boolean;
+        enableAsyncLocalStorage?: boolean;
+        httpLogger?: {};
+        logger?: {
+            verbose?: boolean;
+            info?: {};
+            debug?: {};
+            warning?: {};
+            error?: {};
+            fatal?: {};
+        };
+    };
+    get root(): Shokupan<any>;
+    private routes;
+    private currentGuards;
+    constructor(config?: ShokupanRouteConfig);
+    private isRouterInstance;
+    /**
+     * Mounts a controller instance to a path prefix.
+     *
+     * Controller can be a convection router or an arbitrary class.
+     *
+     * Routes are derived from method names:
+     * - get(ctx) -> GET /prefix/
+     * - getUsers(ctx) -> GET /prefix/users
+     * - postCreate(ctx) -> POST /prefix/create
+     */
+    mount(prefix: string, controller: ShokupanController | ShokupanController<T> | ShokupanRouter | ShokupanRouter<T>): this;
+    /**
+     * Returns all routes attached to this router and its descendants.
+     */
+    getRoutes(): {
+        method: Method;
+        path: string;
+        handler: ShokupanHandler<T>;
+    }[];
+    /**
+     * Makes a sub request to this router.
+     * This is useful for triggering other methods or route handlers.
+     * @param options The request options.
+     * @returns The response.
+     */
+    subRequest(arg: {
+        path: string;
+        method?: Method;
+        headers?: HeadersInit;
+        body?: any;
+    } | string): Promise<Response>;
+    /**
+     * Processes a request directly.
+     */
+    processRequest(options: RequestOptions): Promise<ProcessResult>;
+    /**
+     * Find a route matching the given method and path.
+     * @param method HTTP method
+     * @param path Request path
+     * @returns Route handler and parameters if found, otherwise null
+     */
+    find(method: string, path: string): {
+        handler: ShokupanHandler<T>;
+        params: Record<string, string>;
+    } | null;
+    private parsePath;
+    /**
+     * Adds a route to the router.
+     *
+     * @param method - HTTP method
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handler - Route handler function
+     */
+    add({ method, path, spec, handler, regex: customRegex, group }: {
+        method: Method;
+        path: string;
+        spec?: MethodAPISpec;
+        handler: ShokupanHandler<T>;
+        regex?: RegExp;
+        group?: string;
+    }): this;
+    /**
+     * Adds a GET route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    get(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a GET route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    get(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a POST route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    post(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a POST route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    post(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a PUT route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    put(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a PUT route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    put(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a DELETE route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    delete(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a DELETE route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    delete(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a PATCH route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    patch(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a PATCH route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    patch(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a OPTIONS route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    options(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a OPTIONS route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    options(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a HEAD route to the router.
+     *
+     * @param path - URL path
+     * @param handler - Route handler function
+     */
+    head(path: string, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a HEAD route to the router.
+     *
+     * @param path - URL path
+     * @param spec - OpenAPI specification for the route
+     * @param handlers - Route handler functions
+     */
+    head(path: string, spec: MethodAPISpec, ...handlers: ShokupanHandler<T>[]): any;
+    /**
+     * Adds a guard to the router that applies to all routes added **after** this point.
+     * Guards must return true or call `ctx.next()` to allow the request to continue.
+     *
+     * @param handler - Guard handler function
+     */
+    guard(handler: ShokupanHandler<T>): void;
+    /**
+     * Adds a guard to the router that applies to all routes added **after** this point.
+     * Guards must return true or call `ctx.next()` to allow the request to continue.
+     
+     * @param spec - OpenAPI specification for the guard
+     * @param handler - Guard handler function
+     */
+    guard(spec: GuardAPISpec, handler: ShokupanHandler<T>): any;
+    /**
+     * Statically serves a directory with standard options.
+     * @param uriPath URL path prefix
+     * @param options Configuration options or root directory string
+     */
+    static(uriPath: string, options: string | StaticServeOptions<T>): this;
+    /**
+     * Attach the verb routes with their overload signatures.
+     * Use compose to handle multiple handlers (middleware).
+     */
+    private attachVerb;
+    /**
+     * Generates an OpenAPI 3.1 Document by recursing through the router and its descendants.
+     */
+    generateApiSpec(options?: OpenAPIOptions): OpenAPI.Document;
+}
+export {};

package/dist/shokupan.d.ts

@@ -0,0 +1,41 @@
+import { ShokupanRequest } from './request';
+import { ShokupanRouter } from './router';
+import { $dispatch } from './symbol';
+import { Middleware, ProcessResult, RequestOptions, ShokupanConfig } from './types';
+export declare class Shokupan<T = any> extends ShokupanRouter<T> {
+    readonly applicationConfig: ShokupanConfig;
+    private middleware;
+    get logger(): {
+        verbose?: boolean;
+        info?: {};
+        debug?: {};
+        warning?: {};
+        error?: {};
+        fatal?: {};
+    };
+    constructor(applicationConfig?: ShokupanConfig);
+    /**
+     * Adds middleware to the application.
+     */
+    use(middleware: Middleware): this;
+    /**
+     * Starts the application server.
+     *
+     * @param port - The port to listen on. If not specified, the port from the configuration is used. If that is not specified, port 3000 is used.
+     * @returns The server instance.
+     */
+    listen(port?: number): Bun.Server;
+    [$dispatch](req: ShokupanRequest<T>): Promise<Response>;
+    /**
+     * Processes a request by wrapping the standard fetch method.
+     */
+    processRequest(options: RequestOptions): Promise<ProcessResult>;
+    /**
+     * Handles an incoming request (Bun.serve interface).
+     * This logic contains the middleware chain and router dispatch.
+     *
+     * @param req - The request to handle.
+     * @returns The response to send.
+     */
+    fetch(req: Request): Promise<Response>;
+}

package/dist/symbol.d.ts

@@ -0,0 +1,13 @@
+export declare const $isApplication: unique symbol;
+export declare const $appRoot: unique symbol;
+export declare const $isMounted: unique symbol;
+export declare const $routeMethods: unique symbol;
+export declare const $routeArgs: unique symbol;
+export declare const $controllerPath: unique symbol;
+export declare const $middleware: unique symbol;
+export declare const $isRouter: unique symbol;
+export declare const $parent: unique symbol;
+export declare const $childRouters: unique symbol;
+export declare const $childControllers: unique symbol;
+export declare const $mountPath: unique symbol;
+export declare const $dispatch: unique symbol;

package/dist/types.d.ts

@@ -0,0 +1,142 @@
+import { OpenAPI } from '@scalar/openapi-types';
+import { ShokupanContext } from './context';
+import { $isRouter } from './symbol';
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type MethodAPISpec = OpenAPI.Operation;
+export type GuardAPISpec = DeepPartial<OpenAPI.Operation>;
+export type RouterAPISpec = OpenAPI.Operation & Pick<Required<OpenAPI.Operation>, 'tags'> & {
+    group: string;
+};
+export interface OpenAPIOptions {
+    info?: OpenAPI.Document['info'];
+    servers?: OpenAPI.Document['servers'];
+    components?: OpenAPI.Document['components'];
+    tags?: OpenAPI.Document['tags'];
+    externalDocs?: OpenAPI.Document['externalDocs'];
+    defaultTagGroup?: string;
+    defaultTag?: string;
+}
+export interface CookieOptions {
+    maxAge?: number;
+    expires?: Date;
+    httpOnly?: boolean;
+    secure?: boolean;
+    domain?: string;
+    path?: string;
+    sameSite?: boolean | 'lax' | 'strict' | 'none' | 'Lax' | 'Strict' | 'None';
+    priority?: 'low' | 'medium' | 'high' | 'Low' | 'Medium' | 'High';
+}
+export type ShokupanHandler<T extends Record<string, any> = Record<string, any>> = (ctx: ShokupanContext<T>, next?: NextFn) => Promise<any> | any;
+export declare const HTTPMethods: string[];
+export type Method = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD" | "ALL";
+export declare enum RouteParamType {
+    BODY = "BODY",
+    PARAM = "PARAM",
+    QUERY = "QUERY",
+    HEADER = "HEADER",
+    REQUEST = "REQUEST",
+    CONTEXT = "CONTEXT"
+}
+export type NextFn = () => Promise<any>;
+export type Middleware = (ctx: ShokupanContext<unknown>, next: NextFn) => Promise<any> | any;
+export type ShokupanRouteConfig = DeepPartial<{
+    name: string;
+    group: string;
+    openapi: DeepPartial<OpenAPI.Operation>;
+}>;
+export type ShokupanRoute = {
+    method: Method;
+    path: string;
+    regex: RegExp;
+    keys: string[];
+    handler: ShokupanHandler;
+    handlerSpec?: MethodAPISpec;
+    group?: string;
+    guards?: {
+        handler: ShokupanHandler;
+        spec?: GuardAPISpec;
+    }[];
+};
+export type ShokupanConfig<T extends Record<string, any> = Record<string, any>> = DeepPartial<{
+    port: number;
+    hostname: string;
+    development: boolean;
+    enableAsyncLocalStorage: boolean;
+    httpLogger: (ctx: ShokupanContext<T>) => void;
+    logger: {
+        verbose: boolean;
+        info: (msg: string, props: Record<string, any>) => void;
+        debug: (msg: string, props: Record<string, any>) => void;
+        warning: (msg: string, props: Record<string, any>) => void;
+        error: (msg: string, props: Record<string, any>) => void;
+        /**
+         * Something fatally went wrong and the application cannot continue.
+         */
+        fatal: (msg: string, props: Record<string, any>) => void;
+    };
+    [key: string]: any;
+}>;
+export interface RequestOptions {
+    path?: string;
+    url?: string;
+    method?: Method;
+    headers?: Record<string, string>;
+    body?: any;
+    query?: Record<string, string>;
+}
+export interface ProcessResult {
+    status: number;
+    headers: Record<string, string>;
+    data: any;
+}
+export type ShokupanController<T = any> = (new (...args: any[]) => T) & {
+    [$isRouter]?: undefined;
+};
+export interface StaticServeHooks<T extends Record<string, any>> {
+    onRequest?: (ctx: ShokupanContext<T>) => Promise<Response | void> | Response | void;
+    onResponse?: (ctx: ShokupanContext<T>, response: Response) => Promise<Response> | Response;
+}
+export interface StaticServeOptions<T extends Record<string, any>> {
+    /**
+     * Root directory to serve files from.
+     * Can be an absolute path or relative to the CWD.
+     */
+    root?: string;
+    /**
+     * Whether to list directory contents if no index file is found.
+     * @default false
+     */
+    listDirectory?: boolean;
+    /**
+     * Index file(s) to look for when a directory is requested.
+     * @default ['index.html', 'index.htm']
+     */
+    index?: string | string[];
+    /**
+     * Hooks to intercept requests/responses.
+     */
+    hooks?: StaticServeHooks<T>;
+    /**
+     * How to treat dotfiles (files starting with .)
+     * 'allow': Serve them
+     * 'deny': Return 403
+     * 'ignore': Return 404
+     * @default 'ignore'
+     */
+    dotfiles?: 'allow' | 'deny' | 'ignore';
+    /**
+     * Regex or glob patterns to exclude
+     */
+    exclude?: (string | RegExp)[];
+    /**
+     * Try to append these extensions to the path if the file is not found.
+     * e.g. ['html', 'htm']
+     */
+    extensions?: string[];
+    /**
+     * OpenAPI specification for the static route.
+     */
+    openapi?: MethodAPISpec;
+}

package/dist/util/async-hooks.d.ts

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const asyncContext: AsyncLocalStorage<Map<string, any>>;
+export declare function runInContext<T>(callback: () => T, initialStore?: Map<string, any>): T;

package/dist/util/deep-merge.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple object check.
+ */
+export declare function isObject(item: any): item is Record<string, any>;
+/**
+ * Deep merge two objects.
+ *
+ * - Arrays are concatenated.
+ * - Objects are merged recursively.
+ * - Primitives are overwritten.
+ */
+export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;

package/dist/util/instrumentation.d.ts

@@ -0,0 +1,9 @@
+import { Middleware, ShokupanHandler } from '../types';
+/**
+ * Wraps a middleware function with an OpenTelemetry span.
+ */
+export declare function traceMiddleware(fn: Middleware, name?: string): Middleware;
+/**
+ * Wraps a route handler with an OpenTelemetry span.
+ */
+export declare function traceHandler(fn: ShokupanHandler | ((...args: any[]) => any), name: string): ShokupanHandler;