@cleverbrush/schema 0.0.3 → 0.0.6

package/README.md

@@ -23,7 +23,7 @@ Any schema defined by object can contain the following fields:
 -   `type` - schema type (see the list above)
 -   `isRequired` - defines if `undefined` value is considered valid
 -   `isNullable` - defines if `null` value is considered valid
--   `validators` - optional array of custom validation functions (see [Examples](#examples))
+-   `validators` - optional array of custom validation functions (see Examples section at the bottom of this page)
 
 ### Number
 
@@ -274,6 +274,6 @@ There is a possibility to register a schema, give it a name and then reuse it:
 
     // { valid: true }
 
-## Examples {#examples}
+## Examples
 
 For Examples see unit tests in the schemaValidator.tests.ts

package/dist/index.d.ts

@@ -66,8 +66,8 @@ export interface ISchemasProvider<T = Record<string, never>> {
     };
 }
 export interface ISchemaValidator<T = Record<string, never>> {
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
-        [key in keyof K]: L;
+    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
+        [key in keyof K]: typeof schema;
     }>;
     validate(schema: keyof T | DefaultSchemaType | Schema<any>, obj: any): Promise<ValidationResult>;
 }

package/dist/schemaValidator.d.ts

@@ -2,7 +2,7 @@ import { ISchemasProvider, Schema, ISchemaActions, ObjectSchemaDefinitionParam,
 export default class SchemaValidator<T = Record<string, never>> implements ISchemasProvider<T>, ISchemaValidator<T> {
     private _schemasMap;
     private _schemasCache;
-    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L): SchemaValidator<T & {
+    addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(name: keyof K, schema: L | Array<Schema<any>>): SchemaValidator<T & {
         [key in keyof K]: L;
     }>;
     get schemas(): {

package/dist/schemaValidator.js

@@ -40,13 +40,18 @@ class SchemaValidator {
     addSchemaType(name, schema) {
         if (typeof name !== 'string' || !name)
             throw new Error('Name is required');
-        if (typeof schema !== 'object')
-            throw new Error('Object is required');
         if (isDefaultType(name.toString()))
             throw new Error(`You can't add a schema named "${name}" because it's a name of a default schema, please consider another name to be used`);
         if (this._schemasMap.has(name.toString())) {
             throw new Error(`Schema "${name}" already exists`);
         }
+        if (Array.isArray(schema)) {
+            this._schemasMap.set(name.toString(), schema);
+            this._schemasCache = null;
+            return this;
+        }
+        if (typeof schema !== 'object')
+            throw new Error('Array or Object is required');
         this._schemasMap.set(name.toString(), {
             ...schema,
             type: 'object'

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.3",
+    "version": "0.0.6",
     "keywords": [
         "object schema validator",
         "schema",
@@ -9,12 +9,17 @@
     "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
     "license": "BSD",
     "main": "./dist/index.js",
+    "readme": "https://github.com/cleverbrush/libs/tree/master/libs/schema#readme",
+    "repository": {
+        "type": "git",
+        "url": "github:cleverbrush/libs"
+    },
     "scripts": {
         "watch": "tsc --watch",
         "build": "tsc"
     },
     "dependencies": {
-        "@cleverbrush/deep": "0.0.3"
+        "@cleverbrush/deep": "0.0.6"
     },
     "types": "./dist/index.d.ts"
 }

package/src/index.ts

@@ -124,8 +124,8 @@ export interface ISchemasProvider<T = Record<string, never>> {
 export interface ISchemaValidator<T = Record<string, never>> {
     addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
         name: keyof K,
-        schema: L
-    ): SchemaValidator<T & { [key in keyof K]: L }>;
+        schema: L | Array<Schema<any>>
+    ): SchemaValidator<T & { [key in keyof K]: typeof schema }>;
 
     validate(
         schema: keyof T | DefaultSchemaType | Schema<any>,

package/src/schemaValidator.test.ts

@@ -97,39 +97,39 @@ test('Schemas property is updated after adding a new schema', () => {
 });
 
 test('Trows when trying to add a schema with name = "number"', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() => validator.addSchemaType('number', {})).toThrow();
 });
 
 test('Trows when trying to add a schema with name = "array"', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() => validator.addSchemaType('array', {})).toThrow();
 });
 
 test('Trows when trying to add a schema with name = "date"', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() => validator.addSchemaType('date', {})).toThrow();
 });
 
 test('Trows when trying to add a schema with name = "string"', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() => validator.addSchemaType('string', {})).toThrow();
 });
 
 test('Throws if schema name is empty', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() => validator.addSchemaType('', {})).toThrow();
 });
 
 test('Throws if schema name is not a string', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() =>
         validator.addSchemaType(new Date() as any as string, {})
     ).toThrow();
 });
 
 test('Throws if schema is not an object', () => {
-    let validator = new SchemaValidator();
+    const validator = new SchemaValidator();
     expect(() =>
         validator.addSchemaType(
             'string',
@@ -138,6 +138,33 @@ test('Throws if schema is not an object', () => {
     ).toThrow();
 });
 
+test('Array as schema type', async () => {
+    const validator = new SchemaValidator()
+        .addSchemaType('name', {
+            properties: {
+                name: 'string'
+            }
+        })
+        .addSchemaType('number_or_string', ['number', 'string', 'name']);
+
+    let result = await validator.schemas.number_or_string.validate(123);
+
+    expect(result).toHaveProperty('valid', true);
+
+    result = await validator.schemas.number_or_string.validate('some string');
+
+    expect(result).toHaveProperty('valid', true);
+
+    result = await validator.schemas.number_or_string.validate({});
+
+    expect(result).toHaveProperty('valid', false);
+
+    result = await validator.schemas.number_or_string.validate({
+        name: 'some name'
+    });
+    expect(result).toHaveProperty('valid', true);
+});
+
 test('Validate - no schema', async () => {
     const validator = new SchemaValidator();
     const cth = jest.fn();
@@ -741,7 +768,7 @@ test('Validate - array - ofType - 1', async () => {
 });
 
 test('Validate - object - 1', async () => {
-    let validator = new SchemaValidator().addSchemaType(
+    const validator = new SchemaValidator().addSchemaType(
         'user',
         getUserSchema()
     );
@@ -824,7 +851,7 @@ test('Validate - object - 1', async () => {
 });
 
 test('Validate - object - 2', async () => {
-    let validator = new SchemaValidator().addSchemaType(
+    const validator = new SchemaValidator().addSchemaType(
         'user',
         deepExtend(getUserSchema(), {
             validators: [
@@ -853,7 +880,7 @@ test('Validate - object - 2', async () => {
         aliases: []
     };
 
-    let result = await validator.validate('user', user);
+    const result = await validator.validate('user', user);
     expect(result).toHaveProperty('valid', false);
 });
 

package/src/schemaValidator.ts

@@ -73,11 +73,11 @@ export default class SchemaValidator<T = Record<string, never>>
 
     public addSchemaType<K, L extends ObjectSchemaDefinitionParam<M>, M = any>(
         name: keyof K,
-        schema: L
+        schema: L | Array<Schema<any>>
     ): SchemaValidator<T & { [key in keyof K]: L }> {
         if (typeof name !== 'string' || !name)
             throw new Error('Name is required');
-        if (typeof schema !== 'object') throw new Error('Object is required');
+
         if (isDefaultType(name.toString()))
             throw new Error(
                 `You can't add a schema named "${name}" because it's a name of a default schema, please consider another name to be used`
@@ -86,6 +86,14 @@ export default class SchemaValidator<T = Record<string, never>>
             throw new Error(`Schema "${name}" already exists`);
         }
 
+        if (Array.isArray(schema)) {
+            this._schemasMap.set(name.toString(), schema as Schema<any>);
+            this._schemasCache = null;
+            return this as any as SchemaValidator<T & { [key in keyof K]: L }>;
+        }
+
+        if (typeof schema !== 'object')
+            throw new Error('Array or Object is required');
         this._schemasMap.set(name.toString(), {
             ...schema,
             type: 'object'