@e22m4u/js-repository 0.1.7 → 0.1.9

package/src/adapter/decorator/property-uniqueness-decorator.spec.js

@@ -0,0 +1,135 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {PropertyUniquenessValidator} from '../../definition/index.js';
+
+const S = new Schema();
+S.defineModel({name: 'model'});
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  create(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceOrCreate(modelName, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patch(modelName, modelData, where = undefined) {
+    return Promise.resolve(modelData);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patchById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve(modelData);
+  }
+}
+
+const A = S.getService(TestAdapter);
+const V = S.getService(PropertyUniquenessValidator);
+const sandbox = chai.spy.sandbox();
+
+describe('PropertyUniquenessDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('create');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.create('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "replaceById" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('replaceById');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.eq(1);
+      },
+    );
+    const res = await A.replaceById('model', 1, data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "replaceOrCreate" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('replaceOrCreate');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.replaceOrCreate('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "patch" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('patch');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.undefined;
+      },
+    );
+    const res = await A.patch('model', data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+
+  it('overrides the "patchById" method and validates a given data', async function () {
+    const data = {kind: 'data'};
+    sandbox.on(
+      V,
+      'validate',
+      (countMethod, methodName, modelName, modelData, id = undefined) => {
+        expect(typeof countMethod).to.be.eq('function');
+        expect(methodName).to.be.eq('patchById');
+        expect(modelName).to.be.eq('model');
+        expect(modelData).to.be.eql(data);
+        expect(id).to.be.eq(1);
+      },
+    );
+    const res = await A.patchById('model', 1, data);
+    expect(res).to.be.eql(data);
+    expect(V.validate).to.be.called.once;
+  });
+});

package/src/definition/definition-registry.spec.js

@@ -8,6 +8,7 @@ const sandbox = chai.spy.sandbox();
 
 describe('DefinitionRegistry', function () {
   let S;
+
   beforeEach(function () {
     S = new DefinitionRegistry();
   });

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

@@ -2,5 +2,6 @@ export * from './data-type.js';
 export * from './property-definition.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
+export * from './property-uniqueness-validator.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -2,5 +2,6 @@ export * from './data-type.js';
 export * from './property-definition.js';
 export * from './property-validator/index.js';
 export * from './property-transformer/index.js';
+export * from './property-uniqueness-validator.js';
 export * from './properties-definition-validator.js';
 export * from './primary-keys-definition-validator.js';

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

@@ -297,5 +297,20 @@ export class PropertiesDefinitionValidator extends Service {
         );
       }
     }
+    if (propDef.unique && typeof propDef.unique !== 'boolean')
+      throw new InvalidArgumentError(
+        'The provided option "unique" of the property %v in the model %v ' +
+          'should be a Boolean, but %v given.',
+        propName,
+        modelName,
+        propDef.unique,
+      );
+    if (propDef.unique && propDef.primaryKey)
+      throw new InvalidArgumentError(
+        'The property %v of the model %v is a primary key, ' +
+          'so it should not have the option "unique" to be provided.',
+        propName,
+        modelName,
+      );
   }
 }

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

@@ -250,6 +250,7 @@ describe('PropertiesDefinitionValidator', function () {
             'should be a Boolean, but %s given.',
           v,
         );
+      expect(validate('str')).to.throw(error('"str"'));
       expect(validate(10)).to.throw(error('10'));
       expect(validate([])).to.throw(error('Array'));
       expect(validate({})).to.throw(error('Object'));
@@ -277,7 +278,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate([])).to.throw(error);
       expect(validate({})).to.throw(error);
       expect(validate(null)).to.throw(error);
-      validate(undefined);
+      validate(undefined)();
     });
 
     it('expects the primary key should not have the option "required" to be true', function () {
@@ -294,8 +295,8 @@ describe('PropertiesDefinitionValidator', function () {
           'so it should not have the option "required" to be provided.',
       );
       expect(validate(true)).to.throw(error);
-      validate(false);
-      validate(undefined);
+      validate(false)();
+      validate(undefined)();
     });
 
     it('expects the primary key should not have the option "default" to be provided', function () {
@@ -318,7 +319,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate([])).to.throw(error);
       expect(validate({})).to.throw(error);
       expect(validate(null)).to.throw(error);
-      validate(undefined);
+      validate(undefined)();
     });
 
     it('expects a non-array property should not have the option "itemType" to be provided', function () {
@@ -337,7 +338,7 @@ describe('PropertiesDefinitionValidator', function () {
       expect(validate(DataType.NUMBER)).to.throw(error);
       expect(validate(DataType.BOOLEAN)).to.throw(error);
       expect(validate(DataType.OBJECT)).to.throw(error);
-      validate(DataType.ARRAY);
+      validate(DataType.ARRAY)();
     });
 
     it('the option "model" requires the "object" property type', function () {
@@ -488,5 +489,45 @@ describe('PropertiesDefinitionValidator', function () {
       validate(['myTransformer'])();
       validate({myTransformer: true})();
     });
+
+    it('expects provided the option "unique" to be a boolean', function () {
+      const validate = v => {
+        const foo = {
+          type: DataType.STRING,
+          unique: v,
+        };
+        return () => S.validate('model', {foo});
+      };
+      const error = v =>
+        format(
+          'The provided option "unique" of the property "foo" in the model "model" ' +
+            'should be a Boolean, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      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 primary key should not have the option "unique" to be true', function () {
+      const validate = v => () => {
+        const foo = {
+          type: DataType.ANY,
+          primaryKey: true,
+          unique: 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 "unique" to be provided.',
+      );
+      expect(validate(true)).to.throw(error);
+      validate(false)();
+      validate(undefined)();
+    });
   });
 });

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

@@ -1,5 +1,6 @@
 import {DataType} from './data-type.js';
 import {PropertyValidateOptions} from './property-validator/index.js';
+import {PropertyTransformOptions} from './property-transformer/index.js';
 
 /**
  * Full property definition.
@@ -14,6 +15,8 @@ export declare type FullPropertyDefinition = {
   required?: boolean;
   default?: unknown;
   validate?: PropertyValidateOptions;
+  transform?: PropertyTransformOptions;
+  unique?: boolean;
 };
 
 /**

package/src/definition/model/properties/property-transformer/builtin/index.d.ts

@@ -1 +1,4 @@
 export * from './trim-transformer.js';
+export * from './to-lower-case-transformer.js';
+export * from './to-upper-case-transformer.js';
+export * from './to-title-case-transformer.js';

package/src/definition/model/properties/property-transformer/builtin/index.js

@@ -1 +1,4 @@
 export * from './trim-transformer.js';
+export * from './to-lower-case-transformer.js';
+export * from './to-upper-case-transformer.js';
+export * from './to-title-case-transformer.js';

package/src/definition/model/properties/property-transformer/builtin/to-lower-case-transformer.d.ts

@@ -0,0 +1,6 @@
+import {PropertyTransformer} from '../property-transformer.js';
+
+/**
+ * To lower case transformer.
+ */
+export declare type toLowerCaseTransformer = PropertyTransformer;

package/src/definition/model/properties/property-transformer/builtin/to-lower-case-transformer.js

@@ -0,0 +1,19 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * To lower case transformer.
+ *
+ * @param {*} value
+ * @param {undefined} options
+ * @param {object} context
+ * @returns {string|undefined|null}
+ */
+export function toLowerCaseTransformer(value, options, context) {
+  if (value == null) return value;
+  if (typeof value === 'string') return value.toLowerCase();
+  throw new InvalidArgumentError(
+    'The property transformer %v requires a String value, but %v given.',
+    context.transformerName,
+    value,
+  );
+}

package/src/definition/model/properties/property-transformer/builtin/to-lower-case-transformer.spec.js

@@ -0,0 +1,39 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {toLowerCaseTransformer} from './to-lower-case-transformer.js';
+
+describe('toLowerCaseTransformer', function () {
+  it('returns undefined and null values as is', function () {
+    const res1 = toLowerCaseTransformer(undefined, undefined, {});
+    const res2 = toLowerCaseTransformer(null, undefined, {});
+    expect(res1).to.be.undefined;
+    expect(res2).to.be.null;
+  });
+
+  it('converts the given string to lower case', function () {
+    const res = toLowerCaseTransformer('TEST', undefined, {});
+    expect(res).to.be.eq('test');
+  });
+
+  it('throws an error if the given value is not a string', function () {
+    const throwable = v => () =>
+      toLowerCaseTransformer(v, undefined, {
+        transformerName: 'toLowerCase',
+      });
+    const error = v =>
+      format(
+        'The property transformer "toLowerCase" requires a String value, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable('str')();
+    throwable('')();
+    throwable(undefined)();
+    throwable(null)();
+  });
+});

package/src/definition/model/properties/property-transformer/builtin/to-title-case-transformer.d.ts

@@ -0,0 +1,6 @@
+import {PropertyTransformer} from '../property-transformer.js';
+
+/**
+ * To title case transformer.
+ */
+export declare type toTitleCaseTransformer = PropertyTransformer;

package/src/definition/model/properties/property-transformer/builtin/to-title-case-transformer.js

@@ -0,0 +1,22 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * To title case transformer.
+ *
+ * @param {*} value
+ * @param {undefined} options
+ * @param {object} context
+ * @returns {string|undefined|null}
+ */
+export function toTitleCaseTransformer(value, options, context) {
+  if (value == null) return value;
+  if (typeof value === 'string')
+    return value.replace(/\p{L}\S*/gu, text => {
+      return text.charAt(0).toUpperCase() + text.substring(1).toLowerCase();
+    });
+  throw new InvalidArgumentError(
+    'The property transformer %v requires a String value, but %v given.',
+    context.transformerName,
+    value,
+  );
+}

package/src/definition/model/properties/property-transformer/builtin/to-title-case-transformer.spec.js

@@ -0,0 +1,41 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {toTitleCaseTransformer} from './to-title-case-transformer.js';
+
+describe('toTitleCaseTransformer', function () {
+  it('returns undefined and null values as is', function () {
+    const res1 = toTitleCaseTransformer(undefined, undefined, {});
+    const res2 = toTitleCaseTransformer(null, undefined, {});
+    expect(res1).to.be.undefined;
+    expect(res2).to.be.null;
+  });
+
+  it('converts the given string to title case', function () {
+    const res1 = toTitleCaseTransformer('TEST', undefined, {});
+    const res2 = toTitleCaseTransformer('test', undefined, {});
+    expect(res1).to.be.eq('Test');
+    expect(res2).to.be.eq('Test');
+  });
+
+  it('throws an error if the given value is not a string', function () {
+    const throwable = v => () =>
+      toTitleCaseTransformer(v, undefined, {
+        transformerName: 'toTitleCase',
+      });
+    const error = v =>
+      format(
+        'The property transformer "toTitleCase" requires a String value, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable('str')();
+    throwable('')();
+    throwable(undefined)();
+    throwable(null)();
+  });
+});

package/src/definition/model/properties/property-transformer/builtin/to-upper-case-transformer.d.ts

@@ -0,0 +1,6 @@
+import {PropertyTransformer} from '../property-transformer.js';
+
+/**
+ * To upper case transformer.
+ */
+export declare type toUpperCaseTransformer = PropertyTransformer;

package/src/definition/model/properties/property-transformer/builtin/to-upper-case-transformer.js

@@ -0,0 +1,19 @@
+import {InvalidArgumentError} from '../../../../../errors/index.js';
+
+/**
+ * To upper case transformer.
+ *
+ * @param {*} value
+ * @param {undefined} options
+ * @param {object} context
+ * @returns {string|undefined|null}
+ */
+export function toUpperCaseTransformer(value, options, context) {
+  if (value == null) return value;
+  if (typeof value === 'string') return value.toUpperCase();
+  throw new InvalidArgumentError(
+    'The property transformer %v requires a String value, but %v given.',
+    context.transformerName,
+    value,
+  );
+}

package/src/definition/model/properties/property-transformer/builtin/to-upper-case-transformer.spec.js

@@ -0,0 +1,39 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {toUpperCaseTransformer} from './to-upper-case-transformer.js';
+
+describe('toUpperCaseTransformer', function () {
+  it('returns undefined and null values as is', function () {
+    const res1 = toUpperCaseTransformer(undefined, undefined, {});
+    const res2 = toUpperCaseTransformer(null, undefined, {});
+    expect(res1).to.be.undefined;
+    expect(res2).to.be.null;
+  });
+
+  it('converts the given string to upper case', function () {
+    const res = toUpperCaseTransformer('test', undefined, {});
+    expect(res).to.be.eq('TEST');
+  });
+
+  it('throws an error if the given value is not a string', function () {
+    const throwable = v => () =>
+      toUpperCaseTransformer(v, undefined, {
+        transformerName: 'toUpperCase',
+      });
+    const error = v =>
+      format(
+        'The property transformer "toUpperCase" requires a String value, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error('0'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    throwable('str')();
+    throwable('')();
+    throwable(undefined)();
+    throwable(null)();
+  });
+});

package/src/definition/model/properties/property-transformer/property-transformer-registry.js

@@ -1,5 +1,8 @@
 import {Service} from '@e22m4u/js-service';
 import {trimTransformer} from './builtin/index.js';
+import {toUpperCaseTransformer} from './builtin/index.js';
+import {toLowerCaseTransformer} from './builtin/index.js';
+import {toTitleCaseTransformer} from './builtin/index.js';
 import {InvalidArgumentError} from '../../../../errors/index.js';
 
 /**
@@ -13,6 +16,9 @@ export class PropertyTransformerRegistry extends Service {
    */
   _transformers = {
     trim: trimTransformer,
+    toUpperCase: toUpperCaseTransformer,
+    toLowerCase: toLowerCaseTransformer,
+    toTitleCase: toTitleCaseTransformer,
   };
 
   /**

package/src/definition/model/properties/property-transformer/property-transformer-registry.spec.js

@@ -1,6 +1,9 @@
 import {expect} from 'chai';
 import {format} from '@e22m4u/js-format';
 import {trimTransformer} from './builtin/index.js';
+import {toUpperCaseTransformer} from './builtin/index.js';
+import {toLowerCaseTransformer} from './builtin/index.js';
+import {toTitleCaseTransformer} from './builtin/index.js';
 import {PropertyTransformerRegistry} from './property-transformer-registry.js';
 
 describe('PropertyTransformerRegistry', function () {
@@ -9,6 +12,9 @@ describe('PropertyTransformerRegistry', function () {
       const S = new PropertyTransformerRegistry();
       expect(S['_transformers']).to.be.eql({
         trim: trimTransformer,
+        toUpperCase: toUpperCaseTransformer,
+        toLowerCase: toLowerCaseTransformer,
+        toTitleCase: toTitleCaseTransformer,
       });
     });
 

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

@@ -0,0 +1,31 @@
+import {ModelId} from '../../../types.js';
+import {Service} from '@e22m4u/js-service';
+import {ModelData} from '../../../types.js';
+import {WhereClause} from '../../../filter/index.js';
+
+/**
+ * Count method.
+ */
+type CountMethod = (where: WhereClause) => Promise<number>;
+
+/**
+ * Property uniqueness validator.
+ */
+export declare class PropertyUniquenessValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param countMethod
+   * @param methodName
+   * @param modelName
+   * @param modelData
+   * @param modelId
+   */
+  validate(
+    countMethod: CountMethod,
+    methodName: string,
+    modelName: string,
+    modelData: ModelData,
+    modelId?: ModelId,
+  ): Promise<void>;
+}