@orion-js/schema 3.0.32 → 3.1.1

package/lib/clean/index.d.ts

@@ -1,2 +1,2 @@
 import { CurrentNodeInfoOptions, Schema } from '../types/schema';
-export default function clean(schema: Schema, doc?: {}, opts?: CurrentNodeInfoOptions, ...args: any[]): Promise<Schema>;
+export default function clean(schema: Schema | Function, doc?: {}, opts?: CurrentNodeInfoOptions, ...args: any[]): Promise<Schema>;

package/lib/clean/index.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const getSchemaFromTypedModel_1 = require("../getSchemaFromTypedModel");
 const recursiveClean_1 = __importDefault(require("./recursiveClean"));
 const defaultOptions = {
     autoConvert: true,
@@ -11,6 +12,7 @@ const defaultOptions = {
     removeEmptyStrings: false
 };
 async function clean(schema, doc = {}, opts = {}, ...args) {
+    schema = (0, getSchemaFromTypedModel_1.getSchemaFromTypedModel)(schema);
     const options = { ...defaultOptions, ...opts };
     const params = {
         schema: { type: schema },

package/lib/clean/index.test.js

@@ -467,3 +467,16 @@ test('pass currentDoc cleaning complex schemas', async () => {
     // @ts-ignore TODO: Check why the __clean method is being used here instead of clean
     await (0, index_1.default)(schema, doc);
 });
+test('On blackbox allow use of custom clean', async () => {
+    const schema = {
+        info: {
+            type: 'blackbox',
+            optional: true,
+            async clean(info, { doc }) {
+                return { hello: 'world' };
+            }
+        }
+    };
+    const result = await (0, index_1.default)(schema, { info: { hello: 'night' } });
+    expect(result).toEqual({ info: { hello: 'world' } });
+});

package/lib/clean/recursiveClean.js

@@ -8,6 +8,7 @@ const isArray_1 = __importDefault(require("lodash/isArray"));
 const cleanType_1 = __importDefault(require("./cleanType"));
 const isNil_1 = __importDefault(require("lodash/isNil"));
 const getObjectNode_1 = __importDefault(require("./getObjectNode"));
+const convertTypedModel_1 = require("../getValidationErrors/convertTypedModel");
 const cleanObjectFields = async function ({ schema, value, ...other }) {
     const keys = Object.keys(schema.type).filter(key => !key.startsWith('__'));
     const newDoc = {};
@@ -55,6 +56,7 @@ function getArrayNode(schema, value) {
     return null;
 }
 const clean = async function (info) {
+    (0, convertTypedModel_1.convertTypedModel)(info);
     let { schema, args = [], value } = info;
     const currSchema = schema.type === undefined ? { type: schema } : schema;
     const objectSchema = (0, getObjectNode_1.default)(currSchema, value);

package/lib/getSchemaFromTypedModel.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from '.';
+export declare const getSchemaFromTypedModel: (schema: Schema | Function) => Schema;

package/lib/getSchemaFromTypedModel.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaFromTypedModel = void 0;
+const convertTypedModel_1 = require("./getValidationErrors/convertTypedModel");
+const getSchemaFromTypedModel = (schema) => {
+    const item = schema;
+    if (typeof item !== 'function')
+        return item;
+    if (!(0, convertTypedModel_1.isClass)(item))
+        return item;
+    if (!item.getModel || !item.__schemaId)
+        return item;
+    return item.getModel().getCleanSchema();
+};
+exports.getSchemaFromTypedModel = getSchemaFromTypedModel;

package/lib/getValidationErrors/convertTypedModel.d.ts

@@ -0,0 +1,3 @@
+import { CurrentNodeInfo } from '../types/schema';
+export declare function isClass(obj: any): boolean;
+export declare const convertTypedModel: (info: CurrentNodeInfo) => void;

package/lib/getValidationErrors/convertTypedModel.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertTypedModel = exports.isClass = void 0;
+function isClass(obj) {
+    const isCtorClass = obj.constructor && obj.constructor.toString().substring(0, 5) === 'class';
+    if (obj.prototype === undefined) {
+        return isCtorClass;
+    }
+    const isPrototypeCtorClass = obj.prototype.constructor &&
+        obj.prototype.constructor.toString &&
+        obj.prototype.constructor.toString().substring(0, 5) === 'class';
+    return isCtorClass || isPrototypeCtorClass;
+}
+exports.isClass = isClass;
+const convertOnParam = (info, paramName) => {
+    if (!info[paramName])
+        return;
+    const type = info[paramName].type;
+    if (!type)
+        return;
+    if (typeof type !== 'function')
+        return;
+    if (!isClass(type))
+        return;
+    if (!type.getModel || !type.__schemaId)
+        return;
+    info[paramName].type = type.getModel().getCleanSchema();
+};
+const convertTypedModel = (info) => {
+    convertOnParam(info, 'schema');
+    convertOnParam(info, 'currentSchema');
+};
+exports.convertTypedModel = convertTypedModel;

package/lib/getValidationErrors/doValidation.js

@@ -10,7 +10,9 @@ const clone_1 = __importDefault(require("lodash/clone"));
 const isNil_1 = __importDefault(require("lodash/isNil"));
 const difference_1 = __importDefault(require("lodash/difference"));
 const Errors_1 = __importDefault(require("../Errors"));
+const convertTypedModel_1 = require("./convertTypedModel");
 async function doValidation(params) {
+    (0, convertTypedModel_1.convertTypedModel)(params);
     const { schema, doc, currentDoc, value, currentSchema, keys = [], addError, options, args } = params;
     const info = { schema, doc, currentDoc, value, currentSchema, keys, options, args, addError };
     const error = await (0, getError_1.default)(info);

package/lib/getValidationErrors/index.d.ts

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

package/lib/getValidationErrors/index.js

@@ -3,12 +3,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const getSchemaFromTypedModel_1 = require("../getSchemaFromTypedModel");
 const doValidation_1 = __importDefault(require("./doValidation"));
 const getValidationErrorsObject_1 = __importDefault(require("./getValidationErrorsObject"));
 const defaultOptions = {
     omitRequired: false
 };
 async function getValidationErrors(schema, doc, passedOptions = {}, ...args) {
+    schema = (0, getSchemaFromTypedModel_1.getSchemaFromTypedModel)(schema);
     const options = { ...defaultOptions, ...passedOptions };
     const errors = [];
     const addError = function (keys, code) {

package/lib/types/schema.d.ts

@@ -1,6 +1,7 @@
 import { FieldType } from '../fieldType';
 export declare type Constructor<T> = new (...args: any[]) => T;
 export declare type FieldTypesList = 'string' | 'date' | 'integer' | 'number' | 'ID' | 'boolean' | 'email' | 'blackbox';
+export declare type TypedModelOnSchema = Function;
 export declare type ConstructorsTypesList = Constructor<String> | Constructor<Number> | Constructor<Boolean> | Constructor<Date>;
 export declare type SchemaRecursiveNodeTypeExtras = {
     __clean?: CleanFunction;
@@ -11,8 +12,8 @@ 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 SchemaMetaFieldTypeSingle = FieldTypesList | ConstructorsTypesList | SchemaRecursiveNodeType | FieldType | TypedModelOnSchema;
+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 {

package/lib/validate.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orion-js/schema",
-  "version": "3.0.32",
+  "version": "3.1.1",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "files": [
@@ -36,5 +36,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "8d6dfbbd6fbf5aed082e9d67df81d09db580b015"
+  "gitHead": "776fc314f67ab21707912ebeadc9ed8b525cbaee"
 }