@e22m4u/js-repository 0.0.31

package/src/adapter/decorator/inclusion-decorator.js

@@ -0,0 +1,78 @@
+import {Adapter} from '../adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {IncludeClauseTool} from '../../filter/index.js';
+import {InvalidArgumentError} from '../../errors/index.js';
+
+/**
+ * Inclusion decorator.
+ */
+export class InclusionDecorator extends Service {
+  /**
+   * Decorate.
+   *
+   * @param {Adapter} adapter
+   */
+  decorate(adapter) {
+    if (!adapter || !(adapter instanceof Adapter))
+      throw new InvalidArgumentError(
+        'A first argument of InclusionDecorator.decorate must be ' +
+          'an Adapter instance, but %v given.',
+        adapter,
+      );
+
+    const tool = adapter.getService(IncludeClauseTool);
+    const includeTo = (...args) => tool.includeTo(...args);
+
+    const create = adapter.create;
+    adapter.create = async function (modelName, modelData, filter) {
+      const retvalData = await create.call(this, modelName, modelData, filter);
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo([retvalData], modelName, filter.include);
+      return retvalData;
+    };
+
+    const replaceById = adapter.replaceById;
+    adapter.replaceById = async function (modelName, id, modelData, filter) {
+      const retvalData = await replaceById.call(
+        this,
+        modelName,
+        id,
+        modelData,
+        filter,
+      );
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo([retvalData], modelName, filter.include);
+      return retvalData;
+    };
+
+    const patchById = adapter.patchById;
+    adapter.patchById = async function (modelName, id, modelData, filter) {
+      const retvalData = await patchById.call(
+        this,
+        modelName,
+        id,
+        modelData,
+        filter,
+      );
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo([retvalData], modelName, filter.include);
+      return retvalData;
+    };
+
+    const find = adapter.find;
+    adapter.find = async function (modelName, filter) {
+      const modelItems = await find.call(this, modelName, filter);
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo(modelItems, modelName, filter.include);
+      return modelItems;
+    };
+
+    const findById = adapter.findById;
+    adapter.findById = async function (modelName, id, filter) {
+      const retvalData = await findById.call(this, modelName, id, filter);
+      if (filter && typeof filter === 'object' && filter.include)
+        await includeTo([retvalData], modelName, filter.include);
+      return retvalData;
+    };
+  }
+}

package/src/adapter/decorator/inclusion-decorator.spec.js

@@ -0,0 +1,117 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Adapter} from '../adapter.js';
+import {Schema} from '../../schema.js';
+import {IncludeClauseTool} from '../../filter/index.js';
+
+const S = new Schema();
+S.defineModel({name: 'model'});
+const FILTER = {include: 'parent'};
+
+const MODEL_DATA = {
+  foo: 'fooVal',
+  bar: 'barVal',
+};
+
+const RETVAL_DATA = {
+  foo: MODEL_DATA.foo,
+  bar: MODEL_DATA.bar,
+  baz: 'bazVal',
+};
+
+class TestAdapter extends Adapter {
+  // eslint-disable-next-line no-unused-vars
+  async create(modelName, modelData, filter = undefined) {
+    return Object.assign({}, MODEL_DATA);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async replaceById(modelName, id, modelData, filter = undefined) {
+    return Object.assign({}, MODEL_DATA);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async patchById(modelName, id, modelData, filter = undefined) {
+    return Object.assign({}, MODEL_DATA);
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async find(modelName, filter = undefined) {
+    return [Object.assign({}, MODEL_DATA)];
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async findById(modelName, id, filter = undefined) {
+    return Object.assign({}, MODEL_DATA);
+  }
+}
+
+const A = S.getService(TestAdapter);
+const T = S.getService(IncludeClauseTool);
+const sandbox = chai.spy.sandbox();
+
+describe('InclusionDecorator', function () {
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('overrides the "create" method method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.create('model', {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.includeTo).to.be.called.once;
+  });
+
+  it('overrides the "replaceById" method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.replaceById('model', 1, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.includeTo).to.be.called.once;
+  });
+
+  it('overrides the "patchById" method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.patchById('model', 1, {}, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.includeTo).to.be.called.once;
+  });
+
+  it('overrides the "find" method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.find('model', FILTER);
+    expect(retval).to.be.eql([RETVAL_DATA]);
+    expect(T.includeTo).to.be.called.once;
+  });
+
+  it('overrides the "findById" method and applies clause inclusion', async function () {
+    sandbox.on(T, 'includeTo', function (entities, modelName, clause) {
+      expect(entities).to.be.eql([MODEL_DATA]);
+      expect(modelName).to.be.eql('model');
+      expect(clause).to.be.eql(FILTER.include);
+      Object.assign(entities[0], RETVAL_DATA);
+    });
+    const retval = await A.findById('model', 1, FILTER);
+    expect(retval).to.be.eql(RETVAL_DATA);
+    expect(T.includeTo).to.be.called.once;
+  });
+});

package/src/adapter/decorator/index.d.ts

@@ -0,0 +1,5 @@
+export * from './inclusion-decorator.js';
+export * from './default-values-decorator.js';
+export * from './data-sanitizing-decorator.js';
+export * from './data-validation-decorator.js';
+export * from './fields-filtering-decorator.js';

package/src/adapter/decorator/index.js

@@ -0,0 +1,5 @@
+export * from './inclusion-decorator.js';
+export * from './default-values-decorator.js';
+export * from './data-sanitizing-decorator.js';
+export * from './data-validation-decorator.js';
+export * from './fields-filtering-decorator.js';

package/src/adapter/index.d.ts

@@ -0,0 +1,3 @@
+export * from './adapter.js';
+export * from './adapter-loader.js';
+export * from './adapter-registry.js';

package/src/adapter/index.js

@@ -0,0 +1,3 @@
+export * from './adapter.js';
+export * from './adapter-loader.js';
+export * from './adapter-registry.js';

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

@@ -0,0 +1,14 @@
+import {Service} from '@e22m4u/js-service';
+import {DatasourceDefinition} from './datasource-definition.js';
+
+/**
+ * Datasource definition validator.
+ */
+export declare class DatasourceDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param datasourceDef
+   */
+  validate(datasourceDef: DatasourceDefinition): void;
+}

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

@@ -0,0 +1,33 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+
+/**
+ * Datasource definition validator.
+ */
+export class DatasourceDefinitionValidator extends Service {
+  /**
+   * Validate.
+   *
+   * @param {object} datasourceDef
+   */
+  validate(datasourceDef) {
+    if (!datasourceDef || typeof datasourceDef !== 'object')
+      throw new InvalidArgumentError(
+        'The datasource definition should be an Object, but %v given.',
+        datasourceDef,
+      );
+    if (!datasourceDef.name || typeof datasourceDef.name !== 'string')
+      throw new InvalidArgumentError(
+        'The datasource definition requires the option "name" ' +
+          'as a non-empty String, but %v given.',
+        datasourceDef.name,
+      );
+    if (!datasourceDef.adapter || typeof datasourceDef.adapter !== 'string')
+      throw new InvalidArgumentError(
+        'The datasource %v requires the option "adapter" ' +
+          'as a non-empty String, but %v given.',
+        datasourceDef.name,
+        datasourceDef.adapter,
+      );
+  }
+}

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

@@ -0,0 +1,63 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {DatasourceDefinitionValidator} from './datasource-definition-validator.js';
+
+const S = new DatasourceDefinitionValidator();
+
+describe('DatasourceDefinitionValidator', function () {
+  describe('validate', function () {
+    it('requires a given definition to be an object', function () {
+      const validate = v => () => S.validate(v);
+      const error = v =>
+        format(
+          'The datasource 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(undefined)).to.throw(error('undefined'));
+      expect(validate(null)).to.throw(error('null'));
+      validate({name: 'datasource', adapter: 'adapter'})();
+    });
+
+    it('requires the option "name" as a non-empty string', function () {
+      const validate = v => () => S.validate({name: v, adapter: 'adapter'});
+      const error = v =>
+        format(
+          'The datasource 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('datasource')();
+    });
+
+    it('requires the option "adapter" to be a non-empty string', function () {
+      const validate = v => () => S.validate({name: 'datasource', adapter: v});
+      const error = v =>
+        format(
+          'The datasource "datasource" requires the option "adapter" ' +
+            '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('adapter')();
+    });
+  });
+});

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

@@ -0,0 +1,7 @@
+/**
+ * Datasource definition.
+ */
+export declare type DatasourceDefinition = {
+  name: string;
+  adapter: string;
+};

package/src/definition/datasource/index.d.ts

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

package/src/definition/datasource/index.js

@@ -0,0 +1 @@
+export * from './datasource-definition-validator.js';

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

@@ -0,0 +1,50 @@
+import {Service} from '@e22m4u/js-service';
+import {ModelDefinition} from './model/index.js';
+import {DatasourceDefinition} from './datasource/index.js';
+
+/**
+ * Definition registry.
+ */
+export declare class DefinitionRegistry extends Service {
+  /**
+   * Add datasource.
+   *
+   * @param datasourceDef
+   */
+  addDatasource(datasourceDef: DatasourceDefinition): void;
+
+  /**
+   * Has datasource.
+   *
+   * @param name
+   */
+  hasDatasource(name: string): boolean;
+
+  /**
+   * Get datasource.
+   *
+   * @param name
+   */
+  getDatasource(name: string): DatasourceDefinition;
+
+  /**
+   * Add model.
+   *
+   * @param modelDef
+   */
+  addModel(modelDef: ModelDefinition): void;
+
+  /**
+   * Has model.
+   *
+   * @param name
+   */
+  hasModel(name: string): boolean;
+
+  /**
+   * Get model.
+   *
+   * @param name
+   */
+  getModel(name: string): ModelDefinition;
+}

package/src/definition/definition-registry.js

@@ -0,0 +1,98 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../errors/index.js';
+import {ModelDefinitionValidator} from './model/index.js';
+import {DatasourceDefinitionValidator} from '../definition/index.js';
+
+/**
+ * Definition registry.
+ */
+export class DefinitionRegistry extends Service {
+  /**
+   * Datasources.
+   *
+   * @type {object}
+   */
+  _datasources = {};
+
+  /**
+   * Models.
+   *
+   * @type {object}
+   */
+  _models = {};
+
+  /**
+   * Add datasource.
+   *
+   * @param {object} datasourceDef
+   */
+  addDatasource(datasourceDef) {
+    this.getService(DatasourceDefinitionValidator).validate(datasourceDef);
+    const name = datasourceDef.name;
+    if (name in this._datasources)
+      throw new InvalidArgumentError(
+        'The datasource %v is already defined.',
+        name,
+      );
+    this._datasources[name] = datasourceDef;
+  }
+
+  /**
+   * Has datasource.
+   *
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasDatasource(name) {
+    return Boolean(this._datasources[name]);
+  }
+
+  /**
+   * Get datasource.
+   *
+   * @param {string} name
+   * @returns {object}
+   */
+  getDatasource(name) {
+    const datasourceDef = this._datasources[name];
+    if (!datasourceDef)
+      throw new InvalidArgumentError('The datasource %v is not defined.', name);
+    return datasourceDef;
+  }
+
+  /**
+   * Add model.
+   *
+   * @param {object} modelDef
+   */
+  addModel(modelDef) {
+    this.getService(ModelDefinitionValidator).validate(modelDef);
+    const name = modelDef.name;
+    if (name in this._models)
+      throw new InvalidArgumentError('The model %v is already defined.', name);
+    this._models[name] = modelDef;
+  }
+
+  /**
+   * Has model.
+   *
+   * @param {string} name
+   * @returns {boolean}
+   */
+  hasModel(name) {
+    return Boolean(this._models[name]);
+  }
+
+  /**
+   * Get model.
+   *
+   * @param {string} name
+   * @returns {object}
+   */
+  getModel(name) {
+    const modelDef = this._models[name];
+    if (!modelDef)
+      throw new InvalidArgumentError('The model %v is not defined.', name);
+    return modelDef;
+  }
+}

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

@@ -0,0 +1,78 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {ModelDefinitionValidator} from './model/index.js';
+import {DefinitionRegistry} from './definition-registry.js';
+import {DatasourceDefinitionValidator} from '../definition/index.js';
+
+const sandbox = chai.spy.sandbox();
+
+describe('DefinitionRegistry', function () {
+  let S;
+  beforeEach(function () {
+    S = new DefinitionRegistry();
+  });
+
+  afterEach(function () {
+    sandbox.restore();
+  });
+
+  it('sets a given datasource to the state', function () {
+    const datasource = {name: 'datasource', adapter: 'adapter'};
+    S.addDatasource(datasource);
+    const result = S.getDatasource('datasource');
+    expect(result).to.be.eql(datasource);
+  });
+
+  it('throws an error if a given datasource is already defined', function () {
+    const datasource1 = {name: 'datasource', adapter: 'adapter'};
+    const datasource2 = {name: 'datasource', adapter: 'adapter'};
+    S.addDatasource(datasource1);
+    const throwable = () => S.addDatasource(datasource2);
+    expect(throwable).to.throw(
+      'The datasource "datasource" is already defined.',
+    );
+  });
+
+  it('throws an error when getting a not defined datasource', function () {
+    const throwable = () => S.getDatasource('undefined');
+    expect(throwable).to.throw('The datasource "undefined" is not defined.');
+  });
+
+  it('uses DatasourceDefinitionValidator to validate a given datasource', function () {
+    const V = S.getService(DatasourceDefinitionValidator);
+    sandbox.on(V, 'validate');
+    const datasource = {name: 'datasource', adapter: 'adapter'};
+    S.addDatasource(datasource);
+    expect(V.validate).to.have.been.called.once;
+    expect(V.validate).to.have.been.called.with.exactly(datasource);
+  });
+
+  it('sets a given model to the state', function () {
+    const model = {name: 'model'};
+    S.addModel(model);
+    const result = S.getModel('model');
+    expect(result).to.be.eql(model);
+  });
+
+  it('throws an error if a given model is already defined', function () {
+    const model1 = {name: 'model'};
+    const model2 = {name: 'model'};
+    S.addModel(model1);
+    const throwable = () => S.addModel(model2);
+    expect(throwable).to.throw('The model "model" is already defined.');
+  });
+
+  it('throws an error when getting a not defined model', function () {
+    const throwable = () => S.getModel('undefined');
+    expect(throwable).to.throw('The model "undefined" is not defined.');
+  });
+
+  it('uses ModelDefinitionValidator to validate a given model', function () {
+    const V = S.getService(ModelDefinitionValidator);
+    sandbox.on(V, 'validate');
+    const model = {name: 'model'};
+    S.addModel(model);
+    expect(V.validate).to.have.been.called.once;
+    expect(V.validate).to.have.been.called.with.exactly(model);
+  });
+});

package/src/definition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './model/index.js';
+export * from './datasource/index.js';
+export * from './definition-registry.js';

package/src/definition/index.js

@@ -0,0 +1,3 @@
+export * from './model/index.js';
+export * from './datasource/index.js';
+export * from './definition-registry.js';

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

@@ -0,0 +1,7 @@
+export * from './relations/index.js';
+export * from './properties/index.js';
+export * from './model-definition.js';
+export * from './model-data-validator.js';
+export * from './model-data-sanitizer.js';
+export * from './model-definition-utils.js';
+export * from './model-definition-validator.js';

package/src/definition/model/index.js

@@ -0,0 +1,6 @@
+export * from './relations/index.js';
+export * from './properties/index.js';
+export * from './model-data-validator.js';
+export * from './model-data-sanitizer.js';
+export * from './model-definition-utils.js';
+export * from './model-definition-validator.js';

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

@@ -0,0 +1,15 @@
+import {ModelData} from '../../types.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Model data sanitizer.
+ */
+export declare class ModelDataSanitizer extends Service {
+  /**
+   * Sanitize.
+   *
+   * @param modelName
+   * @param modelData
+   */
+  sanitize(modelName: string, modelData: ModelData): ModelData;
+}

package/src/definition/model/model-data-sanitizer.js

@@ -0,0 +1,33 @@
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../../errors/index.js';
+import {ModelDefinitionUtils} from './model-definition-utils.js';
+
+/**
+ * Model data validator.
+ */
+export class ModelDataSanitizer extends Service {
+  /**
+   * Validate.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @returns {object}
+   */
+  sanitize(modelName, modelData) {
+    if (!modelName || typeof modelName !== 'string')
+      throw new InvalidArgumentError(
+        'The first argument of ModelDataSanitizer.sanitize ' +
+          'must be a string, but %v given.',
+        modelName,
+      );
+    if (!modelData || typeof modelData !== 'object')
+      throw new InvalidArgumentError(
+        'The second argument of ModelDataSanitizer.sanitize ' +
+          'must be an Object, but %v given.',
+        modelData,
+      );
+    return this.getService(
+      ModelDefinitionUtils,
+    ).excludeObjectKeysByRelationNames(modelName, modelData);
+  }
+}