vona-module-a-web 5.0.9 → 5.0.11

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/this.d.ts

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

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/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/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/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,614 @@
+import { appMetadata, BeanInfo, BeanBase, appResource, deepExtend, compose, cast, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
+import { Bean, Scope } from 'vona-module-a-bean';
+import * as ModuleInfo from '@cabloy/module-info';
+import { SymbolUseOnionOptions } from 'vona-module-a-onion';
+import { SymbolRouteHandlersArgumentsValue, SymbolRouteHandlersArgumentsMeta, SymbolOpenApiOptions, mergeFieldsOpenAPIMetadata } from 'vona-module-a-openapi';
+import { valid } from 'vona-module-a-validation';
+import { SymbolUploadValue } from 'vona-module-a-upload';
+import http from 'node:http';
+import { Startup } from 'vona-module-a-startup';
+import Router from 'find-my-way';
+import { SymbolRouterMiddleware } from 'vona-module-a-executor';
+import { Service as Service$1, SymbolRequestMappingHandler as SymbolRequestMappingHandler$1 } from 'vona-module-a-web';
+import { combineParamsAndQuery } from '@cabloy/utils';
+
+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();
+}
+
+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);
+}
+
+function extractValue(ctx, argMeta) {
+  return exchangeKeyForValue(ctx, argMeta.type, argMeta.field);
+}
+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]?.();
+}
+
+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
+      }
+    };
+  });
+}
+
+const SymbolRequestMappingHandler = Symbol('SymbolRequestMappingHandler');
+let RequestMethod = /*#__PURE__*/function (RequestMethod) {
+  RequestMethod["GET"] = "get";
+  RequestMethod["POST"] = "post";
+  RequestMethod["PUT"] = "put";
+  RequestMethod["DELETE"] = "delete";
+  RequestMethod["PATCH"] = "patch";
+  RequestMethod["OPTIONS"] = "options";
+  RequestMethod["HEAD"] = "head";
+  return RequestMethod;
+}({});
+
+var _dec$3, _dec2$3, _class$3;
+const SymbolRouteComposeMiddlewaresCache = Symbol('SymbolRouteComposeMiddlewaresCache');
+let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
+  module: "a-web"
+}), _dec$3(_class$3 = _dec2$3(_class$3 = 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);
+  }
+}) || _class$3) || _class$3);
+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);
+//   }
+// }
+
+var _dec$2, _dec2$2, _class$2;
+let StartupListen = (_dec$2 = Startup({
+  after: true
+}), _dec2$2 = BeanInfo({
+  module: "a-web"
+}), _dec$2(_class$2 = _dec2$2(_class$2 = 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
+    };
+  }
+}) || _class$2) || _class$2);
+
+function config(_app) {
+  return {
+    router: {
+      maxParamLength: 500,
+      defaultRoute: (_req, _res) => {}
+    }
+  };
+}
+
+const __ThisModule__ = 'a-web';
+
+const SymbolRouter = Symbol('SymbolRouter');
+class Main extends BeanSimple {
+  constructor(...args) {
+    super(...args);
+    this[SymbolRouter] = void 0;
+  }
+  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);
+      });
+    });
+  };
+}
+
+var _dec$1, _dec2$1, _class$1;
+let ServiceWeb = (_dec$1 = Service$1(), _dec2$1 = BeanInfo({
+  module: "a-web"
+}), _dec$1(_class$1 = _dec2$1(_class$1 = 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$1, controller.prototype, actionKey);
+    const actionPath = handlerMetadata.path || '';
+    // combine
+    return this.app.util.combineApiPathControllerAndAction(beanOptions.module, controllerPath, actionPath, prefix, simplify);
+  }
+}) || _class$1) || _class$1);
+
+var _dec, _dec2, _class;
+let ScopeModuleAWeb = (_dec = Scope(), _dec2 = BeanInfo({
+  module: "a-web"
+}), _dec(_class = _dec2(_class = class ScopeModuleAWeb extends BeanScopeBase {}) || _class) || _class);
+
+/** scope: end */
+
+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);
+  });
+}
+function Service() {
+  return createBeanDecorator('service');
+}
+function Dto(options) {
+  return createBeanDecorator('dto', options, false, false, target => {
+    mergeFieldsOpenAPIMetadata(target);
+  });
+}
+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);
+  }
+}
+
+const defaultMetadata = {
+  method: RequestMethod.GET,
+  path: '',
+  options: undefined
+};
+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);
+const Web = {
+  post: Post,
+  get: Get,
+  delete: Delete,
+  put: Put,
+  patch: Patch,
+  options: Options,
+  head: Head
+};
+
+function $apiPath(path) {
+  return path;
+}
+function $apiPathAndCombineParamsAndQuery(path, options) {
+  return combineParamsAndQuery(path, options);
+}
+
+export { $apiPath, $apiPathAndCombineParamsAndQuery, BeanRouter, Controller, Dto, Main, RequestMapping, RequestMethod, ScopeModuleAWeb, Service, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, mergeActionsOpenAPIMetadata };

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/index.d.ts

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

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/response.d.ts

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

package/dist/lib/index.d.ts

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

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/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/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/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/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/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/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/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/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/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/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/response.d.ts

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

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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.9",
+  "version": "5.0.11",
   "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 && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }