@e22m4u/js-repository 0.0.31

package/src/repository/repository-registry.js

@@ -0,0 +1,57 @@
+import {Service} from '@e22m4u/js-service';
+import {Repository} from './repository.js';
+import {InvalidArgumentError} from '../errors/index.js';
+
+/**
+ * Repository registry.
+ */
+export class RepositoryRegistry extends Service {
+  /**
+   * Repositories.
+   *
+   * @type {object}
+   */
+  _repositories = {};
+
+  /**
+   * Repository ctor.
+   *
+   * @type {typeof Repository}
+   * @private
+   */
+  _repositoryCtor = Repository;
+
+  /**
+   * Set repository ctor.
+   *
+   * @param {typeof Repository} ctor
+   */
+  setRepositoryCtor(ctor) {
+    if (
+      !ctor ||
+      typeof ctor !== 'function' ||
+      !(ctor.prototype instanceof Repository)
+    ) {
+      throw new InvalidArgumentError(
+        'The first argument of RepositoryRegistry.setRepositoryCtor ' +
+          'must inherit from Repository class, but %v given.',
+        ctor,
+      );
+    }
+    this._repositoryCtor = ctor;
+  }
+
+  /**
+   * Get repository.
+   *
+   * @param {string} modelName
+   * @returns {Repository}
+   */
+  getRepository(modelName) {
+    let repository = this._repositories[modelName];
+    if (repository) return repository;
+    repository = new this._repositoryCtor(this.container, modelName);
+    this._repositories[modelName] = repository;
+    return repository;
+  }
+}

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

@@ -0,0 +1,38 @@
+import {expect} from 'chai';
+import {Schema} from '../schema.js';
+import {Repository} from './repository.js';
+import {RepositoryRegistry} from './repository-registry.js';
+
+describe('RepositoryRegistry', function () {
+  describe('setRepositoryCtor', function () {
+    it('sets a given class as the repository constructor', function () {
+      class MyRepository extends Repository {}
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const registry = schema.getService(RepositoryRegistry);
+      registry.setRepositoryCtor(MyRepository);
+      const rep = registry.getRepository('model');
+      expect(rep).to.be.instanceof(Repository);
+      expect(rep).to.be.instanceof(MyRepository);
+    });
+  });
+
+  describe('getRepository', function () {
+    it('uses a given model name to return an existing repository or create the new', function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'modelA', datasource: 'datasource'});
+      schema.defineModel({name: 'modelB', datasource: 'datasource'});
+      const registry = schema.getService(RepositoryRegistry);
+      const repA1 = registry.getRepository('modelA');
+      const repA2 = registry.getRepository('modelA');
+      const repB1 = registry.getRepository('modelB');
+      const repB2 = registry.getRepository('modelB');
+      expect(repA1).to.be.eq(repA2);
+      expect(repB1).to.be.eq(repB2);
+      expect(repA1).to.be.not.eq(repB1);
+      expect(repA2).to.be.not.eq(repB2);
+    });
+  });
+});

package/src/repository/repository.d.ts

@@ -0,0 +1,164 @@
+import {ModelId} from '../types.js';
+import {Flatten} from '../types.js';
+import {ModelData} from '../types.js';
+import {PartialBy} from '../types.js';
+import {Filter} from '../filter/index.js';
+import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter/index.js';
+import {ItemFilter} from '../filter/index.js';
+import {WhereClause} from '../filter/index.js';
+import {ServiceContainer} from '@e22m4u/js-service';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME} from '../definition/index.js';
+
+/**
+ * Repository.
+ */
+export declare class Repository<
+  Data extends ModelData = ModelData,
+  IdType extends ModelId = ModelId,
+  IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
+  FlatData extends ModelData = Flatten<Data>,
+> extends Service {
+  /**
+   * Model name.
+   */
+  get modelName(): string;
+
+  /**
+   * Datasource name.
+   */
+  get datasourceName(): string;
+
+  /**
+   * Constructor.
+   *
+   * @param container
+   * @param modelName
+   */
+  constructor(container: ServiceContainer, modelName: string);
+
+  /**
+   * Get adapter.
+   */
+  getAdapter(): Promise<Adapter>;
+
+  /**
+   * Create.
+   *
+   * @param data
+   * @param filter
+   */
+  create(
+    data: OptionalUnlessRequiredId<IdName, FlatData>,
+    filter?: ItemFilter,
+  ): Promise<FlatData>;
+
+  /**
+   * Replace by id.
+   *
+   * @param id
+   * @param data
+   * @param filter
+   */
+  replaceById(
+    id: IdType,
+    data: WithoutId<IdName, FlatData>,
+    filter?: ItemFilter,
+  ): Promise<FlatData>;
+
+  /**
+   * Replace or create.
+   *
+   * @param data
+   * @param filter
+   */
+  replaceOrCreate(
+    data: OptionalUnlessRequiredId<IdName, Data>,
+    filter?: ItemFilter,
+  ): Promise<FlatData>;
+
+  /**
+   * Patch by id.
+   *
+   * @param id
+   * @param data
+   * @param filter
+   */
+  patchById(
+    id: IdType,
+    data: PartialWithoutId<IdName, Data>,
+    filter?: ItemFilter,
+  ): Promise<FlatData>;
+
+  /**
+   * Find.
+   *
+   * @param filter
+   */
+  find(filter?: Filter): Promise<FlatData[]>;
+
+  /**
+   * Find one.
+   *
+   * @param filter
+   */
+  findOne(filter?: ItemFilter): Promise<FlatData | undefined>;
+
+  /**
+   * Find by id.
+   *
+   * @param id
+   * @param filter
+   */
+  findById(id: IdType, filter?: ItemFilter): Promise<FlatData>;
+
+  /**
+   * Delete.
+   *
+   * @param where
+   */
+  delete(where?: WhereClause): Promise<number>;
+
+  /**
+   * Delete by id.
+   *
+   * @param id
+   */
+  deleteById(id: IdType): Promise<boolean>;
+
+  /**
+   * Exists.
+   *
+   * @param id
+   */
+  exists(id: IdType): Promise<boolean>;
+
+  /**
+   * Count.
+   *
+   * @param where
+   */
+  count(where?: WhereClause): Promise<number>;
+}
+
+/**
+ * Removes id field.
+ */
+type WithoutId<IdName extends string, Data extends ModelData> = Flatten<
+  Omit<Data, IdName>
+>;
+
+/**
+ * Makes fields as optional and remove id field.
+ */
+type PartialWithoutId<IdName extends string, Data extends ModelData> = Flatten<
+  Partial<Omit<Data, IdName>>
+>;
+
+/**
+ * Makes the required id field as optional.
+ */
+type OptionalUnlessRequiredId<
+  IdName extends string,
+  Data extends ModelData,
+> = Flatten<Data extends {[K in IdName]: any} ? PartialBy<Data, IdName> : Data>;

package/src/repository/repository.js

@@ -0,0 +1,207 @@
+import {Service} from '@e22m4u/js-service';
+import {Adapter} from '../adapter/index.js';
+import {AdapterRegistry} from '../adapter/index.js';
+import {InvalidArgumentError} from '../errors/index.js';
+import {DefinitionRegistry} from '../definition/index.js';
+import {ModelDefinitionUtils} from '../definition/index.js';
+
+/**
+ * Repository.
+ */
+export class Repository extends Service {
+  /**
+   * Model name.
+   *
+   * @type {string}
+   */
+  _modelName;
+
+  /**
+   * Model name.
+   *
+   * @returns {string}
+   */
+  get modelName() {
+    return this._modelName;
+  }
+
+  /**
+   * Datasource name.
+   *
+   * @type {string}
+   */
+  _datasourceName;
+
+  /**
+   * Datasource name.
+   *
+   * @returns {string}
+   */
+  get datasourceName() {
+    return this._datasourceName;
+  }
+
+  /**
+   * Constructor.
+   *
+   * @typedef {import('@e22m4u/js-service').ServiceContainer} ServiceContainer
+   * @param {ServiceContainer} container
+   * @param {string} modelName
+   */
+  constructor(container, modelName) {
+    super(container);
+    this._modelName = modelName;
+    const modelDef = this.getService(DefinitionRegistry).getModel(modelName);
+    const datasourceName = modelDef.datasource;
+    if (!datasourceName)
+      throw new InvalidArgumentError(
+        'The model %v does not have a specified datasource.',
+        modelName,
+      );
+    this._datasourceName = datasourceName;
+  }
+
+  /**
+   * Get adapter.
+   *
+   * @returns {Adapter}
+   */
+  async getAdapter() {
+    return this.getService(AdapterRegistry).getAdapter(this.datasourceName);
+  }
+
+  /**
+   * Create.
+   *
+   * @param {object} data
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async create(data, filter = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.create(this.modelName, data, filter);
+  }
+
+  /**
+   * Replace by id.
+   *
+   * @param {number|string} id
+   * @param {object} data
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async replaceById(id, data, filter = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.replaceById(this.modelName, id, data, filter);
+  }
+
+  /**
+   * Replace or create.
+   *
+   * @param {object} data
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async replaceOrCreate(data, filter = undefined) {
+    const pkPropName = this.getService(
+      ModelDefinitionUtils,
+    ).getPrimaryKeyAsPropertyName(this.modelName);
+    const pkValue = data[pkPropName];
+    if (pkValue == null) return this.create(data, filter);
+    return this.replaceById(pkValue, data, filter);
+  }
+
+  /**
+   * Patch by id.
+   *
+   * @param {number|string} id
+   * @param {object} data
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async patchById(id, data, filter = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.patchById(this.modelName, id, data, filter);
+  }
+
+  /**
+   * Find.
+   *
+   * @param {object|undefined} filter
+   * @returns {Promise<object[]>}
+   */
+  async find(filter = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.find(this.modelName, filter);
+  }
+
+  /**
+   * Find one.
+   *
+   * @param {object|undefined} filter
+   * @returns {Promise<object|undefined>}
+   */
+  async findOne(filter = undefined) {
+    const adapter = await this.getAdapter();
+    filter = filter ?? {};
+    filter.limit = 1;
+    const result = await adapter.find(this.modelName, filter);
+    return result.length ? result[0] : undefined;
+  }
+
+  /**
+   * Find by id.
+   *
+   * @param {number|string} id
+   * @param {object|undefined} filter
+   * @returns {Promise<object>}
+   */
+  async findById(id, filter = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.findById(this.modelName, id, filter);
+  }
+
+  /**
+   * Delete.
+   *
+   * @param {object|undefined} where
+   * @returns {Promise<number>}
+   */
+  async delete(where = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.delete(this.modelName, where);
+  }
+
+  /**
+   * Delete by id.
+   *
+   * @param {number|string} id
+   * @returns {Promise<boolean>}
+   */
+  async deleteById(id) {
+    const adapter = await this.getAdapter();
+    return adapter.deleteById(this.modelName, id);
+  }
+
+  /**
+   * Exists.
+   *
+   * @param {number|string} id
+   * @returns {Promise<boolean>}
+   */
+  async exists(id) {
+    const adapter = await this.getAdapter();
+    return adapter.exists(this.modelName, id);
+  }
+
+  /**
+   * Count.
+   *
+   * @param {object|undefined} where
+   * @returns {Promise<number>}
+   */
+  async count(where = undefined) {
+    const adapter = await this.getAdapter();
+    return adapter.count(this.modelName, where);
+  }
+}

package/src/repository/repository.spec.js

@@ -0,0 +1,202 @@
+import {expect} from 'chai';
+import {Schema} from '../schema.js';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.js';
+
+describe('Repository', function () {
+  describe('create', function () {
+    it('creates a new item from the given data', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const data = {foo: 'bar'};
+      const rep = schema.getRepository('model');
+      const result = await rep.create(data);
+      expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], ...data});
+    });
+  });
+
+  describe('replaceById', function () {
+    it('replaces an item by the given id', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const result = await rep.replaceById(created[DEF_PK], {baz: 'qux'});
+      expect(result).to.be.eql({[DEF_PK]: created[DEF_PK], baz: 'qux'});
+    });
+  });
+
+  describe('replaceOrCreate', function () {
+    it('creates a new item from the given data', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const data = {foo: 'bar'};
+      const rep = schema.getRepository('model');
+      const result = await rep.replaceOrCreate(data);
+      expect(result).to.be.eql({[DEF_PK]: result[DEF_PK], ...data});
+    });
+
+    it('replaces an existing item', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const replacer = {[DEF_PK]: created[DEF_PK], bar: 'qux'};
+      const result = await rep.replaceOrCreate(replacer);
+      expect(result).to.be.eql(replacer);
+    });
+  });
+
+  describe('patchById', function () {
+    it('patches an item by the given id', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const result = await rep.patchById(created[DEF_PK], {baz: 'qux'});
+      expect(result).to.be.eql({
+        [DEF_PK]: created[DEF_PK],
+        foo: 'bar',
+        baz: 'qux',
+      });
+    });
+  });
+
+  describe('find', function () {
+    it('returns all items', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created1 = await rep.create({foo: 'bar'});
+      const created2 = await rep.create({baz: 'qux'});
+      const result = await rep.find();
+      expect(result).to.be.eql([created1, created2]);
+    });
+
+    it('returns found items by the "where" clause', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      const created = await rep.create({baz: 'qux'});
+      const result = await rep.find({where: {baz: 'qux'}});
+      expect(result).to.be.eql([created]);
+    });
+  });
+
+  describe('findOne', function () {
+    it('returns a first item', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      await rep.create({baz: 'qux'});
+      const result = await rep.findOne();
+      expect(result).to.be.eql(created);
+    });
+
+    it('returns a found item by the "where" clause', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      const created = await rep.create({baz: 'qux'});
+      const result = await rep.findOne({where: {baz: 'qux'}});
+      expect(result).to.be.eql(created);
+    });
+  });
+
+  describe('findById', function () {
+    it('returns an item by the given id', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const result = await rep.findById(created[DEF_PK]);
+      expect(result).to.be.eql(created);
+    });
+  });
+
+  describe('delete', function () {
+    it('removes all items', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      await rep.create({baz: 'qux'});
+      const result = await rep.delete();
+      expect(result).to.be.eq(2);
+    });
+
+    it('removes found items by the "where" clause', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      await rep.create({foo: 'bar'});
+      await rep.create({baz: 'qux'});
+      const result = await rep.delete({foo: 'bar'});
+      expect(result).to.be.eql(2);
+    });
+  });
+
+  describe('deleteById', function () {
+    it('removes an item by the given id', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const result = await rep.deleteById(created[DEF_PK]);
+      expect(result).to.be.true;
+    });
+  });
+
+  describe('exists', function () {
+    it('returns true if the given id exists', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      const created = await rep.create({foo: 'bar'});
+      const result = await rep.exists(created[DEF_PK]);
+      expect(result).to.be.true;
+    });
+  });
+
+  describe('count', function () {
+    it('counts all items', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      await rep.create({baz: 'qux'});
+      const result = await rep.count();
+      expect(result).to.be.eq(2);
+    });
+
+    it('counts found items by the "where" clause', async function () {
+      const schema = new Schema();
+      schema.defineDatasource({name: 'datasource', adapter: 'memory'});
+      schema.defineModel({name: 'model', datasource: 'datasource'});
+      const rep = schema.getRepository('model');
+      await rep.create({foo: 'bar'});
+      await rep.create({foo: 'bar'});
+      await rep.create({baz: 'qux'});
+      const result = await rep.count({foo: 'bar'});
+      expect(result).to.be.eq(2);
+    });
+  });
+});

package/src/schema.d.ts

@@ -0,0 +1,37 @@
+import {ModelId} from './types.js';
+import {ModelData} from './types.js';
+import {Service} from '@e22m4u/js-service';
+import {Repository} from './repository/index.js';
+import {ModelDefinition} from './definition/index.js';
+import {DatasourceDefinition} from './definition/index.js';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME} from './definition/index.js';
+
+/**
+ * Schema.
+ */
+export declare class Schema extends Service {
+  /**
+   * Define datasource.
+   *
+   * @param datasourceDef
+   */
+  defineDatasource(datasourceDef: DatasourceDefinition): this;
+
+  /**
+   * Define model.
+   *
+   * @param modelDef
+   */
+  defineModel(modelDef: ModelDefinition): this;
+
+  /**
+   * Get repository.
+   *
+   * @param modelName
+   */
+  getRepository<
+    Data extends ModelData = ModelData,
+    IdType extends ModelId = ModelId,
+    IdName extends string = DEFAULT_PRIMARY_KEY_PROPERTY_NAME,
+  >(modelName: string): Repository<Data, IdType, IdName>;
+}