validno 0.4.4 → 0.4.6

package/dist/dev.d.ts

@@ -1,2 +1,7 @@
-export {};
+export declare const AccessScopes: {
+    readonly Inherit: "inherit";
+    readonly Public: "public";
+    readonly Project: "workspace";
+    readonly User: "user";
+};
 //# sourceMappingURL=dev.d.ts.map

package/dist/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":""}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../src/dev.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY;;;;;CAKf,CAAC"}

package/dist/dev.js

@@ -1,10 +1,135 @@
 import { Schema } from "./Schema.js";
+import isObjectId from "./utils/isObjectId.js";
+import { ObjectId } from "mongodb";
+export const AccessScopes = {
+    Inherit: 'inherit',
+    Public: 'public',
+    Project: 'workspace',
+    User: 'user'
+};
+const checkMethodScope = (value, context) => {
+    const authCollection = context.input.authCollection;
+    if (isObjectId(authCollection, ObjectId))
+        return true;
+    const mainScope = context.input.scope;
+    const methods = context.input.methods;
+    const allMethodsScopes = [
+        mainScope,
+        ...Object.values(methods).filter(method => method.isActive).map(method => method.scope)
+    ];
+    if (!allMethodsScopes.includes(AccessScopes.User) && !allMethodsScopes.includes(AccessScopes.Project)) {
+        return true;
+    }
+    return {
+        result: false,
+        details: 'Invalid scope. To use User or Project scope, the collection must have authCollection to be set.'
+    };
+};
 const test = () => {
-    console.log('--- Custom Test ---');
-    const schema = new Schema({
-        anyKey: { type: String }
+    const data = {
+        scope: 'public',
+        methods: {
+            get: { isActive: false, scope: 'public' },
+            getAll: {
+                isActive: true,
+                scope: 'public',
+                sort: [Object],
+                filter: [Object],
+                search: [Object]
+            },
+            create: { isActive: true, scope: 'public' },
+            update: { isActive: false, scope: 'public', allowedFields: [] },
+            delete: { isActive: false, scope: 'public' },
+            distinct: { isActive: false, scope: 'public', fields: [] }
+        },
+        authSettings: null,
+        authCollection: null
+    };
+    const collectionSettingsSchema = new Schema({
+        authCollection: {
+            type: [ObjectId, null],
+            required: false,
+        },
+        scope: {
+            type: String,
+            rules: {
+                enum: Object.values(AccessScopes).filter(scope => scope !== AccessScopes.Inherit),
+                custom: checkMethodScope
+            },
+        },
+        methods: {
+            get: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: { enum: Object.values(AccessScopes) },
+                    required: false
+                }
+            },
+            getAll: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: {
+                        enum: Object.values(AccessScopes)
+                    },
+                    required: false
+                },
+                sort: { default: { type: String, required: false } },
+                filter: { fields: { type: Array, eachType: String, required: false } },
+                search: { fields: { type: Array, eachType: String, required: false } }
+            },
+            create: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: { enum: Object.values(AccessScopes) },
+                    required: false
+                }
+            },
+            update: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: { enum: Object.values(AccessScopes) },
+                    required: false
+                },
+                allowedFields: { type: Array, eachType: String, required: false }
+            },
+            delete: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: { enum: Object.values(AccessScopes) },
+                    required: false
+                }
+            },
+            distinct: {
+                isActive: { type: Boolean },
+                scope: {
+                    type: String,
+                    rules: { enum: Object.values(AccessScopes) },
+                    required: false
+                },
+                fields: { type: Array, eachType: String }
+            }
+        }
     });
-    const result = schema.validate({ anyKey: null });
-    console.log(result);
+    const validateResult = collectionSettingsSchema.validate(data);
+    console.log(validateResult);
 };
 test();
+const schema = new Schema({
+    select: {
+        type: Array,
+        eachType: String,
+        required: true,
+        rules: {
+            lengthMin: 1
+        }
+    }
+});
+const result1 = schema.validate({ select: ['field1', 'field2'] });
+console.log(result1);
+const result2 = schema.validate({ select: [] });
+console.log(result2);

package/dist/engine/methods/validateRules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateRules.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validateRules.ts"],"names":[],"mappings":"AAEA,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAe,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,GAAG,CAAC;IACV,YAAY,EAAE,OAAO,EAAE,CAAA;CAC1B;AAED,oBAAY,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAItC,eAAO,MAAM,WAAW;;;;CAIvB,CAAA;AAiND,iBAAS,aAAa,CAAC,KAAK,EAAE,kBAAkB,QAe/C;AAED,eAAe,aAAa,CAAC"}
+{"version":3,"file":"validateRules.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validateRules.ts"],"names":[],"mappings":"AAEA,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAGhD,OAAO,EAAe,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAEtE,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,GAAG,CAAC;IACV,YAAY,EAAE,OAAO,EAAE,CAAA;CAC1B;AAED,oBAAY,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AAItC,eAAO,MAAM,WAAW;;;;CAIvB,CAAA;AAmND,iBAAS,aAAa,CAAC,KAAK,EAAE,kBAAkB,QAe/C;AAED,eAAe,aAAa,CAAC"}

package/dist/engine/methods/validateRules.js

@@ -70,33 +70,34 @@ const rulesFunctions = {
     length: (key, val, length) => {
         return {
             result: _validations.lengthIs(val, length),
-            details: `Value must be equal to ${length}`
+            details: `Value length must be equal to ${length} ${Array.isArray(val) ? 'items' : 'characters'}`
         };
     },
     lengthNot: (key, val, lengthNot) => {
         return {
             result: _validations.lengthNot(val, lengthNot),
-            details: `Value must not be equal to ${lengthNot}`
+            details: `Value must not be equal to ${lengthNot} ${Array.isArray(val) ? 'items' : 'characters'}`
         };
     },
     lengthMinMax: (key, val, minMax) => {
         const [min, max] = minMax;
         return {
             result: _validations.lengthMin(val, min) && _validations.lengthMax(val, max),
-            details: `Value must be between ${min} and ${max} characters`
+            details: `Value must be between ${min} and ${max} ${Array.isArray(val) ? 'items' : 'characters'}`
         };
     },
     lengthMin: (key, val, min) => {
         ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes);
         return {
             result: _validations.lengthMin(val, min),
-            details: `Value must be at least ${min} characters`
+            details: `Value must have at least ${min} ${Array.isArray(val) ? 'items' : 'characters'}`
         };
     },
     lengthMax: (key, val, max) => {
+        ensureRuleHasCorrectType(val, rulesParams['lengthMin'].allowedTypes);
         return {
             result: _validations.lengthMax(val, max),
-            details: `Value must not be exceed ${max} characters`
+            details: `Value must not exceed ${max} ${Array.isArray(val) ? 'items' : 'characters'}`
         };
     },
     regex: (key, val, regex) => {

package/dist/engine/methods/validateType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateType.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validateType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAe,MAAM,uBAAuB,CAAC;AACtE,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAiLhD,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,gBAAgB,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,EAAE,CAAA;CACzB;AAED,iBAAS,YAAY,CAAC,KAAK,EAAE,kBAAkB,QAU9C;AAED,eAAe,YAAY,CAAC"}
+{"version":3,"file":"validateType.d.ts","sourceRoot":"","sources":["../../../src/engine/methods/validateType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAe,MAAM,uBAAuB,CAAC;AACtE,OAAO,aAAa,MAAM,qBAAqB,CAAC;AAqLhD,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,aAAa,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,GAAG,CAAC;IACX,IAAI,EAAE,gBAAgB,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,OAAO,EAAE,CAAA;CACzB;AAED,iBAAS,YAAY,CAAC,KAAK,EAAE,kBAAkB,QAU9C;AAED,eAAe,YAAY,CAAC"}

package/dist/engine/methods/validateType.js

@@ -115,6 +115,10 @@ const handleTypeValidation = (key, value, requirements, keyName = key) => {
             break;
         }
         default: {
+            if (value === null && typeBySchema !== null) {
+                result.push(_validateType.getResult(keyName, false, getDetails(false)));
+                break;
+            }
             const isInstanceOf = typeof typeBySchema === 'function' && value instanceof typeBySchema;
             const isConstructorSame = typeof typeBySchema === 'function' && ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === (typeBySchema === null || typeBySchema === void 0 ? void 0 : typeBySchema.name);
             const isBothObjectId = isObjectId(value, typeBySchema);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "validno",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "A lightweight TypeScript validation library for runtime data validation. Used as part of Kodzero API framework.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/tests/cases/corruptedData.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=corruptedData.test.d.ts.map

package/dist/tests/cases/corruptedData.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"corruptedData.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/corruptedData.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/corruptedData.test.js

@@ -1,81 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../../Schema';
-const AccessScopes = {
-    Public: 'public',
-    Project: 'workspace',
-    User: 'user'
-};
-const collectionSettingsSchema = new Schema({
-    auth: { type: null },
-    scope: {
-        type: String,
-        rules: {
-            enum: Object.values(AccessScopes)
-        },
-    },
-    methods: {
-        get: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: { enum: Object.values(AccessScopes) },
-                required: false
-            }
-        },
-        getAll: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: {
-                    enum: Object.values(AccessScopes)
-                },
-                required: false
-            },
-            sort: { default: { type: String } },
-            filter: { fields: { type: Array, eachType: String } },
-            search: { fields: { type: Array, eachType: String } }
-        },
-        create: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: { enum: Object.values(AccessScopes) },
-                required: false
-            }
-        },
-        update: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: { enum: Object.values(AccessScopes) },
-                required: false
-            },
-            allowedFields: { type: Array, eachType: String }
-        },
-        delete: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: { enum: Object.values(AccessScopes) },
-                required: false
-            }
-        },
-        distinct: {
-            isActive: { type: Boolean },
-            scope: {
-                type: String,
-                rules: { enum: Object.values(AccessScopes) },
-                required: false
-            },
-            fields: { type: Array, eachType: String }
-        }
-    }
-});
-const settingsData = { test: 1 };
-describe('Corrupted data in nested keys', () => {
-    test('Corrupted data in nested keys should not pass the validation', () => {
-        const result = collectionSettingsSchema.validate(settingsData);
-        expect(result.ok).toBe(false);
-        expect(result.errors.length).toBeGreaterThan(1);
-    });
-});

package/dist/tests/cases/dataInputIsNotAnObject.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=dataInputIsNotAnObject.test.d.ts.map

package/dist/tests/cases/dataInputIsNotAnObject.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dataInputIsNotAnObject.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/dataInputIsNotAnObject.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/dataInputIsNotAnObject.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../../Schema';
-describe('Data input is not an object → returns failed validation result', () => {
-    const schema = new Schema({
-        name: {
-            type: String
-        }
-    });
-    test('null input fails validation but not throws', () => {
-        const result = schema.validate(null);
-        expect(result).toBeDefined();
-        expect(result.ok).toBe(false);
-    });
-    test('array input fails validation but not throws', () => {
-        const result = schema.validate([]);
-        expect(result).toBeDefined();
-        expect(result.ok).toBe(false);
-    });
-    test('undefined input fails validation but not throws', () => {
-        const result = schema.validate(undefined);
-        expect(result).toBeDefined();
-        expect(result.ok).toBe(false);
-    });
-});

package/dist/tests/cases/notRequiredNestedKey.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=notRequiredNestedKey.test.d.ts.map

package/dist/tests/cases/notRequiredNestedKey.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notRequiredNestedKey.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/notRequiredNestedKey.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/notRequiredNestedKey.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../../Schema';
-describe('Not required nested key', () => {
-    test('[1] Nested key that is not required should pass the validation', () => {
-        const schema = new Schema({
-            query: { type: Object },
-            data: { type: Object },
-            params: {
-                upsert: { type: Boolean, required: false },
-            }
-        });
-        const data = {
-            query: {},
-            data: {}
-        };
-        const result = schema.validate(data);
-        expect(result.ok).toBe(true);
-        expect(result.missed).toEqual([]);
-    });
-    test('[2] Nested key that is required should not pass the validation', () => {
-        const schema = new Schema({
-            query: { type: Object },
-            data: { type: Object },
-            params: {
-                upsert: { type: Boolean, required: true },
-            }
-        });
-        const data = {
-            query: {},
-            data: {}
-        };
-        const result = schema.validate(data);
-        expect(result.ok).toBe(false);
-        expect(result.missed).toEqual(['params.upsert']);
-        expect(result.failed).toEqual(['params.upsert', 'params']);
-        expect(result.passed).toEqual(['query', 'data']);
-    });
-});

package/dist/tests/cases/secondLevelDeepValidates.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=secondLevelDeepValidates.test.d.ts.map

package/dist/tests/cases/secondLevelDeepValidates.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"secondLevelDeepValidates.test.d.ts","sourceRoot":"","sources":["../../../src/tests/cases/secondLevelDeepValidates.test.ts"],"names":[],"mappings":""}

package/dist/tests/cases/secondLevelDeepValidates.test.js

@@ -1,112 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../../Schema';
-const configSchema = new Schema({
-    app: {
-        name: {
-            type: String,
-            required: true,
-            rules: { lengthMin: 1, lengthMax: 50 }
-        },
-        version: {
-            type: String,
-            required: true,
-            rules: {
-                regex: /^\d+\.\d+\.\d+$/
-            }
-        },
-        environment: {
-            type: String,
-            required: true,
-            rules: {
-                enum: ['development', 'testing', 'staging', 'production']
-            }
-        }
-    },
-    database: {
-        host: {
-            type: String,
-            required: true,
-            rules: { lengthMin: 1 }
-        },
-        port: {
-            type: Number,
-            required: true,
-            rules: { min: 1, max: 65535 }
-        },
-        name: {
-            type: String,
-            required: true,
-            rules: { lengthMin: 1, lengthMax: 64 }
-        },
-        ssl: {
-            type: Boolean,
-            required: false
-        }
-    },
-    api: {
-        port: {
-            type: Number,
-            required: true,
-            rules: { min: 1000, max: 9999 }
-        },
-        cors: {
-            enabled: { type: Boolean, required: true },
-            origins: {
-                type: Array,
-                eachType: String,
-                required: false
-            }
-        },
-        rateLimit: {
-            enabled: { type: Boolean, required: true },
-            maxRequests: {
-                type: Number,
-                required: false,
-                rules: { min: 1, max: 10000 }
-            },
-            windowMs: {
-                type: Number,
-                required: false,
-                rules: { min: 1000, max: 86400000 }
-            }
-        }
-    }
-});
-const exampleConfigFile = {
-    "app": {
-        "name": "MyApp",
-        "version": "1.0.0",
-        "environment": "development"
-    },
-    "database": {
-        "host": "localhost",
-        "port": 5432,
-        "name": "myappdb",
-        "ssl": false
-    },
-    "api": {
-        "port": 3000,
-        "cors": {
-            "enabled": true,
-            "origins": ["http://localhost:3000"]
-        },
-        "rateLimit": {
-            "enabled": true,
-            "maxRequests": 1000,
-            "windowMs": 60000
-        }
-    },
-};
-describe('Second level deep validates as expected', () => {
-    test('should validate the api key', () => {
-        const res = configSchema.validate(exampleConfigFile);
-        expect(res.ok).toBe(true);
-        expect(res.failed).toEqual([]);
-        expect(res.missed).toEqual([]);
-    });
-    test('api key shouldn\'t validate with wrong port type', () => {
-        const res2 = configSchema.validate(Object.assign(Object.assign({}, exampleConfigFile), { api: Object.assign(Object.assign({}, exampleConfigFile.api), { port: '99999' }) }));
-        expect(res2.ok).toBe(false);
-        expect(res2.failed).toContain('api');
-    });
-});

package/dist/tests/customMessage.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=customMessage.test.d.ts.map

package/dist/tests/customMessage.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"customMessage.test.d.ts","sourceRoot":"","sources":["../../src/tests/customMessage.test.ts"],"names":[],"mappings":""}

package/dist/tests/customMessage.test.js

@@ -1,102 +0,0 @@
-import { describe, expect, test } from '@jest/globals';
-import { Schema } from '../Schema';
-describe('Тестирование кастомного сообщения об ошибке', () => {
-    test('Кастомные сообщения корректно отображаются в результате валидации', () => {
-        const wrongTypeKey = 'wrongType';
-        const missingKey = 'missingKey';
-        const wrongRule1 = 'wrongRule1';
-        const wrongRule2 = 'wrongRule2';
-        const wrongRule3 = 'wrongRule3';
-        const allKeys = [
-            wrongTypeKey,
-            missingKey,
-            wrongRule1,
-            wrongRule2,
-            wrongRule3
-        ];
-        const getCustomMsg = (key, variation = '') => key + ' custom' + variation;
-        const schema = new Schema({
-            [wrongTypeKey]: {
-                type: Number,
-                required: true,
-                title: 'Не по типу',
-                customMessage: (input) => {
-                    return getCustomMsg(wrongTypeKey);
-                }
-            },
-            [missingKey]: {
-                type: Date,
-                required: true,
-                title: 'Отсутствующий',
-                customMessage: (input) => {
-                    return getCustomMsg(missingKey);
-                }
-            },
-            [wrongRule1]: {
-                type: String,
-                required: true,
-                title: 'Wrong Rule #1',
-                rules: {
-                    is: 'xxx'
-                },
-                customMessage: (input) => {
-                    return getCustomMsg(wrongRule1);
-                }
-            },
-            [wrongRule2]: {
-                type: String,
-                required: true,
-                title: 'Wrong Rule #2',
-                rules: {
-                    lengthMin: 999
-                },
-                customMessage: (input) => {
-                    return getCustomMsg(wrongRule2);
-                }
-            },
-            [wrongRule3]: {
-                type: String,
-                required: true,
-                title: 'Wrong Rule #3',
-                rules: {
-                    lengthMax: 1
-                },
-                customMessage: (input) => {
-                    const { keyword, value, key, title, reqs, schema, rules } = input;
-                    if (keyword === 'lengthMax') {
-                        return getCustomMsg(wrongRule3);
-                    }
-                    return wrongRule3 + ' should reach here';
-                }
-            },
-        });
-        const obj = {
-            [wrongTypeKey]: 'abc',
-            [wrongRule1]: 'def',
-            [wrongRule2]: 'ghi',
-            [wrongRule3]: 'jkl'
-        };
-        const result = schema.validate(obj);
-        expect(result).toEqual({
-            ok: false,
-            missed: [missingKey],
-            failed: [...allKeys],
-            passed: [],
-            errors: allKeys.map(el => getCustomMsg(el)),
-            byKeys: {
-                wrongType: false,
-                missingKey: false,
-                wrongRule1: false,
-                wrongRule2: false,
-                wrongRule3: false
-            },
-            errorsByKeys: {
-                wrongType: [getCustomMsg(allKeys[0])],
-                missingKey: [getCustomMsg(allKeys[1])],
-                wrongRule1: [getCustomMsg(allKeys[2])],
-                wrongRule2: [getCustomMsg(allKeys[3])],
-                wrongRule3: [getCustomMsg(allKeys[4])],
-            }
-        });
-    });
-});

package/dist/tests/customType.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=customType.test.d.ts.map

package/dist/tests/customType.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"customType.test.d.ts","sourceRoot":"","sources":["../../src/tests/customType.test.ts"],"names":[],"mappings":""}