@cleverbrush/schema 0.0.3

package/dist/validators/validateObject.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateObject = void 0;
+const validateObject = async (obj, schema, validator) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'object') {
+        return {
+            valid: false,
+            errors: [
+                `expected to have type='object', but saw '${typeof obj}' instead`
+            ]
+        };
+    }
+    if (typeof schema.properties === 'object' && schema.properties) {
+        const errors = (await Promise.all(Object.entries(schema.properties).map(async ([name, schema]) => {
+            const result = await validator.validate(schema, obj[name]);
+            if (result.valid)
+                return result;
+            return {
+                valid: false,
+                errors: (result.errors || []).map((e) => `->${name} ${e}`)
+            };
+        })))
+            .filter((r) => !r.valid)
+            .map((r) => r.errors)
+            .flat(Infinity);
+        if (errors.length) {
+            return {
+                valid: false,
+                errors
+            };
+        }
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateObject = validateObject;

package/dist/validators/validateString.d.ts

@@ -0,0 +1,2 @@
+import { ValidationResult, StringSchemaDefinition, ISchemaValidator } from '../index';
+export declare const validateString: (obj: any, schema: StringSchemaDefinition<any>, validator: ISchemaValidator<any>) => Promise<ValidationResult>;

package/dist/validators/validateString.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateString = void 0;
+const validateString = async (obj, schema, validator) => {
+    if (typeof obj === 'undefined' &&
+        typeof schema === 'object' &&
+        schema.isRequired === false) {
+        return {
+            valid: true
+        };
+    }
+    if (typeof obj !== 'string')
+        return {
+            valid: false,
+            errors: [`expected type string, but saw ${typeof obj}`]
+        };
+    if (typeof schema === 'string') {
+        return obj === schema
+            ? { valid: true }
+            : {
+                valid: false,
+                errors: [`should be equal to ${schema}`]
+            };
+    }
+    const str = obj;
+    if (typeof schema.equals === 'string' && str !== schema.equals) {
+        return {
+            valid: false,
+            errors: [
+                `expected to be equal to '${schema.equals}' but saw '${str}'`
+            ]
+        };
+    }
+    if (typeof schema.minLength === 'number' && str.length < schema.minLength) {
+        return {
+            valid: false,
+            errors: [`expected to be at least ${schema.minLength} chars long`]
+        };
+    }
+    if (typeof schema.maxLength === 'number' && str.length > schema.maxLength) {
+        return {
+            valid: false,
+            errors: [`expected to be at most ${schema.maxLength} chars long`]
+        };
+    }
+    return {
+        valid: true
+    };
+};
+exports.validateString = validateString;

package/package.json

@@ -0,0 +1,20 @@
+{
+    "name": "@cleverbrush/schema",
+    "version": "0.0.3",
+    "keywords": [
+        "object schema validator",
+        "schema",
+        "validate object"
+    ],
+    "author": "Andrew Zolotukhin <andrew_zol@cleverbrush.com>",
+    "license": "BSD",
+    "main": "./dist/index.js",
+    "scripts": {
+        "watch": "tsc --watch",
+        "build": "tsc"
+    },
+    "dependencies": {
+        "@cleverbrush/deep": "0.0.3"
+    },
+    "types": "./dist/index.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,137 @@
+import SchemaValidator from './schemaValidator';
+
+export type DefaultSchemaType =
+    | 'object'
+    | 'function'
+    | 'number'
+    | 'string'
+    | 'array';
+
+export type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
+
+export type DefaultPropertyDefinition = {
+    isRequired: boolean;
+    isNullable: boolean;
+};
+
+export type ValidationResultRaw = {
+    valid: boolean;
+    errors?: Array<string>;
+};
+
+export type ValidationResult =
+    | ValidationResultRaw
+    | Promise<ValidationResultRaw>;
+
+export type Validator<TObj> = (value: TObj) => ValidationResult;
+
+export type SchemaDefintion<TObj> = {
+    type: DefaultSchemaType;
+    isRequired?: boolean;
+    isNullable?: boolean;
+    validators?: Array<Validator<TObj>>;
+};
+
+export type ObjectSchemaDefinition<T> = Omit<SchemaDefintion<T>, 'type'> & {
+    type: 'object';
+    extends?: string;
+    properties?: Partial<{
+        [S in keyof T]: Schema<PropType<T, S>>;
+    }>;
+};
+
+export type ObjectSchemaDefinitionParam<T> = Omit<
+    ObjectSchemaDefinition<T>,
+    'type'
+>;
+
+export type ParamsValidators<TFunc extends (...args: any) => any> = {
+    [S in keyof Parameters<TFunc>]: SingleSchema<Parameters<TFunc>[S]>;
+};
+
+export type FunctionSchemaDefinition<T extends (...args: any) => any> = Omit<
+    SchemaDefintion<T>,
+    'type'
+> & {
+    type: 'function';
+    params?: ParamsValidators<T>;
+};
+
+export type NumberSchemaDefinition<TObj> = Omit<
+    SchemaDefintion<TObj>,
+    'type'
+> & {
+    type: 'number';
+    min?: number;
+    max?: number;
+    equals?: number;
+    isInteger?: boolean;
+    ensureNotNaN?: boolean;
+    ensureIsFinite?: boolean;
+};
+
+export type StringSchemaDefinition<TObj> = Omit<
+    SchemaDefintion<TObj>,
+    'type'
+> & {
+    type: 'string';
+    equals?: string;
+    minLength?: number;
+    maxLength?: number;
+};
+
+export type ArraySchemaDefinition<TObj> = Omit<
+    SchemaDefintion<TObj>,
+    'type'
+> & {
+    type: 'array';
+    ofType?: Schema<any>;
+    minLength?: number;
+    maxLength?: number;
+};
+
+export 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 type SingleSchema<TObj = Record<string, never>> =
+    | number
+    | string
+    | DefaultSchemaType
+    | CompositeSchema<TObj>;
+
+export type Schema<TObj> = SingleSchema<TObj> | Array<SingleSchema<TObj>>;
+
+export interface ISchemaActions<K, T extends keyof K> {
+    validate(value: any): Promise<ValidationResult>;
+    schema: PropType<K, T>;
+}
+
+export interface ISchemasProvider<T = Record<string, never>> {
+    schemas: {
+        [K in keyof T]: ISchemaActions<T, K>;
+    };
+}
+
+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 }>;
+
+    validate(
+        schema: keyof T | DefaultSchemaType | Schema<any>,
+        obj: any
+    ): Promise<ValidationResult>;
+}
+
+export { SchemaValidator };
+export default SchemaValidator;