vona-module-a-web 5.0.21 → 5.0.23

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

@@ -1,3 +1,30 @@
+/** pipe: begin */
+export * from '../bean/pipe.query.ts';
+export * from '../bean/pipe.valid.ts';
+import type { IPipeOptionsQuery } from '../bean/pipe.query.ts';
+import type { IPipeOptionsValid } from '../bean/pipe.valid.ts';
+import 'vona';
+declare module 'vona-module-a-aspect' {
+    interface IPipeRecordLocal {
+        'a-web:query': IPipeOptionsQuery;
+        'a-web:valid': IPipeOptionsValid;
+    }
+}
+declare module 'vona-module-a-web' {
+    interface PipeQuery {
+    }
+    interface PipeQuery {
+        get $beanFullName(): 'a-web.pipe.query';
+        get $onionName(): 'a-web:query';
+    }
+    interface PipeValid {
+    }
+    interface PipeValid {
+        get $beanFullName(): 'a-web.pipe.valid';
+        get $onionName(): 'a-web:valid';
+    }
+}
+/** pipe: end */
 /** bean: begin */
 export * from '../bean/bean.router.ts';
 import 'vona';

package/dist/bean/pipe.query.d.ts

@@ -0,0 +1,37 @@
+import type { VonaContext } from 'vona';
+import type { IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, IPipeTransform } from 'vona-module-a-aspect';
+import type { ISchemaObjectExtensionField, RouteHandlerArgumentMeta } from 'vona-module-a-openapi';
+import type { IQueryParams } from 'vona-module-a-orm';
+import type { ValidatorOptions } from 'vona-module-a-validation';
+import type z from 'zod';
+import { BeanBase } from 'vona';
+export type TypePipeQueryData = unknown;
+export type TypePipeQueryResult = TypePipeQueryData;
+export interface IPipeOptionsQuery extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+    transformFn?: TypePipeOptionsQueryTransform | string;
+}
+export type TypeQueryParamsPatch = IQueryParams & {
+    where: {};
+};
+export interface IPipeOptionsQueryTransformInfo {
+    params: TypeQueryParamsPatch;
+    query: any;
+    options: IPipeOptionsQuery;
+    originalName: string;
+    fullName: string;
+    key?: string;
+    value?: any;
+    schema?: z.ZodType;
+    openapi?: ISchemaObjectExtensionField;
+}
+export type TypePipeOptionsQueryTransform = (ctx: VonaContext, info: IPipeOptionsQueryTransformInfo) => boolean | undefined;
+export declare class PipeQuery extends BeanBase implements IPipeTransform<TypePipeQueryData, TypePipeQueryResult> {
+    transform(value: TypePipeQueryData, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsQuery): Promise<TypePipeQueryResult>;
+    private _transform;
+    private _transformSystem;
+    private _transformOrders;
+    private _transformField;
+    private _transformFields;
+    private _performTransformFn;
+}
+export declare const ArgQueryPro: (options?: Partial<IPipeOptionsQuery> | undefined) => any;

package/dist/bean/pipe.valid.d.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, IPipeTransform } from 'vona-module-a-aspect';
+import type { RouteHandlerArgumentMeta } from 'vona-module-a-openapi';
+import type { ValidatorOptions } from 'vona-module-a-validation';
+import { BeanBase } from 'vona';
+export type TypePipeValidData = unknown;
+export type TypePipeValidResult = TypePipeValidData;
+export interface IPipeOptionsValid extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+}
+export declare class PipeValid extends BeanBase implements IPipeTransform<TypePipeValidData, TypePipeValidResult> {
+    transform(value: TypePipeValidData, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsValid): Promise<TypePipeValidResult>;
+}
+export declare const ArgValid: (options?: Partial<IPipeOptionsValid> | undefined) => any;

package/dist/index.js

@@ -1,16 +1,217 @@
-import { appMetadata, BeanInfo, BeanBase, appResource, deepExtend, compose, cast, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
+import { HttpStatus, BeanInfo, BeanBase, cast, appMetadata, appResource, deepExtend, compose, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
+import { isNil, combineParamsAndQuery } from '@cabloy/utils';
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { Pipe, createArgumentPipe, setArgumentPipe } from 'vona-module-a-aspect';
 import * as ModuleInfo from '@cabloy/module-info';
 import { Bean, Service, Scope } from 'vona-module-a-bean';
 import { SymbolUseOnionOptions } from 'vona-module-a-onion';
-import { SymbolRouteHandlersArgumentsValue, SymbolRouteHandlersArgumentsMeta, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapi';
-import { valid } from 'vona-module-a-validation';
+import { SymbolRouteHandlersArgumentsValue, SymbolRouteHandlersArgumentsMeta, makeSchemaLikes, $schema, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapi';
 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 { z } from 'zod';
 import { SymbolOpenApiOptions } from 'vona-module-a-openapiutils';
-import { combineParamsAndQuery } from '@cabloy/utils';
+
+var _dec$5, _dec2$5, _class$5;
+const __FieldsSystem = ['columns', 'where', 'orders', 'pageNo', 'pageSize'];
+let PipeQuery = (_dec$5 = Pipe({
+  // ValidatorOptions
+  disableErrorMessages: false,
+  errorHttpStatusCode: HttpStatus.BAD_REQUEST,
+  loose: false,
+  strict: false
+}), _dec2$5 = BeanInfo({
+  module: "a-web"
+}), _dec$5(_class$5 = _dec2$5(_class$5 = class PipeQuery extends BeanBase {
+  async transform(value, metadata, options) {
+    if (!options.schema) throw new Error(`should specify the schema of pipeQuery: ${metadata.controller.name}.${metadata.method}#${metadata.index}`);
+    // validateSchema
+    value = await this.bean.validator.validateSchema(options.schema, value, options, metadata.field);
+    // transform
+    value = this._transform(value, options);
+    // ok
+    return value;
+  }
+  _transform(value, options) {
+    // 1. system: columns/where/orders/pageNo/pageSize
+    const params = this._transformSystem(value);
+    // 2. fields
+    this._transformFields(params, value, options);
+    // 3. system: orders
+    this._transformOrders(params, options);
+    // ok
+    return params;
+  }
+
+  // system: columns/where/orders/pageNo/pageSize
+  _transformSystem(value) {
+    const params = {};
+    // columns
+    if (!isNil(value.columns)) params.columns = value.columns;
+    // where
+    params.where = value.where ?? {};
+    // orders
+    if (!isNil(value.orders)) {
+      if (typeof value.orders === 'string') {
+        if (value.orders.startsWith('[') && value.orders.endsWith(']')) {
+          params.orders = JSON.parse(value.orders);
+        } else {
+          params.orders = [value.orders.split(',')];
+        }
+      } else {
+        params.orders = value.orders;
+      }
+    }
+    // pageNo/pageSize
+    if (!isNil(value.pageNo) && !isNil(value.pageSize)) {
+      params.offset = (value.pageNo - 1) * value.pageSize;
+      params.limit = value.pageSize;
+    }
+    // ok
+    return params;
+  }
+  _transformOrders(params, options) {
+    if (!params.orders) return;
+    // openapi
+    const openapi = ZodMetadata.getOpenapiMetadata(options.schema);
+    const table = openapi?.query?.table;
+    // loop
+    for (const order of params.orders) {
+      const field = order[0];
+      if (field.includes('.')) continue;
+      let tableCurrent = table;
+      let fieldCurrent = field;
+      const fieldSchema = ZodMetadata.unwrapChained(ZodMetadata.getFieldSchema(options.schema, field));
+      if (fieldSchema) {
+        const openapi = ZodMetadata.getOpenapiMetadata(fieldSchema);
+        if (openapi?.query?.table) {
+          tableCurrent = openapi?.query?.table;
+        }
+        if (openapi?.query?.originalName) {
+          fieldCurrent = openapi?.query?.originalName;
+        }
+      }
+      cast(order)[0] = tableCurrent ? `${tableCurrent}.${fieldCurrent}` : fieldCurrent;
+    }
+  }
+  _transformField(key, fieldValue, params, value, options) {
+    if (__FieldsSystem.includes(key)) return;
+    const fieldSchema = ZodMetadata.unwrapChained(ZodMetadata.getFieldSchema(options.schema, key));
+    if (!fieldSchema) return;
+    // openapi
+    const openapi = ZodMetadata.getOpenapiMetadata(fieldSchema);
+    // name
+    const originalName = openapi?.query?.originalName ?? key;
+    let fullName;
+    // joins
+    let joinInfo;
+    if (openapi?.query?.joinOn) {
+      const joinType = openapi.query.joinType ?? 'innerJoin';
+      const joinTable = openapi.query.table;
+      const joinOn = openapi.query.joinOn;
+      joinInfo = [joinType, joinTable, joinOn];
+      fullName = `${joinTable}.${originalName}`;
+    } else {
+      fullName = originalName;
+    }
+    // check where
+    if (Object.prototype.hasOwnProperty.call(params.where, fullName)) return;
+    // custom transform
+    const resTransform = this._performTransformFn(options, {
+      params,
+      query: value,
+      options,
+      originalName,
+      fullName,
+      key,
+      value: fieldValue,
+      schema: fieldSchema,
+      openapi
+    });
+    // res: ignore
+    if (resTransform === false) return;
+    // join
+    if (joinInfo) {
+      if (!params.joins) params.joins = [];
+      if (params.joins.findIndex(item => item[1] === joinInfo.joinTable) === -1) {
+        params.joins.push(joinInfo);
+      }
+    }
+    // res: done
+    if (resTransform === true) return;
+    // default transform
+    let op = openapi?.query?.op;
+    if (!op) {
+      const typeName = fieldSchema.type;
+      if (typeName === 'string') {
+        op = '_includesI_';
+      } else {
+        op = '_eq_';
+      }
+    }
+    if (op === '_eq_') {
+      params.where[fullName] = fieldValue;
+    } else {
+      params.where[fullName] = {
+        [op]: fieldValue
+      };
+    }
+  }
+  _transformFields(params, value, options) {
+    // loop
+    for (const key in value) {
+      this._transformField(key, value[key], params, value, options);
+    }
+    // custom transform
+    this._performTransformFn(options, {
+      params,
+      query: value,
+      options
+    });
+  }
+  _performTransformFn(options, info) {
+    if (options.transformFn) {
+      if (typeof options.transformFn === 'string') {
+        const controller = this.ctx.getControllerBean();
+        if (!controller[options.transformFn]) {
+          throw new Error(`transformFn not found: ${this.ctx.getControllerBeanFullName()}`);
+        }
+        return controller[options.transformFn](info);
+      } else {
+        return options.transformFn(this.ctx, info);
+      }
+    } else {
+      const controller = this.ctx.getControllerBean();
+      const transformFn = `${String(this.ctx.getHandlerName())}QueryTransform`;
+      if (controller[transformFn]) {
+        return controller[transformFn](info);
+      }
+    }
+  }
+}) || _class$5) || _class$5);
+const ArgQueryPro$1 = createArgumentPipe('a-web:query');
+
+var _dec$4, _dec2$4, _class$4;
+let PipeValid = (_dec$4 = Pipe({
+  // ValidatorOptions
+  disableErrorMessages: false,
+  errorHttpStatusCode: HttpStatus.BAD_REQUEST,
+  loose: false,
+  strict: false
+}), _dec2$4 = BeanInfo({
+  module: "a-web"
+}), _dec$4(_class$4 = _dec2$4(_class$4 = class PipeValid extends BeanBase {
+  async transform(value, metadata, options) {
+    if (options.schema) {
+      // validateSchema
+      return await this.bean.validator.validateSchema(options.schema, value, options, metadata.field);
+    }
+    return value;
+  }
+}) || _class$4) || _class$4);
+const ArgValid = createArgumentPipe('a-web:valid');
 
 async function middlewareGuard(ctx, next) {
   // check handler
@@ -35,6 +236,7 @@ function extractValue(ctx, argMeta) {
   return exchangeKeyForValue(ctx, argMeta.type, argMeta.field);
 }
 function exchangeKeyForValue(ctx, type, field) {
+  if (!type) throw new Error('argument type should not empty');
   const req = ctx.request;
   const res = ctx.response;
   const modes = {
@@ -79,8 +281,6 @@ 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
@@ -99,7 +299,7 @@ async function _transformArguments(ctx, controller, handler) {
     length: paramtypes.length
   });
   for (let index = args.length - 1; index >= 0; index--) {
-    const argMeta = argsMeta.find(item => item.index === index);
+    const argMeta = argsMeta.find(item => item?.index === index);
     if (!argMeta) continue;
     // extractValue
     const value = await _extractArgumentValue(ctx, argMeta);
@@ -120,6 +320,7 @@ async function _transformArguments(ctx, controller, handler) {
 async function _transformArgument(ctx, argMeta, metadata, value) {
   // pipes
   const pipes = composePipes(ctx, argMeta, (beanInstance, value, options, _next) => {
+    if (!isNil(options.argIndex) && argMeta.index !== options.argIndex) return value;
     return beanInstance.transform(value, metadata, options);
   });
   if (pipes.length === 0) return value;
@@ -171,11 +372,6 @@ function composePipes(ctx, argMeta, executeCustom) {
 function _collectArgumentMiddlewares(onionPipe, argMeta) {
   if (!argMeta.pipes) return;
   return argMeta.pipes.map(pipe => {
-    if (typeof pipe !== 'function') {
-      pipe = valid({
-        schema: pipe
-      });
-    }
     const {
       pipeName,
       options
@@ -309,24 +505,23 @@ let BeanRouter = (_dec$3 = Bean(), _dec2$3 = BeanInfo({
   }
 }) || _class$3) || _class$3);
 function classControllerMiddleware(ctx) {
-  const beanFullName = ctx.getControllerBeanFullName();
-  const handlerName = ctx.getHandler().name;
-  const controller = ctx.app.bean._getBean(beanFullName);
+  const handlerName = ctx.getHandlerName();
+  const controller = ctx.getControllerBean();
   return controller[handlerName](...(ctx[SymbolRouteHandlersArgumentsValue] || []));
 }
 async function routeStartMiddleware(ctx, next) {
   // next
   const res = await next();
-  // invoke callbackes: handle secondly
-  await ctx.commitDone();
+  // invoke callbacks: handle secondly
+  await ctx.commitsDone();
   // ok
   return res;
 }
 async function routeTailDoneMiddleware(ctx, next) {
   // next
   const res = await next();
-  // invoke callbackes: handle firstly
-  await ctx.commitDone();
+  // invoke callbacks: handle firstly
+  await ctx.commitsDone();
   // ok
   return res;
 }
@@ -343,7 +538,7 @@ async function routeTailDoneMiddleware(ctx, next) {
 //     // next
 //     const res = await next();
 //     // invoke callbackes: handle secondly
-//     await ctx.commitDone();
+//     await ctx.commitsDone();
 //     // ok
 //     return res;
 //   };
@@ -362,7 +557,7 @@ async function routeTailDoneMiddleware(ctx, next) {
 //     // next
 //     const res = await next();
 //     // invoke callbackes: handle firstly
-//     await ctx.commitDone();
+//     await ctx.commitsDone();
 //     // ok
 //     return res;
 //   };
@@ -514,6 +709,86 @@ let ScopeModuleAWeb = (_dec = Scope(), _dec2 = BeanInfo({
 
 /** scope: end */
 
+function createPipesArgumentDecorator(paramType, extractValue) {
+  return function (field, ...schemaLikes) {
+    return function (target, prop, index) {
+      const hasParamField = typeof field === 'string';
+      const paramField = hasParamField ? field : undefined;
+      const paramSchemaLikes = hasParamField ? schemaLikes : [field, ...schemaLikes].filter(item => !!item);
+      const paramtypes = appMetadata.getMetadata('design:paramtypes', target, prop);
+      let metaType;
+      if (paramType === 'file') {
+        metaType = z.string().openapi({
+          format: 'binary'
+        });
+      } else if (paramType === 'files') {
+        metaType = z.array(z.string().openapi({
+          format: 'binary'
+        }));
+      } else {
+        metaType = paramtypes[index];
+      }
+      const argSchema = makeSchemaLikes(paramSchemaLikes, metaType);
+      setArgumentPipe('a-web:valid', {
+        type: paramType,
+        field: paramField,
+        schema: argSchema,
+        extractValue
+      }, target, prop, index);
+    };
+  };
+}
+
+function Param(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('param')(property, ...schemaLikes);
+}
+function Query(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('query')(property, ...schemaLikes);
+}
+function Body(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('body')(property, ...schemaLikes);
+}
+function Headers(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('headers')(property, ...schemaLikes);
+}
+function Fields(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('fields')(property, ...schemaLikes);
+}
+function Field(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('field')(property, ...schemaLikes);
+}
+function Files(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('files')(property, ...schemaLikes);
+}
+function File(property, ...schemaLikes) {
+  return createPipesArgumentDecorator('file')(property, ...schemaLikes);
+}
+function User(...schemaLikes) {
+  return createPipesArgumentDecorator('user')(undefined, ...schemaLikes);
+}
+function ArgQueryPro(schemaLike, transformFn) {
+  return function (target, prop, index) {
+    const schema = $schema(schemaLike);
+    setArgumentPipe('a-web:query', {
+      type: 'query',
+      schema,
+      transformFn
+    }, target, prop, index);
+  };
+}
+const Arg = {
+  param: Param,
+  query: Query,
+  body: Body,
+  headers: Headers,
+  fields: Fields,
+  field: Field,
+  files: Files,
+  file: File,
+  user: User,
+  queryPro: ArgQueryPro
+};
+
 function Controller(path, options) {
   if (typeof path === 'string') {
     options = Object.assign({}, options, {
@@ -611,4 +886,4 @@ function $apiPathAndCombineParamsAndQuery(path, options) {
   return combineParamsAndQuery(path, options);
 }
 
-export { $apiPath, $apiPathAndCombineParamsAndQuery, BeanRouter, Controller, Dto, Main, RequestMapping, ScopeModuleAWeb, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, mergeActionsOpenapiMetadata };
+export { $apiPath, $apiPathAndCombineParamsAndQuery, Arg, ArgQueryPro$1 as ArgQueryPro, ArgValid, BeanRouter, Controller, Dto, Main, PipeQuery, PipeValid, RequestMapping, ScopeModuleAWeb, ServiceWeb, StartupListen, SymbolRequestMappingHandler, Web, config, createPipesArgumentDecorator, mergeActionsOpenapiMetadata };

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

@@ -0,0 +1,43 @@
+import type { Constructable } from 'vona';
+import type { SchemaLike } from 'vona-module-a-openapiutils';
+import type z from 'zod';
+import type { TypePipeOptionsQueryTransform } from '../../bean/pipe.query.ts';
+declare function Param(): ParameterDecorator;
+declare function Param(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Param(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Query(): ParameterDecorator;
+declare function Query(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Query(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Body(): ParameterDecorator;
+declare function Body(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Body(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Headers(): ParameterDecorator;
+declare function Headers(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Headers(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Fields(): ParameterDecorator;
+declare function Fields(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Fields(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Field(): ParameterDecorator;
+declare function Field(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Field(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Files(): ParameterDecorator;
+declare function Files(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function Files(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function File(): ParameterDecorator;
+declare function File(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function File(property: string, ...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function User(...schemaLikes: SchemaLike[]): ParameterDecorator;
+declare function ArgQueryPro(schemaLike: z.ZodType | Constructable, transformFn?: TypePipeOptionsQueryTransform | string): any;
+export declare const Arg: {
+    param: typeof Param;
+    query: typeof Query;
+    body: typeof Body;
+    headers: typeof Headers;
+    fields: typeof Fields;
+    field: typeof Field;
+    files: typeof Files;
+    file: typeof File;
+    user: typeof User;
+    queryPro: typeof ArgQueryPro;
+};
+export {};

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

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

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

@@ -0,0 +1,3 @@
+import type { RouteHandlerArgumentType, TypeExtractValue } from 'vona-module-a-openapi';
+import type { SchemaLike } from 'vona-module-a-openapiutils';
+export declare function createPipesArgumentDecorator(paramType: RouteHandlerArgumentType, extractValue?: TypeExtractValue): (field?: string | SchemaLike, ...schemaLikes: SchemaLike[]) => ParameterDecorator;

package/dist/types/controller.d.ts

@@ -28,7 +28,7 @@ export interface IDecoratorControllerOptions extends TypeOnionOptionsEnableSimpl
 }
 declare module 'vona-module-a-onion' {
     interface BeanOnion {
-        controller: ServiceOnion<IDecoratorControllerOptions, keyof IControllerRecord>;
+        controller: ServiceOnion<IControllerRecord>;
     }
 }
 declare module 'vona' {

package/dist/types/dto.d.ts

@@ -1,6 +1,7 @@
 import type { OmitNever } from 'vona';
 import type { ServiceOnion } from 'vona-module-a-onion';
 import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { SchemaLike } from 'vona-module-a-openapiutils';
 import type { SymbolKeyFieldsMore } from 'vona-module-a-orm';
 export interface IDtoRecord {
 }
@@ -8,10 +9,11 @@ export interface IDecoratorDtoOptions<FieldsMore = never> {
     [SymbolKeyFieldsMore]?: FieldsMore;
     independent?: boolean;
     openapi?: TypeOpenapiMetadata;
+    pipes?: SchemaLike | SchemaLike[];
 }
 declare module 'vona-module-a-onion' {
     interface BeanOnion {
-        dto: ServiceOnion<IDecoratorDtoOptions, keyof IDtoRecord>;
+        dto: ServiceOnion<IDtoRecord>;
     }
 }
 declare module 'vona' {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.21",
+  "version": "5.0.23",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {