@e22m4u/js-repository 0.0.31

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

@@ -0,0 +1,373 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {DataType} from './data-type.js';
+import {format} from '@e22m4u/js-format';
+import {PropertiesDefinitionValidator} from './properties-definition-validator.js';
+import {PrimaryKeysDefinitionValidator} from './primary-keys-definition-validator.js';
+import {DefaultValuesDefinitionValidator} from './default-values-definition-validator.js';
+
+const S = new PropertiesDefinitionValidator();
+const sandbox = chai.spy.sandbox();
+
+describe('PropertiesDefinitionValidator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  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 PropertiesDefinitionValidator.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('requires a property name as a non-empty string', function () {
+      const validate = v => () => S.validate('model', v);
+      const error = v =>
+        format(
+          'The property name of the model "model" should be ' +
+            'a non-empty String, but %s given.',
+          v,
+        );
+      expect(validate({['']: {}})).to.throw(error('""'));
+      validate({foo: DataType.STRING})();
+    });
+
+    it('requires a property definition', function () {
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
+        format(
+          'The property "foo" of the model "model" should have ' +
+            'a property definition, but %s given.',
+          v,
+        );
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate(DataType.STRING)();
+      validate({type: DataType.STRING})();
+    });
+
+    it('expects a short property definition to be DataType', function () {
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
+        format(
+          'In case of a short property definition, the property "foo" ' +
+            'of the model "model" should have one of data types: %l, but %s given.',
+          Object.values(DataType),
+          v,
+        );
+      expect(validate('invalid')).to.throw(error('"invalid"'));
+      validate(DataType.STRING)();
+    });
+
+    it('expects a full property definition to be an object', function () {
+      const validate = v => () => S.validate('model', {foo: v});
+      const error = v =>
+        format(
+          'In case of a full property definition, the property "foo" ' +
+            'of the model "model" should be an Object, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      validate({type: DataType.STRING})();
+    });
+
+    it('requires the option "type" to be a DataType', function () {
+      const validate = v => () => S.validate('model', {foo: {type: v}});
+      const error = v =>
+        format(
+          'The property "foo" of the model "model" requires the option "type" ' +
+            'to have one of data types: %l, but %s given.',
+          Object.values(DataType),
+          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({})).to.throw(error('Object'));
+      expect(validate(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate(DataType.STRING)();
+    });
+
+    it('expects provided the option "itemType" to be a DataType', function () {
+      const validate = v => {
+        const foo = {type: DataType.ARRAY, itemType: v};
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "itemType" of the property "foo" in the model "model" ' +
+            'should have one of data types: %l, but %s given.',
+          Object.values(DataType),
+          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'));
+      expect(validate({})).to.throw(error('Object'));
+      validate(DataType.STRING)();
+    });
+
+    it('expects provided the option "model" to be a string', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.OBJECT,
+          model: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "model" of the property "foo" in 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('model')();
+    });
+
+    it('expects provided the option "primaryKey" to be a boolean', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          primaryKey: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "primaryKey" of the property "foo" in the model "model" ' +
+            'should be a Boolean, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate(true)();
+      validate(false)();
+    });
+
+    it('expects provided the option "columnName" to be a string', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          columnName: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "columnName" of the property "foo" in 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('columnName')();
+    });
+
+    it('expects provided the option "columnType" to be a string', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          columnType: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "columnType" of the property "foo" in 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('columnType')();
+    });
+
+    it('expects provided the option "required" to be a boolean', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          required: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "required" of the property "foo" in the model "model" ' +
+            'should be a Boolean, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate([])).to.throw(error('Array'));
+      expect(validate({})).to.throw(error('Object'));
+      validate(true)();
+      validate(false)();
+    });
+
+    it('expects the required property should not have the option "default" to be provided', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          required: true,
+          default: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = format(
+        'The property "foo" of the model "model" is a required property, ' +
+          'so it should not have the option "default" to be provided.',
+      );
+      expect(validate('str')).to.throw(error);
+      expect(validate(10)).to.throw(error);
+      expect(validate(true)).to.throw(error);
+      expect(validate(false)).to.throw(error);
+      expect(validate([])).to.throw(error);
+      expect(validate({})).to.throw(error);
+      expect(validate(null)).to.throw(error);
+      validate(undefined);
+    });
+
+    it('expects the primary key should not have the option "required" to be true', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          primaryKey: true,
+          required: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = format(
+        'The property "foo" of the model "model" is a primary key, ' +
+          'so it should not have the option "required" to be provided.',
+      );
+      expect(validate(true)).to.throw(error);
+      validate(false);
+      validate(undefined);
+    });
+
+    it('expects the primary key should not have the option "default" to be provided', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          primaryKey: true,
+          default: v,
+        };
+        S.validate('model', {foo});
+      };
+      const error = format(
+        'The property "foo" of the model "model" is a primary key, ' +
+          'so it should not have the option "default" to be provided.',
+      );
+      expect(validate('str')).to.throw(error);
+      expect(validate(10)).to.throw(error);
+      expect(validate(true)).to.throw(error);
+      expect(validate(false)).to.throw(error);
+      expect(validate([])).to.throw(error);
+      expect(validate({})).to.throw(error);
+      expect(validate(null)).to.throw(error);
+      validate(undefined);
+    });
+
+    it('expects a non-array property should not have the option "itemType" to be provided', function () {
+      const validate = v => () => {
+        const foo = {
+          type: v,
+          itemType: DataType.STRING,
+        };
+        S.validate('model', {foo});
+      };
+      const error =
+        'The property "foo" of the model "model" has the non-array type, ' +
+        'so it should not have the option "itemType" to be provided.';
+      expect(validate(DataType.ANY)).to.throw(error);
+      expect(validate(DataType.STRING)).to.throw(error);
+      expect(validate(DataType.NUMBER)).to.throw(error);
+      expect(validate(DataType.BOOLEAN)).to.throw(error);
+      expect(validate(DataType.OBJECT)).to.throw(error);
+      validate(DataType.ARRAY);
+    });
+
+    it('expects a non-object property should not have the option "model" to be provided', function () {
+      const validate = v => () => {
+        const foo = {
+          type: v,
+          model: 'model',
+        };
+        S.validate('model', {foo});
+      };
+      const error =
+        'The property "foo" of the model "model" has the non-object type, ' +
+        'so it should not have the option "model" to be provided.';
+      expect(validate(DataType.ANY)).to.throw(error);
+      expect(validate(DataType.STRING)).to.throw(error);
+      expect(validate(DataType.NUMBER)).to.throw(error);
+      expect(validate(DataType.BOOLEAN)).to.throw(error);
+      expect(validate(DataType.ARRAY)).to.throw(error);
+      validate(DataType.OBJECT);
+    });
+
+    it('uses PrimaryKeysDefinitionValidator to validate primary keys', function () {
+      const V = S.getService(PrimaryKeysDefinitionValidator);
+      sandbox.on(V, 'validate');
+      const propDefs = {};
+      S.validate('model', propDefs);
+      expect(V.validate).to.have.been.called.once;
+      expect(V.validate).to.have.been.called.with.exactly('model', propDefs);
+    });
+
+    it('uses DefaultValuesDefinitionValidator to validate default values', function () {
+      const V = S.getService(DefaultValuesDefinitionValidator);
+      sandbox.on(V, 'validate');
+      const propDefs = {};
+      S.validate('model', propDefs);
+      expect(V.validate).to.have.been.called.once;
+      expect(V.validate).to.have.been.called.with.exactly('model', propDefs);
+    });
+  });
+});

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

@@ -0,0 +1,20 @@
+import {DataType} from './data-type.js';
+
+/**
+ * Full property definition.
+ */
+export declare type FullPropertyDefinition = {
+  type: DataType;
+  itemType?: DataType;
+  model?: string;
+  primaryKey?: boolean;
+  columnName?: string;
+  columnType?: string;
+  required?: boolean;
+  default?: unknown;
+};
+
+/**
+ * Property definition.
+ */
+declare type PropertyDefinition = DataType | FullPropertyDefinition;

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

@@ -0,0 +1,3 @@
+export * from './relation-type.js';
+export * from './relation-definition.js';
+export * from './relations-definition-validator.js';

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

@@ -0,0 +1,2 @@
+export * from './relation-type.js';
+export * from './relations-definition-validator.js';

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

@@ -0,0 +1,254 @@
+import {RelationType} from './relation-type.js';
+
+/**
+ * Relation definition.
+ *
+ * @example Available options.
+ * ```ts
+ * {
+ *   type: RelationType;
+ *   model?: string;
+ *   foreignKey?: string;
+ *   polymorphic?: boolean | string;
+ *   discriminator?: string;
+ * }
+ * ```
+ */
+export declare type RelationDefinition =
+  // belongsTo
+  | BelongsToDefinition
+  | PolyBelongsToDefinition
+  // hasOne
+  | HasOneDefinition
+  | PolyHasOneDefinitionWithTargetRelationName
+  | PolyHasOneDefinitionWithTargetKeys
+  // hasMany
+  | HasManyDefinition
+  | PolyHasManyDefinitionWithTargetRelationName
+  | PolyHasManyDefinitionWithTargetKeys
+  // referencesMany
+  | ReferencesManyDefinition;
+
+/**
+ * The regular "belongsTo" relation.
+ *
+ * @example Required options only.
+ * ```
+ * {
+ *   type: RelationType.BELONGS_TO,
+ *   model: 'model',
+ * }
+ * ```
+ *
+ * @example Verbose definition.
+ * ```
+ * {
+ *   type: RelationType.BELONGS_TO,
+ *   model: 'model',
+ *   foreignKey: 'modelId',
+ * }
+ * ```
+ */
+export declare type BelongsToDefinition = {
+  type: RelationType.BELONGS_TO;
+  polymorphic?: false;
+  model: string;
+  foreignKey?: string;
+};
+
+/**
+ * The polymorphic "belongsTo" relation.
+ *
+ * @example Required fields only.
+ * ```
+ * {
+ *   type: RelationType.BELONGS_TO,
+ *   polymorphic: true,
+ * }
+ * ```
+ *
+ * @example Verbose definition.
+ * ```
+ * {
+ *   type: RelationType.BELONGS_TO,
+ *   polymorphic: true,
+ *   foreignKey: 'referenceId',
+ *   discriminator: 'referenceType,
+ * }
+ * ```
+ */
+export declare type PolyBelongsToDefinition = {
+  type: RelationType.BELONGS_TO;
+  polymorphic: true;
+  foreignKey?: string;
+  discriminator?: string;
+};
+
+/**
+ * The regular "hasOne" relation.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: RelationType.HAS_ONE,
+ *   model: 'model',
+ *   foreignKey: 'modelId',
+ * }
+ * ```
+ */
+export declare type HasOneDefinition = {
+  type: RelationType.HAS_ONE;
+  model: string;
+  polymorphic?: false;
+  foreignKey?: string;
+  discriminator?: undefined;
+};
+
+/**
+ * The polymorphic "hasOne" relation with a target relation name.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: RelationType.HAS_ONE,
+ *   model: 'model',
+ *   polymorphic: 'reference',
+ * }
+ * ```
+ */
+export declare type PolyHasOneDefinitionWithTargetRelationName = {
+  type: RelationType.HAS_ONE;
+  model: string;
+  polymorphic: string;
+  foreignKey?: undefined;
+  discriminator?: undefined;
+};
+
+/**
+ * The polymorphic "hasOne" relation with target relation keys.
+ *
+ * @example Required options only.
+ * ```
+ * {
+ *   type: RelationType.HAS_ONE,
+ *   model: 'model',
+ *   polymorphic: true,
+ * }
+ * ```
+ *
+ * @example Verbose definition.
+ * ```
+ * {
+ *   type: RelationType.HAS_ONE,
+ *   model: 'model',
+ *   polymorphic: true,
+ *   foreignKey: 'referenceId',
+ *   discriminator: 'referenceType,
+ * }
+ * ```
+ */
+export declare type PolyHasOneDefinitionWithTargetKeys = {
+  type: RelationType.HAS_ONE;
+  model: string;
+  polymorphic: true;
+  foreignKey?: string;
+  discriminator?: string;
+};
+
+/**
+ * The regular "hasMany" relation.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: RelationType.HAS_MANY,
+ *   model: 'model',
+ *   foreignKey: 'modelId',
+ * }
+ * ```
+ */
+export declare type HasManyDefinition = {
+  type: RelationType.HAS_MANY;
+  model: string;
+  polymorphic?: false;
+  foreignKey?: string;
+  discriminator?: undefined;
+};
+
+/**
+ * The polymorphic "hasMany" relation with a target relation name.
+ *
+ * @example
+ * ```ts
+ * {
+ *   type: RelationType.HAS_MANY,
+ *   model: 'model',
+ *   polymorphic: 'reference',
+ * }
+ * ```
+ */
+export declare type PolyHasManyDefinitionWithTargetRelationName = {
+  type: RelationType.HAS_MANY;
+  model: string;
+  polymorphic: string;
+  foreignKey?: undefined;
+  discriminator?: undefined;
+};
+
+/**
+ * The polymorphic "hasMany" relation with target relation keys.
+ *
+ * @example Required options only.
+ * ```
+ * {
+ *   type: RelationType.HAS_MANY,
+ *   model: 'model',
+ *   polymorphic: true,
+ * }
+ * ```
+ *
+ * @example Verbose definition.
+ * ```
+ * {
+ *   type: RelationType.HAS_MANY,
+ *   model: 'model',
+ *   polymorphic: true,
+ *   foreignKey: 'referenceId',
+ *   discriminator: 'referenceType,
+ * }
+ * ```
+ */
+export declare type PolyHasManyDefinitionWithTargetKeys = {
+  type: RelationType.HAS_MANY;
+  model: string;
+  polymorphic: true;
+  foreignKey?: string;
+  discriminator?: string;
+};
+
+/**
+ * The regular "referencesMany" relation.
+ *
+ * @example Required options only.
+ * ```
+ * {
+ *   type: RelationType.REFERENCES_MANY,
+ *   model: 'model',
+ * }
+ * ```
+ *
+ * @example Verbose definition.
+ * ```
+ * {
+ *   type: RelationType.REFERENCES_MANY,
+ *   model: 'model',
+ *   foreignKey: 'modelIds',
+ * }
+ * ```
+ */
+export declare type ReferencesManyDefinition = {
+  type: RelationType.REFERENCES_MANY;
+  model: string;
+  foreignKey?: string;
+  discriminator?: undefined;
+};

package/src/definition/model/relations/relation-type.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Relation type.
+ */
+export declare enum RelationType {
+  BELONGS_TO = 'belongsTo',
+  HAS_ONE = 'hasOne',
+  HAS_MANY = 'hasMany',
+  REFERENCES_MANY = 'referencesMany',
+}

package/src/definition/model/relations/relation-type.js

@@ -0,0 +1,9 @@
+/**
+ * Relation type.
+ */
+export const RelationType = {
+  BELONGS_TO: 'belongsTo',
+  HAS_ONE: 'hasOne',
+  HAS_MANY: 'hasMany',
+  REFERENCES_MANY: 'referencesMany',
+};

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

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