@e22m4u/js-repository 0.0.31

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@e22m4u/js-repository",
+  "version": "0.0.31",
+  "description": "Абстракция для работы с базами данных для Node.js",
+  "type": "module",
+  "main": "src/index.js",
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "lint": "tsc && eslint .",
+    "lint:fix": "tsc && eslint . --fix",
+    "format": "prettier --write \"./src/**/*.js\"",
+    "test": "npm run lint && c8 --reporter=text-summary mocha",
+    "test:coverage": "npm run lint && c8 --reporter=text mocha",
+    "prepare": "npx husky install"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/e22m4u/js-repository.git"
+  },
+  "keywords": [
+    "Repository",
+    "ORM",
+    "ODM",
+    "Database",
+    "Datasource",
+    "Relation",
+    "Inclusion",
+    "Memory"
+  ],
+  "author": "e22m4u <e22m4u@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/e22m4u/js-repository",
+  "dependencies": {
+    "@e22m4u/js-service": "0.0.7",
+    "@e22m4u/js-format": "0.0.7"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.7.1",
+    "@commitlint/config-conventional": "^17.7.0",
+    "c8": "^8.0.1",
+    "chai": "^4.3.7",
+    "chai-as-promised": "^7.1.1",
+    "chai-spies": "^1.0.0",
+    "chai-subset": "^1.6.0",
+    "eslint": "^8.47.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-plugin-chai-expect": "^3.0.0",
+    "eslint-plugin-jsdoc": "^46.8.2",
+    "eslint-plugin-mocha": "^10.1.0",
+    "husky": "^8.0.3",
+    "mocha": "^10.2.0",
+    "prettier": "^3.0.1",
+    "typescript": "^5.2.2"
+  }
+}

package/src/adapter/adapter-loader.d.ts

@@ -0,0 +1,16 @@
+import {Adapter} from './adapter.js';
+import {AnyObject} from '../types.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Adapter loader.
+ */
+export declare class AdapterLoader extends Service {
+  /**
+   * Load by name.
+   *
+   * @param adapterName
+   * @param settings
+   */
+  loadByName(adapterName: string, settings?: AnyObject): Promise<Adapter>;
+}

package/src/adapter/adapter-loader.js

@@ -0,0 +1,63 @@
+import {Adapter} from './adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {InvalidArgumentError} from '../errors/index.js';
+
+/**
+ * Adapter loader.
+ */
+export class AdapterLoader extends Service {
+  /**
+   * Load by name.
+   *
+   * @param {string} adapterName
+   * @param {object|undefined} settings
+   * @returns {Promise<Adapter>}
+   */
+  async loadByName(adapterName, settings = undefined) {
+    if (!adapterName || typeof adapterName !== 'string')
+      throw new InvalidArgumentError(
+        'The adapter name must be a non-empty String, but %v given.',
+        adapterName,
+      );
+    let adapterCtor;
+    try {
+      const module = await import(`./builtin/${adapterName}-adapter.js`);
+      adapterCtor = findAdapterCtorInModule(module);
+    } catch (e) {
+      /**/
+    }
+    if (!adapterCtor)
+      try {
+        const module = await import(
+          `@e22m4u/js-repository-${adapterName}-adapter`
+        );
+        adapterCtor = findAdapterCtorInModule(module);
+      } catch (e) {
+        /**/
+      }
+    if (!adapterCtor)
+      throw new InvalidArgumentError(
+        'The adapter %v is not found.',
+        adapterName,
+      );
+    return new adapterCtor(this.container, settings);
+  }
+}
+
+/**
+ * Find adapter ctor in module.
+ *
+ * @param {object} module
+ * @returns {*}
+ */
+function findAdapterCtorInModule(module) {
+  let adapterCtor;
+  if (!module || typeof module !== 'object' || Array.isArray(module)) return;
+  for (const ctor of Object.values(module)) {
+    if (typeof ctor === 'function' && ctor.prototype instanceof Adapter) {
+      adapterCtor = ctor;
+      break;
+    }
+  }
+  return adapterCtor;
+}

package/src/adapter/adapter-loader.spec.js

@@ -0,0 +1,31 @@
+import {expect} from 'chai';
+import {Adapter} from './adapter.js';
+import {AdapterLoader} from './adapter-loader.js';
+
+const S = new AdapterLoader();
+
+describe('AdapterLoader', function () {
+  describe('loadByName', function () {
+    it('requires an adapter name as a non-empty string', async function () {
+      const promise = S.loadByName('');
+      await expect(promise).to.be.rejectedWith(
+        'The adapter name must be a non-empty String, but "" given.',
+      );
+    });
+
+    it('throws an error if a given adapter name is not found', async function () {
+      const promise = S.loadByName('unknown');
+      await expect(promise).to.be.rejectedWith(
+        'The adapter "unknown" is not found.',
+      );
+    });
+
+    it('returns an adapter instance that is loaded from "builtin" folder', async function () {
+      const settings = {};
+      const adapter = await S.loadByName('memory', settings);
+      expect(adapter).to.be.instanceof(Adapter);
+      expect(adapter.container).to.be.eq(S.container);
+      expect(adapter.settings).to.be.eq(settings);
+    });
+  });
+});

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

@@ -0,0 +1,14 @@
+import {Adapter} from './adapter.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Adapter registry.
+ */
+export declare class AdapterRegistry extends Service {
+  /**
+   * Get adapter.
+   *
+   * @param datasourceName
+   */
+  getAdapter(datasourceName: string): Promise<Adapter>;
+}

package/src/adapter/adapter-registry.js

@@ -0,0 +1,36 @@
+import {Adapter} from './adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {AdapterLoader} from './adapter-loader.js';
+import {DefinitionRegistry} from '../definition/index.js';
+
+/**
+ * Adapter registry.
+ */
+export class AdapterRegistry extends Service {
+  /**
+   * Adapters.
+   *
+   * @type {object}
+   */
+  _adapters = {};
+
+  /**
+   * Get adapter.
+   *
+   * @param {string} datasourceName
+   * @returns {Promise<Adapter>}
+   */
+  async getAdapter(datasourceName) {
+    let adapter = this._adapters[datasourceName];
+    if (adapter) return adapter;
+    const datasource =
+      this.getService(DefinitionRegistry).getDatasource(datasourceName);
+    const adapterName = datasource.adapter;
+    adapter = await this.getService(AdapterLoader).loadByName(
+      adapterName,
+      datasource,
+    );
+    this._adapters[datasourceName] = adapter;
+    return adapter;
+  }
+}

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

@@ -0,0 +1,36 @@
+import {expect} from 'chai';
+import {Schema} from '../schema.js';
+import {AdapterRegistry} from './adapter-registry.js';
+import {MemoryAdapter} from './builtin/memory-adapter.js';
+
+describe('AdapterRegistry', function () {
+  describe('getAdapter', function () {
+    it('instantiates a new or returns an existing adapter by a given datasource name', async function () {
+      const S = new Schema();
+      S.defineDatasource({name: 'datasource', adapter: 'memory'});
+      const R = S.getService(AdapterRegistry);
+      const adapter = await R.getAdapter('datasource');
+      expect(adapter).to.be.instanceof(MemoryAdapter);
+      const sameAdapter = await R.getAdapter('datasource');
+      expect(sameAdapter).to.be.eq(adapter);
+    });
+
+    it('throws an error if a datasource is not exists', async function () {
+      const R = new AdapterRegistry();
+      const promise = R.getAdapter('unknown');
+      await expect(promise).to.be.rejectedWith(
+        'The datasource "unknown" is not defined.',
+      );
+    });
+
+    it('throws an error if an adapter is not exists', async function () {
+      const S = new Schema();
+      S.defineDatasource({name: 'datasource', adapter: 'unknown'});
+      const R = S.getService(AdapterRegistry);
+      const promise = R.getAdapter('datasource');
+      await expect(promise).to.be.rejectedWith(
+        'The adapter "unknown" is not found.',
+      );
+    });
+  });
+});

package/src/adapter/adapter.d.ts

@@ -0,0 +1,118 @@
+import {ModelId} from '../types.js';
+import {AnyObject} from '../types.js';
+import {ModelData} from '../types.js';
+import {Filter} from '../filter/index.js';
+import {Service} from '@e22m4u/js-service';
+import {ItemFilter} from '../filter/index.js';
+import {WhereClause} from '../filter/index.js';
+import {ServiceContainer} from '@e22m4u/js-service';
+
+/**
+ * Adapter.
+ */
+export declare class Adapter extends Service {
+  /**
+   * Settings.
+   */
+  get settings(): AnyObject | undefined;
+
+  /**
+   * Constructor.
+   *
+   * @param container
+   * @param settings
+   */
+  constructor(container?: ServiceContainer, settings?: AnyObject);
+
+  /**
+   * Create.
+   *
+   * @param modelName
+   * @param modelData
+   * @param filter
+   */
+  create(
+    modelName: string,
+    modelData: ModelData,
+    filter?: ItemFilter,
+  ): Promise<ModelData>;
+
+  /**
+   * Replace by id.
+   *
+   * @param modelName
+   * @param id
+   * @param modelData
+   * @param filter
+   */
+  replaceById(
+    modelName: string,
+    id: ModelId,
+    modelData: ModelData,
+    filter?: ItemFilter,
+  ): Promise<ModelData>;
+
+  /**
+   * Patch by id.
+   *
+   * @param modelName
+   * @param id
+   * @param modelData
+   * @param filter
+   */
+  patchById(
+    modelName: string,
+    id: ModelId,
+    modelData: ModelData,
+    filter?: ItemFilter,
+  ): Promise<ModelData>;
+
+  /**
+   * Find.
+   *
+   * @param modelName
+   * @param filter
+   */
+  find(modelName: string, filter?: Filter): Promise<ModelData[]>;
+
+  /**
+   * Find by id.
+   *
+   * @param modelName
+   * @param id
+   * @param filter
+   */
+  findById(modelName: string, id: ModelId, filter?: Filter): Promise<ModelData>;
+
+  /**
+   * Delete.
+   *
+   * @param modelName
+   * @param where
+   */
+  delete(modelName: string, where?: WhereClause): Promise<number>;
+
+  /**
+   * Delete by id.
+   *
+   * @param modelName
+   * @param id
+   */
+  deleteById(modelName: string, id: ModelId): Promise<boolean>;
+
+  /**
+   * Exists.
+   *
+   * @param modelName
+   * @param id
+   */
+  exists(modelName: string, id: ModelId): Promise<boolean>;
+
+  /**
+   * Count.
+   *
+   * @param modelName
+   * @param where
+   */
+  count(modelName: string, where?: WhereClause): Promise<number>;
+}

package/src/adapter/adapter.js

@@ -0,0 +1,181 @@
+/* eslint no-unused-vars: 0 */
+/* eslint jsdoc/require-returns-check: 0 */
+import {Service} from '@e22m4u/js-service';
+import {NotImplementedError} from '../errors/index.js';
+import {InclusionDecorator} from './decorator/index.js';
+import {DefaultValuesDecorator} from './decorator/index.js';
+import {DataValidationDecorator} from './decorator/index.js';
+import {DataSanitizingDecorator} from './decorator/index.js';
+import {FieldsFilteringDecorator} from './decorator/index.js';
+
+/**
+ * Adapter.
+ */
+export class Adapter extends Service {
+  /**
+   * Settings.
+   *
+   * @type {object|undefined}
+   */
+  _settings;
+
+  /**
+   * Settings.
+   *
+   * @returns {object|undefined}
+   */
+  get settings() {
+    return this._settings;
+  }
+
+  /**
+   * Constructor.
+   *
+   * @param {object|undefined} container
+   * @param {object|undefined} settings
+   */
+  constructor(container = undefined, settings = undefined) {
+    super(container);
+    this._settings = settings;
+    // decorate only extended classes
+    if (this.constructor !== Adapter) {
+      this.getService(DataValidationDecorator).decorate(this);
+      this.getService(DataSanitizingDecorator).decorate(this);
+      this.getService(DefaultValuesDecorator).decorate(this);
+      this.getService(FieldsFilteringDecorator).decorate(this);
+      this.getService(InclusionDecorator).decorate(this);
+    }
+  }
+
+  /**
+   * Create.
+   *
+   * @param {string} modelName
+   * @param {object} modelData
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  create(modelName, modelData, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.create is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Replace by id.
+   *
+   * @param {string} modelName
+   * @param {number|string} id
+   * @param {object} modelData
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  replaceById(modelName, id, modelData, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.replaceById is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Patch by id.
+   *
+   * @param {string} modelName
+   * @param {number|string} id
+   * @param {object} modelData
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  patchById(modelName, id, modelData, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.patchById is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Find.
+   *
+   * @param {string} modelName
+   * @param {object|undefined} filter
+   * @returns {Promise<object[]>}
+   */
+  find(modelName, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.find is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Find by id.
+   *
+   * @param {string} modelName
+   * @param {number|string} id
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  findById(modelName, id, filter = undefined) {
+    throw new NotImplementedError(
+      '%s.findById is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Delete.
+   *
+   * @param {string} modelName
+   * @param {object|undefined} where
+   * @returns {Promise<number>}
+   */
+  delete(modelName, where = undefined) {
+    throw new NotImplementedError(
+      '%s.delete is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Delete by id.
+   *
+   * @param {string} modelName
+   * @param {number|string} id
+   * @returns {Promise<boolean>}
+   */
+  deleteById(modelName, id) {
+    throw new NotImplementedError(
+      '%s.deleteById is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Exists.
+   *
+   * @param {string} modelName
+   * @param {number|string} id
+   * @returns {Promise<boolean>}
+   */
+  exists(modelName, id) {
+    throw new NotImplementedError(
+      '%s.exists is not implemented.',
+      this.constructor.name,
+    );
+  }
+
+  /**
+   * Count.
+   *
+   * @param {string} modelName
+   * @param {object|undefined} where
+   * @returns {Promise<number>}
+   */
+  count(modelName, where = undefined) {
+    throw new NotImplementedError(
+      '%s.count is not implemented.',
+      this.constructor.name,
+    );
+  }
+}

package/src/adapter/adapter.spec.js

@@ -0,0 +1,144 @@
+import chai from 'chai';
+import {expect} from 'chai';
+import {Schema} from '../schema.js';
+import {Adapter} from './adapter.js';
+import {Service} from '@e22m4u/js-service';
+import {ServiceContainer} from '@e22m4u/js-service';
+import {InclusionDecorator} from './decorator/index.js';
+import {DefaultValuesDecorator} from './decorator/index.js';
+import {DataValidationDecorator} from './decorator/index.js';
+import {DataSanitizingDecorator} from './decorator/index.js';
+import {FieldsFilteringDecorator} from './decorator/index.js';
+
+const sandbox = chai.spy.sandbox();
+
+describe('Adapter', function () {
+  describe('constructor', function () {
+    afterEach(function () {
+      sandbox.restore();
+    });
+
+    it('inherits from the Service class', function () {
+      const adapter = new Adapter();
+      expect(adapter).to.be.instanceof(Service);
+    });
+
+    it('sets given service container and settings', function () {
+      const container = new ServiceContainer();
+      const settings = {};
+      const adapter = new Adapter(container, settings);
+      expect(adapter.container).to.be.eq(container);
+      expect(adapter._settings).to.be.eq(settings);
+    });
+
+    it('decorates only extended adapter', function () {
+      const schema = new Schema();
+      const dec1 = schema.getService(DataValidationDecorator);
+      const dec2 = schema.getService(DataSanitizingDecorator);
+      const dec3 = schema.getService(DefaultValuesDecorator);
+      const dec4 = schema.getService(FieldsFilteringDecorator);
+      const dec5 = schema.getService(InclusionDecorator);
+      const order = [];
+      const decorate = function (ctx) {
+        expect(ctx).to.be.instanceof(Adapter);
+        order.push(this);
+      };
+      sandbox.on(dec1, 'decorate', decorate);
+      sandbox.on(dec2, 'decorate', decorate);
+      sandbox.on(dec3, 'decorate', decorate);
+      sandbox.on(dec4, 'decorate', decorate);
+      sandbox.on(dec5, 'decorate', decorate);
+      new Adapter(schema.container);
+      expect(order).to.be.empty;
+      expect(dec1.decorate).to.be.not.called;
+      expect(dec2.decorate).to.be.not.called;
+      expect(dec3.decorate).to.be.not.called;
+      expect(dec4.decorate).to.be.not.called;
+      expect(dec5.decorate).to.be.not.called;
+      class ExtendedAdapter extends Adapter {}
+      new ExtendedAdapter(schema.container);
+      expect(order[0]).to.be.eql(dec1);
+      expect(order[1]).to.be.eql(dec2);
+      expect(order[2]).to.be.eql(dec3);
+      expect(order[3]).to.be.eql(dec4);
+      expect(order[4]).to.be.eql(dec5);
+      expect(dec1.decorate).to.be.called.once;
+      expect(dec2.decorate).to.be.called.once;
+      expect(dec3.decorate).to.be.called.once;
+      expect(dec4.decorate).to.be.called.once;
+      expect(dec5.decorate).to.be.called.once;
+    });
+  });
+
+  describe('create', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.create();
+      expect(throwable).to.throw('Adapter.create is not implemented.');
+    });
+  });
+
+  describe('replaceById', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.replaceById();
+      expect(throwable).to.throw('Adapter.replaceById is not implemented.');
+    });
+  });
+
+  describe('patchById', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.patchById();
+      expect(throwable).to.throw('Adapter.patchById is not implemented.');
+    });
+  });
+
+  describe('find', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.find();
+      expect(throwable).to.throw('Adapter.find is not implemented.');
+    });
+  });
+
+  describe('findById', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.findById();
+      expect(throwable).to.throw('Adapter.findById is not implemented.');
+    });
+  });
+
+  describe('delete', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.delete();
+      expect(throwable).to.throw('Adapter.delete is not implemented.');
+    });
+  });
+
+  describe('deleteById', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.deleteById();
+      expect(throwable).to.throw('Adapter.deleteById is not implemented.');
+    });
+  });
+
+  describe('exists', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.exists();
+      expect(throwable).to.throw('Adapter.exists is not implemented.');
+    });
+  });
+
+  describe('count', function () {
+    it('throws the "Not implemented"', function () {
+      const adapter = new Adapter();
+      const throwable = () => adapter.count();
+      expect(throwable).to.throw('Adapter.count is not implemented.');
+    });
+  });
+});