@e22m4u/js-repository 0.0.31

package/src/adapter/decorator/data-sanitizing-decorator.d.ts

@@ -0,0 +1,13 @@
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Data sanitizing decorator.
+ */
+export declare class DataSanitizingDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter): void;
+}

package/src/adapter/decorator/data-sanitizing-decorator.js

@@ -0,0 +1,44 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDataSanitizer} from '../../definition/index.js';
+
+/**
+ * Data sanitizing decorator.
+ */
+export class DataSanitizingDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'A first argument of DataSanitizingDecorator.decorate must be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+
+    const sanitizer = adapter.getService(ModelDataSanitizer);
+    const sanitize = (...args) => sanitizer.sanitize(...args);
+
+    const create = adapter.create;
+    adapter.create = async function (modelName, modelData, filter) {
+      modelData = sanitize(modelName, modelData);
+      return create.call(this, modelName, modelData, filter);
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      modelData = sanitize(modelName, modelData);
+      return replaceById.call(this, modelName, id, modelData, filter);
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      modelData = sanitize(modelName, modelData);
+      return patchById.call(this, modelName, id, modelData, filter);
+    };
+  }
+}

package/src/adapter/decorator/data-sanitizing-decorator.spec.js

@@ -0,0 +1,59 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {ModelDataSanitizer} 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({});
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patchById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+}
+
+const A = S.getService(TestAdapter);
+const V = S.getService(ModelDataSanitizer);
+const sandbox = chai.spy.sandbox();
+
+describe('DataSanitizingDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method and sanitizes a given data', async function () {
+    sandbox.on(V, 'sanitize');
+    const data = {};
+    await A.create('model', data);
+    expect(V.sanitize).to.be.called.once;
+    expect(V.sanitize).to.be.called.with.exactly('model', data);
+  });
+
+  it('overrides the "replaceById" method and sanitizes a given data', async function () {
+    sandbox.on(V, 'sanitize');
+    const data = {};
+    await A.replaceById('model', 1, data);
+    expect(V.sanitize).to.be.called.once;
+    expect(V.sanitize).to.be.called.with.exactly('model', data);
+  });
+
+  it('overrides the "patchById" method and sanitizes a given data', async function () {
+    sandbox.on(V, 'sanitize');
+    const data = {};
+    await A.patchById('model', 1, data);
+    expect(V.sanitize).to.be.called.once;
+    expect(V.sanitize).to.be.called.with.exactly('model', data);
+  });
+});

package/src/adapter/decorator/data-validation-decorator.d.ts

@@ -0,0 +1,13 @@
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Data validation decorator.
+ */
+export declare class DataValidationDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter): void;
+}

package/src/adapter/decorator/data-validation-decorator.js

@@ -0,0 +1,41 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDataValidator} from '../../definition/index.js';
+
+/**
+ * Data validation decorator.
+ */
+export class DataValidationDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'A first argument of DataValidationDecorator.decorate must be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+
+    const create = adapter.create;
+    adapter.create = function (modelName, modelData, filter) {
+      this.getService(ModelDataValidator).validate(modelName, modelData);
+      return create.call(this, modelName, modelData, filter);
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = function (modelName, id, modelData, filter) {
+      this.getService(ModelDataValidator).validate(modelName, modelData);
+      return replaceById.call(this, modelName, id, modelData, filter);
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = function (modelName, id, modelData, filter) {
+      this.getService(ModelDataValidator).validate(modelName, modelData, true);
+      return patchById.call(this, modelName, id, modelData, filter);
+    };
+  }
+}

package/src/adapter/decorator/data-validation-decorator.spec.js

@@ -0,0 +1,59 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {ModelDataValidator} 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({});
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  replaceById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  patchById(modelName, id, modelData, filter = undefined) {
+    return Promise.resolve({});
+  }
+}
+
+const A = S.getService(TestAdapter);
+const V = S.getService(ModelDataValidator);
+const sandbox = chai.spy.sandbox();
+
+describe('DataValidationDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method and validates a given data', async function () {
+    sandbox.on(V, 'validate');
+    const data = {};
+    await A.create('model', data);
+    expect(V.validate).to.be.called.once;
+    expect(V.validate).to.be.called.with.exactly('model', data);
+  });
+
+  it('overrides the "replaceById" method and validates a given data', async function () {
+    sandbox.on(V, 'validate');
+    const data = {};
+    await A.replaceById('model', 1, data);
+    expect(V.validate).to.be.called.once;
+    expect(V.validate).to.be.called.with.exactly('model', data);
+  });
+
+  it('overrides the "patchById" method and validates a given data', async function () {
+    sandbox.on(V, 'validate');
+    const data = {};
+    await A.patchById('model', 1, data);
+    expect(V.validate).to.be.called.once;
+    expect(V.validate).to.be.called.with.exactly('model', data, true);
+  });
+});

package/src/adapter/decorator/default-values-decorator.d.ts

@@ -0,0 +1,13 @@
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Default values decorator.
+ */
+export declare class DefaultValuesDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter): void;
+}

package/src/adapter/decorator/default-values-decorator.js

@@ -0,0 +1,57 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDefinitionUtils} from '../../definition/index.js';
+
+/**
+ * Default values decorator.
+ */
+export class DefaultValuesDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'A first argument of DefaultValuesDecorator.decorate must be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+
+    const utils = adapter.getService(ModelDefinitionUtils);
+    const setDefaults = (...args) =>
+      utils.setDefaultValuesToEmptyProperties(...args);
+
+    const create = adapter.create;
+    adapter.create = function (modelName, modelData, filter) {
+      modelData = setDefaults(modelName, modelData);
+      return create.call(this, modelName, modelData, filter);
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = function (modelName, id, modelData, filter) {
+      modelData = setDefaults(modelName, modelData);
+      return replaceById.call(this, modelName, id, modelData, filter);
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = function (modelName, id, modelData, filter) {
+      modelData = setDefaults(modelName, modelData, true);
+      return patchById.call(this, modelName, id, modelData, filter);
+    };
+
+    const find = adapter.find;
+    adapter.find = async function (modelName, filter) {
+      const modelItems = await find.call(this, modelName, filter);
+      return modelItems.map(modelItem => setDefaults(modelName, modelItem));
+    };
+
+    const findById = adapter.findById;
+    adapter.findById = async function (modelName, id, filter) {
+      const retvalData = await findById.call(this, modelName, id, filter);
+      return setDefaults(modelName, retvalData);
+    };
+  }
+}

package/src/adapter/decorator/default-values-decorator.spec.js

@@ -0,0 +1,141 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {DataType} from '../../definition/index.js';
+import {ModelDefinitionUtils} from '../../definition/index.js';
+
+const S = new Schema();
+S.defineModel({
+  name: 'model',
+  properties: {
+    prop: {
+      type: DataType.STRING,
+      default: 'value',
+    },
+  },
+});
+
+const INPUT_DATA = {};
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  async create(modelName, modelData, filter = undefined) {
+    return modelData;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async replaceById(modelName, id, modelData, filter = undefined) {
+    return modelData;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async patchById(modelName, id, modelData, filter = undefined) {
+    return modelData;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async find(modelName, filter = undefined) {
+    return [INPUT_DATA];
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async findById(modelName, id, filter = undefined) {
+    return INPUT_DATA;
+  }
+}
+
+const A = S.getService(TestAdapter);
+const U = S.getService(ModelDefinitionUtils);
+const sandbox = chai.spy.sandbox();
+
+describe('DefaultValuesDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method method and sets default values to input data', async function () {
+    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+    const retval = await A.create('model', INPUT_DATA);
+    expect(retval).to.be.eql({prop: 'value'});
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+      'model',
+      INPUT_DATA,
+    );
+  });
+
+  it('overrides the "replaceById" method and sets default values to input data', async function () {
+    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+    const retval = await A.replaceById('model', 1, INPUT_DATA);
+    expect(retval).to.be.eql({prop: 'value'});
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+      'model',
+      INPUT_DATA,
+    );
+  });
+
+  describe('overrides the "patchById" method and sets default values to input data', function () {
+    it('does not set default values to not existing properties of input data', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {};
+      const retval = await A.patchById('model', 1, data);
+      expect(retval).to.be.eql({});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+
+    it('does set default values to input properties of null', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {prop: null};
+      const retval = await A.patchById('model', 2, data);
+      expect(retval).to.be.eql({prop: 'value'});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+
+    it('does set default values to input properties of undefined', async function () {
+      sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+      const data = {prop: undefined};
+      const retval = await A.patchById('model', 3, data);
+      expect(retval).to.be.eql({prop: 'value'});
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+      expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+        'model',
+        data,
+        true,
+      );
+    });
+  });
+
+  it('overrides the "find" method and sets default values to output data', async function () {
+    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+    const retval = await A.find('model');
+    expect(retval).to.be.eql([{prop: 'value'}]);
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+      'model',
+      INPUT_DATA,
+    );
+  });
+
+  it('overrides the "findById" method and sets default values to output data', async function () {
+    sandbox.on(U, 'setDefaultValuesToEmptyProperties');
+    const retval = await A.findById('model', 1);
+    expect(retval).to.be.eql({prop: 'value'});
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.once;
+    expect(U.setDefaultValuesToEmptyProperties).to.be.called.with.exactly(
+      'model',
+      INPUT_DATA,
+    );
+  });
+});

package/src/adapter/decorator/fields-filtering-decorator.d.ts

@@ -0,0 +1,13 @@
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Fields filtering decorator.
+ */
+export declare class FieldsFilteringDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter): void;
+}

package/src/adapter/decorator/fields-filtering-decorator.js

@@ -0,0 +1,72 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {FieldsClauseTool} from '../../filter/index.js';
+import {InvalidArgumentError} from '../../errors/index.js';
+
+/**
+ * Fields filtering decorator.
+ */
+export class FieldsFilteringDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'A first argument of FieldsFilteringDecorator.decorate must be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+
+    const tool = adapter.getService(FieldsClauseTool);
+    const selectFields = (...args) => tool.filter(...args);
+
+    const create = adapter.create;
+    adapter.create = async function (modelName, modelData, filter) {
+      let result = await create.call(this, modelName, modelData, filter);
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      let result = await replaceById.call(
+        this,
+        modelName,
+        id,
+        modelData,
+        filter,
+      );
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      let result = await patchById.call(this, modelName, id, modelData, filter);
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+
+    const find = adapter.find;
+    adapter.find = async function (modelName, filter) {
+      let result = await find.call(this, modelName, filter);
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+
+    const findById = adapter.findById;
+    adapter.findById = async function (modelName, id, filter) {
+      let result = await findById.call(this, modelName, id, filter);
+      if (filter && typeof filter === 'object' && filter.fields)
+        result = selectFields(result, modelName, filter.fields);
+      return result;
+    };
+  }
+}

package/src/adapter/decorator/fields-filtering-decorator.spec.js

@@ -0,0 +1,119 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {FieldsClauseTool} from '../../filter/index.js';
+
+const S = new Schema();
+const MODEL_NAME = 'model';
+S.defineModel({name: MODEL_NAME});
+
+const FILTER = {fields: ['foo', 'bar']};
+const MODEL_DATA = {
+  foo: 'fooVal',
+  bar: 'barVal',
+  baz: 'bazVal',
+  qux: 'quxVal',
+};
+
+const RETVAL_DATA = {
+  foo: MODEL_DATA.foo,
+  bar: MODEL_DATA.bar,
+};
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  async create(modelName, modelData, filter = undefined) {
+    return MODEL_DATA;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async replaceById(modelName, id, modelData, filter = undefined) {
+    return MODEL_DATA;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async patchById(modelName, id, modelData, filter = undefined) {
+    return MODEL_DATA;
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async find(modelName, filter = undefined) {
+    return [MODEL_DATA];
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async findById(modelName, id, filter = undefined) {
+    return MODEL_DATA;
+  }
+}
+
+const A = S.getService(TestAdapter);
+const T = S.getService(FieldsClauseTool);
+const sandbox = chai.spy.sandbox();
+
+describe('FieldsFilteringDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method method and filtering output fields', async function () {
+    sandbox.on(T, 'filter');
+    const retval = await A.create(MODEL_NAME, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.filter).to.be.called.once;
+    expect(T.filter).to.be.called.with.exactly(
+      MODEL_DATA,
+      MODEL_NAME,
+      FILTER.fields,
+    );
+  });
+
+  it('overrides the "replaceById" method and filtering output fields', async function () {
+    sandbox.on(T, 'filter');
+    const retval = await A.replaceById(MODEL_NAME, 1, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.filter).to.be.called.once;
+    expect(T.filter).to.be.called.with.exactly(
+      MODEL_DATA,
+      MODEL_NAME,
+      FILTER.fields,
+    );
+  });
+
+  it('overrides the "patchById" method and filtering output fields', async function () {
+    sandbox.on(T, 'filter');
+    const retval = await A.patchById(MODEL_NAME, 1, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.filter).to.be.called.once;
+    expect(T.filter).to.be.called.with.exactly(
+      MODEL_DATA,
+      MODEL_NAME,
+      FILTER.fields,
+    );
+  });
+
+  it('overrides the "find" method and filtering output fields', async function () {
+    sandbox.on(T, 'filter', function (entities, modelName, fields) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eq(MODEL_NAME);
+      expect(fields).to.be.eql(FILTER.fields);
+      return [RETVAL_DATA];
+    });
+    const retval = await A.find(MODEL_NAME, FILTER);
+    expect(retval).to.be.eql([RETVAL_DATA]);
+    expect(T.filter).to.be.called.once;
+  });
+
+  it('overrides the "findById" method and filtering output fields', async function () {
+    sandbox.on(T, 'filter');
+    const retval = await A.findById(MODEL_NAME, 1, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.filter).to.be.called.once;
+    expect(T.filter).to.be.called.with.exactly(
+      MODEL_DATA,
+      MODEL_NAME,
+      FILTER.fields,
+    );
+  });
+});

package/src/adapter/decorator/inclusion-decorator.d.ts

@@ -0,0 +1,13 @@
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Inclusion decorator.
+ */
+export declare class InclusionDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param adapter
+   */
+  decorate(adapter): void;
+}