vona-module-a-web 5.0.9 → 5.0.10

package/dist/.metadata/index.d.ts

@@ -0,0 +1,89 @@
+import type { BeanScopeUtil, TypeModuleConfig } from 'vona';
+import type { IDecoratorStartupOptions } from 'vona-module-a-startup';
+/** bean: end */
+/** bean: begin */
+import type { BeanRouter } from '../bean/bean.router.ts';
+import type { config } from '../config/config.ts';
+/** service: end */
+/** service: begin */
+import type { ServiceWeb } from '../service/web.ts';
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+/** service: end */
+/** service: begin */
+/** bean: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from '../bean/bean.router.ts';
+declare module 'vona' {
+}
+declare module 'vona-module-a-web' {
+    interface BeanRouter {
+    }
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        router: BeanRouter;
+    }
+}
+/** bean: end */
+/** startup: begin */
+export * from '../bean/startup.listen.ts';
+declare module 'vona-module-a-startup' {
+    interface IStartupRecord {
+        'a-web:listen': IDecoratorStartupOptions;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface StartupListen {
+    }
+}
+/** service: end */
+/** config: begin */
+export * from '../config/config.ts';
+declare module 'vona-module-a-web' {
+    interface IServiceRecord {
+        'a-web:web': never;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface ServiceWeb {
+    }
+}
+export interface IModuleService {
+    web: ServiceWeb;
+}
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-web.service.web': ServiceWeb;
+    }
+}
+/** config: end */
+/** main: begin */
+export * from '../main.ts';
+/** startup: end */
+/** service: begin */
+export * from '../service/web.ts';
+export declare class ScopeModuleAWeb extends BeanScopeBase {
+}
+export interface ScopeModuleAWeb {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    service: IModuleService;
+}
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-web': ScopeModuleAWeb;
+    }
+    interface IBeanScopeContainer {
+        web: ScopeModuleAWeb;
+    }
+    interface IBeanScopeConfig {
+        'a-web': ReturnType<typeof config>;
+    }
+}
+/** scope: end */

package/dist/.metadata/index.js

@@ -0,0 +1,38 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase } from 'vona';
+import { Scope } from 'vona-module-a-bean';
+/** service: end */
+/** service: begin */
+/** bean: begin */
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+import 'vona';
+export * from "../bean/bean.router.js";
+/** bean: end */
+/** startup: begin */
+export * from "../bean/startup.listen.js";
+/** service: end */
+/** config: begin */
+export * from "../config/config.js";
+/** config: end */
+/** main: begin */
+export * from "../main.js";
+/** startup: end */
+/** service: begin */
+export * from "../service/web.js";
+let ScopeModuleAWeb = class ScopeModuleAWeb extends BeanScopeBase {
+};
+ScopeModuleAWeb = __decorate([
+    Scope()
+], ScopeModuleAWeb);
+export { ScopeModuleAWeb };
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-web";
+export { ScopeModuleAWeb as ScopeModule } from './index.ts';

package/dist/.metadata/this.js

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'a-web';
+export { ScopeModuleAWeb as ScopeModule } from "./index.js";

package/dist/bean/bean.router.d.ts

@@ -0,0 +1,12 @@
+import type { Constructable, VonaContext } from 'vona';
+import * as ModuleInfo from '@cabloy/module-info';
+import Router from 'find-my-way';
+import { BeanBase } from 'vona';
+export declare class BeanRouter extends BeanBase {
+    registerController(moduleName: string, controller: Constructable): void;
+    register(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean, fn: Router.Handler<Router.HTTPVersion.V1>): void;
+    unRegister(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean): void;
+    findByPath(method: Router.HTTPMethod, moduleName: ModuleInfo.IModuleInfo | string, path: string | undefined, simplify: boolean): any;
+    private _registerControllerAction;
+    _registerComposeMiddlewares(ctx: VonaContext): (context: any, next?: any) => any;
+}

package/dist/bean/bean.router.js

@@ -0,0 +1,188 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import * as ModuleInfo from '@cabloy/module-info';
+import Router from 'find-my-way';
+import { appMetadata, appResource, BeanBase, deepExtend } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+import { SymbolUseOnionOptions } from 'vona-module-a-onion';
+import { SymbolRouteHandlersArgumentsValue } from 'vona-module-a-openapi';
+import { middlewareGuard } from "../lib/middleware/middlewareGuard.js";
+import { middlewareInterceptor } from "../lib/middleware/middlewareInterceptor.js";
+import { middlewarePipe } from "../lib/middleware/middlewarePipe.js";
+import { RequestMethod, SymbolRequestMappingHandler } from "../types/request.js";
+const SymbolRouteComposeMiddlewaresCache = Symbol('SymbolRouteComposeMiddlewaresCache');
+let BeanRouter = class BeanRouter extends BeanBase {
+    registerController(moduleName, controller) {
+        // info
+        const info = ModuleInfo.parseInfo(moduleName);
+        // controller options
+        const beanOptions = appResource.getBean(controller);
+        if (!beanOptions)
+            return;
+        const controllerBeanFullName = beanOptions.beanFullName;
+        const controllerOptions = beanOptions.options;
+        const controllerPath = controllerOptions.path;
+        const controllerMiddlewaresOptions = appMetadata.getMetadata(SymbolUseOnionOptions, controller);
+        // descs
+        const descs = Object.getOwnPropertyDescriptors(controller.prototype);
+        for (const actionKey in descs) {
+            const desc = descs[actionKey];
+            if (['constructor'].includes(actionKey))
+                continue;
+            if (!desc.value || typeof desc.value !== 'function')
+                continue;
+            this._registerControllerAction(info, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc);
+        }
+    }
+    register(method, moduleName, path, simplify, fn) {
+        const app = this.app;
+        const _path = app.util.combineApiPath(path, moduleName, true, simplify);
+        app.router.on(method, _path, fn);
+    }
+    unRegister(method, moduleName, path, simplify) {
+        const app = this.app;
+        const _path = app.util.combineApiPath(path, moduleName, true, simplify);
+        app.router.off(method, _path);
+    }
+    findByPath(method, moduleName, path, simplify) {
+        const app = this.app;
+        const _path = app.util.combineApiPath(path, moduleName, true, simplify);
+        return app.router.findRoute(method, _path);
+    }
+    _registerControllerAction(info, controller, controllerBeanFullName, controllerPath, controllerMiddlewaresOptions, actionKey, desc) {
+        // app
+        const app = this.app;
+        // actionPath/actionMethod
+        if (!appMetadata.hasMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey))
+            return;
+        const handlerMetadata = appMetadata.getMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey);
+        const actionPath = handlerMetadata.path || '';
+        const actionMethod = handlerMetadata.method || RequestMethod.GET;
+        // routePath
+        const routePath = app.util.combineApiPathControllerAndAction(info.relativeName, controllerPath, actionPath, true, true);
+        const routePathRaw = app.util.combineApiPathControllerAndActionRaw(info.relativeName, controllerPath, actionPath, true);
+        // middlewares options
+        const actionMiddlewaresOptions = appMetadata.getMetadata(SymbolUseOnionOptions, controller.prototype, actionKey);
+        // route
+        const route = {
+            meta: deepExtend({}, controllerMiddlewaresOptions, actionMiddlewaresOptions),
+        };
+        // route
+        const _route = {
+            pid: info.pid,
+            module: info.name,
+            controller,
+            actionDescriptor: desc,
+            controllerBeanFullName,
+            action: actionKey,
+            route,
+            routeMethod: actionMethod,
+            routePath,
+            routePathRaw,
+        };
+        // fn
+        const self = this;
+        const fn = function (_req, _res, params, _store, searchParams) {
+            const ctx = this;
+            ctx.route = _route;
+            ctx.request.params = params;
+            ctx.request.query = searchParams;
+            if (!_route[SymbolRouteComposeMiddlewaresCache]) {
+                _route[SymbolRouteComposeMiddlewaresCache] = self._registerComposeMiddlewares(ctx);
+            }
+            return _route[SymbolRouteComposeMiddlewaresCache](ctx);
+        };
+        // register
+        app.router.on(_route.routeMethod.toUpperCase(), _route.routePath.toString(), fn);
+    }
+    _registerComposeMiddlewares(ctx) {
+        // start
+        const fnStart = routeStartMiddleware;
+        // mid: guard/interceptor/pipes/tail
+        const fnMid = [];
+        fnMid.push(middlewareGuard);
+        fnMid.push(middlewareInterceptor);
+        fnMid.push(middlewarePipe);
+        fnMid.push(routeTailDoneMiddleware);
+        // end: controller
+        const fnEnd = classControllerMiddleware;
+        // compose
+        return this.app.bean.onion.middleware.compose(ctx, fnStart, fnMid, fnEnd);
+    }
+};
+BeanRouter = __decorate([
+    Bean()
+], BeanRouter);
+export { BeanRouter };
+function classControllerMiddleware(ctx) {
+    const beanFullName = ctx.getControllerBeanFullName();
+    const handlerName = ctx.getHandler().name;
+    const controller = ctx.app.bean._getBean(beanFullName);
+    return controller[handlerName](...(ctx[SymbolRouteHandlersArgumentsValue] || []));
+}
+async function routeStartMiddleware(ctx, next) {
+    // next
+    const res = await next();
+    // invoke callbackes: handle secondly
+    await ctx.commitDone();
+    // ok
+    return res;
+}
+async function routeTailDoneMiddleware(ctx, next) {
+    // next
+    const res = await next();
+    // invoke callbackes: handle firstly
+    await ctx.commitDone();
+    // ok
+    return res;
+}
+// _registerInner(route, middlewaresLocal) {
+//   // app
+//   const app = this.app;
+//   // args
+//   let args: any[] = [];
+//   // middlewares: start
+//   const fnStart = async (ctx: VonaContext, next: Next) => {
+//     // route
+//     ctx.route = route;
+//     // next
+//     const res = await next();
+//     // invoke callbackes: handle secondly
+//     await ctx.commitDone();
+//     // ok
+//     return res;
+//   };
+//   fnStart._name = 'start';
+//   args.push(fnStart);
+//   // middlewares: globals
+//   args.push(...app.bean.onion.middleware.composedOnionsGlobal);
+//   // middlewares: guard/interceptor/pipes
+//   args.push(middlewareGuard);
+//   args.push(middlewareInterceptor);
+//   args.push(middlewarePipe);
+//   // middlewares: tailDone
+//   const fnTailDone = async (ctx, next) => {
+//     // next
+//     const res = await next();
+//     // invoke callbackes: handle firstly
+//     await ctx.commitDone();
+//     // ok
+//     return res;
+//   };
+//   fnTailDone._name = 'tailDone';
+//   args.push(fnTailDone);
+//   // middlewares
+//   if (middlewaresLocal.length > 0) {
+//     args = args.concat(middlewaresLocal);
+//   }
+//   // load
+//   if (route.routeName) {
+//     app.router[route.routeMethod](route.routeName, route.routePath, ...args);
+//   } else {
+//     app.router[route.routeMethod](route.routePath, ...args);
+//   }
+// }

package/dist/bean/startup.listen.d.ts

@@ -0,0 +1,7 @@
+import type { IStartupExecute } from 'vona-module-a-startup';
+import { BeanBase } from 'vona';
+export declare class StartupListen extends BeanBase implements IStartupExecute {
+    execute(): Promise<void>;
+    private _listen;
+    private _callback;
+}

package/dist/bean/startup.listen.js

@@ -0,0 +1,34 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import http from 'node:http';
+import { BeanBase, cast, compose } from 'vona';
+import { Startup } from 'vona-module-a-startup';
+let StartupListen = class StartupListen extends BeanBase {
+    async execute() {
+        if (!this.app.config.server.listen.disable) {
+            this.app.server = this._listen(this.app.config.server.listen.port, this.app.config.server.listen.hostname);
+        }
+    }
+    _listen(port, hostname) {
+        const server = http.createServer(this._callback());
+        return server.listen(port, hostname);
+    }
+    _callback() {
+        const fn = compose(this.app.middleware);
+        if (!this.app.listenerCount('error'))
+            this.app.on('error', this.app.onerror);
+        return (req, res) => {
+            return this.app.bean.executor.newCtx(() => {
+                return cast(this.app).handleRequest(this.app.ctx, fn);
+            }, { dbInfo: { level: 0 }, innerAccess: false, req, res }); // not set instanceName
+        };
+    }
+};
+StartupListen = __decorate([
+    Startup({ after: true })
+], StartupListen);
+export { StartupListen };

package/dist/config/config.d.ts

@@ -0,0 +1,6 @@
+import type Router from 'find-my-way';
+import type { Config } from 'find-my-way';
+import type { VonaApplication } from 'vona';
+export declare function config(_app: VonaApplication): {
+    router: Config<Router.HTTPVersion.V1>;
+};

package/dist/config/config.js

@@ -0,0 +1,8 @@
+export function config(_app) {
+    return {
+        router: {
+            maxParamLength: 500,
+            defaultRoute: (_req, _res) => { },
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/index.ts';
+export * from './lib/index.ts';
+export * from './types/index.ts';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./.metadata/index.js";
+export * from "./lib/index.js";
+export * from "./types/index.js";

package/dist/lib/decorator/bean.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from 'vona';
+import type { IDecoratorControllerOptions } from '../../types/controller.ts';
+import type { IDecoratorDtoOptions } from '../../types/dto.ts';
+export declare function Controller<T extends IDecoratorControllerOptions>(options?: T): ClassDecorator;
+export declare function Controller<T extends IDecoratorControllerOptions>(path?: string, options?: Omit<T, 'path'>): ClassDecorator;
+export declare function Service(): ClassDecorator;
+export declare function Dto<T extends IDecoratorDtoOptions<any>>(options?: T): ClassDecorator;
+export declare function mergeActionsOpenAPIMetadata(target: Constructable): void;

package/dist/lib/decorator/bean.js

@@ -0,0 +1,42 @@
+import { appMetadata, appResource, cast, createBeanDecorator, deepExtend } from 'vona';
+import { mergeFieldsOpenAPIMetadata, SymbolOpenApiOptions } from 'vona-module-a-openapi';
+export function Controller(path, options) {
+    if (typeof path === 'string') {
+        options = Object.assign({}, options, { path });
+    }
+    else {
+        options = path || {};
+    }
+    return createBeanDecorator('controller', options, false, false, target => {
+        // IOpenApiOptions
+        const optionsMeta = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target);
+        for (const key of ['exclude', 'tags']) {
+            if (options[key] !== undefined)
+                optionsMeta[key] = options[key];
+        }
+        // IOpenApiOptions
+        mergeActionsOpenAPIMetadata(target);
+    });
+}
+export function Service() {
+    return createBeanDecorator('service');
+}
+export function Dto(options) {
+    return createBeanDecorator('dto', options, false, false, target => {
+        mergeFieldsOpenAPIMetadata(target);
+    });
+}
+export function mergeActionsOpenAPIMetadata(target) {
+    // beanOptions
+    const beanOptions = appResource.getBean(target);
+    const actions = cast(beanOptions?.options)?.actions;
+    if (!actions)
+        return;
+    for (const key in actions) {
+        const action = actions[key];
+        if (!action)
+            continue;
+        const options = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target.prototype, key);
+        deepExtend(options, action);
+    }
+}

package/dist/lib/decorator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bean.ts';
+export * from './request.ts';
+export * from './response.ts';

package/dist/lib/decorator/index.js

@@ -0,0 +1,3 @@
+export * from "./bean.js";
+export * from "./request.js";
+export * from "./response.js";

package/dist/lib/decorator/request.d.ts

@@ -0,0 +1,17 @@
+import type { IOpenApiOptions } from 'vona-module-a-openapi';
+import { RequestMethod } from '../../types/request.ts';
+export interface RequestMappingMetadata {
+    path?: string;
+    method?: RequestMethod;
+    options?: IOpenApiOptions;
+}
+export declare function RequestMapping(metadata?: RequestMappingMetadata): MethodDecorator;
+export declare const Web: {
+    post: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    get: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    delete: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    put: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    patch: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    options: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+    head: (path?: IOpenApiOptions | string, options?: IOpenApiOptions) => MethodDecorator;
+};

package/dist/lib/decorator/request.js

@@ -0,0 +1,46 @@
+import { appMetadata } from 'vona';
+import { SymbolOpenApiOptions } from 'vona-module-a-openapi';
+import { RequestMethod, SymbolRequestMappingHandler } from "../../types/request.js";
+const defaultMetadata = {
+    method: RequestMethod.GET,
+    path: '',
+    options: undefined,
+};
+export function RequestMapping(metadata = defaultMetadata) {
+    const path = metadata.path || '';
+    const method = metadata.method || RequestMethod.GET;
+    const options = metadata.options;
+    return (target, prop, descriptor) => {
+        appMetadata.defineMetadata(SymbolRequestMappingHandler, { path, method }, target, prop);
+        if (options) {
+            const optionsMeta = appMetadata.getOwnMetadataMap(false, SymbolOpenApiOptions, target, prop);
+            Object.assign(optionsMeta, options);
+        }
+        return descriptor;
+    };
+}
+function createMappingDecorator(method) {
+    return (path, options) => {
+        if (path && typeof path === 'object') {
+            options = path;
+            path = undefined;
+        }
+        return RequestMapping({ method, path, options });
+    };
+}
+const Post = createMappingDecorator(RequestMethod.POST);
+const Get = createMappingDecorator(RequestMethod.GET);
+const Delete = createMappingDecorator(RequestMethod.DELETE);
+const Put = createMappingDecorator(RequestMethod.PUT);
+const Patch = createMappingDecorator(RequestMethod.PATCH);
+const Options = createMappingDecorator(RequestMethod.OPTIONS);
+const Head = createMappingDecorator(RequestMethod.HEAD);
+export const Web = {
+    post: Post,
+    get: Get,
+    delete: Delete,
+    put: Put,
+    patch: Patch,
+    options: Options,
+    head: Head,
+};

package/dist/lib/decorator/response.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/decorator/response.js

@@ -0,0 +1,12 @@
+// todo: 如果没有必要，就删除这里的代码
+// import { appMetadata, MetadataKey } from 'vona';
+// import { SymbolResponseMetadata, TypeResponseContentType } from '../../types/response.ts';
+export {};
+// function contentType(contentType: TypeResponseContentType): MethodDecorator {
+//   return function (target: object, prop?: MetadataKey, descriptor?: PropertyDescriptor) {
+//     const map = appMetadata.getOwnMetadataMap(false, SymbolResponseMetadata, target, prop);
+//     map.contentType = contentType;
+//     return descriptor;
+//   } as any;
+// }
+// export const Res = { contentType };

package/dist/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './decorator/index.ts';
+export * from './utils.ts';

package/dist/lib/index.js

@@ -0,0 +1,2 @@
+export * from "./decorator/index.js";
+export * from "./utils.js";

package/dist/lib/middleware/extractValue.d.ts

@@ -0,0 +1,4 @@
+import type { VonaContext } from 'vona';
+import type { RouteHandlerArgumentMetaDecorator, RouteHandlerArgumentType } from 'vona-module-a-openapi';
+export declare function extractValue(ctx: VonaContext, argMeta: RouteHandlerArgumentMetaDecorator): any;
+export declare function exchangeKeyForValue(ctx: VonaContext, type: RouteHandlerArgumentType, field: string | undefined): any;

package/dist/lib/middleware/extractValue.js

@@ -0,0 +1,48 @@
+import { SymbolUploadValue } from 'vona-module-a-upload';
+export function extractValue(ctx, argMeta) {
+    return exchangeKeyForValue(ctx, argMeta.type, argMeta.field);
+}
+export function exchangeKeyForValue(ctx, type, field) {
+    const req = ctx.request;
+    const res = ctx.response;
+    const modes = {
+        request: () => req,
+        response: () => res,
+        body: () => (field && req.body ? req.body[field] : req.body),
+        query: () => (field ? req.query[field] : req.query),
+        param: () => (field ? req.params[field] : req.params),
+        headers: () => (field ? req.headers[field.toLowerCase()] : req.headers),
+        host: () => {
+            const hosts = req.hosts || {};
+            return field ? hosts[field] : hosts;
+        },
+        ip: () => req.ip,
+        rawBody: () => req.rawBody,
+        user: () => ctx.app.bean.passport.getCurrentUser(),
+        fields: () => {
+            const uploadValue = ctx[SymbolUploadValue];
+            if (!uploadValue)
+                throw new Error('should use interceptor: a-upload:upload');
+            return field ? uploadValue.fields.filter(item => item.name === field).map(item => item.value) : uploadValue.fields;
+        },
+        field: () => {
+            const uploadValue = ctx[SymbolUploadValue];
+            if (!uploadValue)
+                throw new Error('should use interceptor: a-upload:upload');
+            return field ? uploadValue.fields.find(item => item.name === field)?.value : uploadValue.fields[0]?.value;
+        },
+        files: () => {
+            const uploadValue = ctx[SymbolUploadValue];
+            if (!uploadValue)
+                throw new Error('should use interceptor: a-upload:upload');
+            return field ? uploadValue.files.filter(item => item.name === field) : uploadValue.files;
+        },
+        file: () => {
+            const uploadValue = ctx[SymbolUploadValue];
+            if (!uploadValue)
+                throw new Error('should use interceptor: a-upload:upload');
+            return field ? uploadValue.files.find(item => item.name === field) : uploadValue.files[0];
+        },
+    };
+    return modes[type]?.();
+}

package/dist/lib/middleware/middlewareGuard.d.ts

@@ -0,0 +1,2 @@
+import type { Next, VonaContext } from 'vona';
+export declare function middlewareGuard(ctx: VonaContext, next: Next): Promise<any>;

package/dist/lib/middleware/middlewareGuard.js

@@ -0,0 +1,12 @@
+export async function middlewareGuard(ctx, next) {
+    // check handler
+    const handler = ctx.getHandler();
+    if (!handler)
+        return next();
+    // compose
+    const result = await ctx.app.bean.onion.guard.compose(ctx)(ctx);
+    if (result === false)
+        ctx.app.throw(403);
+    // next
+    return next();
+}

package/dist/lib/middleware/middlewareInterceptor.d.ts

@@ -0,0 +1,2 @@
+import type { Next, VonaContext } from 'vona';
+export declare function middlewareInterceptor(ctx: VonaContext, next: Next): Promise<any>;

package/dist/lib/middleware/middlewareInterceptor.js

@@ -0,0 +1,8 @@
+export async function middlewareInterceptor(ctx, next) {
+    // check handler
+    const handler = ctx.getHandler();
+    if (!handler)
+        return next();
+    // compose
+    return await ctx.app.bean.onion.interceptor.compose(ctx)(ctx, next);
+}

package/dist/lib/middleware/middlewarePipe.d.ts

@@ -0,0 +1,2 @@
+import type { Next, VonaContext } from 'vona';
+export declare function middlewarePipe(ctx: VonaContext, next: Next): Promise<any>;

package/dist/lib/middleware/middlewarePipe.js

@@ -0,0 +1,118 @@
+import { appMetadata } from 'vona';
+import { SymbolRouteHandlersArgumentsMeta, SymbolRouteHandlersArgumentsValue, } from 'vona-module-a-openapi';
+import { valid } from 'vona-module-a-validation';
+import { extractValue } from "./extractValue.js";
+export async function middlewarePipe(ctx, next) {
+    // check handler
+    const handler = ctx.getHandler();
+    if (!handler)
+        return next();
+    // body parser
+    await ctx.app.bean._getBean('a-body.service.body').parse(true);
+    // arguments
+    ctx[SymbolRouteHandlersArgumentsValue] = await _transformArguments(ctx, ctx.getController(), handler);
+    // next
+    return next();
+}
+async function _transformArguments(ctx, controller, handler) {
+    const paramtypes = appMetadata.getMetadata('design:paramtypes', controller.prototype, handler.name);
+    if (!paramtypes)
+        return;
+    // meta
+    const argsMeta = appMetadata.getMetadata(SymbolRouteHandlersArgumentsMeta, controller.prototype, handler.name);
+    if (!argsMeta)
+        return;
+    // args
+    const args = Array.from({ length: paramtypes.length });
+    for (let index = args.length - 1; index >= 0; index--) {
+        const argMeta = argsMeta.find(item => item.index === index);
+        if (!argMeta)
+            continue;
+        // extractValue
+        const value = await _extractArgumentValue(ctx, argMeta);
+        // metadata
+        const metadata = {
+            type: argMeta.type,
+            field: argMeta.field,
+            metaType: paramtypes[index],
+            controller,
+            method: handler.name,
+            index: argMeta.index,
+        };
+        // transform
+        args[index] = await _transformArgument(ctx, argMeta, metadata, value);
+    }
+    return args;
+}
+async function _transformArgument(ctx, argMeta, metadata, value) {
+    // pipes
+    const pipes = composePipes(ctx, argMeta, (beanInstance, value, options, _next) => {
+        return beanInstance.transform(value, metadata, options);
+    });
+    if (pipes.length === 0)
+        return value;
+    // apply
+    for (const pipe of pipes) {
+        value = await pipe(value, _pipeNextDefault);
+    }
+    return value;
+}
+function _pipeNextDefault(value) {
+    return value;
+}
+async function _extractArgumentValue(ctx, argMeta) {
+    if (argMeta.extractValue) {
+        return await argMeta.extractValue(ctx, argMeta);
+    }
+    return extractValue(ctx, argMeta);
+}
+const SymbolCacheMiddlewaresArgument = Symbol('SymbolCacheMiddlewaresArgument');
+function composePipes(ctx, argMeta, executeCustom) {
+    if (!ctx.app.meta[SymbolCacheMiddlewaresArgument])
+        ctx.app.meta[SymbolCacheMiddlewaresArgument] = {};
+    const __cacheMiddlewaresArgument = ctx.app.meta[SymbolCacheMiddlewaresArgument];
+    const onionPipe = ctx.app.bean.onion.pipe;
+    const beanFullName = ctx.getControllerBeanFullName();
+    const handlerName = ctx.getHandler().name;
+    const key = `${beanFullName}:${handlerName}:${argMeta.index}`;
+    if (!__cacheMiddlewaresArgument[key]) {
+        const middlewares = [];
+        // pipes: global
+        for (const item of onionPipe.onionsGlobal) {
+            middlewares.push(onionPipe._wrapOnion(item, executeCustom));
+        }
+        // pipes: route
+        const middlewaresLocal = onionPipe._collectOnionsHandler(ctx);
+        for (const item of middlewaresLocal) {
+            middlewares.push(onionPipe._wrapOnion(item, executeCustom));
+        }
+        // pipes: arguments
+        const middlewaresArgument = _collectArgumentMiddlewares(onionPipe, argMeta);
+        if (middlewaresArgument) {
+            for (const item of middlewaresArgument) {
+                middlewares.push(onionPipe._wrapOnion(item, executeCustom));
+            }
+        }
+        __cacheMiddlewaresArgument[key] = middlewares;
+    }
+    return __cacheMiddlewaresArgument[key];
+}
+function _collectArgumentMiddlewares(onionPipe, argMeta) {
+    if (!argMeta.pipes)
+        return;
+    return argMeta.pipes.map(pipe => {
+        if (typeof pipe !== 'function') {
+            pipe = valid({ schema: pipe });
+        }
+        const { pipeName, options } = pipe();
+        const item = onionPipe.onionsNormal[pipeName];
+        if (!item)
+            throw new Error(`${onionPipe.sceneName} not found: ${pipeName}`);
+        return {
+            ...item,
+            argumentPipe: {
+                options,
+            },
+        };
+    });
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,6 @@
+import type { IApiPathRecord } from '../types/controller.ts';
+export declare function $apiPath<K extends keyof IApiPathRecord>(path: K): K;
+export declare function $apiPathAndCombineParamsAndQuery<K extends keyof IApiPathRecord>(path: K, options?: {
+    params?: object;
+    query?: object;
+}): string;

package/dist/lib/utils.js

@@ -0,0 +1,7 @@
+import { combineParamsAndQuery } from '@cabloy/utils';
+export function $apiPath(path) {
+    return path;
+}
+export function $apiPathAndCombineParamsAndQuery(path, options) {
+    return combineParamsAndQuery(path, options);
+}

package/dist/main.d.ts

@@ -0,0 +1,11 @@
+import type { IModuleMain } from 'vona';
+import { BeanSimple } from 'vona';
+declare const SymbolRouter: unique symbol;
+export declare class Main extends BeanSimple implements IModuleMain {
+    private [SymbolRouter];
+    moduleLoading(): Promise<void>;
+    moduleLoaded(): Promise<void>;
+    configLoaded(_config: any): Promise<void>;
+    private _wrapOnion;
+}
+export {};

package/dist/main.js

@@ -0,0 +1,63 @@
+import Router from 'find-my-way';
+import { BeanSimple, compose } from 'vona';
+import { SymbolRouterMiddleware } from 'vona-module-a-executor';
+import { __ThisModule__ } from "./.metadata/this.js";
+const SymbolRouter = Symbol('SymbolRouter');
+export class Main extends BeanSimple {
+    [SymbolRouter];
+    async moduleLoading() { }
+    async moduleLoaded() {
+        const config = this.bean.scope(__ThisModule__).config;
+        const self = this;
+        // router
+        Object.defineProperty(this.app, 'router', {
+            get() {
+                if (!self[SymbolRouter]) {
+                    self[SymbolRouter] = Router(config.router);
+                }
+                return self[SymbolRouter];
+            },
+        });
+        // register controllers
+        for (const controller of this.bean.onion.controller.getOnionsEnabled()) {
+            this.bean.router.registerController(controller.beanOptions.module, controller.beanOptions.beanClass);
+        }
+        // middleware: system
+        const middlewares = this.bean.onion.middlewareSystem.getOnionsEnabledWrapped(item => {
+            return this._wrapOnion(item);
+        });
+        this.app.use(compose(middlewares));
+        // middleware: router
+        this.app[SymbolRouterMiddleware] = routerMiddleware(this[SymbolRouter]);
+        this.app.use(this.app[SymbolRouterMiddleware]);
+    }
+    async configLoaded(_config) { }
+    _wrapOnion(item) {
+        const fn = (_ctx, next) => {
+            const options = item.beanOptions.options;
+            if (!this.bean.onion.checkOnionOptionsEnabled(options, this.ctx.path)) {
+                return next();
+            }
+            // execute
+            const beanFullName = item.beanOptions.beanFullName;
+            const beanInstance = this.app.bean._getBean(beanFullName);
+            if (!beanInstance) {
+                throw new Error(`middlewareSystem bean not found: ${beanFullName}`);
+            }
+            return beanInstance.execute(options, next);
+        };
+        fn._name = item.name;
+        return fn;
+    }
+}
+function routerMiddleware(router) {
+    return function (ctx) {
+        return new Promise((resolve, reject) => {
+            router.lookup(ctx.req, ctx.res, ctx, (err, result) => {
+                if (err)
+                    reject(err);
+                resolve(result);
+            });
+        });
+    };
+}

package/dist/service/web.d.ts

@@ -0,0 +1,5 @@
+import type { Constructable, MetadataKey } from 'vona';
+import { BeanBase } from 'vona';
+export declare class ServiceWeb extends BeanBase {
+    combineControllerActionApiPath(controller: Constructable, actionKey: MetadataKey, prefix?: string | boolean, simplify?: boolean): string | undefined;
+}

package/dist/service/web.js

@@ -0,0 +1,28 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { appMetadata, appResource, BeanBase } from 'vona';
+import { Service, SymbolRequestMappingHandler } from 'vona-module-a-web';
+let ServiceWeb = class ServiceWeb extends BeanBase {
+    combineControllerActionApiPath(controller, actionKey, prefix, simplify) {
+        // beanOptions
+        const beanOptions = appResource.getBean(controller);
+        if (!beanOptions)
+            return undefined;
+        // controllerPath
+        const controllerOptions = beanOptions.options;
+        const controllerPath = controllerOptions.path;
+        // actionPath
+        const handlerMetadata = appMetadata.getMetadata(SymbolRequestMappingHandler, controller.prototype, actionKey);
+        const actionPath = handlerMetadata.path || '';
+        // combine
+        return this.app.util.combineApiPathControllerAndAction(beanOptions.module, controllerPath, actionPath, prefix, simplify);
+    }
+};
+ServiceWeb = __decorate([
+    Service()
+], ServiceWeb);
+export { ServiceWeb };

package/dist/types/controller.d.ts

@@ -0,0 +1,42 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { IOnionOptionsEnable } from 'vona-module-a-onion';
+export interface IApiPathRecordMethodMap {
+    get: IApiPathGetRecord;
+    post: IApiPathPostRecord;
+    delete: IApiPathDeleteRecord;
+    put: IApiPathPutRecord;
+    patch: IApiPathPatchRecord;
+}
+export interface IApiPathRecord extends IApiPathGetRecord, IApiPathPostRecord, IApiPathDeleteRecord, IApiPathPutRecord, IApiPathPatchRecord {
+}
+export interface IApiPathGetRecord {
+}
+export interface IApiPathPostRecord {
+}
+export interface IApiPathDeleteRecord {
+}
+export interface IApiPathPutRecord {
+}
+export interface IApiPathPatchRecord {
+}
+export interface IControllerRecord {
+}
+export interface IDecoratorControllerOptions extends IOnionOptionsEnable {
+    path?: string;
+    exclude?: boolean;
+    tags?: string[];
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        controller: ServiceOnion<IDecoratorControllerOptions, keyof IControllerRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        controller: OmitNever<IControllerRecord>;
+    }
+    interface IBeanSceneRecord {
+        controller: never;
+    }
+}

package/dist/types/controller.js

@@ -0,0 +1 @@
+export {};

package/dist/types/dto.d.ts

@@ -0,0 +1,23 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { TypeOpenAPIMetadata } from 'vona-module-a-openapi';
+export interface IDtoRecord {
+}
+export interface IDecoratorDtoOptions<FieldsMore = never> {
+    independent?: boolean;
+    openapi?: TypeOpenAPIMetadata;
+    fieldsMore?: FieldsMore;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        dto: ServiceOnion<IDecoratorDtoOptions, keyof IDtoRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        dto: OmitNever<IDtoRecord>;
+    }
+    interface IBeanSceneRecord {
+        dto: never;
+    }
+}

package/dist/types/dto.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from './controller.ts';
+export * from './dto.ts';
+export * from './request.ts';
+export * from './response.ts';
+export * from './router.ts';
+export * from './service.ts';

package/dist/types/index.js

@@ -0,0 +1,6 @@
+export * from "./controller.js";
+export * from "./dto.js";
+export * from "./request.js";
+export * from "./response.js";
+export * from "./router.js";
+export * from "./service.js";

package/dist/types/request.d.ts

@@ -0,0 +1,11 @@
+export declare const SymbolRequestMappingHandler: unique symbol;
+export type TypeRequestMethod = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'options' | 'head';
+export declare enum RequestMethod {
+    GET = "get",
+    POST = "post",
+    PUT = "put",
+    DELETE = "delete",
+    PATCH = "patch",
+    OPTIONS = "options",
+    HEAD = "head"
+}

package/dist/types/request.js

@@ -0,0 +1,11 @@
+export const SymbolRequestMappingHandler = Symbol('SymbolRequestMappingHandler');
+export var RequestMethod;
+(function (RequestMethod) {
+    RequestMethod["GET"] = "get";
+    RequestMethod["POST"] = "post";
+    RequestMethod["PUT"] = "put";
+    RequestMethod["DELETE"] = "delete";
+    RequestMethod["PATCH"] = "patch";
+    RequestMethod["OPTIONS"] = "options";
+    RequestMethod["HEAD"] = "head";
+})(RequestMethod || (RequestMethod = {}));

package/dist/types/response.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/response.js

@@ -0,0 +1,4 @@
+export {};
+// todo: 如果没有必要，就删除这里的代码
+// export const SymbolResponseMetadata = Symbol('SymbolResponseMetadata');
+// export type TypeResponseMetadata = Record<string, any>;

package/dist/types/router.d.ts

@@ -0,0 +1,36 @@
+import type Router from 'find-my-way';
+import type { Constructable } from 'vona';
+import type { RequestMethod } from './request.ts';
+export interface ContextRouteMetadata {
+    meta: any;
+}
+export interface ContextRoute {
+    pid: string;
+    module: string;
+    controller: Constructable;
+    actionDescriptor: PropertyDescriptor;
+    controllerBeanFullName: string;
+    action: string;
+    route: ContextRouteMetadata;
+    routeMethod: RequestMethod;
+    routePath: string | RegExp;
+    routePathRaw: string | RegExp;
+}
+declare module 'vona' {
+    interface VonaApplication {
+        router: Router.Instance<Router.HTTPVersion.V1>;
+    }
+    interface VonaContext {
+        route: ContextRoute;
+    }
+}
+declare module 'koa' {
+    interface Request {
+        params: {
+            [key: string]: string;
+        };
+        query: {
+            [key: string]: string;
+        };
+    }
+}

package/dist/types/router.js

@@ -0,0 +1 @@
+export {};

package/dist/types/service.d.ts

@@ -0,0 +1,13 @@
+import type { ServiceOnion } from 'vona-module-a-onion';
+export interface IServiceRecord {
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        service: ServiceOnion<never, keyof IServiceRecord>;
+    }
+}
+declare module 'vona' {
+    interface IBeanSceneRecord {
+        service: never;
+    }
+}

package/dist/types/service.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.10",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {
@@ -55,8 +55,12 @@
   "dependencies": {
     "find-my-way": "^9.2.0"
   },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
   "scripts": {
-    "clean": "rimraf dist tsconfig.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc"
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
   }
 }