@midwayjs/validate 3.9.9 → 3.10.1

package/dist/configuration.d.ts

@@ -1,8 +1,9 @@
-import { MidwayDecoratorService } from '@midwayjs/core';
+import { MidwayDecoratorService, IMidwayContainer } from '@midwayjs/core';
 import { ValidateService } from './service';
 export declare class ValidateConfiguration {
     decoratorService: MidwayDecoratorService;
     validateService: ValidateService;
-    onReady(): Promise<void>;
+    init(): Promise<void>;
+    onReady(container: IMidwayContainer): Promise<void>;
 }
 //# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -11,40 +11,37 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidateConfiguration = void 0;
 const core_1 = require("@midwayjs/core");
-const constants_1 = require("./constants");
-const util = require("util");
 const DefaultConfig = require("./config/config.default");
 const service_1 = require("./service");
 const i18n = require("@midwayjs/i18n");
-const debug = util.debuglog('midway:debug');
+const pipe_1 = require("./pipe");
+const constants_1 = require("./constants");
 let ValidateConfiguration = class ValidateConfiguration {
-    async onReady() {
-        debug(`[midway:validate] Register @validate "${constants_1.VALIDATE_KEY}" handler"`);
-        this.decoratorService.registerMethodHandler(constants_1.VALIDATE_KEY, options => {
-            var _a;
-            // get param types from method
-            const paramTypes = (0, core_1.getMethodParamTypes)(options.target, options.propertyName);
-            const validateOptions = (_a = options.metadata) === null || _a === void 0 ? void 0 : _a.options;
-            // add aspect method
-            return {
-                before: (joinPoint) => {
-                    for (let i = 0; i < paramTypes.length; i++) {
-                        if (!validateOptions.locale) {
-                            const maybeCtx = joinPoint.target[core_1.REQUEST_OBJ_CTX_KEY];
-                            if (maybeCtx && maybeCtx.getAttr) {
-                                validateOptions.locale = maybeCtx.getAttr(i18n.I18N_ATTR_KEY);
-                            }
-                        }
-                        const item = paramTypes[i];
-                        const result = this.validateService.validate(item, joinPoint.args[i], validateOptions);
-                        if (result && result.value) {
-                            joinPoint.args[i] = result.value;
-                        }
-                    }
-                },
-            };
+    async init() {
+        this.decoratorService.registerParameterHandler(constants_1.VALID_KEY, ({ parameterIndex, originParamType, originArgs, metadata }) => {
+            if (!metadata.schema) {
+                metadata.schema = this.validateService.getSchema(originParamType);
+            }
+            return originArgs[parameterIndex];
         });
     }
+    async onReady(container) {
+        await container.getAsync(pipe_1.ValidationPipe);
+        await container.getAsync(pipe_1.ParseIntPipe);
+        await container.getAsync(pipe_1.ParseBoolPipe);
+        await container.getAsync(pipe_1.ParseFloatPipe);
+        await container.getAsync(pipe_1.DefaultValidPipe);
+        this.decoratorService.registerParameterHandler(constants_1.VALID_KEY, ({ parameterIndex, originParamType, originArgs, metadata }) => {
+            if (!metadata.schema) {
+                metadata.schema = this.validateService.getSchema(originParamType);
+            }
+            return originArgs[parameterIndex];
+        });
+        // register web param default pipe
+        this.decoratorService.registerParameterPipes(core_1.WEB_ROUTER_PARAM_KEY, [
+            pipe_1.ValidationPipe,
+        ]);
+    }
 };
 __decorate([
     (0, core_1.Inject)(),
@@ -54,6 +51,12 @@ __decorate([
     (0, core_1.Inject)(),
     __metadata("design:type", service_1.ValidateService)
 ], ValidateConfiguration.prototype, "validateService", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ValidateConfiguration.prototype, "init", null);
 ValidateConfiguration = __decorate([
     (0, core_1.Configuration)({
         namespace: 'validate',

package/dist/constants.d.ts

@@ -1,3 +1,4 @@
 export declare const RULES_KEY = "common:rules";
 export declare const VALIDATE_KEY = "common:validate";
+export declare const VALID_KEY = "validate:valid";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VALIDATE_KEY = exports.RULES_KEY = void 0;
+exports.VALID_KEY = exports.VALIDATE_KEY = exports.RULES_KEY = void 0;
 exports.RULES_KEY = 'common:rules';
 exports.VALIDATE_KEY = 'common:validate';
+exports.VALID_KEY = 'validate:valid';
 //# sourceMappingURL=constants.js.map

package/dist/decorator/valid.d.ts

@@ -0,0 +1,3 @@
+import { AnySchema } from 'joi';
+export declare function Valid(schema?: AnySchema<any>): ParameterDecorator;
+//# sourceMappingURL=valid.d.ts.map

package/dist/decorator/valid.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Valid = void 0;
+const core_1 = require("@midwayjs/core");
+const constants_1 = require("../constants");
+const pipe_1 = require("../pipe");
+function Valid(schema) {
+    return (0, core_1.createCustomParamDecorator)(constants_1.VALID_KEY, {
+        schema,
+    }, {
+        pipes: [pipe_1.DefaultValidPipe],
+    });
+}
+exports.Valid = Valid;
+//# sourceMappingURL=valid.js.map

package/dist/decorator/validate.d.ts

@@ -4,5 +4,5 @@ export interface ValidateOptions {
     locale?: string;
     validationOptions?: Joi.ValidationOptions;
 }
-export declare function Validate(options?: ValidateOptions): MethodDecorator;
+export declare function Validate(options?: ValidateOptions): (target: any, methodName: any, descriptor: any) => void;
 //# sourceMappingURL=validate.d.ts.map

package/dist/decorator/validate.js

@@ -4,9 +4,9 @@ exports.Validate = void 0;
 const core_1 = require("@midwayjs/core");
 const constants_1 = require("../constants");
 function Validate(options = {}) {
-    return (0, core_1.createCustomMethodDecorator)(constants_1.VALIDATE_KEY, {
-        options,
-    });
+    return (target, methodName, descriptor) => {
+        (0, core_1.savePropertyMetadata)(constants_1.VALIDATE_KEY, options, target, methodName);
+    };
 }
 exports.Validate = Validate;
 //# sourceMappingURL=validate.js.map

package/dist/dtoHelper.d.ts

@@ -1,6 +1,6 @@
 export interface Dto<T> extends Function {
     new (): T;
 }
-export declare function PickDto<T, K extends keyof T>(dto: Dto<T>, keys: K[]): Dto<Pick<T, typeof keys[number]>>;
-export declare function OmitDto<T, K extends keyof T>(dto: Dto<T>, keys: K[]): Dto<Omit<T, typeof keys[number]>>;
+export declare function PickDto<T, K extends keyof T>(dto: Dto<T>, keys: K[]): Dto<Pick<T, (typeof keys)[number]>>;
+export declare function OmitDto<T, K extends keyof T>(dto: Dto<T>, keys: K[]): Dto<Omit<T, (typeof keys)[number]>>;
 //# sourceMappingURL=dtoHelper.d.ts.map

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 export { ValidateConfiguration as Configuration } from './configuration';
 export * from './decorator/rule';
 export * from './decorator/validate';
+export * from './decorator/valid';
 export * from './dtoHelper';
 export * from './service';
 export * from './error';
+export * from './pipe';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -19,7 +19,9 @@ var configuration_1 = require("./configuration");
 Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.ValidateConfiguration; } });
 __exportStar(require("./decorator/rule"), exports);
 __exportStar(require("./decorator/validate"), exports);
+__exportStar(require("./decorator/valid"), exports);
 __exportStar(require("./dtoHelper"), exports);
 __exportStar(require("./service"), exports);
 __exportStar(require("./error"), exports);
+__exportStar(require("./pipe"), exports);
 //# sourceMappingURL=index.js.map

package/dist/pipe.d.ts

@@ -0,0 +1,36 @@
+import { PipeTransform, TransformOptions } from '@midwayjs/core';
+import { ValidateService } from './service';
+import { ValidateOptions } from './decorator/validate';
+import * as Joi from 'joi';
+export declare abstract class AbstractValidationPipe implements PipeTransform {
+    protected validateService: ValidateService;
+    abstract transform(value: any, options: TransformOptions): any;
+    validateWithSchema(value: any, options: TransformOptions, schema: Joi.AnySchema): any;
+    validate(value: any, options: TransformOptions): any;
+    protected parseValidationOptions(options: TransformOptions): ValidateOptions;
+    protected getSchema(): any;
+}
+export declare class ValidationPipe extends AbstractValidationPipe {
+    transform(value: any, options: TransformOptions): any;
+}
+declare abstract class ParsePipe extends AbstractValidationPipe {
+    transform(value: any, options: TransformOptions): any;
+}
+export declare class DefaultValidPipe extends ParsePipe {
+}
+export declare class ParseIntPipe extends ParsePipe {
+    getSchema(): Joi.AnySchema<any>;
+}
+export declare class ParseBoolPipe extends ParsePipe {
+    getSchema(): Joi.AnySchema<any>;
+}
+export declare class ParseFloatPipe extends ParsePipe {
+    getSchema(): Joi.AnySchema<any>;
+}
+export declare class DefaultValuePipe<T = any, R = any> implements PipeTransform<T, R> {
+    protected readonly defaultValue: R;
+    constructor(defaultValue: R);
+    transform(value: any, options: any): any;
+}
+export {};
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipe.js

@@ -0,0 +1,119 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultValuePipe = exports.ParseFloatPipe = exports.ParseBoolPipe = exports.ParseIntPipe = exports.DefaultValidPipe = exports.ValidationPipe = exports.AbstractValidationPipe = void 0;
+const core_1 = require("@midwayjs/core");
+const service_1 = require("./service");
+const i18n = require("@midwayjs/i18n");
+const constants_1 = require("./constants");
+const Joi = require("joi");
+class AbstractValidationPipe {
+    validateWithSchema(value, options, schema) {
+        const validateOptions = this.parseValidationOptions(options);
+        const result = this.validateService.validateWithSchema(schema, value, validateOptions);
+        if (result && result.value !== undefined) {
+            return result.value;
+        }
+        return value;
+    }
+    validate(value, options) {
+        const validateOptions = this.parseValidationOptions(options);
+        if (options.metaType.isBaseType) {
+            return value;
+        }
+        const result = this.validateService.validate(options.metaType.originDesign, value, validateOptions);
+        if (result && result.value) {
+            return result.value;
+        }
+        return value;
+    }
+    parseValidationOptions(options) {
+        const validateOptions = (0, core_1.getPropertyMetadata)(constants_1.VALIDATE_KEY, options.target, options.methodName) ||
+            {};
+        if (!validateOptions.locale) {
+            const maybeCtx = options.target[core_1.REQUEST_OBJ_CTX_KEY];
+            if (maybeCtx && maybeCtx.getAttr) {
+                validateOptions.locale = maybeCtx.getAttr(i18n.I18N_ATTR_KEY);
+            }
+        }
+        return validateOptions;
+    }
+    getSchema() {
+        return undefined;
+    }
+}
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", service_1.ValidateService)
+], AbstractValidationPipe.prototype, "validateService", void 0);
+exports.AbstractValidationPipe = AbstractValidationPipe;
+let ValidationPipe = class ValidationPipe extends AbstractValidationPipe {
+    transform(value, options) {
+        return this.validate(value, options);
+    }
+};
+ValidationPipe = __decorate([
+    (0, core_1.Pipe)()
+], ValidationPipe);
+exports.ValidationPipe = ValidationPipe;
+class ParsePipe extends AbstractValidationPipe {
+    transform(value, options) {
+        return this.validateWithSchema(value, options, options.metadata['schema'] || this.getSchema());
+    }
+}
+let DefaultValidPipe = class DefaultValidPipe extends ParsePipe {
+};
+DefaultValidPipe = __decorate([
+    (0, core_1.Pipe)()
+], DefaultValidPipe);
+exports.DefaultValidPipe = DefaultValidPipe;
+let ParseIntPipe = class ParseIntPipe extends ParsePipe {
+    getSchema() {
+        return Joi.number().integer().required();
+    }
+};
+ParseIntPipe = __decorate([
+    (0, core_1.Pipe)()
+], ParseIntPipe);
+exports.ParseIntPipe = ParseIntPipe;
+let ParseBoolPipe = class ParseBoolPipe extends ParsePipe {
+    getSchema() {
+        return Joi.boolean().required();
+    }
+};
+ParseBoolPipe = __decorate([
+    (0, core_1.Pipe)()
+], ParseBoolPipe);
+exports.ParseBoolPipe = ParseBoolPipe;
+let ParseFloatPipe = class ParseFloatPipe extends ParsePipe {
+    getSchema() {
+        return Joi.number().required();
+    }
+};
+ParseFloatPipe = __decorate([
+    (0, core_1.Pipe)()
+], ParseFloatPipe);
+exports.ParseFloatPipe = ParseFloatPipe;
+class DefaultValuePipe {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    transform(value, options) {
+        if (value === undefined ||
+            value === null ||
+            (typeof value === 'number' && isNaN(value))) {
+            return this.defaultValue;
+        }
+        return value;
+    }
+}
+exports.DefaultValuePipe = DefaultValuePipe;
+//# sourceMappingURL=pipe.js.map

package/dist/service.d.ts

@@ -1,7 +1,7 @@
 import * as DefaultConfig from './config/config.default';
 import * as Joi from 'joi';
 import { MidwayI18nServiceSingleton } from '@midwayjs/i18n';
-import { ObjectSchema } from 'joi';
+import { ObjectSchema, AnySchema } from 'joi';
 export declare class ValidateService {
     protected validateConfig: typeof DefaultConfig.validate;
     protected i18nConfig: any;
@@ -13,7 +13,7 @@ export declare class ValidateService {
         locale?: string;
         validationOptions?: Joi.ValidationOptions;
     }): Joi.ValidationResult<T> | undefined;
-    validateWithSchema<T>(schema: ObjectSchema<any>, value: any, options?: {
+    validateWithSchema<T>(schema: AnySchema<T>, value: any, options?: {
         errorStatus?: number;
         locale?: string;
         validationOptions?: Joi.ValidationOptions;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midwayjs/validate",
-  "version": "3.9.9",
+  "version": "3.10.1",
   "description": "Midway Component for mongoose",
   "main": "dist/index.js",
   "typings": "index.d.ts",
@@ -23,14 +23,14 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@midwayjs/i18n": "^3.9.9",
+    "@midwayjs/i18n": "^3.10.1",
     "joi": "^17.2.1"
   },
   "devDependencies": {
-    "@midwayjs/core": "^3.9.0",
-    "@midwayjs/express": "^3.9.9",
-    "@midwayjs/koa": "^3.9.9",
-    "@midwayjs/mock": "^3.9.0"
+    "@midwayjs/core": "^3.10.1",
+    "@midwayjs/express": "^3.10.1",
+    "@midwayjs/koa": "^3.10.1",
+    "@midwayjs/mock": "^3.10.1"
   },
-  "gitHead": "95bb5b3f23b41f685372c45d1c3bb12a3e31b4e0"
+  "gitHead": "6bc9f7a97e4188399d2406f5a38bad5aeb983e07"
 }