@e22m4u/js-repository 0.0.31

package/src/filter/slice-clause-tool.spec.js

@@ -0,0 +1,117 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {SliceClauseTool} from './slice-clause-tool.js';
+
+const S = new SliceClauseTool();
+
+describe('SliceClauseTool', function () {
+  describe('filter', function () {
+    it('does nothing if no clauses provided', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects);
+      expect(result).to.be.eql(objects);
+    });
+
+    it('does nothing if a given skip is zero', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, 0);
+      expect(result).to.be.eql(objects);
+    });
+
+    it('uses a given skip to exclude array elements from start', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, 2);
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(objects[2]);
+    });
+
+    it('returns an empty array if skipping too much', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, 10);
+      expect(result).to.have.length(0);
+    });
+
+    it('does nothing if a given limit is zero', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, undefined, 0);
+      expect(result).to.be.eql(objects);
+    });
+
+    it('uses a given limit to trim a given array', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, undefined, 2);
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(objects[0]);
+      expect(result[1]).to.be.eql(objects[1]);
+    });
+
+    it('able to combine a skip and a limit option together', function () {
+      const objects = [{id: 1}, {id: 2}, {id: 3}];
+      const result = S.slice(objects, 1, 1);
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(objects[1]);
+    });
+
+    it('throws an error if a first argument is not an array', function () {
+      const throwable = () => S.slice(10);
+      expect(throwable).to.throw(
+        'A first argument of SliceClauseTool.slice ' +
+          'should be an Array, but 10 given.',
+      );
+    });
+
+    it('throws an error if the given "skip" option is not a number', function () {
+      const throwable = () => S.slice([], 'invalid');
+      expect(throwable).to.throw(
+        'The provided option "skip" should be a Number, but "invalid" given.',
+      );
+    });
+
+    it('throws an error if the given "limit" option is not a number', function () {
+      const throwable = () => S.slice([], undefined, 'invalid');
+      expect(throwable).to.throw(
+        'The provided option "limit" should be a Number, but "invalid" given.',
+      );
+    });
+  });
+
+  describe('validateSkipClause', function () {
+    it('requires a number value or a falsy value', function () {
+      const validate = v => () => SliceClauseTool.validateSkipClause(v);
+      const error = v =>
+        format(
+          'The provided option "skip" should be a Number, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      validate('')();
+      validate(false)();
+      validate(undefined)();
+      validate(null)();
+      validate(10)();
+      validate(0)();
+    });
+  });
+
+  describe('validateLimitClause', function () {
+    it('requires a number value or a falsy value', function () {
+      const validate = v => () => SliceClauseTool.validateLimitClause(v);
+      const error = v =>
+        format(
+          'The provided option "limit" should be a Number, but %s given.',
+          v,
+        );
+      expect(validate('str')).to.throw(error('"str"'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate([])).to.throw(error('Array'));
+      validate('')();
+      validate(false)();
+      validate(undefined)();
+      validate(null)();
+      validate(10)();
+      validate(0)();
+    });
+  });
+});

package/src/filter/where-clause-tool.d.ts

@@ -0,0 +1,23 @@
+import {ModelData} from '../types.js';
+import {WhereClause} from './filter.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Where clause tool.
+ */
+export declare class WhereClauseTool extends Service {
+  /**
+   * Filter.
+   *
+   * @param entities
+   * @param where
+   */
+  filter(entities: ModelData[], where: WhereClause | undefined): ModelData[];
+
+  /**
+   * Validate where clause.
+   *
+   * @param clause
+   */
+  static validateWhereClause(clause: WhereClause | undefined): void;
+}

package/src/filter/where-clause-tool.js

@@ -0,0 +1,165 @@
+import {Service} from '@e22m4u/js-service';
+import {getValueByPath} from '../utils/index.js';
+import {InvalidArgumentError} from '../errors/index.js';
+import {OperatorClauseTool} from './operator-clause-tool.js';
+
+/**
+ * Where clause tool.
+ *
+ * @typedef {object|Function} WhereClause
+ */
+export class WhereClauseTool extends Service {
+  /**
+   * Filter by where clause.
+   *
+   * @example
+   * ```
+   * const entities = [
+   *   {foo: 1, bar: 'a'},
+   *   {foo: 2, bar: 'b'},
+   *   {foo: 3, bar: 'b'},
+   *   {foo: 4, bar: 'b'},
+   * ];
+   *
+   * const result = filterByWhereClause(entities, {
+   *   foo: {gt: 2},
+   *   bar: 'b',
+   * });
+   *
+   * console.log(result);
+   * // [
+   * //   {foo: 3, bar: 'b'},
+   * //   {foo: 4, bar: 'b'},
+   * // ];
+   *
+   * ```
+   *
+   * @param {object[]} entities
+   * @param {WhereClause|undefined} where
+   * @returns {object[]}
+   */
+  filter(entities, where = undefined) {
+    if (!Array.isArray(entities))
+      throw new InvalidArgumentError(
+        'A first argument of WhereUtils.filter ' +
+          'should be an Array of Objects, but %v given.',
+        entities,
+      );
+    if (!where) return entities;
+    return entities.filter(this._createFilter(where));
+  }
+
+  /**
+   * Create where filter.
+   *
+   * @param {WhereClause} whereClause
+   * @returns {Function}
+   */
+  _createFilter(whereClause) {
+    if (typeof whereClause === 'function') return whereClause;
+    if (typeof whereClause !== 'object')
+      throw new InvalidArgumentError(
+        'The provided option "where" should be an Object, but %v given.',
+        whereClause,
+      );
+    const keys = Object.keys(whereClause);
+    return data => {
+      if (typeof data !== 'object')
+        throw new InvalidArgumentError(
+          'A first argument of WhereUtils.filter ' +
+            'should be an Array of Objects, but %v given.',
+          data,
+        );
+      return keys.every(key => {
+        // AndClause (recursion)
+        if (key === 'and' && key in whereClause) {
+          const andClause = whereClause[key];
+          if (Array.isArray(andClause))
+            return andClause.every(clause => this._createFilter(clause)(data));
+          // OrClause (recursion)
+        } else if (key === 'or' && key in whereClause) {
+          const orClause = whereClause[key];
+          if (Array.isArray(orClause))
+            return orClause.some(clause => this._createFilter(clause)(data));
+        }
+        // PropertiesClause (properties)
+        const value = getValueByPath(data, key);
+        const matcher = whereClause[key];
+        // Property value is an array.
+        if (Array.isArray(value)) {
+          // {neq: ...}
+          if (
+            typeof matcher === 'object' &&
+            matcher !== null &&
+            'neq' in matcher &&
+            matcher.neq !== undefined
+          ) {
+            // The following condition is for the case where
+            // we are querying with a neq filter, and when
+            // the value is an empty array ([]).
+            if (value.length === 0) return true;
+            // The neq operator requires each element
+            // of the array to be excluded.
+            return value.every((el, index) => {
+              const where = {};
+              where[index] = matcher;
+              return this._createFilter(where)({...value});
+            });
+          }
+          // Requires one of an array elements to be match.
+          return value.some((el, index) => {
+            const where = {};
+            where[index] = matcher;
+            return this._createFilter(where)({...value});
+          });
+        }
+        // Test property value.
+        if (this._test(matcher, value)) return true;
+      });
+    };
+  }
+
+  /**
+   * Value testing.
+   *
+   * @param {*} example
+   * @param {*} value
+   * @returns {boolean}
+   */
+  _test(example, value) {
+    // Test null.
+    if (example == null) {
+      return value == null;
+    }
+    // Test RegExp.
+    // noinspection ALL
+    if (example instanceof RegExp) {
+      if (typeof value === 'string') return !!value.match(example);
+      return false;
+    }
+    // Operator clause.
+    if (typeof example === 'object') {
+      const operatorsTest = this.getService(OperatorClauseTool).testAll(
+        example,
+        value,
+      );
+      if (operatorsTest !== undefined) return operatorsTest;
+    }
+    // Not strict equality.
+    return example == value;
+  }
+
+  /**
+   * Validate where clause.
+   *
+   * @param {WhereClause|undefined} clause
+   */
+  static validateWhereClause(clause) {
+    if (!clause) return;
+    if (typeof clause !== 'object' || Array.isArray(clause))
+      throw new InvalidArgumentError(
+        'The provided option "where" should be an Object, but %v given.',
+        clause,
+      );
+  }
+}

package/src/filter/where-clause-tool.spec.js

@@ -0,0 +1,280 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {WhereClauseTool} from './where-clause-tool.js';
+
+const S = new WhereClauseTool();
+
+const OBJECTS = [
+  {
+    id: 1,
+    name: 'John',
+    surname: 'Doe',
+    age: 21,
+    hobbies: ['bicycle', 'yoga'],
+    nickname: 'Spear',
+    birthdate: '2002-04-14',
+  },
+  {
+    id: 2,
+    name: 'Mary',
+    surname: 'Smith',
+    age: 21,
+    hobbies: ['yoga', 'meditation'],
+    nickname: 'Flower',
+    birthdate: '2002-01-12',
+  },
+  {
+    id: 3,
+    name: 'James',
+    surname: 'Smith',
+    age: 21,
+    hobbies: [],
+    nickname: null,
+    birthdate: '2002-03-01',
+  },
+  {
+    id: 4,
+    name: 'Oliver',
+    surname: 'Smith',
+    age: 32,
+    hobbies: ['bicycle'],
+    birthdate: '1991-06-24',
+  },
+];
+
+describe('WhereClauseTool', function () {
+  describe('filter', function () {
+    it('returns the same array if no given condition', function () {
+      const result = S.filter(OBJECTS);
+      expect(result).to.be.eql(OBJECTS);
+    });
+
+    it('returns a filtered array by matched properties', function () {
+      const result = S.filter(OBJECTS, {surname: 'Smith', age: 21});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('the and operator requires each given condition to be met', function () {
+      const result = S.filter(OBJECTS, {
+        and: [{name: 'James'}, {age: 21}],
+      });
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('the or operator requires one of a given condition to be met', function () {
+      const result = S.filter(OBJECTS, {
+        or: [{name: 'James'}, {age: 21}],
+      });
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+      expect(result[2]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses property value to match an array value', function () {
+      const result = S.filter(OBJECTS, {hobbies: 'yoga'});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+    });
+
+    it('uses given RegExp to match a property value', function () {
+      const result = S.filter(OBJECTS, {surname: /^Sm.+/});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+      expect(result[2]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses given RegExp to match an array value', function () {
+      const result = S.filter(OBJECTS, {hobbies: /^\w+cycle/});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('skips not supported values for RegExp', function () {
+      const result = S.filter(OBJECTS, {id: /test/});
+      expect(result).to.be.empty;
+    });
+
+    it('uses an "eq" operator to match equality', function () {
+      const result = S.filter(OBJECTS, {name: {eq: 'John'}});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+    });
+
+    it('uses a "neq" operator to match non-equality', function () {
+      const result = S.filter(OBJECTS, {name: {neq: 'John'}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+      expect(result[2]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "neq" operator to match an empty array', function () {
+      const result = S.filter(OBJECTS, {hobbies: {neq: 'bicycle'}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a "gt" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {gt: 2}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[2]);
+      expect(result[1]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "gte" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {gte: 2}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+      expect(result[2]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "lt" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {lt: 3}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+    });
+
+    it('uses a "lte" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {lte: 3}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+      expect(result[2]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a "inq" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {inq: [2, 3]}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a "nin" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {nin: [2, 3]}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "between" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {id: {between: [2, 3]}});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+      expect(result[1]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses an "exists" operator to check existence', function () {
+      const result = S.filter(OBJECTS, {nickname: {exists: true}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+      expect(result[2]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses an "exists" operator to check non-existence', function () {
+      const result = S.filter(OBJECTS, {nickname: {exists: false}});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "like" operator to match by a substring', function () {
+      const result = S.filter(OBJECTS, {name: {like: 'liv'}});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "nlike" operator to exclude by a substring', function () {
+      const result = S.filter(OBJECTS, {name: {nlike: 'liv'}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+      expect(result[2]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a "ilike" operator to case-insensitively matching by a substring', function () {
+      const result = S.filter(OBJECTS, {name: {ilike: 'LIV'}});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a "nilike" operator to exclude case-insensitively by a substring', function () {
+      const result = S.filter(OBJECTS, {name: {nilike: 'LIV'}});
+      expect(result).to.have.length(3);
+      expect(result[0]).to.be.eql(OBJECTS[0]);
+      expect(result[1]).to.be.eql(OBJECTS[1]);
+      expect(result[2]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a "regexp" operator to compare values', function () {
+      const result = S.filter(OBJECTS, {name: {regexp: '^Jam.*'}});
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[2]);
+    });
+
+    it('uses a null to match an undefined and null value', function () {
+      const result = S.filter(OBJECTS, {nickname: null});
+      expect(result).to.have.length(2);
+      expect(result[0]).to.be.eql(OBJECTS[2]);
+      expect(result[1]).to.be.eql(OBJECTS[3]);
+    });
+
+    it('uses a given function to filter values', function () {
+      const result = S.filter(OBJECTS, v => v.nickname === 'Flower');
+      expect(result).to.have.length(1);
+      expect(result[0]).to.be.eql(OBJECTS[1]);
+    });
+
+    it('throws an error if a first argument is not an Array', function () {
+      const throwable = () => S.filter(10, {});
+      expect(throwable).to.throw(
+        'A first argument of WhereUtils.filter ' +
+          'should be an Array of Objects, but 10 given.',
+      );
+    });
+
+    it('throws an error if elements of a first argument is not an Object', function () {
+      const throwable = () => S.filter([10], {});
+      expect(throwable).to.throw(
+        'A first argument of WhereUtils.filter ' +
+          'should be an Array of Objects, but 10 given.',
+      );
+    });
+
+    it('throws an error if a provided second argument is not an Object', function () {
+      const throwable = () => S.filter([], 10);
+      expect(throwable).to.throw(
+        'The provided option "where" should be an Object, but 10 given.',
+      );
+    });
+  });
+
+  describe('validateWhereClause', function () {
+    it('requires an object value or a falsy value', function () {
+      const validate = v => () => WhereClauseTool.validateWhereClause(v);
+      const error = v =>
+        format(
+          'The provided option "where" 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([])).to.throw(error('Array'));
+      validate('')();
+      validate(false)();
+      validate(undefined)();
+      validate(null)();
+      validate({})();
+    });
+  });
+});

package/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types.js';
+export * from './schema.js';
+export * from './utils/index.js';
+export * from './filter/index.js';
+export * from './errors/index.js';
+export * from './adapter/index.js';
+export * from './relations/index.js';
+export * from './definition/index.js';
+export * from './repository/index.js';

package/src/index.js

@@ -0,0 +1,8 @@
+export * from './schema.js';
+export * from './utils/index.js';
+export * from './errors/index.js';
+export * from './filter/index.js';
+export * from './adapter/index.js';
+export * from './relations/index.js';
+export * from './definition/index.js';
+export * from './repository/index.js';

package/src/relations/belongs-to-resolver.d.ts

@@ -0,0 +1,46 @@
+import {ModelData} from '../types.js';
+import {Filter} from '../filter/index.js';
+import {Service} from '@e22m4u/js-service';
+
+/**
+ * Belongs to resolver.
+ */
+export declare class BelongsToResolver extends Service {
+  /**
+   * Include to.
+   *
+   * @param entities
+   * @param sourceName
+   * @param targetName
+   * @param relationName
+   * @param foreignKey
+   * @param scope
+   */
+  includeTo(
+    entities: ModelData[],
+    sourceName: string,
+    targetName: string,
+    relationName: string,
+    foreignKey?: string,
+    scope?: Filter,
+  ): Promise<void>;
+
+  /**
+   * Include polymorphic to.
+   *
+   * @param entities
+   * @param sourceName
+   * @param relationName
+   * @param foreignKey
+   * @param discriminator
+   * @param scope
+   */
+  includePolymorphicTo(
+    entities: ModelData[],
+    sourceName: string,
+    relationName: string,
+    foreignKey?: string,
+    discriminator?: string,
+    scope?: Filter,
+  ): Promise<void>;
+}