feat: more types + strip fix + extend fix

juneil · juneil · commit 7023032fe051 · 2018-10-04T10:30:16.000+02:00
diff --git a/README.md b/README.md
@@ -37,16 +37,23 @@ user2.isValid() // false
 
 ### Static methods
 
-- `schema(ModeEnum): Joi.Schema`
+- `schema(ModeEnum | EntityOptions): Joi.Schema`
     - Build and return the schema for a mode
 
 ### Instance methods
 
-- `schema(ModeEnum): Joi.Schema`
+- `schema(ModeEnum | EntityOptions): Joi.Schema`
     - Build and return the schema for a mode
 - `isValid(ModeEnum): boolean`
     - Based on the schema, valid the instance
 
+### EntityOptions
+
+`strict?: boolean` - Default: `true` - Used in the constructor of the entity to throw an error if validation failed
+`mode?: ModeEnum` - Default: `ModeEnum.READ` - Schema mode
+`array?: boolean` - Default: `false` - Build the schema as a list of the Entity
+`unknown?: boolean` - Default: `true` - Allow unknown keys in the payload
+
 ### Decorators
 
 #### Type
@@ -157,7 +164,14 @@ Works with types: `String | Array | Buffer | TypeEnum`
 @Description(string)
 ```
 
-Add description metadata to the property
+#### Regex
+
+```javascript
+@Regex(pattern)
+```
+
+Add regex validation for a string
+Works with type: `String`
 
 ### TypeEnum
 
@@ -167,6 +181,8 @@ Add description metadata to the property
 - `Entity.Type.Base64`: String in base64 format
 - `Entity.Type.IsoDate`: String in iso date format
 - `Entity.Type.URI`: String URI format
+- `Entity.Type.Email`: String Email format
+- `Entity.Type.Timestamp`: Date timestamp format
 
 ### ModeEnum
 
diff --git a/src/lib/decorators.ts b/src/lib/decorators.ts
@@ -156,6 +156,16 @@ export function ObjectPattern(pattern: RegExp, schema: PropertyType): DecoratorF
     return insertRule({ key: decorators.KEY_OBJECT_PATTERN, value: { pattern, schema }});
 }
 
+/**
+ * Decorator @Regex()
+ *
+ * @param  {RegExp} pattern
+ * @returns DecoratorFunc
+ */
+export function Regex(pattern: RegExp): DecoratorFunc {
+    return insertRule({ key: decorators.KEY_REGEX, value: pattern });
+}
+
 /**
  * Insert a new rule of a property
  * in the metadata of the Entity
diff --git a/src/lib/entity.ts b/src/lib/entity.ts
@@ -6,10 +6,12 @@ import { JoiTransformer } from '../transformers/joi.transformer';
 export interface EntityOptions {
     strict?: boolean;
     mode?: ModeEnum;
+    array?: boolean;
+    unknown?: boolean;
 }
 
 export interface EntityTransformer<T> {
-    build: (source: PropertyMetadata[], mode: ModeEnum, more?: T, parent?: BaseEntity) => T;
+    build: (source: PropertyMetadata[], opts: EntityOptions, more?: T, parent?: BaseEntity) => T;
     isValid: (value: BaseEntity, schema: T) => boolean;
     validate: (value: BaseEntity, schema: T) => { value: any, error: Error };
 }
@@ -36,13 +38,18 @@ export class BaseEntity {
      * @param  {ModeEnum=ModeEnum.READ} mode
      * @returns T
      */
-    static schema<T>(mode: ModeEnum = ModeEnum.READ): T {
+    static schema<T>(opts?: ModeEnum | EntityOptions): T {
+        if (Object.values(ModeEnum).includes(opts)) {
+            opts = <EntityOptions>{ mode: opts };
+        } else if (!opts) {
+            opts = <EntityOptions>{ mode: ModeEnum.READ };
+        }
         if (!(this.transformers && this.transformers.length > 0)) {
             return;
         }
         return this
             .transformers[0]
-            .build(Reflect.getMetadata(KEY_PROPS, this), mode, this.more(), this.parent);
+            .build(Reflect.getMetadata(KEY_PROPS, this), <EntityOptions>opts, this.more(), this.parent);
     }
 
     /**
@@ -65,17 +72,17 @@ export class BaseEntity {
     constructor(payload = {}, options?: EntityOptions) {
         options = options || { strict: true, mode: ModeEnum.READ };
         payload = payload || {};
+        options.unknown = false;
         const result = this
             .constructor
             ['transformers'][0]
-            .validate(payload, this.constructor['schema'](options.mode));
+            .validate(payload, this.constructor['schema'](options));
         if (options.strict !== false && !!result.error) {
             throw result.error;
         }
         []
-            .concat(Reflect.getOwnMetadata(KEY_PROPS, this.constructor))
-            .filter(_ => !!_)
-            .forEach((_: PropertyMetadata) => Reflect.set(this, _.property, result.value[_.property] || undefined))
+            .concat(Object.keys(result.value))
+            .forEach((_: string) => Reflect.set(this, _, result.value[_] || undefined))
     }
 
     /**
@@ -96,8 +103,8 @@ export class BaseEntity {
      *
      * @param  {ModeEnum} mode
      */
-    schema<T>(mode?: ModeEnum): T {
-        return this.constructor['schema'](mode);
+    schema<T>(opts?: ModeEnum | EntityOptions): T {
+        return this.constructor['schema'](opts);
     }
 }
 
@@ -120,9 +127,12 @@ export const Entity = EntityTo(JoiTransformer);
 
 export function EntityExtends(parent: any) {
     const _p = Reflect.construct(parent, [{}, { strict: false }]);
+    if (!(_p instanceof BaseEntity)) {
+        throw new Error('You need to extends another Entity');
+    }
     return class extends BaseEntity {
         static transformers = [new JoiTransformer()];
-        static parent = (_p instanceof BaseEntity) ? parent : undefined;
+        static parent = parent;
         static more() {};
     }
 }
diff --git a/src/lib/enums.ts b/src/lib/enums.ts
@@ -12,5 +12,7 @@ export enum TypeEnum {
     IsoDate         = <any>Symbol('type_isodate'),
     Integer         = <any>Symbol('type_integer'),
     IP              = <any>Symbol('type_ip'),
-    URI             = <any>Symbol('type_uri')
+    URI             = <any>Symbol('type_uri'),
+    Email           = <any>Symbol('type_email'),
+    Timestamp       = <any>Symbol('type_timestamp')
 }
diff --git a/src/lib/symbols.ts b/src/lib/symbols.ts
@@ -37,5 +37,8 @@ export const decorators = {
     KEY_LENGTH      : Symbol('key_length'),
 
     // Key of @ObjectPattern()
-    KEY_OBJECT_PATTERN  : Symbol('key_object_pattern')
+    KEY_OBJECT_PATTERN  : Symbol('key_object_pattern'),
+
+    // Key of @Regex()
+    KEY_REGEX       : Symbol('key_regex')
 }
diff --git a/src/transformers/joi.transformer.ts b/src/transformers/joi.transformer.ts
@@ -1,7 +1,7 @@
 import * as Joi from 'joi';
 import { PropertyMetadata, PropertyRule } from '../lib/decorators';
 import { ModeEnum, TypeEnum } from '../lib/enums';
-import { BaseEntity, EntityRef, EntityTransformer } from '../lib/entity';
+import { BaseEntity, EntityRef, EntityTransformer, EntityOptions } from '../lib/entity';
 import { decorators } from '../lib/symbols';
 
 interface PropertySchema {
@@ -12,14 +12,21 @@ interface PropertySchema {
 
 export { ObjectSchema as SchemaType } from 'joi';
 
-export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
+export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema | Joi.ArraySchema> {
 
     private objectIdRegex = /^[0-9a-fA-F]{24}$/;
 
-    build(source: PropertyMetadata[], mode: ModeEnum, more: Joi.ObjectSchema = Joi.object(), parent?: BaseEntity): Joi.ObjectSchema {
-        return !source ? undefined : more.concat(
-            this.reduceSchema(source.map(_ => this.propertyHandler(_, mode)), !!parent ? parent.schema(mode) : undefined)
+    build(source: PropertyMetadata[], opts: EntityOptions, more: Joi.ObjectSchema = Joi.object(),
+            parent?: BaseEntity): Joi.ObjectSchema | Joi.ArraySchema {
+        opts.unknown = opts.unknown === undefined || opts.unknown === null ? true : opts.unknown;
+        const result = !source ? undefined : more.concat(
+            this.reduceSchema(source.map(_ => this.propertyHandler(_, opts.mode, opts.unknown)),
+                opts.unknown, !!parent ? parent.schema(opts) : undefined)
         );
+        if (!!opts.array) {
+            return Joi.array().items(result);
+        }
+        return result;
     }
 
     isValid(data: BaseEntity, schema: Joi.ObjectSchema): boolean {
@@ -43,9 +50,9 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
      * @param  {PropertySchema[]} source
      * @returns Joi.ObjectSchema
      */
-    private reduceSchema(source: PropertySchema[], parent?: Joi.ObjectSchema): Joi.ObjectSchema {
+    private reduceSchema(source: PropertySchema[], unknown: boolean, parent?: Joi.ObjectSchema): Joi.ObjectSchema {
         const _s = !!parent ? parent : Joi.object();
-        return _s.keys(
+        const res = _s.keys(
             source
                 .map(_ => ({
                     property: _.property,
@@ -55,7 +62,8 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
                     acc[cur.property] = cur.schema;
                     return acc;
                 }, {})
-        ).unknown();
+        );
+        return !!unknown ? res.unknown() : res;
     }
 
     /**
@@ -67,19 +75,19 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
      * @param  {ModeEnum} mode
      * @returns PropertySchema
      */
-    private propertyHandler(source: PropertyMetadata, mode: ModeEnum): PropertySchema {
+    private propertyHandler(source: PropertyMetadata, mode: ModeEnum, unknown: boolean): PropertySchema {
         const base = source
             .rules
             .filter(_ => _.key === decorators.KEY_TYPE || _.key === decorators.KEY_ARRAY || _.key === decorators.KEY_OBJECT_PATTERN)
-            .map(_ => this.ruleHandler(_, mode))
+            .map(_ => this.ruleHandler(_, mode, unknown))
             .shift() || Joi.any();
         return {
             property: source.property,
             base,
             schemas: source
                 .rules
                 .filter(_ => (_.key !== decorators.KEY_TYPE && _.key !== decorators.KEY_ARRAY && _.key !== decorators.KEY_OBJECT_PATTERN))
-                .map(_ => this.ruleHandler(_, mode, base))
+                .map(_ => this.ruleHandler(_, mode, unknown, base))
                 .filter(_ => !!_)
         }
     }
@@ -94,12 +102,12 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
      * @param  {Joi.Schema} base
      * @returns Joi.Schema
      */
-    private ruleHandler(rule: PropertyRule, mode: ModeEnum, base?: Joi.Schema): Joi.Schema {
+    private ruleHandler(rule: PropertyRule, mode: ModeEnum, unknown: boolean, base?: Joi.Schema): Joi.Schema {
         switch (rule.key) {
             case decorators.KEY_TYPE:
-                return this.typeMapper(rule, mode);
+                return this.typeMapper(rule, mode, unknown);
             case decorators.KEY_ARRAY:
-                return Joi.array().items(this.typeMapper(rule, mode));
+                return Joi.array().items(this.typeMapper(rule, mode, unknown));
             case decorators.KEY_REQUIRED:
                 return this.requireMapper(rule, mode);
             case decorators.KEY_STRIP:
@@ -119,7 +127,9 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
             case decorators.KEY_LENGTH:
                 return this.lengthMapper(rule, base);
             case decorators.KEY_OBJECT_PATTERN:
-                return this.objectPatternMapper(rule);
+                return this.objectPatternMapper(rule, unknown);
+            case decorators.KEY_REGEX:
+                return this.regexMapper(rule);
             /* istanbul ignore next */
             default:
                 return Joi.any();
@@ -132,7 +142,7 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
      * @param  {PropertyRule} rule
      * @returns Joi.Schema
      */
-    private typeMapper(rule: PropertyRule, mode: ModeEnum): Joi.Schema {
+    private typeMapper(rule: PropertyRule, mode: ModeEnum, unknown: boolean): Joi.Schema {
         switch (rule.value) {
             case String:
                 return Joi.string();
@@ -141,7 +151,7 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
             case Boolean:
                 return Joi.boolean();
             case Object:
-                return Joi.object().unknown();
+                return unknown ? Joi.object().unknown() : Joi.object();
             case Buffer:
                 return Joi.binary();
             case Date:
@@ -160,6 +170,10 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
                 return Joi.string().ip();
             case TypeEnum.URI:
                 return Joi.string().uri();
+            case TypeEnum.Email:
+                return Joi.string().email();
+            case TypeEnum.Timestamp:
+                return Joi.date().timestamp();
             /* istanbul ignore next */
             default:
                 if (typeof rule.value === 'function' && new rule.value(null, { strict: false }) instanceof BaseEntity) {
@@ -317,13 +331,28 @@ export class JoiTransformer implements EntityTransformer<Joi.ObjectSchema> {
      * @param  {PropertyRule} rule
      * @returns Joi.Schema
      */
-    private objectPatternMapper(rule: PropertyRule): Joi.Schema {
+    private objectPatternMapper(rule: PropertyRule, unknown: boolean): Joi.Schema {
         if (!rule.value.schema) {
             throw new Error('Wrong schema provided');
         } else if (rule.value.schema instanceof BaseEntity) {
             return Joi.object().pattern(rule.value.pattern, rule.value.schema.schema());
         } else {
-            return Joi.object().pattern(rule.value.pattern, this.typeMapper({ key: null, value: rule.value.schema }, ModeEnum.READ));
+            return Joi.object().pattern(rule.value.pattern,
+                this.typeMapper({ key: null, value: rule.value.schema }, ModeEnum.READ, unknown));
+        }
+    }
+
+    /**
+     * Regex mapping
+     *
+     * @param  {PropertyRule} rule
+     * @returns Joi.Schema
+     */
+    private regexMapper(rule: PropertyRule): Joi.Schema {
+        if (!(rule.value instanceof RegExp)) {
+            throw new Error('Wrong regex provided');
+        } else {
+            return Joi.string().regex(rule.value);
         }
     }
 }
diff --git a/test/unit/entity.test.ts b/test/unit/entity.test.ts
@@ -65,13 +65,13 @@ export class SuiteEntity {
             name: string;
         }
 
-        const instance = new MyTest();
+        const instance = new MyTest(null, { strict: false });
 
         unit
             .object(instance)
-            .isInstanceOf(BaseEntity)
-            .hasProperty('id', undefined)
-            .hasProperty('name', undefined)
+            .isInstanceOf(BaseEntity);
+        unit.value(instance.id).is(undefined);
+        unit.value(instance.name).is(undefined);
 
     }
 
diff --git a/test/unit/extends.test.ts b/test/unit/extends.test.ts
diff --git a/test/unit/joi.transformer.test.ts b/test/unit/joi.transformer.test.ts

Original file line number	Diff line number	Diff line change
`@@ -12,5 +12,7 @@ export enum TypeEnum {`
`12`	`12`	`IsoDate = <any>Symbol('type_isodate'),`
`13`	`13`	`Integer = <any>Symbol('type_integer'),`
`14`	`14`	`IP = <any>Symbol('type_ip'),`
`15`		`- URI = <any>Symbol('type_uri')`
	`15`	`+ URI = <any>Symbol('type_uri'),`
	`16`	`+ Email = <any>Symbol('type_email'),`
	`17`	`+ Timestamp = <any>Symbol('type_timestamp')`
`16`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,5 +37,8 @@ export const decorators = {`
`37`	`37`	`KEY_LENGTH : Symbol('key_length'),`
`38`	`38`
`39`	`39`	`// Key of @ObjectPattern()`
`40`		`- KEY_OBJECT_PATTERN : Symbol('key_object_pattern')`
	`40`	`+ KEY_OBJECT_PATTERN : Symbol('key_object_pattern'),`
	`41`	`+`
	`42`	`+ // Key of @Regex()`
	`43`	`+ KEY_REGEX : Symbol('key_regex')`
`41`	`44`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,13 +65,13 @@ export class SuiteEntity {`
`65`	`65`	`name: string;`
`66`	`66`	`}`
`67`	`67`
`68`		`- const instance = new MyTest();`
	`68`	`+ const instance = new MyTest(null, { strict: false });`
`69`	`69`
`70`	`70`	`unit`
`71`	`71`	`.object(instance)`
`72`		`- .isInstanceOf(BaseEntity)`
`73`		`- .hasProperty('id', undefined)`
`74`		`- .hasProperty('name', undefined)`
	`72`	`+ .isInstanceOf(BaseEntity);`
	`73`	`+ unit.value(instance.id).is(undefined);`
	`74`	`+ unit.value(instance.name).is(undefined);`
`75`	`75`
`76`	`76`	`}`
`77`	`77`