definition-generator-framework 1.12.3 → 1.12.5

package/dist/helpers/validator/validator.spec.js

@@ -0,0 +1,322 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+const validator_1 = require("./validator");
+const joi_custom_validators_1 = require("./joi-custom-validators");
+const mocks_1 = require("../../_mocks/mocks");
+const custom_validator_helper_1 = require("./custom-validator-helper/custom-validator.helper");
+const context_1 = require("../../framework/context");
+const definition_store_1 = require("../../framework/definition-store");
+joi_custom_validators_1.JoiCustomValidators.decorate(joi_1.default, { existsSync: (path) => path !== 'D:/test/false/path.png' });
+const ComponentType = 'ASSET';
+class Asset {
+    static { this.$meta = {
+        componentName: ComponentType
+    }; }
+    async process() { }
+}
+const TestSchema = joi_1.default.object().keys({
+    str1: joi_1.default.string().required(),
+    str2: joi_1.default.string().path().optional()
+});
+function getSampleRawDefinition(str, pathString) {
+    let rawDefinition = {
+        componentName: ComponentType,
+        location: mocks_1.SampleLocation1,
+        parsedStructure: {
+            line: mocks_1.SampleLocation1.line + 1,
+            rawData: {
+                str1: {
+                    rawData: str,
+                    line: mocks_1.SampleLocation1.line + 1
+                },
+                str2: {
+                    rawData: pathString,
+                    line: mocks_1.SampleLocation1.line + 2
+                }
+            }
+        }
+    };
+    return rawDefinition;
+}
+const SampleNestedRawDefinition = {
+    componentName: ComponentType,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+        line: mocks_1.SampleLocation1.line + 1,
+        rawData: {
+            obj1: {
+                line: mocks_1.SampleLocation1.line + 1,
+                rawData: [
+                    {
+                        line: mocks_1.SampleLocation1.line + 2,
+                        rawData: {
+                            obj2: {
+                                line: mocks_1.SampleLocation1.line + 2,
+                                rawData: 'test data'
+                            }
+                        }
+                    }
+                ]
+            }
+        }
+    }
+};
+describe('VALIDATOR', () => {
+    beforeEach(() => {
+        (0, mocks_1.resetContext)();
+        custom_validator_helper_1.CustomValidatorHelper['duplicateHelpers'] = new Map();
+    });
+    describe('Convert', () => {
+        test('valid definition', () => {
+            context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+            let definitions = validator_1.Validator.validateAndConvert(ComponentType, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+            expect(definitions).toStrictEqual([{ str1: 'str1', str2: '.test/images/test.png' }]);
+        });
+        test('singular definition', () => {
+            context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+            let definitions = validator_1.Validator.validateAndConvert(ComponentType, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+            expect(definitions).toStrictEqual([{ str1: 'str1', str2: '.test/images/test.png' }]);
+        });
+        test('should allow references in the same namespace', () => {
+            let rawDefinition1 = {
+                componentName: ComponentType,
+                location: mocks_1.SampleLocation1,
+                parsedStructure: {
+                    line: mocks_1.SampleLocation1.line + 1,
+                    rawData: {
+                        name: {
+                            rawData: 'asset2',
+                            line: mocks_1.SampleLocation1.line + 1
+                        },
+                        ref: {
+                            rawData: 'asset1',
+                            line: mocks_1.SampleLocation1.line + 2
+                        }
+                    }
+                }
+            };
+            let rawDefinition2 = {
+                componentName: ComponentType,
+                location: mocks_1.SampleLocation1,
+                parsedStructure: {
+                    line: mocks_1.SampleLocation1.line + 1,
+                    rawData: {
+                        name: {
+                            rawData: 'asset1',
+                            line: mocks_1.SampleLocation1.line + 1
+                        }
+                    }
+                }
+            };
+            context_1.Context.rawDefinitions.push(rawDefinition1);
+            context_1.Context.rawDefinitions.push(rawDefinition2);
+            let schema = joi_1.default.object().keys({
+                name: joi_1.default.string().required(),
+                ref: joi_1.default.string().reference(Asset).optional()
+            });
+            definition_store_1.DefinitionStore['setRawDefinition'](Asset, 'asset1', rawDefinition2);
+            let definitions = validator_1.Validator.validateAndConvert(ComponentType, schema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+            expect(definitions).toStrictEqual([
+                {
+                    name: 'asset2',
+                    ref: 'asset1'
+                },
+                {
+                    name: 'asset1'
+                }
+            ]);
+        });
+    });
+    describe('Convert Singular', () => {
+        test('valid definition', () => {
+            context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+            let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+            expect(definition).toStrictEqual({ str1: 'str1', str2: '.test/images/test.png' });
+        });
+        test('should log error for no definition', () => {
+            let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(definition).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: 'Singleton definition has no declared entry "ASSET"',
+                    location: {
+                        line: 0,
+                        path: '*'
+                    }
+                }
+            ]);
+        });
+        test('should log error for multiple definitions', () => {
+            context_1.Context.rawDefinitions.push(getSampleRawDefinition('str1', 'images/test.png'));
+            context_1.Context.rawDefinitions.push(getSampleRawDefinition('str2', 'images/test.png'));
+            let definition = validator_1.Validator.validateAndConvertSingular(ComponentType, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(definition).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: 'Only one definition can be defined for "ASSET"',
+                    location: {
+                        line: 2,
+                        path: 'D:/test/file-1.md'
+                    }
+                },
+                {
+                    description: 'Only one definition can be defined for "ASSET"',
+                    location: {
+                        line: 2,
+                        path: 'D:/test/file-1.md'
+                    }
+                }
+            ]);
+        });
+    });
+    describe('Validate', () => {
+        test('should handle valid raw definition', () => {
+            let rawDefinition = getSampleRawDefinition('a', 'images/test.png');
+            let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual({ str1: 'a', str2: '.test/images/test.png' });
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+        });
+        test('should log error for required fields', () => {
+            let rawDefinition = getSampleRawDefinition(undefined, 'images/test.png');
+            let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: '"str1" is required',
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 1,
+                        path: mocks_1.SampleLocation1.path
+                    }
+                }
+            ]);
+        });
+        test('should log error for invalid flag attribute value', () => {
+            let rawDefinition = getSampleRawDefinition('a', 'wrong text');
+            let value = validator_1.Validator['validate'](rawDefinition, TestSchema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: `"str2" with value "wrong text" fails to match the required pattern: /^[\\S]+$/`,
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 2,
+                        path: mocks_1.SampleLocation1.path
+                    }
+                }
+            ]);
+        });
+        test('should log error for non matching pattern', () => {
+            let schema = joi_1.default.object().keys({
+                str1: joi_1.default.string()
+                    .regex(/^[a-z]+([a-zA-Z0-9]+)*$/)
+                    .required(),
+                str2: joi_1.default.string()
+                    .regex(/^[a-z]+([a-zA-Z0-9]+)*$/)
+                    .required()
+            });
+            let rawDefinition = getSampleRawDefinition('1a', 'wrong string');
+            let value = validator_1.Validator['validate'](rawDefinition, schema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: `"str1" with value "1a" fails to match the required pattern: /^[a-z]+([a-zA-Z0-9]+)*$/`,
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 1,
+                        path: mocks_1.SampleLocation1.path
+                    }
+                },
+                {
+                    description: `"str2" with value "wrong string" fails to match the required pattern: /^[a-z]+([a-zA-Z0-9]+)*$/`,
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 2,
+                        path: mocks_1.SampleLocation1.path
+                    }
+                }
+            ]);
+        });
+        test('should validate primitive definition', () => {
+            let rawDefinition = {
+                componentName: ComponentType,
+                location: mocks_1.SampleLocation1,
+                parsedStructure: {
+                    line: mocks_1.SampleLocation1.line + 1,
+                    rawData: 'test'
+                }
+            };
+            let value = validator_1.Validator['validate'](rawDefinition, joi_1.default.string());
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual('test');
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+        });
+        test('should log error for primitive definition', () => {
+            let rawDefinition = {
+                componentName: ComponentType,
+                location: mocks_1.SampleLocation1,
+                parsedStructure: {
+                    line: mocks_1.SampleLocation1.line + 1,
+                    rawData: 'test'
+                }
+            };
+            let value = validator_1.Validator['validate'](rawDefinition, joi_1.default.string().valid('only'));
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: '"value" must be [only]',
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 1,
+                        path: mocks_1.SampleLocation1.path
+                    }
+                }
+            ]);
+        });
+        test('should validate nested object', () => {
+            let schema = joi_1.default.object().keys({
+                obj1: joi_1.default.array().items(joi_1.default.object().keys({
+                    obj2: joi_1.default.string()
+                }))
+            });
+            let value = validator_1.Validator['validate'](SampleNestedRawDefinition, schema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual({ obj1: [{ obj2: 'test data' }] });
+            expect(context_1.Context.errorLogs).toStrictEqual([]);
+        });
+        test('should log error for nested object', () => {
+            let schema = joi_1.default.object().keys({
+                obj1: joi_1.default.array().items(joi_1.default.object().keys({
+                    obj2: joi_1.default.string().valid('only')
+                }))
+            });
+            let value = validator_1.Validator['validate'](SampleNestedRawDefinition, schema);
+            custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+            expect(value).toStrictEqual(undefined);
+            expect(context_1.Context.errorLogs).toStrictEqual([
+                {
+                    description: '"obj1[0].obj2" must be [only]',
+                    location: {
+                        line: mocks_1.SampleLocation1.line + 2,
+                        path: 'D:/test/file-1.md'
+                    }
+                }
+            ]);
+        });
+    });
+});
+//# sourceMappingURL=validator.spec.js.map

package/dist/pipeline/1-select-definitions.spec.d.ts

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

package/dist/pipeline/1-select-definitions.spec.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1_select_definitions_helper_1 = require("./1-select-definitions-helper");
+const mocks_1 = require("../_mocks/mocks");
+const custom_validator_helper_spec_1 = require("../helpers/validator/custom-validator-helper/custom-validator.helper.spec");
+const definition_store_1 = require("../framework/definition-store");
+definition_store_1.DefinitionStore['definitionsMap'].set(custom_validator_helper_spec_1.AssetComponentName, new Map());
+describe('SELECT DEFINITIONS HELPER', () => {
+    let selectDefinitionsHelper;
+    beforeEach(() => {
+        selectDefinitionsHelper = new _1_select_definitions_helper_1.SelectDefinitionsHelper();
+    });
+    test('should handle empty files', () => {
+        let content = ``;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([]);
+        expect(result.errorLogs).toStrictEqual([]);
+    });
+    test('should handle files without definitions', () => {
+        let content = `
+      Explanation
+
+      ### ASSET
+      Name: singular name
+      Path: path to file
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([]);
+        expect(result.errorLogs).toStrictEqual([]);
+    });
+    test('should select definitions', () => {
+        let content = `
+      # DEFINITIONS
+      ### ASSET
+      Name: test
+      Path: test.png
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([
+            {
+                type: 'ASSET',
+                content: ['      Name: test', '      Path: test.png'],
+                location: { line: 3, path: fileInfo.path }
+            }
+        ]);
+        expect(result.errorLogs).toStrictEqual([]);
+    });
+    test('should ignore comments', () => {
+        let content = `
+      # DEFINITIONS
+      ### ASSET
+      Name: test // comment
+      Path: test.png     // comment
+      // ----comment----\r
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([
+            {
+                type: 'ASSET',
+                content: ['      Name: test', '      Path: test.png'],
+                location: { line: 3, path: fileInfo.path }
+            }
+        ]);
+        expect(result.errorLogs).toStrictEqual([]);
+    });
+    test('should not allow empty definitions', () => {
+        let content = `
+      # DEFINITIONS
+      ### ASSET
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([]);
+        expect(result.errorLogs).toStrictEqual([
+            {
+                description: 'Definitions cannot be empty!',
+                location: { line: 3, path: fileInfo.path }
+            }
+        ]);
+    });
+    test('should not allow unknown definition header after the first valid definition', () => {
+        let content = `
+      # DEFINITIONS
+      ### ASSET
+      Name: test
+      Path: test.png
+
+      ### Some text
+      some text
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.errorLogs).toStrictEqual([
+            {
+                description: 'Invalid definition header: "### Some text"',
+                location: { line: 7, path: fileInfo.path }
+            }
+        ]);
+    });
+    test('invalid definitions should not corrupt other definitions', () => {
+        let content = `
+      # DEFINITIONS
+      ### ASSET
+      Name: test
+      Path: test.png
+
+      ### Some text
+      some text
+
+      ### ASSET
+      Name: test2
+      Path: test2.png
+    `;
+        let fileInfo = (0, mocks_1.getMockFileInfo)(content);
+        let result = selectDefinitionsHelper.process(fileInfo);
+        expect(result.definitionPlaneTexts).toStrictEqual([
+            {
+                type: 'ASSET',
+                content: ['      Name: test', '      Path: test.png'],
+                location: { line: 3, path: fileInfo.path }
+            },
+            {
+                type: 'ASSET',
+                content: ['      Name: test2', '      Path: test2.png'],
+                location: { line: 10, path: fileInfo.path }
+            }
+        ]);
+        expect(result.errorLogs).toStrictEqual([
+            {
+                description: 'Invalid definition header: "### Some text"',
+                location: { line: 7, path: fileInfo.path }
+            }
+        ]);
+    });
+});
+//# sourceMappingURL=1-select-definitions.spec.js.map

package/dist/pipeline/2-structure-parser.helper.spec.d.ts

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