@cleverbrush/schema 0.0.5 → 0.0.8

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import SchemaValidator from './schemaValidator';
-export declare type DefaultSchemaType = 'object' | 'function' | 'number' | 'string' | 'array';
+export declare type DefaultSchemaType = 'object' | 'function' | 'number' | 'string' | 'array' | 'alias';
 export declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
 export declare type DefaultPropertyDefinition = {
     isRequired: boolean;
@@ -24,6 +24,10 @@ export declare type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'>
         [S in keyof T]: Schema<PropType<T, S>>;
     }>;
 };
+export declare type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
+    type: 'alias';
+    schemaName: string;
+};
 export declare type ObjectSchemaDefinitionParam<T> = Omit<ObjectSchemaDefinition<T>, 'type'>;
 export declare type ParamsValidators<TFunc extends (...args: any) => any> = {
     [S in keyof Parameters<TFunc>]: SingleSchema<Parameters<TFunc>[S]>;
@@ -53,7 +57,7 @@ export declare type ArraySchemaDefinition<TObj> = Omit<SchemaDefintion<TObj>, 't
     minLength?: number;
     maxLength?: number;
 };
-export declare type CompositeSchema<TObj> = TObj extends (...args: any) => any ? FunctionSchemaDefinition<TObj> : TObj extends number ? NumberSchemaDefinition<TObj> : TObj extends string ? StringSchemaDefinition<TObj> | 'string' : NumberSchemaDefinition<TObj> | StringSchemaDefinition<TObj> | ArraySchemaDefinition<TObj> | ObjectSchemaDefinition<TObj>;
+export declare type CompositeSchema<TObj> = TObj extends (...args: any) => any ? FunctionSchemaDefinition<TObj> : TObj extends number ? NumberSchemaDefinition<TObj> : TObj extends string ? StringSchemaDefinition<TObj> | 'string' : NumberSchemaDefinition<TObj> | StringSchemaDefinition<TObj> | ArraySchemaDefinition<TObj> | ObjectSchemaDefinition<TObj> | AliasSchemaDefinition<TObj>;
 export declare type SingleSchema<TObj = Record<string, never>> = number | string | DefaultSchemaType | CompositeSchema<TObj>;
 export declare type Schema<TObj> = SingleSchema<TObj> | Array<SingleSchema<TObj>>;
 export interface ISchemaActions<K, T extends keyof K> {
@@ -66,8 +70,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'
@@ -90,6 +95,11 @@ class SchemaValidator {
         throw new Error('not implemented');
     }
     async checkValidators(schema, value) {
+        if (!schema.isRequired && typeof value === 'undefined') {
+            return {
+                valid: true
+            };
+        }
         if (Array.isArray(schema.validators)) {
             const validatorsResults = await Promise.allSettled(schema.validators.map((v) => Promise.resolve(v(value))));
             const rejections = validatorsResults
@@ -123,6 +133,10 @@ class SchemaValidator {
                 return await this.validateDefaultType(schema, obj);
             }
             else if (typeof this.schemas[schema] !== 'undefined') {
+                if (Array.isArray(this.schemas[schema].schema)) {
+                    return this.validate(this.schemas[schema]
+                        .schema, obj);
+                }
                 const objSchema = (0, deep_1.deepExtend)(defaultSchemas.object, this.schemas[schema].schema);
                 const res = await (0, validateObject_1.validateObject)(obj, objSchema, this);
                 if (!res.valid)
@@ -157,6 +171,19 @@ class SchemaValidator {
             if (isDefaultType(schema.type)) {
                 return await this.validateDefaultType(schema.type, obj, schema);
             }
+            else if (schema.type === 'alias') {
+                const alias = this.schemas[schema.schemaName]
+                    .schema;
+                if (Array.isArray(alias))
+                    throw new Error('it is impossible to use alternative schema alias as "type" field');
+                if (typeof alias !== 'object')
+                    throw new Error('it is only possible to use a full schema schema definition as alias');
+                const schemaToMerge = { ...schema };
+                delete schemaToMerge.type;
+                delete schemaToMerge.schemaName;
+                const finalSchema = (0, deep_1.deepExtend)(alias, schemaToMerge);
+                return await this.validate(finalSchema, obj);
+            }
             else if (schema.type === 'object') {
                 const preliminaryResult = await (0, validateObject_1.validateObject)(obj, schema, this);
                 if (!preliminaryResult.valid)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cleverbrush/schema",
-    "version": "0.0.5",
+    "version": "0.0.8",
     "keywords": [
         "object schema validator",
         "schema",
@@ -19,7 +19,7 @@
         "build": "tsc"
     },
     "dependencies": {
-        "@cleverbrush/deep": "0.0.5"
+        "@cleverbrush/deep": "0.0.8"
     },
     "types": "./dist/index.d.ts"
 }

package/src/index.ts

@@ -5,7 +5,8 @@ export type DefaultSchemaType =
     | 'function'
     | 'number'
     | 'string'
-    | 'array';
+    | 'array'
+    | 'alias';
 
 export type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
 
@@ -40,6 +41,11 @@ export type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
     }>;
 };
 
+export type AliasSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
+    type: 'alias';
+    schemaName: string;
+};
+
 export type ObjectSchemaDefinitionParam<T> = Omit<
     ObjectSchemaDefinition<T>,
     'type'
@@ -100,7 +106,8 @@ export type CompositeSchema<TObj> = TObj extends (...args: any) => any
           | NumberSchemaDefinition<TObj>
           | StringSchemaDefinition<TObj>
           | ArraySchemaDefinition<TObj>
-          | ObjectSchemaDefinition<TObj>;
+          | ObjectSchemaDefinition<TObj>
+          | AliasSchemaDefinition<TObj>;
 
 export type SingleSchema<TObj = Record<string, never>> =
     | number
@@ -124,8 +131,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);
 });
 
@@ -885,3 +912,243 @@ test('Validate - one of - 1', async () => {
     );
     expect(result).toHaveProperty('valid', true);
 });
+
+test('Validate schema - 1', async () => {
+    const authorsReportSpecificationSchema = {
+        properties: {
+            type: {
+                type: 'string',
+                equals: 'author'
+            },
+            start: 'Date',
+            end: 'Date',
+            selectionStart: 'Date',
+            selectionEnd: 'Date',
+            granularity: ['day', 'week', 'month'],
+            metrics: {
+                type: 'array',
+                ofType: [
+                    'articlesPublished',
+                    'searchReferrers',
+                    'socialReferrers',
+                    'views',
+                    'visitors',
+                    'newVisitors'
+                ]
+            },
+            filters: {
+                type: 'object',
+                properties: {
+                    author: 'AuthorFilter'
+                    // publication: 'PublicationFilter',
+                    // article: 'ArticleFilter'
+                }
+            }
+        },
+        validators: [
+            (value) =>
+                value.start <= value.end &&
+                value.selectionStart <= value.selectionEnd &&
+                value.selectionStart >= value.start &&
+                value.selectionStart <= value.end &&
+                value.selectionEnd >= value.start &&
+                value.selectionEnd <= value.end
+                    ? {
+                          valid: true
+                      }
+                    : {
+                          valid: false,
+                          errors: [
+                              'selectionStart <=> selectionEnd should be inside the start <=> end interval'
+                          ]
+                      }
+        ]
+    };
+
+    const validator = new SchemaValidator()
+        .addSchemaType('Date', {
+            validators: [
+                (value) =>
+                    value instanceof Date && !Number.isNaN(value)
+                        ? {
+                              valid: true
+                          }
+                        : {
+                              valid: false,
+                              errors: ['should be a valid Date object']
+                          }
+            ]
+        })
+        .addSchemaType('EqualsFilterCondition', {
+            properties: {
+                operation: {
+                    type: 'string',
+                    equals: 'equals'
+                },
+                value: ['object', 'string', 'number']
+            }
+        })
+        .addSchemaType('GreaterThanFilterCondition', {
+            properties: {
+                operation: {
+                    type: 'string',
+                    equals: 'greater_than'
+                },
+                value: 'number'
+            }
+        })
+        .addSchemaType('LessThanFilterCondition', {
+            properties: {
+                operation: {
+                    type: 'string',
+                    equals: 'less_than'
+                },
+                value: 'number'
+            }
+        })
+        .addSchemaType('ContainsFilterCondition', {
+            properties: {
+                operation: {
+                    type: 'string',
+                    equals: 'contains'
+                },
+                value: [
+                    'string',
+                    'number',
+                    {
+                        type: 'array',
+                        ofType: ['string', 'number']
+                    }
+                ]
+            }
+        })
+        .addSchemaType('LikeFilterCondition', {
+            properties: {
+                operation: 'like',
+                value: 'string'
+            }
+        })
+        .addSchemaType('BetweenFilterCondition', {
+            properties: {
+                operation: 'between',
+                from: 'number',
+                to: 'number'
+            },
+            validators: [
+                (value) =>
+                    value.from <= value.to
+                        ? { valid: true }
+                        : { valid: false, error: ['from must be <= to'] }
+            ]
+        })
+        .addSchemaType('StringFilterCondition', [
+            'EqualsFilterCondition',
+            'LikeFilterCondition'
+        ])
+        .addSchemaType('AuthorFilter', {
+            properties: {
+                fullName: 'StringFilterCondition'
+            }
+        })
+        .addSchemaType(
+            'AuthorsReportSpecification',
+            authorsReportSpecificationSchema as ObjectSchemaDefinitionParam<any>
+        );
+
+    /**
+     * @type {import('smg-iq/editorial-analytics.reports').AuthorsReportSpecification}
+     */
+    let reportSpec = {
+        type: 'author',
+        start: new Date(2021, 0, 1),
+        end: new Date(),
+        selectionStart: new Date(2022, 0, 1),
+        selectionEnd: new Date(2022, 2, 1),
+        granularity: 'day',
+        metrics: [
+            'articlesPublished',
+            'searchReferrers',
+            'socialReferrers',
+            'views',
+            'visitors',
+            'newVisitors'
+        ],
+        filters: {
+            author: {
+                fullName: {
+                    operation: 'between',
+                    value: 'some name'
+                }
+            }
+        }
+    };
+
+    let result = await validator.schemas.AuthorsReportSpecification.validate(
+        reportSpec
+    );
+
+    expect(result).toHaveProperty('valid', false);
+
+    reportSpec = {
+        type: 'author',
+        start: new Date(2021, 0, 1),
+        end: new Date(),
+        selectionStart: new Date(2022, 0, 1),
+        selectionEnd: new Date(2022, 2, 1),
+        granularity: 'day',
+        metrics: [
+            'articlesPublished',
+            'searchReferrers',
+            'socialReferrers',
+            'views',
+            'visitors',
+            'newVisitors'
+        ],
+        filters: {
+            author: {
+                fullName: {
+                    operation: 'equals',
+                    value: 'some name'
+                }
+            }
+        }
+    };
+
+    result = await validator.schemas.AuthorsReportSpecification.validate(
+        reportSpec
+    );
+
+    expect(result).toHaveProperty('valid', true);
+});
+
+test('Validate schema - 2', async () => {
+    const validator = new SchemaValidator().addSchemaType('Date', {
+        validators: [
+            (value) =>
+                value instanceof Date && !Number.isNaN(value)
+                    ? {
+                          valid: true
+                      }
+                    : {
+                          valid: false,
+                          errors: ['should be a valid Date object']
+                      }
+        ]
+    });
+
+    const result = await validator.validate(
+        {
+            type: 'object',
+            properties: {
+                date: {
+                    type: 'alias',
+                    schemaName: 'Date',
+                    isRequired: false
+                }
+            }
+        },
+        {}
+    );
+
+    expect(result).toHaveProperty('valid', true);
+});

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'
@@ -148,6 +156,11 @@ export default class SchemaValidator<T = Record<string, never>>
         schema: CompositeSchema<Record<string, never>>,
         value: any
     ): Promise<ValidationResult> {
+        if (!schema.isRequired && typeof value === 'undefined') {
+            return {
+                valid: true
+            };
+        }
         if (Array.isArray(schema.validators)) {
             const validatorsResults = await Promise.allSettled(
                 schema.validators.map((v) => Promise.resolve(v(value)))
@@ -194,6 +207,13 @@ export default class SchemaValidator<T = Record<string, never>>
                     obj
                 );
             } else if (typeof this.schemas[schema as keyof T] !== 'undefined') {
+                if (Array.isArray(this.schemas[schema as keyof T].schema)) {
+                    return this.validate(
+                        this.schemas[schema as keyof T]
+                            .schema as any as Schema<any>,
+                        obj
+                    );
+                }
                 const objSchema = deepExtend(
                     defaultSchemas.object,
                     this.schemas[schema as keyof T].schema
@@ -236,6 +256,26 @@ export default class SchemaValidator<T = Record<string, never>>
                     obj,
                     schema
                 );
+            } else if (schema.type === 'alias') {
+                const alias = this.schemas[schema.schemaName]
+                    .schema as Schema<any>;
+                if (Array.isArray(alias))
+                    throw new Error(
+                        'it is impossible to use alternative schema alias as "type" field'
+                    );
+                if (typeof alias !== 'object')
+                    throw new Error(
+                        'it is only possible to use a full schema schema definition as alias'
+                    );
+
+                const schemaToMerge = { ...schema };
+                delete schemaToMerge.type;
+                delete schemaToMerge.schemaName;
+                const finalSchema: Schema<any> = deepExtend(
+                    alias,
+                    schemaToMerge
+                );
+                return await this.validate(finalSchema, obj);
             } else if (schema.type === 'object') {
                 const preliminaryResult = await validateObject(
                     obj,