@cleverbrush/schema 0.0.17 → 1.0.0-beta.0

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/dist/builders/AliasSchemaBuilder.d.ts

@@ -0,0 +1,14 @@
+import { ISchemaBuilder } from './SchemaBuilder.js';
+import { InferType } from '../schema.js';
+import { ISchemaRegistry } from '../index.js';
+export interface IAliasSchemaBuilder<TSchemaName extends keyof TAliases, TRequired extends boolean = true, TNullable extends boolean = false, TAliases extends Record<string, any> = never, TAliasesCompiledType = any, TExternalRegistryKeys extends Record<string, any> = {}> extends ISchemaBuilder<TRequired, TNullable> {
+    readonly type: 'alias';
+    schemaName: TSchemaName;
+    externalRegistry: ISchemaRegistry<TExternalRegistryKeys>;
+    optional(): IAliasSchemaBuilder<TSchemaName, false, TNullable, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
+    required(): IAliasSchemaBuilder<TSchemaName, true, TNullable, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
+    nullable(): IAliasSchemaBuilder<TSchemaName, TRequired, true, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
+    notNullable(): IAliasSchemaBuilder<TSchemaName, TRequired, false, TAliases, TAliasesCompiledType, TExternalRegistryKeys>;
+}
+export declare const alias: <TSchemaName extends keyof TAliases, TAliases extends Record<string, any>, TAliasesCompiledType = InferType<TAliases[TSchemaName]>>(schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, TAliases, TAliasesCompiledType, {}>;
+export declare const externalAlias: <TSchemaName extends keyof TAliases, TAliases extends Record<string, any>, TExternalSchemaRegistry extends ISchemaRegistry<TAliases>, TAliasesCompiledType = InferType<TAliases[TSchemaName]>>(registry: TExternalSchemaRegistry, schemaName: TSchemaName) => IAliasSchemaBuilder<TSchemaName, true, false, TAliases, TAliasesCompiledType, {}>;

package/dist/builders/AliasSchemaBuilder.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.externalAlias = exports.alias = void 0;
+const SchemaBuilder_js_1 = require("./SchemaBuilder.js");
+const defaultSchemas_js_1 = require("../defaultSchemas.js");
+class AliasSchemaBuilder extends SchemaBuilder_js_1.SchemaBuilder {
+    clone() {
+        return AliasSchemaBuilder.create(this._schema);
+    }
+    get _schema() {
+        return Object.assign({
+            type: this.type,
+            schemaName: this.schemaName,
+            externalRegistry: this.externalRegistry
+        }, this.getCommonSchema());
+    }
+    static create(obj) {
+        return new AliasSchemaBuilder(obj);
+    }
+    schemaName;
+    externalRegistry;
+    constructor(obj) {
+        super(obj);
+        if (typeof obj === 'object' && obj) {
+            if (typeof obj.schemaName === 'string') {
+                this.schemaName = obj.schemaName;
+            }
+            if (typeof obj.externalRegistry === 'object' &&
+                obj.externalRegistry) {
+                this.externalRegistry = obj.externalRegistry;
+            }
+        }
+        else {
+            const defaultSchema = defaultSchemas_js_1.defaultSchemas['alias'];
+            this.isRequired = defaultSchema.isRequired;
+            this.isNullable = defaultSchema.isNullable;
+        }
+    }
+    get type() {
+        return 'alias';
+    }
+    optional() {
+        if (this.isRequired === false) {
+            return this;
+        }
+        return AliasSchemaBuilder.create({
+            ...this._schema,
+            isRequired: false
+        });
+    }
+    required() {
+        if (this.isRequired === true) {
+            return this;
+        }
+        return AliasSchemaBuilder.create({
+            ...this._schema,
+            isRequired: true
+        });
+    }
+    nullable() {
+        if (this._isNullable === true) {
+            return this;
+        }
+        return AliasSchemaBuilder.create({
+            ...this._schema,
+            isNullable: true
+        });
+    }
+    notNullable() {
+        if (this.isNullable === false) {
+            return this;
+        }
+        return AliasSchemaBuilder.create({
+            ...this._schema,
+            isNullable: false
+        });
+    }
+}
+const alias = (schemaName) => AliasSchemaBuilder.create({
+    schemaName,
+    isRequired: true,
+    isNullable: false
+});
+exports.alias = alias;
+const externalAlias = (registry, schemaName) => AliasSchemaBuilder.create({
+    schemaName,
+    isRequired: true,
+    isNullable: false,
+    externalRegistry: registry
+});
+exports.externalAlias = externalAlias;

package/dist/builders/ArraySchemaBuilder.d.ts

@@ -0,0 +1,15 @@
+import { ISchemaBuilder } from './SchemaBuilder.js';
+import { Schema } from '../schema.js';
+export interface IArraySchemaBuilder<TRequired extends boolean = true, TNullable extends boolean = false, TOfType extends Schema | undefined = undefined, TMaxLength extends number | undefined = undefined, TMinLength extends number | undefined = undefined> extends ISchemaBuilder<TRequired, TNullable> {
+    optional(): IArraySchemaBuilder<false, TNullable, TOfType, TMaxLength, TMinLength>;
+    required(): IArraySchemaBuilder<true, TNullable, TOfType, TMaxLength, TMinLength>;
+    ofType<T extends Schema>(schema: T): IArraySchemaBuilder<TRequired, TNullable, T, TMaxLength, TMinLength>;
+    nullable(): IArraySchemaBuilder<TRequired, true, TOfType, TMaxLength, TMinLength>;
+    notNullable(): IArraySchemaBuilder<TRequired, false, TOfType, TMaxLength, TMinLength>;
+    clearOfType(): IArraySchemaBuilder<TRequired, TNullable, undefined, TMaxLength, TMinLength>;
+    maxLength<T extends number>(length: T): IArraySchemaBuilder<TRequired, TNullable, TOfType, T, TMinLength>;
+    clearMaxLength(): IArraySchemaBuilder<TRequired, TNullable, TOfType, undefined, TMinLength>;
+    minLength<T extends number>(length: T): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, T>;
+    clearMinLength(): IArraySchemaBuilder<TRequired, TNullable, TOfType, TMaxLength, TMinLength>;
+}
+export declare const array: () => IArraySchemaBuilder<true, false, undefined, undefined, undefined>;