@cleverbrush/schema 0.0.17 → 1.0.0-beta.1

package/README.md

@@ -29,19 +29,21 @@ Any schema defined by object can contain the following fields:
 
 `number` schema can be defined as follows:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-
-    // validates for integer number between 1 and 100
-    let result = await validator.validate(
-        {
-            type: "number",
-            isInteger: true,
-            min: 1,
-            max: 100,
-        },
-        10
-    );
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
+const validator = new SchemaValidator();
+
+// validates for integer number between 1 and 100
+let result = await validator.validate(
+    {
+        type: 'number',
+        isInteger: true,
+        min: 1,
+        max: 100
+    },
+    10
+);
+```
 
 All fields available (apart of common fields for all schemas) are:
 
@@ -54,43 +56,56 @@ All fields available (apart of common fields for all schemas) are:
 
 Also it can be defined either by shortcut:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate('number', 10);
-    // { valid: true }
-    result = await validator.validate('number', 'some string');
-    // { valid: false, errors: [ 'expected type number, but saw string' ] }
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
+
+const validator = new SchemaValidator();
+let result = await validator.validate('number', 10);
+// { valid: true }
+result = await validator.validate('number', 'some string');
+// { valid: false, errors: [ 'expected type number, but saw string' ] }
+```
 
 which is equal to:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate({
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
+
+const validator = new SchemaValidator();
+
+let result = await validator.validate(
+    {
         type: 'number',
         isRequired: true,
         isNullable: false,
         ensureNotNaN: true,
         ensureIsFinite: true
-    }, 0 / 0);
-    // { valid: false }
+    },
+    0 / 0
+);
+// { valid: false }
+```
 
 ### String
 
 `string` schema can be defined as follows:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
 
-    // validates for non empty string no longer than 100 chars
-    let result = await validator.validate(
-        {
-            type: "string",
-            minLength: 1,
-            maxLength: 100
-        },
-        "some value here"
-    );
-    // { valid: true }
+const validator = new SchemaValidator();
+
+// validates for non empty string no longer than 100 chars
+let result = await validator.validate(
+    {
+        type: 'string',
+        minLength: 1,
+        maxLength: 100
+    },
+    'some value here'
+);
+// { valid: true }
+```
 
 All fields available (apart of common fields for all schemas) are:
 
@@ -100,46 +115,59 @@ All fields available (apart of common fields for all schemas) are:
 
 Also it can be defined either by shortcut:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate('string', 'something');
-    // { valid: true }
-    result = await validator.validate('string', 10);
-    // { valid: false, errors: [ 'expected type string, but saw number' ] }
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
 
-which is equal to:
+const validator = new SchemaValidator();
+
+let result = await validator.validate('string', 'something');
+// { valid: true }
+result = await validator.validate('string', 10);
+// { valid: false, errors: [ 'expected type string, but saw number' ] }
+```
+
+or by detailed descriptor:
+
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate({
+const validator = new SchemaValidator();
+
+let result = await validator.validate(
+    {
         type: 'string',
         isNullable: false,
         isRequired: true
-    }, 1230);
-    // { valid: false }
+    },
+    1230
+);
+// { valid: false }
+```
 
 ### Array
 
 `array` schema can be defined as follows:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-
-    // validates for non empty string no longer than 100 chars
-    let result = await validator.validate(
-        {
-            type: "array",
-            minLength: 5,
-            maxLength: 10,
-            ofType: {
-                type: "number",
-                min: 1,
-                max: 10
-            }
-        },
-        [5, 6, 7, 8, 9]
-    );
-    // { valid: true }
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
+const validator = new SchemaValidator();
+
+// validates for non empty string no longer than 100 chars
+let result = await validator.validate(
+    {
+        type: 'array',
+        minLength: 5,
+        maxLength: 10,
+        ofType: {
+            type: 'number',
+            min: 1,
+            max: 10
+        }
+    },
+    [5, 6, 7, 8, 9]
+);
+// { valid: true }
+```
 
 All fields available (apart of common fields for all schemas) are:
 
@@ -149,60 +177,74 @@ All fields available (apart of common fields for all schemas) are:
 
 Also it can be defined either by shortcut:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate('array', []);
-    // { valid: true }
-    result = await validator.validate('array', 10);
-    // { valid: false, errors: [ 'expected array' ] }
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
 
-which is equal to:
+const validator = new SchemaValidator();
+
+let result = await validator.validate('array', []);
+// { valid: true }
+result = await validator.validate('array', 10);
+// { valid: false, errors: [ 'expected array' ] }
+```
+
+or by detailed descriptor:
 
-    import { SchemaValidator } from '@cleverbrush/schema';
-    const validator = new SchemaValidator();
-    let result = await validator.validate({
+```typescript
+import { SchemaValidator } from '@cleverbrush/schema';
+
+const validator = new SchemaValidator();
+
+let result = await validator.validate(
+    {
         type: 'array'
-    }, 1230);
-    // { valid: false, errors: [ 'expected array' ] }
+    },
+    1230
+);
+// { valid: false, errors: [ 'expected array' ] }
+```
 
 ### Object
 
 `object` type allows to define a complex object schema. For example:
 
-    await validator.validate(
-        {
-            type: "object",
-            properties: {
-                id: "number",
-                name: {
-                    type: "string",
-                    minLength: 1,
-                    maxLength: 100,
-                },
-                address: {
-                    type: "object",
-                    properties: {
-                        city: "string",
-                        street: {
-                            type: "string",
-                            isRequired: false,
-                        },
-                    },
-                },
+```typescript
+await validator.validate(
+    {
+        type: 'object',
+        properties: {
+            id: 'number',
+            name: {
+                type: 'string',
+                minLength: 1,
+                maxLength: 100
             },
-        },
-        {
-            id: 10,
-            name: "Andrew",
             address: {
-                city: "Madrid",
-            },
+                type: 'object',
+                properties: {
+                    city: 'string',
+                    street: {
+                        type: 'string',
+                        isRequired: false
+                    }
+                }
+            }
         }
-    );
-    // {valid: true}
+    },
+    {
+        id: 10,
+        name: 'Andrew',
+        address: {
+            city: 'Madrid'
+        }
+    }
+);
+// {valid: true}
+```
 
 All fields available are:
 
+-   `noUnknownProperties` - Validator will return an error if this field is set to `true` and validated objects contain fields not defined in the object schema. Equals to `false` by default.
 -   `properties` - the list of properties, every property has corresponding schema definition (see example above).
 
 ## Alternative schema
@@ -210,94 +252,102 @@ All fields available are:
 Everywhere you pass a `schema` object to the library, you may pass an array of `schema` objects which will validate the object to match at least one schema from this list.
 For example, if you want to check that array is consisting either from number or from `{ name: string, value: number }` objects, you can do the following:
 
-    await validator.validate(
-        {
-        type: "array",
+```typescript
+await validator.validate(
+    {
+        type: 'array',
         ofType: [
-            "number",
+            'number',
             {
-            type: "object",
-            properties: {
-                name: "string",
-                value: "number",
-            },
-            },
-        ],
-        },
-        [
+                type: 'object',
+                properties: {
+                    name: 'string',
+                    value: 'number'
+                }
+            }
+        ]
+    },
+    [
         10,
-        { name: "something", value: 1 },
+        { name: 'something', value: 1 },
         100,
-        { name: "another string", value: 1 },
-        ]
-    );
-    // {valid: true}
+        { name: 'another string', value: 1 }
+    ]
+);
+// {valid: true}
+```
 
 ## Named schemas
 
 There is a possibility to register a schema, give it a name and then reuse it:
 
-    const validator = new SchemaValidator().addSchemaType("Address", {
+```typescript
+const validator = new SchemaValidator().addSchemaType('Address', {
     properties: {
         id: {
-        type: "number",
-        min: 1,
+            type: 'number',
+            min: 1
         },
-        street: "string",
-        zip: "number",
-    },
-    });
-
-    await validator.validate(
-        {
-        type: "object",
+        street: 'string',
+        zip: 'number'
+    }
+});
+
+await validator.validate(
+    {
+        type: 'object',
         properties: {
-            name: "string",
-            address1: "Address",
-            address2: "Address",
-        },
-        },
-        {
-        name: "Andrew",
+            name: 'string',
+            address1: 'Address',
+            address2: 'Address'
+        }
+    },
+    {
+        name: 'Andrew',
         address1: {
             id: 1,
-            street: "some street",
-            zip: 12345,
+            street: 'some street',
+            zip: 12345
         },
         address2: {
             id: 2,
-            street: "some street 2",
-            zip: 3456,
-        },
+            street: 'some street 2',
+            zip: 3456
         }
-    );
+    }
+);
 
-    // { valid: true }
+// { valid: true }
+```
 
 Also there is a possibility to organize schemas in modules (or even submodules):
 
-    const validator = new SchemaValidator().addSchemaType("Module1.DTOs.Address", {
+```typescript
+const validator = new SchemaValidator()
+    .addSchemaType('Module1.DTOs.Address', {
         properties: {
             id: {
-            type: "number",
-            min: 1,
+                type: 'number',
+                min: 1
             },
-            street: "string",
-            zip: "number",
+            street: 'string',
+            zip: 'number'
         }
-    }).addSchemaType("Module1.Models.Person", {
+    })
+    .addSchemaType('Module1.Models.Person', {
         properties: {
-            firstName: "string",
-            lastName: "string"
-        },
+            firstName: 'string',
+            lastName: 'string'
+        }
     });
 
-    const resultPerson = await validator.schemas.Module1.Models.Person.validate({
-         fistName: 'John',
-         lastName: 'Smith'
-         });
+const resultPerson = await validator.schemas.Module1.Models.Person.validate({
+    fistName: 'John',
+    lastName: 'Smith'
+});
 
-    const resultAddress = await validator.schemas.Module1.DTOs.Address.validate({ });
+const resultAddress = await validator.schemas.Module1.DTOs.Address.validate({});
+```
 
 ## Examples
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.17",
+    "version": "1.0.0-beta.1",
     "keywords": [
         "object schema validator",
         "schema",
@@ -18,8 +18,8 @@
         "watch": "tsc --watch",
         "build": "tsc"
     },
-    "dependencies": {
-        "@cleverbrush/deep": "0.0.17"
+    "devDependencies": {
+        "@cleverbrush/deep": "1.0.0-beta.1"
     },
     "types": "./dist/index.d.ts"
 }