vona-module-a-web 5.0.10 → 5.0.12

package/dist/index.js

@@ -1,3 +1,614 @@
-export * from "./.metadata/index.js";
-export * from "./lib/index.js";
-export * from "./types/index.js";
+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');
+
+// export enum RequestMethod {
+//   GET = 'get',
+//   POST = 'post',
+//   PUT = 'put',
+//   DELETE = 'delete',
+//   PATCH = 'patch',
+//   OPTIONS = 'options',
+//   HEAD = 'head',
+// }
+
+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 || '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: 'get',
+  path: '',
+  options: undefined
+};
+function RequestMapping(metadata = defaultMetadata) {
+  const path = metadata.path || '';
+  const method = metadata.method || '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('post');
+const Get = createMappingDecorator('get');
+const Delete = createMappingDecorator('delete');
+const Put = createMappingDecorator('put');
+const Patch = createMappingDecorator('patch');
+const Options = createMappingDecorator('options');
+const Head = createMappingDecorator('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, ScopeModuleAWeb, Service, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, mergeActionsOpenAPIMetadata };

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

@@ -1,8 +1,8 @@
 import type { IOpenApiOptions } from 'vona-module-a-openapi';
-import { RequestMethod } from '../../types/request.ts';
+import type { TypeRequestMethod } from '../../types/request.ts';
 export interface RequestMappingMetadata {
     path?: string;
-    method?: RequestMethod;
+    method?: TypeRequestMethod;
     options?: IOpenApiOptions;
 }
 export declare function RequestMapping(metadata?: RequestMappingMetadata): MethodDecorator;

package/dist/types/request.d.ts

@@ -1,11 +1,2 @@
 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/router.d.ts

@@ -1,6 +1,6 @@
 import type Router from 'find-my-way';
 import type { Constructable } from 'vona';
-import type { RequestMethod } from './request.ts';
+import type { TypeRequestMethod } from './request.ts';
 export interface ContextRouteMetadata {
     meta: any;
 }
@@ -12,7 +12,7 @@ export interface ContextRoute {
     controllerBeanFullName: string;
     action: string;
     route: ContextRouteMetadata;
-    routeMethod: RequestMethod;
+    routeMethod: TypeRequestMethod;
     routePath: string | RegExp;
     routePathRaw: string | RegExp;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.10",
+  "version": "5.0.12",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {
@@ -61,6 +61,6 @@
   },
   "scripts": {
     "clean": "rimraf dist tsconfig.build.tsbuildinfo",
-    "tsc:publish": "npm run clean && tsc -p tsconfig.build.json"
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
   }
 }