mev - npm Package Compare versions

Comparing version 2.0.0 to 2.1.0

dist/field/Field.d.ts

@@ -6,2 +6,3 @@ import { Rule } from '../rule/Rule';
     fieldName?: string;
+    useFieldName?: boolean;
 }
@@ -8,0 +9,0 @@ export declare const defaultFieldOptions: FieldOptions;

dist/field/Field.js

@@ -6,6 +6,7 @@ "use strict";
     rule: new Rule_1.Rule(),
+    useFieldName: false,
 };
 class Field {
     constructor(opts = exports.defaultFieldOptions) {
-        this.opts = opts;
+        this.opts = Object.assign({}, exports.defaultFieldOptions, opts);
         this.rules = [];
@@ -12,0 +13,0 @@ }

dist/index.d.ts

 export { createValidationField } from './field/FieldFactory';
 export { createValidationRule } from './rule/RuleFactory';
-export { createValidationSchema } from './schema/Schema';
+export { createValidationSchema, Schema } from './schema/Schema';
 export { isSuccess, isError } from './utils';

dist/index.js

@@ -9,2 +9,3 @@ "use strict";
 exports.createValidationSchema = Schema_1.createValidationSchema;
+exports.Schema = Schema_1.Schema;
 var utils_1 = require("./utils");
@@ -11,0 +12,0 @@ exports.isSuccess = utils_1.isSuccess;

dist/rule/Rule.d.ts

@@ -5,2 +5,3 @@ import { DefaultValidationRuleError, RuleTest, ValidationRuleResult } from '../types/ValidationRule';
     fieldName?: string;
+    useFieldName?: boolean;
     initialTypeTestType?: string;
@@ -7,0 +8,0 @@ }

dist/rule/Rule.js

@@ -7,3 +7,3 @@ "use strict";
     constructor(opts = exports.defaultRuleOptions) {
-        this.opts = opts;
+        this.opts = Object.assign({}, exports.defaultRuleOptions, opts);
         this.testRunner = new RuleTestRunner_1.RuleTestRunner(Object.assign({}, opts));
@@ -26,6 +26,7 @@ }
         const fieldName = this.getFieldNameOrEmpty();
+        const init = this.opts.useFieldName ? fieldName : '';
         if (this.resultIsError(validationRuleResult)) {
             return {
-                title: `${fieldName}${this.internalTitle || validationRuleResult.title}`,
-                description: `${fieldName}${this.internalDescription || validationRuleResult.description}`,
+                title: init + (this.internalTitle || validationRuleResult.title),
+                description: init + (this.internalDescription || validationRuleResult.description),
             };
@@ -32,0 +33,0 @@ }

dist/rule/Rule.spec.js

@@ -88,3 +88,3 @@ "use strict";
             it('should prepend the field name to any error message and description on failure', () => {
-                const rule = new Rule_1.Rule({ fieldName: 'username' })
+                const rule = new Rule_1.Rule({ fieldName: 'username', useFieldName: true })
                     .title('will fail')
@@ -91,0 +91,0 @@ .description('will fail, description')

dist/schema/Schema.d.ts

@@ -10,8 +10,12 @@ import { Field } from '../field/Field';
     protected opts: SchemaOptions;
-    protected fields: Map<string, Field<any, Rule<any>>>;
+    protected fields: Map<string, Schema | Field<any, Rule<any>>>;
     constructor(opts?: SchemaOptions);
     addField<T, F extends Field<T, Rule<T>>>(fieldName: string, field: (ff: FieldFactory<T, Rule<T>>) => F): this;
     addField<T, F extends Field<T, Rule<T>>>(fieldName: string, field: F): this;
+    addSchemaField(fieldName: string, schema: Schema): this;
+    addSchemaField(fieldName: string, schema: (sf: Schema) => Schema): this;
     run(obj: any): Validation;
+    private ensureFieldNameIsUnique;
 }
+export declare function isSchema(s: Schema | Field<any, Rule<any>>): s is Schema;
 export declare function createValidationSchema(opts?: SchemaOptions): Schema;

dist/schema/Schema.js

@@ -12,2 +12,3 @@ "use strict";
     addField(fieldName, field) {
+        this.ensureFieldNameIsUnique(fieldName);
         if (typeof field === 'function') {
@@ -17,5 +18,2 @@ return this.addField(fieldName, field(new FieldFactory_1.FieldFactory(Object.assign({}, this.opts, { fieldName }))));
         else {
-            if (this.fields.has(fieldName)) {
-                throw new Error(`Field ${fieldName} already exists in schema. Duplicate field names are disallowed.`);
-            }
             this.fields.set(fieldName, field);
@@ -25,2 +23,12 @@ return this;
     }
+    addSchemaField(fieldName, schema) {
+        this.ensureFieldNameIsUnique(fieldName);
+        if (typeof schema === 'function') {
+            return this.addSchemaField(fieldName, schema(new Schema()));
+        }
+        else {
+            this.fields.set(fieldName, schema);
+            return this;
+        }
+    }
     run(obj) {
@@ -30,17 +38,44 @@ function objHasResultPropAsFailure(o) {
         }
+        function validateFieldOrSchema(field, data) {
+            if (isSchema(field)) {
+                return field.run(data);
+            }
+            else {
+                return field.validate(data);
+            }
+        }
+        const fieldAndResultToIncludeFieldNameAndOptionallyParent = (asdf) => {
+            const { fieldName, testResult } = asdf;
+            if (isSchema(this.fields.get(fieldName))) {
+                return testResult.errors.map((error) => (Object.assign({ parent: fieldName }, error)));
+            }
+            else {
+                return testResult.errors.map((error) => (Object.assign({ fieldName }, error)));
+            }
+        };
         const errors = Array
             .from(this.fields)
-            .map(([fieldName, field]) => ({ fieldName, testResult: field.validate(obj[fieldName]) }))
-            // .filter(({ result }) => !isSuccess(result))
+            .map(([fieldName, field]) => ({ fieldName, testResult: validateFieldOrSchema(field, obj[fieldName]) }))
             .filter(objHasResultPropAsFailure)
-            .map(({ fieldName, testResult }) => testResult.errors.map(({ title, description }) => ({
-            title,
-            description,
-            fieldName,
-        })))
+            .map(fieldAndResultToIncludeFieldNameAndOptionallyParent)
+            /*({ fieldName, testResult }) =>
+            testResult.errors.map((error: ValidationRuleError) => ({
+              fieldName,
+              ...error,
+            })),
+          )*/
             .reduce((t, e) => t.concat(e), []);
         return errors.length === 0 ? { success: true } : { errors };
     }
+    ensureFieldNameIsUnique(fieldName) {
+        if (this.fields.has(fieldName)) {
+            throw new Error(`Field ${fieldName} already exists in schema. Duplicate field names are disallowed.`);
+        }
+    }
 }
 exports.Schema = Schema;
+function isSchema(s) {
+    return s instanceof Schema;
+}
+exports.isSchema = isSchema;
 function createValidationSchema(opts) {
@@ -47,0 +82,0 @@ return new Schema(opts);

dist/schema/Schema.spec.js

@@ -15,2 +15,57 @@ "use strict";
     });
+    describe('addSchemaField', () => {
+        it('should accept deep objects as arguments', () => {
+            const childSchema = new Schema_1.Schema()
+                .addField('child', (f) => f
+                .string()
+                .addRule((r) => r.title('title').description('description').maxLength(0)));
+            const parentSchema = new Schema_1.Schema().addSchemaField('parent', childSchema);
+            const expectedError = {
+                errors: [
+                    {
+                        title: 'title',
+                        description: 'description',
+                        fieldName: 'child',
+                        parent: 'parent',
+                    },
+                ],
+            };
+            const validation = parentSchema.run({ parent: { child: 'asdf' } });
+            chai_1.expect(validation).to.deep.equal(expectedError);
+        });
+        it('should accept deeper objects as arguments', () => {
+            const schema1 = new Schema_1.Schema()
+                .addField('internal', (f) => f
+                .string()
+                .addRule((r) => r.title('fail').description('fail').maxLength(0)));
+            const schema2 = new Schema_1.Schema().addSchemaField('schema1', schema1);
+            const schema3 = new Schema_1.Schema().addSchemaField('schema2', schema2);
+            const schema4 = new Schema_1.Schema().addSchemaField('schema3', schema3);
+            const expectedError = {
+                errors: [
+                    {
+                        title: 'fail',
+                        description: 'fail',
+                        fieldName: 'internal',
+                        parent: 'schema1',
+                    },
+                ],
+            };
+            const data = {
+                schema3: {
+                    schema2: {
+                        schema1: {
+                            internal: 'asdf',
+                        },
+                    },
+                },
+            };
+            chai_1.expect(schema4.run(data)).to.deep.equal(expectedError);
+        });
+        it('should accept a function which is passed a new schema', () => {
+            const createSchema = () => new Schema_1.Schema()
+                .addSchemaField('name', (s) => s);
+            chai_1.expect(createSchema).to.not.throw(Error);
+        });
+    });
     describe('run', () => {
@@ -17,0 +72,0 @@ it('should return errors for each failing test for each field', () => {

dist/test_helpers/rule.d.ts

@@ -5,3 +5,5 @@ import { ValidationRuleError, ValidationRuleSuccess } from '../types/ValidationRule';
 export declare const emptyData: any;
-export declare const truthyTest: () => boolean;
-export declare const falsyTest: () => boolean;
+export declare const truthyTest: (o: any) => boolean;
+export declare const falsyTest: (o: any) => boolean;
+export declare const truthyRule: import("../rule/Rule").Rule<any>;
+export declare const falsyRule: import("../rule/Rule").Rule<any>;

dist/test_helpers/rule.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
 exports.emptyFail = {
@@ -11,4 +12,6 @@ title: '',
 exports.emptyData = null;
-exports.truthyTest = () => true;
-exports.falsyTest = () => false;
+exports.truthyTest = (o) => true;
+exports.falsyTest = (o) => false;
+exports.truthyRule = __1.createValidationRule().any().addTestFunction(exports.truthyTest);
+exports.falsyRule = __1.createValidationRule().any().addTestFunction(exports.falsyTest);
 //# sourceMappingURL=rule.js.map

dist/types/ValidationRule.d.ts

 export declare type ValidationRuleResult = ValidationRuleError | ValidationRuleSuccess;
 export interface ValidationRuleError extends DefaultValidationRuleError {
     fieldName?: string;
+    parent?: string;
 }
@@ -5,0 +6,0 @@ export interface DefaultValidationRuleError {

dist/utils/index.d.ts

@@ -0,3 +1,8 @@
+import { Schema } from '..';
 import { Validation, ValidationError, ValidationSuccess } from '../types/Validation';
 export declare function isSuccess(val: Validation): val is ValidationSuccess;
 export declare function isError(val: Validation): val is ValidationError;
+export interface MiddlewareOptions {
+    ignoredParamsInReturn: string[];
+}
+export declare const middlewave: (schema: Schema, options?: MiddlewareOptions) => (req: any, res: any, next: () => {}) => void;

dist/utils/index.js

@@ -11,2 +11,29 @@ "use strict";
 exports.isError = isError;
+const defaultMiddlewareOptions = {
+    ignoredParamsInReturn: [],
+};
+function deleteMatchingAttributes(obj, attributes) {
+    return Object.keys(obj)
+        .filter((prop) => !attributes.includes(prop))
+        .map((prop) => ({
+        p: prop,
+        d: typeof obj[prop] === 'object' ? deleteMatchingAttributes(obj[prop], attributes) : obj[prop],
+    }))
+        .reduce((o, { p, d }) => (Object.assign({}, o, { [p]: d })), {});
+}
+exports.middlewave = (schema, options = defaultMiddlewareOptions) => (req, res, next) => {
+    options = Object.assign({}, defaultMiddlewareOptions, options);
+    if (req.body && req.body && req.body.data === 'object') {
+        const validation = schema.run(req.body.data);
+        if (isSuccess(validation)) {
+            next();
+        }
+        else {
+            const { errors } = validation;
+            res.status(422).json({
+                status: 'failure',
+            });
+        }
+    }
+};
 //# sourceMappingURL=index.js.map

lib/field/Field.ts

@@ -8,2 +8,3 @@ import { Rule } from '../rule/Rule';
   fieldName?: string;
+  useFieldName?: boolean;
 }
@@ -13,2 +14,3 @@
   rule: new Rule(),
+  useFieldName: false,
 };
@@ -21,3 +23,3 @@
   constructor(opts: FieldOptions = defaultFieldOptions) {
-    this.opts = opts;
+    this.opts = { ... defaultFieldOptions, ...opts };
     this.rules = [];
@@ -24,0 +26,0 @@ }

lib/index.ts

 export { createValidationField } from './field/FieldFactory';
 export { createValidationRule } from './rule/RuleFactory';
-export { createValidationSchema } from './schema/Schema';
+export { createValidationSchema, Schema } from './schema/Schema';
 export { isSuccess, isError } from './utils';

lib/rule/Rule.spec.ts

@@ -116,3 +116,3 @@ import { expect } from 'chai';
       it('should prepend the field name to any error message and description on failure', () => {
-        const rule = new Rule({ fieldName: 'username' })
+        const rule = new Rule({ fieldName: 'username', useFieldName: true })
           .title('will fail')
@@ -119,0 +119,0 @@ .description('will fail, description')

lib/rule/Rule.ts

@@ -11,2 +11,3 @@ import {
   fieldName?: string;
+  useFieldName?: boolean;
   initialTypeTestType?: string;
@@ -24,3 +25,3 @@ }
   constructor(opts: RuleOptions = defaultRuleOptions) {
-    this.opts = opts;
+    this.opts = { ...defaultRuleOptions, ...opts };
     this.testRunner = new RuleTestRunner<T>({ ...opts } as RuleTestRunnerOptions);
@@ -47,6 +48,7 @@ }
     const fieldName = this.getFieldNameOrEmpty();
+    const init = this.opts.useFieldName ? fieldName : '';
     if (this.resultIsError(validationRuleResult)) {
       return {
-        title: `${fieldName}${this.internalTitle || validationRuleResult.title}`,
-        description: `${fieldName}${this.internalDescription || validationRuleResult.description}`,
+        title: init + (this.internalTitle || validationRuleResult.title),
+        description: init + (this.internalDescription || validationRuleResult.description),
       };
@@ -53,0 +55,0 @@ } else {

lib/schema/Schema.spec.ts

 import { expect } from 'chai';
 import 'mocha';
 import { StringRule } from '../rule/StringRule';
+import { emptyData, emptyFail, truthyTest } from '../test_helpers/rule';
+import { Validation, ValidationError } from '../types/Validation';
 import { Schema } from './Schema';
@@ -18,2 +20,68 @@
 
+  describe('addSchemaField', () => {
+    it('should accept deep objects as arguments', () => {
+      const childSchema: Schema = new Schema()
+        .addField('child', (f) => f
+          .string()
+          .addRule((r) => r.title('title').description('description').maxLength(0)));
+      const parentSchema: Schema = new Schema().addSchemaField('parent', childSchema);
+
+      const expectedError: ValidationError = {
+        errors: [
+          {
+            title: 'title',
+            description: 'description',
+            fieldName: 'child',
+            parent: 'parent',
+          },
+        ],
+      };
+
+      const validation: Validation = parentSchema.run({ parent: { child: 'asdf' } });
+
+      expect(validation).to.deep.equal(expectedError);
+    });
+
+    it('should accept deeper objects as arguments', () => {
+      const schema1: Schema = new Schema()
+        .addField('internal', (f) => f
+          .string()
+          .addRule((r) => r.title('fail').description('fail').maxLength(0)),
+        );
+      const schema2: Schema = new Schema().addSchemaField('schema1', schema1);
+      const schema3: Schema = new Schema().addSchemaField('schema2', schema2);
+      const schema4: Schema = new Schema().addSchemaField('schema3', schema3);
+
+      const expectedError: ValidationError = {
+        errors: [
+          {
+            title: 'fail',
+            description: 'fail',
+            fieldName: 'internal',
+            parent: 'schema1',
+          },
+        ],
+      };
+
+      const data = {
+        schema3: {
+          schema2: {
+            schema1: {
+              internal: 'asdf',
+            },
+          },
+        },
+      };
+
+      expect(schema4.run(data)).to.deep.equal(expectedError);
+    });
+
+    it('should accept a function which is passed a new schema', () => {
+      const createSchema = () => new Schema()
+        .addSchemaField('name', (s) => s);
+
+      expect(createSchema).to.not.throw(Error);
+    });
+  });
+
   describe('run', () => {
@@ -20,0 +88,0 @@ it('should return errors for each failing test for each field', () => {

lib/schema/Schema.ts

 import { Field } from '../field/Field';
 import { FieldFactory } from '../field/FieldFactory';
 import { Rule } from '../rule/Rule';
-import { Validation, ValidationError, ValidationSuccess } from '../types/Validation';
+import { Validation, ValidationError } from '../types/Validation';
 import { ValidationRuleError } from '../types/ValidationRule';
-import { isError, isSuccess } from '../utils';
+import { isError } from '../utils';
 
@@ -15,3 +15,3 @@ export interface SchemaOptions {
   protected opts: SchemaOptions;
-  protected fields: Map<string, Field<any, Rule<any>>>;
+  protected fields: Map<string, Schema | Field<any, Rule<any>>>;
 
@@ -28,10 +28,6 @@ constructor(opts: SchemaOptions = defaultSchemaOptions) {
   ): this {
+    this.ensureFieldNameIsUnique(fieldName);
     if (typeof field === 'function') {
       return this.addField(fieldName, field(new FieldFactory({ ...this.opts, fieldName })));
     } else {
-      if (this.fields.has(fieldName)) {
-        throw new Error(
-          `Field ${fieldName} already exists in schema. Duplicate field names are disallowed.`,
-        );
-      }
       this.fields.set(fieldName, field);
@@ -42,2 +38,14 @@ return this;
 
+  public addSchemaField(fieldName: string, schema: Schema): this;
+  public addSchemaField(fieldName: string, schema: (sf: Schema) => Schema): this;
+  public addSchemaField(fieldName: string, schema: Schema | ((sf: Schema) => Schema)): this {
+    this.ensureFieldNameIsUnique(fieldName);
+    if (typeof schema === 'function') {
+      return this.addSchemaField(fieldName, schema(new Schema()));
+    } else {
+      this.fields.set(fieldName, schema);
+      return this;
+    }
+  }
+
   public run(obj: any): Validation {
@@ -49,14 +57,38 @@ function objHasResultPropAsFailure(o: { fieldName: string, testResult: Validation }):
 
+    function validateFieldOrSchema(field: Schema | Field<any, Rule<any>>, data: any): Validation {
+      if (isSchema(field)) {
+        return field.run(data);
+      } else {
+        return field.validate(data);
+      }
+    }
+
+    const fieldAndResultToIncludeFieldNameAndOptionallyParent:
+      (a: { fieldName: string, testResult: ValidationError }) => ValidationRuleError[] =
+      (asdf) => {
+        const { fieldName, testResult } = asdf;
+        if (isSchema(this.fields.get(fieldName))) {
+          return testResult.errors.map((error: ValidationRuleError) => ({
+            parent: fieldName,
+            ...error,
+          }));
+        } else {
+          return testResult.errors.map((error: ValidationRuleError) => ({
+            fieldName,
+            ...error,
+          }));
+        }
+      };
+
     const errors = Array
       .from(this.fields)
-      .map(([fieldName, field]) => ({ fieldName, testResult: field.validate(obj[fieldName]) }))
-      // .filter(({ result }) => !isSuccess(result))
+      .map(([fieldName, field]) => ({ fieldName, testResult: validateFieldOrSchema(field, obj[fieldName]) }))
       .filter(objHasResultPropAsFailure)
-      .map(({ fieldName, testResult }) =>
-        testResult.errors.map(({ title, description }) => ({
-          title,
-          description,
-          fieldName,
-        })),
-      )
+      .map(fieldAndResultToIncludeFieldNameAndOptionallyParent)
+      /*({ fieldName, testResult }) =>
+      testResult.errors.map((error: ValidationRuleError) => ({
+        fieldName,
+        ...error,
+      })),
+    )*/
       .reduce((t, e) => t.concat(e), []);
@@ -66,6 +98,18 @@
   }
+
+  private ensureFieldNameIsUnique(fieldName: string) {
+    if (this.fields.has(fieldName)) {
+      throw new Error(
+        `Field ${fieldName} already exists in schema. Duplicate field names are disallowed.`,
+      );
+    }
+  }
 }
 
+export function isSchema(s: Schema | Field<any, Rule<any>>): s is Schema {
+  return s instanceof Schema;
+}
+
 export function createValidationSchema(opts?: SchemaOptions): Schema {
   return new Schema(opts);
 }

lib/test_helpers/rule.ts

@@ -0,1 +1,2 @@
+import { createValidationField, createValidationRule } from '..';
 import { ValidationRuleError, ValidationRuleSuccess } from '../types/ValidationRule';
@@ -14,3 +15,6 @@
 
-export const truthyTest = () => true;
-export const falsyTest = () => false;
+export const truthyTest = (o: any) => true;
+export const falsyTest = (o: any) => false;
+
+export const truthyRule = createValidationRule().any().addTestFunction(truthyTest);
+export const falsyRule = createValidationRule().any().addTestFunction(falsyTest);

lib/types/ValidationRule.ts

@@ -5,2 +5,3 @@ export type ValidationRuleResult = ValidationRuleError | ValidationRuleSuccess;
   fieldName?: string;
+  parent?: string;
 }
@@ -7,0 +8,0 @@

lib/utils/index.ts

@@ -0,1 +1,2 @@
+import { Schema } from '..';
 import { Validation, ValidationError, ValidationSuccess } from '../types/Validation';
@@ -10,1 +11,36 @@
 }
+
+export interface MiddlewareOptions {
+  ignoredParamsInReturn: string[];
+}
+
+const defaultMiddlewareOptions: MiddlewareOptions = {
+  ignoredParamsInReturn: [],
+};
+
+function deleteMatchingAttributes(obj: any, attributes: string[]): any {
+  return Object.keys(obj)
+    .filter((prop) => !attributes.includes(prop))
+    .map((prop) => ({
+      p: prop,
+      d: typeof obj[prop] === 'object' ? deleteMatchingAttributes(obj[prop], attributes) : obj[prop],
+    }))
+    .reduce((o, {p, d}) => ({ ...o, [p]: d }), {});
+}
+
+export const middlewave =
+  (schema: Schema, options: MiddlewareOptions = defaultMiddlewareOptions) =>
+    (req: any, res: any, next: () => {}) => {
+      options = { ...defaultMiddlewareOptions, ...options };
+      if (req.body && req.body && req.body.data === 'object') {
+        const validation = schema.run(req.body.data);
+        if (isSuccess(validation)) {
+          next();
+        } else {
+          const { errors } = validation;
+          res.status(422).json({
+            status: 'failure',
+          });
+        }
+      }
+};

package.json

 {
   "name": "mev",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Another validator..",
@@ -8,3 +8,3 @@ "main": "dist/index.js",
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist/* && tsc",
     "lint": "tslint --project .",
@@ -11,0 +11,0 @@ "test": "mocha --require ts-node/register --reporter spec 'lib/**/*.spec.ts'"

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

288631

increased by5.52%

Lines of code

3421

increased by8.71%

No dependency changes