@orion-js/schema 3.0.0-alpha.11 → 3.0.0

package/lib/clean/cleanType.d.ts

@@ -1,3 +1,3 @@
-import { CurrentNodeInfo, SchemaMetaFieldType, SchemaNode, SchemaNodeType } from '../types/schema';
+import { CurrentNodeInfo, SchemaMetaFieldType, SchemaNode } from '../types/schema';
 import { FieldValidatorType } from '../types/fieldValidators';
-export default function cleanType<T extends SchemaNodeType>(type: SchemaMetaFieldType<T> | FieldValidatorType, fieldSchema: Partial<SchemaNode<T>>, value: T, info: CurrentNodeInfo<any>, ...args: any[]): Promise<T>;
+export default function cleanType(type: SchemaMetaFieldType | FieldValidatorType, fieldSchema: Partial<SchemaNode>, value: any, info: CurrentNodeInfo, ...args: any[]): Promise<any>;

package/lib/clean/cleanType.js

@@ -13,7 +13,7 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
     }
     const { clean: rootFieldClean } = await (0, getFieldType_1.default)(type);
     if (rootFieldClean && !(0, isNil_1.default)(value)) {
-        value = (await rootFieldClean(value, info, ...args));
+        value = await rootFieldClean(value, info, ...args);
     }
     let needReClean = false;
     const objectTypeSchema = (0, getObjectNode_1.default)(fieldSchema, value);
@@ -42,7 +42,7 @@ async function cleanType(type, fieldSchema, value, info, ...args) {
         value = await clean(value, info, ...args);
     }
     if (needReClean && rootFieldClean && !(0, isNil_1.default)(value)) {
-        value = (await rootFieldClean(value, info, ...args));
+        value = await rootFieldClean(value, info, ...args);
     }
     return value;
 }

package/lib/clean/getObjectNode.d.ts

@@ -1,2 +1,2 @@
-import { SchemaNode, SchemaNodeType } from '../types/schema';
-export default function getObjectNode<T extends SchemaNodeType>(schema: Partial<SchemaNode<T>>, value: T | T[]): SchemaNode<object> | void;
+import { SchemaNode } from '../types/schema';
+export default function getObjectNode(schema: Partial<SchemaNode>, value: any): SchemaNode | void;

package/lib/clean/index.test.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("../types/schema");
 const index_1 = __importDefault(require("./index"));
 test('autoconverts values', async () => {
     const schema = {
@@ -125,12 +124,12 @@ test('filter fields not in schema', async () => {
 });
 test('runs autovalues with arrays', async () => {
     const schema = {
-        texts: (0, schema_1.asSchemaNode)({
+        texts: {
             type: [String],
             autoValue(values) {
                 return values.map(val => val + ' world');
             }
-        })
+        }
     };
     const doc = {
         texts: ['hello', 'good bye']
@@ -313,22 +312,22 @@ test('pass currentDoc cleaning arrays', async () => {
     const aItem = { name: 'Nicolás' };
     const doc = { items: [aItem] };
     const item = {
-        name: (0, schema_1.asSchemaNode)({
+        name: {
             type: String,
             async autoValue(name, { currentDoc }) {
                 expect(currentDoc).toBe(aItem);
                 return name;
             }
-        })
+        }
     };
     const schema = {
-        items: (0, schema_1.asSchemaNode)({
+        items: {
             type: [item],
             async autoValue(items, { currentDoc }) {
                 expect(currentDoc).toBe(doc);
                 return items;
             }
-        })
+        }
     };
     expect.assertions(2);
     await (0, index_1.default)(schema, doc);
@@ -339,7 +338,9 @@ test('omit undefined items in array', async () => {
         name: {
             type: String
         },
-        __clean() { }
+        __clean() {
+            return undefined;
+        }
     };
     const schema = {
         items: {

package/lib/clean/recursiveClean.d.ts

@@ -1,3 +1,3 @@
-import { CurrentNodeInfo, SchemaNodeType } from '../types/schema';
-declare const clean: <T extends SchemaNodeType>(info: CurrentNodeInfo<T, any>) => Promise<T>;
+import { CurrentNodeInfo } from '../types/schema';
+declare const clean: (info: CurrentNodeInfo) => Promise<any>;
 export default clean;

package/lib/cleanKey.test.js

@@ -104,7 +104,6 @@ test('should inject doc on cleanKey', async () => {
         data: {
             type: String,
             clean(value, { doc }) {
-                console.log(value, doc);
                 expect(doc).toEqual(item);
                 return value;
             }

package/lib/fieldType.d.ts

@@ -1,13 +1,13 @@
-import { CleanFunction, SchemaNodeType, ValidateFunction } from './types/schema';
-export interface FieldTypeOpts<T extends SchemaNodeType> {
+import { CleanFunction, ValidateFunction } from './types/schema';
+export interface FieldTypeOpts {
     name: string;
-    validate?: ValidateFunction<T>;
-    clean?: CleanFunction<T>;
+    validate?: ValidateFunction;
+    clean?: CleanFunction;
 }
-export interface FieldType<T extends SchemaNodeType> {
+export interface FieldType {
     name: string;
-    validate: ValidateFunction<T>;
-    clean: CleanFunction<T>;
+    validate: ValidateFunction;
+    clean: CleanFunction;
     _isFieldType: boolean;
 }
-export default function fieldType<T extends SchemaNodeType>(opts: FieldTypeOpts<T>): FieldType<T>;
+export default function fieldType(opts: FieldTypeOpts): FieldType;

package/lib/fieldTypes/ID.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<string>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/array.d.ts

@@ -1,3 +1,2 @@
-import { SchemaNodeType } from '../types/schema';
-declare const _default: import("../fieldType").FieldType<SchemaNodeType>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/blackbox.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<import("..").SchemaNodeType>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/boolean.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<import("..").SchemaNodeType>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/date.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<import("..").SchemaNodeType>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/email.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<string>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/index.d.ts

@@ -1,13 +1,13 @@
 declare const _default: {
-    array: import("../fieldType").FieldType<import("..").SchemaNodeType>;
-    plainObject: import("../fieldType").FieldType<object>;
-    string: import("../fieldType").FieldType<string>;
-    date: import("../fieldType").FieldType<import("..").SchemaNodeType>;
-    integer: import("../fieldType").FieldType<number>;
-    number: import("../fieldType").FieldType<number>;
-    ID: import("../fieldType").FieldType<string>;
-    boolean: import("../fieldType").FieldType<import("..").SchemaNodeType>;
-    email: import("../fieldType").FieldType<string>;
-    blackbox: import("../fieldType").FieldType<import("..").SchemaNodeType>;
+    array: import("../fieldType").FieldType;
+    plainObject: import("../fieldType").FieldType;
+    string: import("../fieldType").FieldType;
+    date: import("../fieldType").FieldType;
+    integer: import("../fieldType").FieldType;
+    number: import("../fieldType").FieldType;
+    ID: import("../fieldType").FieldType;
+    boolean: import("../fieldType").FieldType;
+    email: import("../fieldType").FieldType;
+    blackbox: import("../fieldType").FieldType;
 };
 export default _default;

package/lib/fieldTypes/integer.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<number>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/number.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<number>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/plainObject.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<object>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/fieldTypes/string.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../fieldType").FieldType<string>;
+declare const _default: import("../fieldType").FieldType;
 export default _default;

package/lib/getValidationErrors/doValidation.d.ts

@@ -1,2 +1,2 @@
-import { CurrentNodeInfo, SchemaNodeType } from '../types/schema';
-export default function doValidation<T extends SchemaNodeType>(params: CurrentNodeInfo<T>): Promise<void>;
+import { CurrentNodeInfo } from '../types/schema';
+export default function doValidation(params: CurrentNodeInfo): Promise<void>;

package/lib/getValidationErrors/doValidation.js

@@ -24,8 +24,9 @@ async function doValidation(params) {
      * Deep validation
      */
     if ((0, isPlainObject_1.default)(currentSchema.type)) {
-        if (typeof currentSchema.type?.__skipChildValidation === 'function') {
-            if (await currentSchema.type?.__skipChildValidation(value, info)) {
+        const type = currentSchema.type;
+        if (typeof type?.__skipChildValidation === 'function') {
+            if (await type?.__skipChildValidation(value, info)) {
                 return;
             }
         }
@@ -56,7 +57,7 @@ async function doValidation(params) {
         for (let i = 0; i < value.length; i++) {
             const itemValue = value[i];
             const keyItemKeys = (0, clone_1.default)(keys);
-            keyItemKeys.push(i);
+            keyItemKeys.push(i.toString());
             await doValidation({
                 ...info,
                 currentDoc: value,

package/lib/getValidationErrors/getError/getFieldType.d.ts

@@ -1,4 +1,4 @@
-import { SchemaMetaFieldType, SchemaNodeType } from '../../types/schema';
+import { SchemaMetaFieldType } from '../../types/schema';
 import { FieldValidatorType } from '../../types/fieldValidators';
 import { FieldType } from '../../fieldType';
-export default function getFieldType<T extends SchemaNodeType>(type: SchemaMetaFieldType<T> | FieldValidatorType | any): FieldType<T>;
+export default function getFieldType(type: SchemaMetaFieldType | FieldValidatorType | any): FieldType;

package/lib/getValidationErrors/getError/index.d.ts

@@ -1,2 +1,2 @@
-import { CurrentNodeInfo, SchemaNodeType } from '../../types/schema';
-export default function getValidationErrors<T extends SchemaNodeType>(params: CurrentNodeInfo<T>): Promise<object | string | void>;
+import { CurrentNodeInfo } from '../../types/schema';
+export default function getValidationErrors(params: CurrentNodeInfo): Promise<object | string | void>;

package/lib/getValidationErrors/getError/index.js

@@ -32,8 +32,9 @@ async function getValidationErrors(params) {
             return customError;
         }
     }
-    if (currentSchema.type.__validate) {
-        const typeError = await currentSchema.type.__validate(value, info, ...args);
+    const type = currentSchema.type;
+    if (type.__validate) {
+        const typeError = await type.__validate(value, info, ...args);
         if (typeError) {
             return typeError;
         }

package/lib/getValidationErrors/index.d.ts

@@ -1,2 +1,2 @@
-import { Schema, SchemaNodeType } from '../types/schema';
-export default function getValidationErrors<T extends SchemaNodeType>(schema: Schema, doc: T, passedOptions?: {}, ...args: any[]): Promise<any>;
+import { Schema } from '../types/schema';
+export default function getValidationErrors(schema: Schema, doc: any, passedOptions?: {}, ...args: any[]): Promise<any>;

package/lib/isValid.d.ts

@@ -1,2 +1,2 @@
-import { Schema, SchemaNodeType } from './types/schema';
-export default function isValid<T extends SchemaNodeType>(schema: Schema, doc: T, passedOptions?: {}, ...args: any[]): Promise<boolean>;
+import { Schema } from './types/schema';
+export default function isValid(schema: Schema, doc: any, passedOptions?: {}, ...args: any[]): Promise<boolean>;

package/lib/types/schema.d.ts

@@ -1,47 +1,40 @@
+import { FieldType } from '../fieldType';
 export declare type Constructor<T> = new (...args: any[]) => T;
-export declare type SpecialSchemaString = 'ID' | 'email' | 'string';
-export declare type SpecialSchemaNumber = 'integer' | 'number';
-export declare type SpecialSchemaObject = 'blackbox';
+export declare type FieldTypesList = 'string' | 'date' | 'integer' | 'number' | 'ID' | 'boolean' | 'email' | 'blackbox';
+export declare type ConstructorsTypesList = Constructor<String> | Constructor<Number> | Constructor<Boolean> | Constructor<Date>;
 export declare type SchemaRecursiveNodeTypeExtras = {
-    __clean?: CleanFunction<any>;
-    __validate?: ValidateFunction<any>;
+    __clean?: CleanFunction;
+    __validate?: ValidateFunction;
+    __skipChildValidation?: (value: any, info: CurrentNodeInfo) => Promise<boolean>;
 };
-export declare type SchemaRecursiveType = {
-    [key: string]: SchemaNode<SchemaNodeType> | Function;
-};
-export declare type SchemaRecursiveNodeType = SchemaRecursiveType & SchemaRecursiveNodeTypeExtras;
-export declare type SchemaNodeType = string | Date | number | boolean | object | SchemaNodeArrayType;
-export declare type SchemaNodeArrayType = Array<string> | Array<Date> | Array<number> | Array<boolean> | Array<object>;
-/**
- * Converts the SchemaNodeType to its abstraction.
- * E.g. if the Node has type string, it will return the String constructor.
- */
-export declare type StringAllowedTypeValues = SpecialSchemaString | Constructor<String>;
-export declare type NumberAllowedTypeValues = SpecialSchemaNumber | Constructor<Number>;
-export declare type ObjectAllowedTypeValues = SpecialSchemaObject | SchemaRecursiveNodeType;
-export declare type SchemaMetaFieldType<T> = T extends string ? StringAllowedTypeValues : T extends number ? NumberAllowedTypeValues : T extends boolean ? Constructor<Boolean> : T extends Date ? Constructor<Date> : T extends Array<infer U> ? Array<SchemaMetaFieldType<U>> : T extends object ? ObjectAllowedTypeValues : T;
-export declare type ValidateFunction<T extends SchemaNodeType> = (value: T, info?: Partial<CurrentNodeInfo<T>>, ...args: any[]) => object | string | void | Promise<object | string | void>;
-export declare type CleanFunction<T extends SchemaNodeType> = (value: T, info?: Partial<CurrentNodeInfo<T>>, ...args: any[]) => T | Promise<T>;
-export interface SchemaNode<T extends SchemaNodeType> {
+export interface Schema {
+    [key: string]: SchemaNode | Function;
+}
+export declare type SchemaRecursiveNodeType = Schema & SchemaRecursiveNodeTypeExtras;
+export declare type SchemaMetaFieldTypeSingle = FieldTypesList | ConstructorsTypesList | SchemaRecursiveNodeType | FieldType;
+export declare type SchemaMetaFieldType = SchemaMetaFieldTypeSingle | [SchemaMetaFieldTypeSingle];
+export declare type ValidateFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => object | string | void | Promise<object | string | void>;
+export declare type CleanFunction = (value: any, info?: Partial<CurrentNodeInfo>, ...args: any[]) => any | Promise<any>;
+export interface SchemaNode {
     /**
      * The type of the field. Used for type validations. Can also contain a subschema.
      */
-    type: SchemaMetaFieldType<T>;
+    type: SchemaMetaFieldType;
     /**
      * Defaults to false
      */
     optional?: boolean;
-    allowedValues?: Array<T>;
-    defaultValue?: T | ((info: CurrentNodeInfo<T>, ...args: any[]) => T | Promise<T>);
+    allowedValues?: Array<any>;
+    defaultValue?: ((info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>) | any;
     /**
      * Function that takes a value and returns an error message if there are any errors. Must return null or undefined otherwise.
      */
-    validate?: ValidateFunction<T>;
+    validate?: ValidateFunction;
     /**
      * Function that preprocesses a value before it is set.
      */
-    clean?: CleanFunction<T>;
-    autoValue?: (value: T, info: CurrentNodeInfo<T>, ...args: any[]) => T | Promise<T>;
+    clean?: CleanFunction;
+    autoValue?: (value: any, info: CurrentNodeInfo, ...args: any[]) => any | Promise<any>;
     /**
      * The minimum value if it's a number, the minimum length if it's a string or array.
      */
@@ -55,15 +48,22 @@ export interface SchemaNode<T extends SchemaNodeType> {
      */
     isBlackboxChild?: boolean;
     /**
-     * Deprecated
+     * @deprecated
+     */
+    custom?: ValidateFunction;
+    /**
+     * Used in GraphQL. If true, the field will be omitted from the schema.
+     */
+    private?: boolean;
+    /**
+     * Used in GraphQL. When in GraphQL, this resolver will replace the static field.
+     */
+    graphQLResolver?: (...args: any) => any;
+    /**
+     * Used in GraphQL. Sets the key of the field in the GraphQL schema. You must set this value when building your schema.
      */
-    custom?: ValidateFunction<T>;
+    key?: string;
 }
-/**
- * It's the same as defining the object directly, but works better with TypeScript for type inference.
- */
-export declare const asSchemaNode: <T extends SchemaNodeType>(schemaNode: SchemaNode<T>) => SchemaNode<T>;
-export declare type Schema = SchemaRecursiveType;
 export interface CurrentNodeInfoOptions {
     autoConvert?: boolean;
     filter?: boolean;
@@ -72,22 +72,22 @@ export interface CurrentNodeInfoOptions {
     forceDoc?: any;
     omitRequired?: boolean;
 }
-export interface CurrentNodeInfo<T extends SchemaNodeType, S extends SchemaNodeType = any> {
+export interface CurrentNodeInfo {
     /**
      * The global schema, prefaced by {type: {...}} to be compatible with subschemas
      * Sometimes it's given without {type: {...}}. TODO: Normalize this.
      */
-    schema?: SchemaNode<T> | Schema;
+    schema?: SchemaNode | Schema;
     /**
      * The current node subschema
      */
-    currentSchema?: Partial<SchemaNode<S>>;
-    value: T;
-    doc?: T;
-    currentDoc?: T;
+    currentSchema?: Partial<SchemaNode>;
+    value: any;
+    doc?: any;
+    currentDoc?: any;
     options?: CurrentNodeInfoOptions;
     args?: any[];
-    type?: SchemaMetaFieldType<T>;
+    type?: SchemaMetaFieldType;
     keys?: string[];
     addError?: (keys: string[], code: string | object) => void;
 }

package/lib/types/schema.js

@@ -1,8 +1,3 @@
 "use strict";
+/* eslint-disable @typescript-eslint/ban-types */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.asSchemaNode = void 0;
-/**
- * It's the same as defining the object directly, but works better with TypeScript for type inference.
- */
-const asSchemaNode = (schemaNode) => schemaNode;
-exports.asSchemaNode = asSchemaNode;

package/lib/types/types.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/types.test.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+test('check ts types for schema', async () => {
+    const schema = {
+        numbers: {
+            type: [Number]
+        },
+        string: {
+            type: 'string',
+            optional: true,
+            private: true
+        }
+    };
+    const result = await (0, __1.clean)(schema, { numbers: ['2'], string: 1 });
+    expect(result).toEqual({ numbers: [2], string: '1' });
+});

package/lib/validate.d.ts

@@ -1,2 +1,2 @@
-import { Schema, SchemaNodeType } from './types/schema';
-export default function validate<T extends SchemaNodeType>(schema: Schema, doc: T, passedOptions?: {}, ...args: any[]): Promise<void>;
+import { Schema } from './types/schema';
+export default function validate(schema: Schema, doc: any, passedOptions?: {}, ...args: any[]): Promise<void>;

package/lib/validateKey/dotGetSchema.d.ts

@@ -1 +1,2 @@
-export default function (schema: any, path: any): any;
+import { Schema } from '..';
+export default function (schema: Schema, path: string): any;

package/lib/validateKey/dotGetSchema.js

@@ -9,7 +9,7 @@ const dotGet = function dotGet(object, path) {
     if (path === '')
         return object;
     const pathParts = path.split('.');
-    let first = pathParts.shift();
+    const first = pathParts.shift();
     const remainingPath = pathParts.join('.');
     const levelObject = object.type;
     if (first === '$' || /^[0-9]+$/.test(first)) {

package/lib/validateKey/dotGetSchema.test.js

@@ -7,6 +7,9 @@ const dotGetSchema_1 = __importDefault(require("./dotGetSchema"));
 const tag = {
     name: {
         type: String
+    },
+    other: {
+        type: 'string'
     }
 };
 const car = {

package/lib/validateKey/index.d.ts

@@ -1 +1,2 @@
-export default function (schema: any, key: any, value: any, passedOptions?: {}, ...args: any[]): Promise<any>;
+import { CurrentNodeInfoOptions, Schema } from '..';
+export default function (schema: Schema, key: string, value: any, passedOptions?: CurrentNodeInfoOptions, ...args: any[]): Promise<any>;

package/lib/validateKey/index.test.js

@@ -17,12 +17,12 @@ test('autoconvert value', async () => {
 test('deep validate fields', async () => {
     const tag = {
         name: {
-            type: String
+            type: 'string'
         }
     };
     const car = {
         brand: {
-            type: String
+            type: 'string'
         },
         tags: {
             type: [tag]
@@ -30,7 +30,7 @@ test('deep validate fields', async () => {
     };
     const schema = {
         name: {
-            type: String
+            type: 'string'
         },
         car: {
             type: car
@@ -80,6 +80,5 @@ test('validate blackbox child', async () => {
         _id: { type: 'ID' },
         services: { type: 'blackbox' }
     };
-    console.log('will validtea blackbox');
     expect(await (0, index_1.default)(schema, 'services.phoneVerification.tries', 1)).toBeNull();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/schema",
-  "version": "3.0.0-alpha.11",
+  "version": "3.0.0",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -10,8 +10,9 @@
   "license": "MIT",
   "scripts": {
     "prepare": "yarn run build",
-    "build": "tsc",
-    "watch": "tsc -w",
+    "clean": "rm -rf ./lib",
+    "build": "yarn run clean && tsc",
+    "watch": "yarn run clean && tsc -w",
     "test": "jest --config jest.config.js"
   },
   "dependencies": {
@@ -26,6 +27,7 @@
     "@babel/preset-env": "^7.5.5",
     "@types/eslint": "^7.28.2",
     "@types/jest": "27.0.2",
+    "@types/lodash": "4.14.176",
     "@types/node": "16.11.1",
     "@typescript-eslint/eslint-plugin": "5.1.0",
     "@typescript-eslint/parser": "5.1.0",
@@ -38,5 +40,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "7f7fb73a75f6f233c7a868ae0dda870fb70fe7c3"
+  "gitHead": "27bda585ffc16d92c70c958227605f3b61171c64"
 }