definition-generator-framework 1.12.4 → 1.12.6

package/dist/helpers/validator/custom-validator-helper/custom-validator.helper.spec.js

@@ -0,0 +1,191 @@
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.AssetComponentName = void 0;
+const joi_1 = __importDefault(require('joi'));
+const joi_custom_validators_1 = require('../joi-custom-validators');
+const mocks_1 = require('../../../_mocks/mocks');
+const raw_definition_helper_1 = require('../../raw-definition-helper/raw-definition.helper');
+const custom_validator_helper_1 = require('./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' });
+exports.AssetComponentName = 'ASSET';
+class Asset {
+  static {
+    this.$meta = {
+      componentName: exports.AssetComponentName
+    };
+  }
+  async process() {}
+}
+class AssetGroup {
+  static {
+    this.$meta = {
+      componentName: 'ASSET-GROUP'
+    };
+  }
+  async process() {}
+}
+function getSimpleRawDefinition(value, offset = 1) {
+  return {
+    componentName: exports.AssetComponentName,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+      line: mocks_1.SampleLocation1.line + offset,
+      rawData: {
+        value: {
+          rawData: value,
+          line: mocks_1.SampleLocation1.line + offset
+        }
+      }
+    }
+  };
+}
+function getFlatRawDefinition(value, offset = 1) {
+  return {
+    componentName: exports.AssetComponentName,
+    location: mocks_1.SampleLocation1,
+    parsedStructure: {
+      line: mocks_1.SampleLocation1.line + offset,
+      rawData: value
+    }
+  };
+}
+describe('JOI CUSTOM VALIDATORS', () => {
+  beforeEach(() => {
+    context_1.Context.config.projectRoot = 'D:/';
+    custom_validator_helper_1.CustomValidatorHelper['duplicateHelpers'] = new Map();
+  });
+  describe('Variable Name', () => {
+    let schema = joi_1.default.object().keys({
+      value: joi_1.default.string().required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'test' });
+      expect(error).toEqual(undefined);
+    });
+    test('different groups should not create duplicates', () => {
+      let schema2 = joi_1.default.object().keys({
+        value: joi_1.default.string().required()
+      });
+      let rawDefinition1 = getSimpleRawDefinition('test', 1);
+      let rawDefinition2 = getSimpleRawDefinition('test', 2);
+      schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition1), {
+        abortEarly: false,
+        context: rawDefinition1
+      });
+      schema2.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition2), {
+        abortEarly: false,
+        context: rawDefinition2
+      });
+      (0, mocks_1.resetContext)();
+      custom_validator_helper_1.CustomValidatorHelper.logDuplicates();
+      expect(context_1.Context.errorLogs).toStrictEqual([]);
+    });
+  });
+  describe('Reference', () => {
+    let schema = joi_1.default.object().keys({
+      value: joi_1.default.string().reference(Asset).required()
+    });
+    let multipleSchema = joi_1.default.object().keys({
+      value: joi_1.default.string().reference([AssetGroup, Asset]).required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      definition_store_1.DefinitionStore['setRawDefinition'](Asset, 'test', rawDefinition);
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'test' });
+      expect(error).toEqual(undefined);
+    });
+    test('multiple reference', () => {
+      let rawDefinition = getSimpleRawDefinition('test');
+      definition_store_1.DefinitionStore['setRawDefinition'](Asset, 'test', rawDefinition);
+      let { value, error } = multipleSchema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: 'test' });
+      expect(error).toEqual(undefined);
+    });
+    test('primitive valid data', () => {
+      let rawDefinition = getFlatRawDefinition('test');
+      let primitiveSchema = joi_1.default.string().reference(Asset).required();
+      definition_store_1.DefinitionStore['setRawDefinition'](Asset, 'test', rawDefinition);
+      let { value, error } = primitiveSchema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual('test');
+      expect(error).toEqual(undefined);
+    });
+  });
+  describe('Path', () => {
+    let schema = joi_1.default.object().keys({
+      value: joi_1.default.string().path().required()
+    });
+    test('valid data', () => {
+      let rawDefinition = getSimpleRawDefinition('images/test.png');
+      let { value, error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(value).toEqual({ value: '.test/images/test.png' });
+      expect(error).toEqual(undefined);
+    });
+    test('should detect files not existing, invalid url', () => {
+      let rawDefinition = getSimpleRawDefinition('invalid data');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toStrictEqual([
+        {
+          message: '"value" with value "invalid data" fails to match the required pattern: /^[\\S]+$/',
+          path: ['value'],
+          type: 'string.pattern.base',
+          context: {
+            name: undefined,
+            regex: /^[\S]+$/,
+            value: 'invalid data',
+            label: 'value',
+            key: 'value'
+          }
+        }
+      ]);
+    });
+    test('should detect files not existing, missing file', () => {
+      let rawDefinition = getSimpleRawDefinition('false/path.png');
+      let { error } = schema.validate(raw_definition_helper_1.RawDefinitionHelper.flatten(rawDefinition), {
+        abortEarly: false,
+        context: rawDefinition
+      });
+      expect(error?.details).toStrictEqual([
+        {
+          message: '"value" failed custom validation because No file is found in the path: "D:/test/false/path.png"',
+          path: ['value'],
+          type: 'any.custom',
+          context: {
+            error: new Error('No file is found in the path: "D:/test/false/path.png"'),
+            label: 'value',
+            value: 'false/path.png',
+            key: 'value'
+          }
+        }
+      ]);
+    });
+  });
+});
+//# sourceMappingURL=custom-validator.helper.spec.js.map

package/dist/helpers/validator/custom-validators/image.custom-validator.d.ts

@@ -3,12 +3,12 @@ import { Vec2 } from 'pixi-framework';
 import { CustomValidator } from '../joi-custom-validators';
 import { FileSystem } from '../../../framework/framework.model';
 export interface ValidatedImageUrl {
-    readonly url: string;
-    readonly size: Vec2;
+  readonly url: string;
+  readonly size: Vec2;
 }
 export declare class ImageCustomValidator implements CustomValidator {
-    private fs;
-    readonly regex: RegExp;
-    readonly validate: (value: string, helpers: Joi.CustomHelpers) => any | ErrorReport;
-    constructor(fs: FileSystem);
+  private fs;
+  readonly regex: RegExp;
+  readonly validate: (value: string, helpers: Joi.CustomHelpers) => any | ErrorReport;
+  constructor(fs: FileSystem);
 }

package/dist/helpers/validator/custom-validators/image.custom-validator.js

@@ -1,43 +1,44 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.ImageCustomValidator = void 0;
-const image_size_1 = __importDefault(require("image-size"));
-const custom_validator_helper_1 = require("../custom-validator-helper/custom-validator.helper");
-const context_1 = require("../../../framework/context");
+const image_size_1 = __importDefault(require('image-size'));
+const custom_validator_helper_1 = require('../custom-validator-helper/custom-validator.helper');
+const context_1 = require('../../../framework/context');
 class ImageCustomValidator {
-    constructor(fs) {
-        this.fs = fs;
-        this.regex = /^[\S]+$/;
-        this.validate = (value, helpers) => {
-            let validationState = custom_validator_helper_1.CustomValidatorHelper.getValidationState(helpers);
-            if (validationState === 'valid') {
-                let { rawDefinition } = custom_validator_helper_1.CustomValidatorHelper.getPathAndRawDefinition(helpers);
-                let pathPrefix = rawDefinition.location.path.substring(0, rawDefinition.location.path.lastIndexOf('/') + 1);
-                value = pathPrefix + value;
-                if (!this.fs.existsSync(value)) {
-                    throw new Error(`No file is found in the path: "${value}"`);
-                }
-                else {
-                    try {
-                        let size = (0, image_size_1.default)(value);
-                        return {
-                            url: value.replace(context_1.Context.config.projectRoot, '.'),
-                            size: { x: size.width, y: size.height }
-                        };
-                    }
-                    catch (error) {
-                        throw new Error(`The file in the path "${value}" is not an image`);
-                    }
-                }
-            }
-            else {
-                throw new Error(`Internal Error; joi validation context for image validator: Path: "${helpers.state.path}", RawDefinition: "${JSON.stringify(helpers.prefs.context)}"`);
-            }
-        };
-    }
+  constructor(fs) {
+    this.fs = fs;
+    this.regex = /^[\S]+$/;
+    this.validate = (value, helpers) => {
+      let validationState = custom_validator_helper_1.CustomValidatorHelper.getValidationState(helpers);
+      if (validationState === 'valid') {
+        let { rawDefinition } = custom_validator_helper_1.CustomValidatorHelper.getPathAndRawDefinition(helpers);
+        let pathPrefix = rawDefinition.location.path.substring(0, rawDefinition.location.path.lastIndexOf('/') + 1);
+        value = pathPrefix + value;
+        if (!this.fs.existsSync(value)) {
+          throw new Error(`No file is found in the path: "${value}"`);
+        } else {
+          try {
+            let size = (0, image_size_1.default)(value);
+            return {
+              url: value.replace(context_1.Context.config.projectRoot, '.'),
+              size: { x: size.width, y: size.height }
+            };
+          } catch (error) {
+            throw new Error(`The file in the path "${value}" is not an image`);
+          }
+        }
+      } else {
+        throw new Error(
+          `Internal Error; joi validation context for image validator: Path: "${helpers.state.path}", RawDefinition: "${JSON.stringify(helpers.prefs.context)}"`
+        );
+      }
+    };
+  }
 }
 exports.ImageCustomValidator = ImageCustomValidator;
-//# sourceMappingURL=image.custom-validator.js.map
+//# sourceMappingURL=image.custom-validator.js.map

package/dist/helpers/validator/custom-validators/unique-name-group.custom-validator.d.ts

@@ -2,8 +2,8 @@ import Joi, { ErrorReport } from 'joi';
 import { CustomValidator } from '../joi-custom-validators';
 import { DefinitionComponentClassType } from '../../../framework/definition-component';
 export declare class UniqueNameGroupCustomValidator implements CustomValidator {
-    private definitionComponentClass;
-    readonly regex: RegExp;
-    readonly validate: (value: string, helpers: Joi.CustomHelpers) => any | ErrorReport;
-    constructor(definitionComponentClass: DefinitionComponentClassType<any>);
+  private definitionComponentClass;
+  readonly regex: RegExp;
+  readonly validate: (value: string, helpers: Joi.CustomHelpers) => any | ErrorReport;
+  constructor(definitionComponentClass: DefinitionComponentClassType<any>);
 }

package/dist/helpers/validator/custom-validators/unique-name-group.custom-validator.js

@@ -1,33 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.UniqueNameGroupCustomValidator = void 0;
-const common_functions_1 = require("../../common-functions/common-functions");
-const raw_definition_helper_1 = require("../../raw-definition-helper/raw-definition.helper");
-const custom_validator_helper_1 = require("../custom-validator-helper/custom-validator.helper");
+const common_functions_1 = require('../../common-functions/common-functions');
+const raw_definition_helper_1 = require('../../raw-definition-helper/raw-definition.helper');
+const custom_validator_helper_1 = require('../custom-validator-helper/custom-validator.helper');
 class UniqueNameGroupCustomValidator {
-    constructor(definitionComponentClass) {
-        this.definitionComponentClass = definitionComponentClass;
-        this.regex = /^[a-z]+([a-zA-Z0-9]+)*$/;
-        this.validate = (value, helpers) => {
-            let componentName = this.definitionComponentClass.$meta.componentName;
-            let validationState = custom_validator_helper_1.CustomValidatorHelper.getValidationState(helpers);
-            if (validationState === 'valid') {
-                let { path, rawDefinition } = custom_validator_helper_1.CustomValidatorHelper.getPathAndRawDefinition(helpers);
-                let duplicateHelper = custom_validator_helper_1.CustomValidatorHelper.getDuplicateHelper(componentName);
-                duplicateHelper.newEntry(value, {
-                    line: raw_definition_helper_1.RawDefinitionHelper.findLine(rawDefinition, path),
-                    path: rawDefinition.location.path
-                });
-                return common_functions_1.CommonFunctions.decorateDefinitionName(value, componentName);
-            }
-            else if (validationState === 'registerLoop') {
-                custom_validator_helper_1.CustomValidatorHelper.getDefinitionNames(componentName).add(value);
-            }
-            else {
-                throw new Error(`Internal Error; joi validation context for uniqueNameGroup validator: Path: "${helpers.state.path}", RawDefinition: "${JSON.stringify(helpers.prefs.context)}"`);
-            }
-        };
-    }
+  constructor(definitionComponentClass) {
+    this.definitionComponentClass = definitionComponentClass;
+    this.regex = /^[a-z]+([a-zA-Z0-9]+)*$/;
+    this.validate = (value, helpers) => {
+      let componentName = this.definitionComponentClass.$meta.componentName;
+      let validationState = custom_validator_helper_1.CustomValidatorHelper.getValidationState(helpers);
+      if (validationState === 'valid') {
+        let { path, rawDefinition } = custom_validator_helper_1.CustomValidatorHelper.getPathAndRawDefinition(helpers);
+        let duplicateHelper = custom_validator_helper_1.CustomValidatorHelper.getDuplicateHelper(componentName);
+        duplicateHelper.newEntry(value, {
+          line: raw_definition_helper_1.RawDefinitionHelper.findLine(rawDefinition, path),
+          path: rawDefinition.location.path
+        });
+        return common_functions_1.CommonFunctions.decorateDefinitionName(value, componentName);
+      } else if (validationState === 'registerLoop') {
+        custom_validator_helper_1.CustomValidatorHelper.getDefinitionNames(componentName).add(value);
+      } else {
+        throw new Error(
+          `Internal Error; joi validation context for uniqueNameGroup validator: Path: "${helpers.state.path}", RawDefinition: "${JSON.stringify(helpers.prefs.context)}"`
+        );
+      }
+    };
+  }
 }
 exports.UniqueNameGroupCustomValidator = UniqueNameGroupCustomValidator;
-//# sourceMappingURL=unique-name-group.custom-validator.js.map
+//# sourceMappingURL=unique-name-group.custom-validator.js.map

package/dist/helpers/validator/joi-custom-validators.spec.d.ts

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