@e22m4u/js-repository 0.0.31

package/src/definition/model/properties/primary-keys-definition-validator.spec.js

@@ -0,0 +1,145 @@
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../model-definition-utils.js';
+
+const S = new PrimaryKeysDefinitionValidator();
+
+describe('PrimaryKeysDefinitionValidator', function () {
+  describe('validate', function () {
+    it('does not throw an error if no primary keys provided in case of a short property definition', function () {
+      S.validate('model', {
+        foo: DataType.STRING,
+        bar: DataType.NUMBER,
+      });
+    });
+
+    it('does not throw an error if no primary keys provided in case of a full property definition', function () {
+      S.validate('model', {
+        foo: {
+          type: DataType.STRING,
+          default: 'string',
+        },
+        bar: {
+          type: DataType.NUMBER,
+          default: 10,
+        },
+      });
+    });
+
+    it('throws an error if a model definition has a multiple primary keys', function () {
+      const throwable = () =>
+        S.validate('model', {
+          foo: {
+            type: DataType.NUMBER,
+            primaryKey: true,
+          },
+          bar: {
+            type: DataType.NUMBER,
+            primaryKey: true,
+          },
+        });
+      expect(throwable).to.throw(
+        'The model definition "model" should not have ' +
+          'multiple primary keys, but 2 keys given.',
+      );
+    });
+
+    it('throws an error if a default primary key is already in use as a regular property in case of a short property definition', function () {
+      const throwable = () =>
+        S.validate('model', {
+          [DEF_PK]: DataType.NUMBER,
+        });
+      expect(throwable).to.throw(
+        format(
+          'The property name %v of the model "model" is defined as a regular property. ' +
+            'In this case, a primary key should be defined explicitly. ' +
+            'Do use the option "primaryKey" to specify the primary key.',
+          DEF_PK,
+        ),
+      );
+    });
+
+    it('throws an error if a default primary key is already in use as a regular property in case of a full property definition', function () {
+      const throwable = () =>
+        S.validate('model', {
+          [DEF_PK]: {
+            type: DataType.NUMBER,
+          },
+        });
+      expect(throwable).to.throw(
+        format(
+          'The property name %v of the model "model" is defined as a regular property. ' +
+            'In this case, a primary key should be defined explicitly. ' +
+            'Do use the option "primaryKey" to specify the primary key.',
+          DEF_PK,
+        ),
+      );
+    });
+
+    it('throws an error if a default primary key is already in use as a regular property with a default value', function () {
+      const throwable = () =>
+        S.validate('model', {
+          [DEF_PK]: {
+            type: DataType.NUMBER,
+            default: 10,
+          },
+        });
+      expect(throwable).to.throw(
+        format(
+          'The property name %v of the model "model" is defined as a regular property. ' +
+            'In this case, a primary key should be defined explicitly. ' +
+            'Do use the option "primaryKey" to specify the primary key.',
+          DEF_PK,
+        ),
+      );
+    });
+
+    it('throws an error if a default primary key defined explicitly and it has a default value', function () {
+      const throwable = () =>
+        S.validate('model', {
+          [DEF_PK]: {
+            type: DataType.NUMBER,
+            primaryKey: true,
+            default: 10,
+          },
+        });
+      expect(throwable).to.throw(
+        format(
+          'Do not specify a default value for the ' +
+            'primary key %v of the model "model".',
+          DEF_PK,
+        ),
+      );
+    });
+
+    it('does not throw an error if a default primary key is defined explicitly', function () {
+      S.validate('model', {
+        [DEF_PK]: {
+          type: DataType.NUMBER,
+          primaryKey: true,
+        },
+      });
+    });
+
+    it('does not throw an error if a primary key has a custom name', function () {
+      S.validate('model', {
+        myId: {
+          type: DataType.NUMBER,
+          primaryKey: true,
+        },
+      });
+    });
+
+    it('does not throw an error if a primary key has a custom name and a default primary key is used as a regular property', function () {
+      S.validate('model', {
+        myId: {
+          type: DataType.NUMBER,
+          primaryKey: true,
+        },
+        [DEF_PK]: DataType.STRING,
+      });
+    });
+  });
+});

package/src/definition/model/properties/properties-definition-validator.d.ts

@@ -0,0 +1,15 @@
+import {Service} from '@e22m4u/js-service';
+import {PropertyDefinitionMap} from '../model-definition.js';
+
+/**
+ * Properties definition validator.
+ */
+export declare class PropertiesDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param modelName
+   * @param propDefs
+   */
+  validate(modelName: string, propDefs: PropertyDefinitionMap): void;
+}

package/src/definition/model/properties/properties-definition-validator.js

@@ -0,0 +1,194 @@
+import {Service} from '@e22m4u/js-service';
+import {DataType as Type} from './data-type.js';
+import {InvalidArgumentError} from '../../../errors/index.js';
+import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
+import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
+
+/**
+ * Properties definition validator.
+ */
+export class PropertiesDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {string} modelName
+   * @param {object} propDefs
+   */
+  validate(modelName, propDefs) {
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'A first argument of PropertiesDefinitionValidator.validate ' +
+          'should be a non-empty String, but %v given.',
+        modelName,
+      );
+    if (!propDefs || typeof propDefs !== 'object' || Array.isArray(propDefs)) {
+      throw new InvalidArgumentError(
+        'The provided option "properties" of the model %v ' +
+          'should be an Object, but %v given.',
+        modelName,
+        propDefs,
+      );
+    }
+    const propNames = Object.keys(propDefs);
+    propNames.forEach(propName => {
+      const propDef = propDefs[propName];
+      this._validateProperty(modelName, propName, propDef);
+    });
+    this.getService(PrimaryKeysDefinitionValidator).validate(
+      modelName,
+      propDefs,
+    );
+    this.getService(DefaultValuesDefinitionValidator).validate(
+      modelName,
+      propDefs,
+    );
+  }
+
+  /**
+   * Validate property.
+   *
+   * @param {string} modelName
+   * @param {string} propName
+   * @param {object} propDef
+   */
+  _validateProperty(modelName, propName, propDef) {
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'A first argument of PropertiesDefinitionValidator._validateProperty ' +
+          'should be a non-empty String, but %v given.',
+        modelName,
+      );
+    if (!propName || typeof propName !== 'string')
+      throw new InvalidArgumentError(
+        'The property name of the model %v should be ' +
+          'a non-empty String, but %v given.',
+        modelName,
+        propName,
+      );
+    if (!propDef)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v should have ' +
+          'a property definition, but %v given.',
+        propName,
+        modelName,
+        propDef,
+      );
+    if (typeof propDef === 'string') {
+      if (!Object.values(Type).includes(propDef))
+        throw new InvalidArgumentError(
+          'In case of a short property definition, the property %v ' +
+            'of the model %v should have one of data types: %l, but %v given.',
+          propName,
+          modelName,
+          Object.values(Type),
+          propDef,
+        );
+      return;
+    }
+    if (!propDef || typeof propDef !== 'object' || Array.isArray(propDef)) {
+      throw new InvalidArgumentError(
+        'In case of a full property definition, the property %v ' +
+          'of the model %v should be an Object, but %v given.',
+        propName,
+        modelName,
+        propDef,
+      );
+    }
+    if (!propDef.type || !Object.values(Type).includes(propDef.type))
+      throw new InvalidArgumentError(
+        'The property %v of the model %v requires the option "type" ' +
+          'to have one of data types: %l, but %v given.',
+        propName,
+        modelName,
+        Object.values(Type),
+        propDef.type,
+      );
+    if (propDef.itemType && !Object.values(Type).includes(propDef.itemType)) {
+      throw new InvalidArgumentError(
+        'The provided option "itemType" of the property %v in the model %v ' +
+          'should have one of data types: %l, but %v given.',
+        propName,
+        modelName,
+        Object.values(Type),
+        propDef.itemType,
+      );
+    }
+    if (propDef.model && typeof propDef.model !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "model" of the property %v in the model %v ' +
+          'should be a String, but %v given.',
+        propName,
+        modelName,
+        propDef.model,
+      );
+    if (propDef.primaryKey && typeof propDef.primaryKey !== 'boolean')
+      throw new InvalidArgumentError(
+        'The provided option "primaryKey" of the property %v in the model %v ' +
+          'should be a Boolean, but %v given.',
+        propName,
+        modelName,
+        propDef.primaryKey,
+      );
+    if (propDef.columnName && typeof propDef.columnName !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "columnName" of the property %v in the model %v ' +
+          'should be a String, but %v given.',
+        propName,
+        modelName,
+        propDef.columnName,
+      );
+    if (propDef.columnType && typeof propDef.columnType !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "columnType" of the property %v in the model %v ' +
+          'should be a String, but %v given.',
+        propName,
+        modelName,
+        propDef.columnType,
+      );
+    if (propDef.required && typeof propDef.required !== 'boolean')
+      throw new InvalidArgumentError(
+        'The provided option "required" of the property %v in the model %v ' +
+          'should be a Boolean, but %v given.',
+        propName,
+        modelName,
+        propDef.required,
+      );
+    if (propDef.required && propDef.default !== undefined)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v is a required property, ' +
+          'so it should not have the option "default" to be provided.',
+        propName,
+        modelName,
+      );
+    if (propDef.primaryKey && propDef.required)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v is a primary key, ' +
+          'so it should not have the option "required" to be provided.',
+        propName,
+        modelName,
+      );
+    if (propDef.primaryKey && propDef.default !== undefined)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v is a primary key, ' +
+          'so it should not have the option "default" to be provided.',
+        propName,
+        modelName,
+      );
+    if (propDef.itemType && propDef.type !== Type.ARRAY)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v has the non-array type, ' +
+          'so it should not have the option "itemType" to be provided.',
+        propName,
+        modelName,
+        propDef.type,
+      );
+    if (propDef.model && propDef.type !== Type.OBJECT)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v has the non-object type, ' +
+          'so it should not have the option "model" to be provided.',
+        propName,
+        modelName,
+        propDef.type,
+      );
+  }
+}