vona-module-a-web 5.0.20 → 5.0.22

package/cli/dto/metadata/generate.ts

@@ -11,7 +11,7 @@ export default async function (options: IMetadataCustomGenerateOptions): Promise
     contentImports.push(`import type { ${className} } from '${fileNameJSRelative}';`);
     contentFields.push(`
     export interface ${opionsName} {
-      fields?: TypeEntityOptionsFields<${className}, ${opionsName}['_fieldsMore_']>;
+      fields?: TypeEntityOptionsFields<${className}, ${opionsName}[TypeSymbolKeyFieldsMore]>;
     }`);
   }
   if (contentFields.length === 0) return '';

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';
@@ -28,6 +55,10 @@ declare module 'vona-module-a-bean' {
 declare module 'vona-module-a-web' {
     interface ServiceWeb {
     }
+    interface ServiceWeb {
+        get $beanFullName(): 'a-web.service.web';
+        get $onionName(): 'a-web:web';
+    }
 }
 /** service: end */
 /** service: begin */
@@ -55,6 +86,10 @@ declare module 'vona-module-a-startup' {
 declare module 'vona-module-a-web' {
     interface StartupListen {
     }
+    interface StartupListen {
+        get $beanFullName(): 'a-web.startup.listen';
+        get $onionName(): 'a-web:listen';
+    }
 }
 /** startup: end */
 /** config: begin */

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

@@ -0,0 +1,29 @@
+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 interface IPipeOptionsQuery extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+    transform?: TypePipeOptionsQueryTransform;
+}
+export interface IPipeOptionsQueryTransformInfo {
+    params: IQueryParams;
+    query: any;
+    options: IPipeOptionsQuery;
+    originalName: string;
+    fullName: string;
+    key: string;
+    value: any;
+    schema: z.ZodSchema;
+    openapi?: ISchemaObjectExtensionField;
+}
+export type TypePipeOptionsQueryTransform = (ctx: VonaContext, info: IPipeOptionsQueryTransformInfo) => boolean | undefined;
+export declare class PipeQuery extends BeanBase implements IPipeTransform<any> {
+    transform(value: any, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsQuery): Promise<any>;
+    private _transform;
+    private _transformSystem;
+    private _transformFields;
+}
+export declare const ArgQuery: (options?: Partial<IPipeOptionsQuery> | undefined) => any;

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

@@ -0,0 +1,10 @@
+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 interface IPipeOptionsValid extends IDecoratorPipeOptions, IDecoratorPipeOptionsArgument, ValidatorOptions {
+}
+export declare class PipeValid extends BeanBase implements IPipeTransform<any> {
+    transform(value: any, metadata: RouteHandlerArgumentMeta, options: IPipeOptionsValid): Promise<any>;
+}
+export declare const ArgValid: (options?: Partial<IPipeOptionsValid> | undefined) => any;

package/dist/index.js

@@ -1,16 +1,155 @@
-import { appMetadata, BeanInfo, BeanBase, appResource, deepExtend, compose, cast, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
+import { HttpStatus, BeanInfo, BeanBase, appMetadata, appResource, deepExtend, compose, cast, BeanSimple, BeanScopeBase, createBeanDecorator } from 'vona';
+import { isNil, combineParamsAndQuery } from '@cabloy/utils';
+import { ZodMetadata } from '@cabloy/zod-query';
+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,
+  passthrough: 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
+    return this._transformFields(params, value, options);
+  }
+
+  // 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;
+  }
+  _transformFields(params, value, options) {
+    for (const key in value) {
+      if (__FieldsSystem.includes(key)) continue;
+      const fieldSchema = ZodMetadata.unwrapChained(ZodMetadata.getFieldSchema(options.schema, key));
+      if (!fieldSchema) continue;
+      // openapi
+      const openapi = ZodMetadata.getOpenapiMetadata(fieldSchema);
+      // name
+      const originalName = openapi?.query?.originalName ?? key;
+      let fullName;
+      // joins
+      if (openapi?.query?.join) {
+        if (!params.joins) params.joins = [];
+        const joinType = openapi.query.join.type ?? 'innerJoin';
+        const joinTable = openapi.query.join.table;
+        const joinOn = openapi.query.join.on;
+        if (params.joins.findIndex(item => item[1] === joinTable) === -1) {
+          params.joins.push([joinType, joinTable, joinOn]);
+        }
+        fullName = `${joinTable}.${originalName}`;
+      } else {
+        fullName = originalName;
+      }
+      // check where
+      if (params.where[fullName]) continue;
+      // custom transform
+      if (options.transform) {
+        const res = options.transform(this.ctx, {
+          params,
+          query: value,
+          options,
+          originalName,
+          fullName,
+          key,
+          value: value[key],
+          schema: fieldSchema,
+          openapi
+        });
+        if (res === true || res === false) continue;
+      }
+      // default transform
+      let op = openapi?.query?.op;
+      if (!op) {
+        const typeName = fieldSchema._def.typeName;
+        if (typeName === 'ZodString') {
+          op = '_includesI_';
+        } else {
+          op = '_eq_';
+        }
+      }
+      if (op === '_eq_') {
+        params.where[fullName] = value[key];
+      } else {
+        params.where[fullName] = {
+          [op]: value[key]
+        };
+      }
+    }
+    return params;
+  }
+}) || _class$5) || _class$5);
+const ArgQuery = createArgumentPipe('a-web:query');
+
+var _dec$4, _dec2$4, _class$4;
+let PipeValid = (_dec$4 = Pipe({
+  // ValidatorOptions
+  disableErrorMessages: false,
+  errorHttpStatusCode: HttpStatus.BAD_REQUEST,
+  passthrough: 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 +174,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 = {
@@ -99,7 +239,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);
@@ -171,11 +311,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
@@ -514,6 +649,85 @@ 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) {
+  return function (target, prop, index) {
+    const schema = $schema(schemaLike);
+    setArgumentPipe('a-web:query', {
+      type: 'query',
+      schema
+    }, 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, {
@@ -522,7 +736,7 @@ function Controller(path, options) {
   } else {
     options = path || {};
   }
-  return createBeanDecorator('controller', options, false, false, target => {
+  return createBeanDecorator('controller', options, false, target => {
     // beanOptions
     const beanOptions = appResource.getBean(target);
     // IOpenApiOptions
@@ -536,7 +750,7 @@ function Controller(path, options) {
   });
 }
 function Dto(options) {
-  return createBeanDecorator('dto', options, false, false, target => {
+  return createBeanDecorator('dto', options, false, target => {
     mergeFieldsOpenapiMetadata(target);
   });
 }
@@ -611,4 +825,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, ArgQuery, 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,42 @@
+import type { Constructable } from 'vona';
+import type { SchemaLike } from 'vona-module-a-openapiutils';
+import type z from 'zod';
+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.ZodSchema | Constructable): 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/bean.d.ts

@@ -3,5 +3,5 @@ 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 Dto<T extends IDecoratorDtoOptions<any>>(options?: Omit<T, '_fieldsMore_'>): 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

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

@@ -1,12 +1,13 @@
 import type { OmitNever } from 'vona';
 import type { ServiceOnion } from 'vona-module-a-onion';
 import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { SymbolKeyFieldsMore } from 'vona-module-a-orm';
 export interface IDtoRecord {
 }
 export interface IDecoratorDtoOptions<FieldsMore = never> {
+    [SymbolKeyFieldsMore]?: FieldsMore;
     independent?: boolean;
     openapi?: TypeOpenapiMetadata;
-    _fieldsMore_?: FieldsMore;
 }
 declare module 'vona-module-a-onion' {
     interface BeanOnion {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-web",
   "type": "module",
-  "version": "5.0.20",
+  "version": "5.0.22",
   "title": "a-web",
   "vonaModule": {
     "capabilities": {
@@ -11,7 +11,6 @@
     "onions": {
       "dto": {
         "sceneIsolate": true,
-        "optionsCustomInterfaceTemplate": "Omit<{{optionsCustomInterface}}, '_fieldsMore_'>",
         "optionsGlobalInterfaceName": "IDecoratorDtoOptions",
         "optionsGlobalInterfaceFrom": "vona-module-a-web",
         "boilerplate": "cli/dto/boilerplate",