@e22m4u/js-repository 0.0.31

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

@@ -0,0 +1,14 @@
+import {Service} from '@e22m4u/js-service';
+import {ModelDefinition} from './model-definition.js';
+
+/**
+ * Model definition validator.
+ */
+export declare class ModelDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param modelDef
+   */
+  validate(modelDef: ModelDefinition): void;
+}

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

@@ -0,0 +1,83 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {RelationsDefinitionValidator} from './relations/index.js';
+import {PropertiesDefinitionValidator} from './properties/index.js';
+
+/**
+ * Model definition validator.
+ */
+export class ModelDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {object} modelDef
+   */
+  validate(modelDef) {
+    if (!modelDef || typeof modelDef !== 'object' || Array.isArray(modelDef))
+      throw new InvalidArgumentError(
+        'The model definition should be an Object, but %v given.',
+        modelDef,
+      );
+    if (!modelDef.name || typeof modelDef.name !== 'string')
+      throw new InvalidArgumentError(
+        'The model definition requires the option "name" ' +
+          'as a non-empty String, but %v given.',
+        modelDef.name,
+      );
+    if (modelDef.datasource && typeof modelDef.datasource !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "datasource" of the model %v ' +
+          'should be a String, but %v given.',
+        modelDef.name,
+        modelDef.datasource,
+      );
+    if (modelDef.base && typeof modelDef.base !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "base" of the model %v ' +
+          'should be a String, but %v given.',
+        modelDef.name,
+        modelDef.base,
+      );
+    if (modelDef.tableName && typeof modelDef.tableName !== 'string')
+      throw new InvalidArgumentError(
+        'The provided option "tableName" of the model %v ' +
+          'should be a String, but %v given.',
+        modelDef.name,
+        modelDef.tableName,
+      );
+    if (modelDef.properties) {
+      if (
+        typeof modelDef.properties !== 'object' ||
+        Array.isArray(modelDef.properties)
+      ) {
+        throw new InvalidArgumentError(
+          'The provided option "properties" of the model %v ' +
+            'should be an Object, but %v given.',
+          modelDef.name,
+          modelDef.properties,
+        );
+      }
+      this.getService(PropertiesDefinitionValidator).validate(
+        modelDef.name,
+        modelDef.properties,
+      );
+    }
+    if (modelDef.relations) {
+      if (
+        typeof modelDef.relations !== 'object' ||
+        Array.isArray(modelDef.relations)
+      ) {
+        throw new InvalidArgumentError(
+          'The provided option "relations" of the model %v ' +
+            'should be an Object, but %v given.',
+          modelDef.name,
+          modelDef.relations,
+        );
+      }
+      this.getService(RelationsDefinitionValidator).validate(
+        modelDef.name,
+        modelDef.relations,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,143 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {RelationsDefinitionValidator} from './relations/index.js';
+import {PropertiesDefinitionValidator} from './properties/index.js';
+import {ModelDefinitionValidator} from './model-definition-validator.js';
+
+const S = new ModelDefinitionValidator();
+const sandbox = chai.spy.sandbox();
+
+describe('ModelDefinitionValidator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  describe('validate', function () {
+    it('requires the given definition to be an object', function () {
+      const validate = v => () => S.validate(v);
+      const error = v =>
+        format('The model definition should be an Object, but %s given.', v);
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate({name: 'model'})();
+    });
+
+    it('requires the option "name" as a non-empty string', function () {
+      const validate = v => () => S.validate({name: v});
+      const error = v =>
+        format(
+          'The model definition requires the option "name" ' +
+            'as a non-empty String, but %s given.',
+          v,
+        );
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate('model')();
+    });
+
+    it('expects the provided option "datasource" to be a string', function () {
+      const validate = v => () => S.validate({name: 'model', datasource: v});
+      const error = v =>
+        format(
+          'The provided option "datasource" of the model "model" ' +
+            'should be a String, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate('datasource')();
+    });
+
+    it('expects the provided option "base" to be a string', function () {
+      const validate = v => () => S.validate({name: 'model', base: v});
+      const error = v =>
+        format(
+          'The provided option "base" of the model "model" ' +
+            'should be a String, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate('base')();
+    });
+
+    it('expects the provided option "tableName" to be a string', function () {
+      const validate = v => () => S.validate({name: 'model', tableName: v});
+      const error = v =>
+        format(
+          'The provided option "tableName" of the model "model" ' +
+            'should be a String, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate('tableName')();
+    });
+
+    it('expects the provided option "properties" to be an object', function () {
+      const validate = v => () => S.validate({name: 'model', properties: v});
+      const error = v =>
+        format(
+          'The provided option "properties" of the model "model" ' +
+            'should be an Object, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      validate({})();
+    });
+
+    it('expects the provided option "relations" to be an object', function () {
+      const validate = v => () => S.validate({name: 'model', relations: v});
+      const error = v =>
+        format(
+          'The provided option "relations" of the model "model" ' +
+            'should be an Object, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      validate({})();
+    });
+
+    it('uses PropertiesDefinitionValidator service to validate model properties', function () {
+      const V = S.getService(PropertiesDefinitionValidator);
+      sandbox.on(V, 'validate');
+      const properties = {};
+      S.validate({name: 'model', properties});
+      expect(V.validate).to.have.been.called.once;
+      expect(V.validate).to.have.been.called.with.exactly('model', properties);
+    });
+
+    it('uses RelationsDefinitionValidator service to validate model relations', function () {
+      const V = S.getService(RelationsDefinitionValidator);
+      sandbox.on(V, 'validate');
+      const relations = {};
+      S.validate({name: 'model', relations});
+      expect(V.validate).to.have.been.called.once;
+      expect(V.validate).to.have.been.called.with.exactly('model', relations);
+    });
+  });
+});

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

@@ -0,0 +1,28 @@
+import {RelationDefinition} from './relations/index.js';
+import {PropertyDefinition} from './properties/index.js';
+
+/**
+ * Property definition map.
+ */
+export declare type PropertyDefinitionMap = {
+  [name: string]: PropertyDefinition;
+};
+
+/**
+ * Relation definition map.
+ */
+export declare type RelationDefinitionMap = {
+  [name: string]: RelationDefinition;
+};
+
+/**
+ * Model definition.
+ */
+export declare type ModelDefinition = {
+  name: string;
+  datasource?: string;
+  base?: string;
+  tableName?: string;
+  properties?: PropertyDefinitionMap;
+  relations?: RelationDefinitionMap;
+};

package/src/definition/model/properties/data-type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Data type.
+ */
+export declare enum DataType {
+  ANY = 'any',
+  STRING = 'string',
+  NUMBER = 'number',
+  BOOLEAN = 'boolean',
+  ARRAY = 'array',
+  OBJECT = 'object',
+}

package/src/definition/model/properties/data-type.js

@@ -0,0 +1,11 @@
+/**
+ * Data type.
+ */
+export const DataType = {
+  ANY: 'any',
+  STRING: 'string',
+  NUMBER: 'number',
+  BOOLEAN: 'boolean',
+  ARRAY: 'array',
+  OBJECT: 'object',
+};

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

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

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

@@ -0,0 +1,53 @@
+import {Service} from '@e22m4u/js-service';
+import {ModelDataValidator} from '../model-data-validator.js';
+import {InvalidArgumentError} from '../../../errors/index.js';
+
+/**
+ * Default values definition validator.
+ */
+export class DefaultValuesDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {string} modelName
+   * @param {object} propDefs
+   */
+  validate(modelName, propDefs) {
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'A first argument of DefaultValuesDefinitionValidator.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,
+      );
+    Object.keys(propDefs).forEach(propName => {
+      const propDef = propDefs[propName];
+      if (typeof propDef === 'string') return;
+      if (!('default' in propDef)) return;
+      const propValue =
+        propDef.default instanceof Function
+          ? propDef.default()
+          : propDef.default;
+      try {
+        this.getService(ModelDataValidator).validatePropertyValue(
+          modelName,
+          propName,
+          propDef,
+          propValue,
+        );
+      } catch (error) {
+        if (error instanceof InvalidArgumentError)
+          throw new InvalidArgumentError(
+            `A default value is invalid. ${error.message}`,
+          );
+        throw error;
+      }
+    });
+  }
+}

package/src/definition/model/properties/default-values-definition-validator.spec.js

@@ -0,0 +1,136 @@
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
+
+const S = new DefaultValuesDefinitionValidator();
+
+describe('DefaultValuesDefinitionValidator', function () {
+  describe('validate', function () {
+    it('requires a first argument to be a non-empty string', function () {
+      const validate = v => () => S.validate(v, {});
+      const error = v =>
+        format(
+          'A first argument of DefaultValuesDefinitionValidator.validate ' +
+            'should be a non-empty String, but %s given.',
+          v,
+        );
+      expect(validate('')).to.throw(error('""'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate('model')();
+    });
+
+    it('requires a second argument to be an object', function () {
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
+        format(
+          'The provided option "properties" of the model "model" ' +
+            'should be an Object, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate(false)).to.throw(error('false'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate({})();
+    });
+
+    it('does not throw an error if no properties defined', function () {
+      S.validate('model', {});
+    });
+
+    it('does not throw an error if no default value specified for a required property', function () {
+      S.validate('model', {
+        foo: {
+          type: DataType.STRING,
+          required: true,
+        },
+      });
+    });
+
+    it('does not throw an error if a default value matches a property type', function () {
+      S.validate('model', {
+        foo: {
+          type: DataType.BOOLEAN,
+          default: false,
+        },
+      });
+    });
+
+    it('does not throw an error if a default value from a factory function matches a property type', function () {
+      S.validate('model', {
+        foo: {
+          type: DataType.BOOLEAN,
+          default: () => false,
+        },
+      });
+    });
+
+    it('throws an error if a default value does not match a property type', function () {
+      const throwable = () =>
+        S.validate('model', {
+          foo: {
+            type: DataType.STRING,
+            default: 10,
+          },
+        });
+      expect(throwable).to.throw(
+        'A default value is invalid. The property "foo" of the model ' +
+          '"model" must have a String, but Number given.',
+      );
+    });
+
+    it('throws an error if a default value from a factory function does not match a property type', function () {
+      const throwable = () =>
+        S.validate('model', {
+          foo: {
+            type: DataType.STRING,
+            default: () => 10,
+          },
+        });
+      expect(throwable).to.throw(
+        'A default value is invalid. The property "foo" of the model ' +
+          '"model" must have a String, but Number given.',
+      );
+    });
+
+    it('throws an error if an array element of a default value does not match an item type', function () {
+      const throwable = () =>
+        S.validate('model', {
+          foo: {
+            type: DataType.ARRAY,
+            itemType: DataType.STRING,
+            default: [10],
+          },
+        });
+      expect(throwable).to.throw(
+        'A default value is invalid. The array property "foo" of the model "model" ' +
+          'must have a String element, but Number given.',
+      );
+    });
+
+    it('throws an error if an array element from a default value factory does not match an item type', function () {
+      const throwable = () =>
+        S.validate('model', {
+          foo: {
+            type: DataType.ARRAY,
+            itemType: DataType.STRING,
+            default: () => [10],
+          },
+        });
+      expect(throwable).to.throw(
+        'A default value is invalid. The array property "foo" of the model "model" ' +
+          'must have a String element, but Number given.',
+      );
+    });
+  });
+});

package/src/definition/model/properties/index.d.ts

@@ -0,0 +1,5 @@
+export * from './data-type.js';
+export * from './property-definition.js';
+export * from './properties-definition-validator.js';
+export * from './primary-keys-definition-validator.js';
+export * from './default-values-definition-validator.js';

package/src/definition/model/properties/index.js

@@ -0,0 +1,4 @@
+export * from './data-type.js';
+export * from './properties-definition-validator.js';
+export * from './primary-keys-definition-validator.js';
+export * from './default-values-definition-validator.js';

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

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

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

@@ -0,0 +1,55 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../../errors/index.js';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../model-definition-utils.js';
+
+/**
+ * Primary keys definition validator.
+ */
+export class PrimaryKeysDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {string} modelName
+   * @param {object} propDefs
+   */
+  validate(modelName, propDefs) {
+    const propNames = Object.keys(propDefs).filter(propName => {
+      const propDef = propDefs[propName];
+      return propDef && typeof propDef === 'object' && propDef.primaryKey;
+    });
+    if (propNames.length < 1) {
+      const isDefaultPrimaryKeyAlreadyInUse =
+        Object.keys(propDefs).includes(DEF_PK);
+      if (isDefaultPrimaryKeyAlreadyInUse)
+        throw new InvalidArgumentError(
+          'The property name %v of the model %v 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,
+          modelName,
+        );
+      return;
+    }
+    if (propNames.length > 1)
+      throw new InvalidArgumentError(
+        'The model definition %v should not have ' +
+          'multiple primary keys, but %v keys given.',
+        modelName,
+        propNames.length,
+      );
+    const pkPropName = propNames[0];
+    const pkPropDef = propDefs[pkPropName];
+    if (
+      pkPropDef &&
+      typeof pkPropDef === 'object' &&
+      pkPropDef.default !== undefined
+    ) {
+      throw new InvalidArgumentError(
+        'Do not specify a default value for the ' +
+          'primary key %v of the model %v.',
+        pkPropName,
+        modelName,
+      );
+    }
+  }
+}