@e22m4u/js-repository 0.0.31

package/src/errors/index.d.ts

@@ -0,0 +1,3 @@
+export * from './not-implemented-error.js';
+export * from './invalid-argument-error.js';
+export * from './invalid-operator-value-error.js';

package/src/errors/index.js

@@ -0,0 +1,3 @@
+export * from './not-implemented-error.js';
+export * from './invalid-argument-error.js';
+export * from './invalid-operator-value-error.js';

package/src/errors/invalid-argument-error.d.ts

@@ -0,0 +1,6 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Invalid argument error.
+ */
+export declare class InvalidArgumentError extends Errorf {}

package/src/errors/invalid-argument-error.js

@@ -0,0 +1,6 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Invalid argument error.
+ */
+export class InvalidArgumentError extends Errorf {}

package/src/errors/invalid-argument-error.spec.js

@@ -0,0 +1,33 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {InvalidArgumentError} from './invalid-argument-error.js';
+
+describe('InvalidArgumentError', function () {
+  it('inherits from Error class', function () {
+    const error = new InvalidArgumentError();
+    expect(error).to.be.instanceof(Error);
+  });
+
+  it('sets a given message', function () {
+    const error = new InvalidArgumentError('This is the Error');
+    expect(error.message).to.be.eq('This is the Error');
+  });
+
+  it('interpolates a given pattern with variables', function () {
+    const throwable = v => () => {
+      throw new InvalidArgumentError('%v', v);
+    };
+    const error = v => format('%s', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error(0));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(() => undefined)).to.throw(error('Function'));
+  });
+});

package/src/errors/invalid-operator-value-error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Invalid operator value error.
+ */
+export declare class InvalidOperatorValueError extends Error {
+  /**
+   * Constructor.
+   *
+   * @param operator
+   * @param expects
+   * @param value
+   */
+  constructor(operator: string, expects: string, value: unknown);
+}

package/src/errors/invalid-operator-value-error.js

@@ -0,0 +1,24 @@
+import {format} from '@e22m4u/js-format';
+
+/**
+ * Invalid operator value error.
+ */
+export class InvalidOperatorValueError extends Error {
+  /**
+   * Constructor.
+   *
+   * @param {string} operator
+   * @param {string} expected
+   * @param {*} value
+   */
+  constructor(operator, expected, value) {
+    super(
+      format(
+        'Condition of {%s: ...} should have %s, %v given.',
+        operator,
+        expected,
+        value,
+      ),
+    );
+  }
+}

package/src/errors/invalid-operator-value-error.spec.js

@@ -0,0 +1,11 @@
+import {expect} from 'chai';
+import {InvalidOperatorValueError} from './invalid-operator-value-error.js';
+
+describe('InvalidOperatorValueError', function () {
+  it('sets specific message', function () {
+    const error = new InvalidOperatorValueError('exists', 'a boolean', '');
+    const message =
+      'Condition of {exists: ...} should have a boolean, "" given.';
+    expect(error.message).to.be.eq(message);
+  });
+});

package/src/errors/not-implemented-error.d.ts

@@ -0,0 +1,6 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Not implemented error.
+ */
+export declare class NotImplementedError extends Errorf {}

package/src/errors/not-implemented-error.js

@@ -0,0 +1,6 @@
+import {Errorf} from '@e22m4u/js-format';
+
+/**
+ * Not implemented error.
+ */
+export class NotImplementedError extends Errorf {}

package/src/errors/not-implemented-error.spec.js

@@ -0,0 +1,33 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {NotImplementedError} from './not-implemented-error.js';
+
+describe('NotImplementedError', function () {
+  it('inherits from Error class', function () {
+    const error = new NotImplementedError();
+    expect(error).to.be.instanceof(Error);
+  });
+
+  it('sets a given message', function () {
+    const error = new NotImplementedError('This is the Error');
+    expect(error.message).to.be.eq('This is the Error');
+  });
+
+  it('interpolates a given pattern with variables', function () {
+    const throwable = v => () => {
+      throw new NotImplementedError('%v', v);
+    };
+    const error = v => format('%s', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(0)).to.throw(error(0));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(() => undefined)).to.throw(error('Function'));
+  });
+});

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

@@ -0,0 +1,38 @@
+import {ModelData} from '../types.js';
+import {FieldsClause} from './filter.js';
+import {Service} from '@e22m4u/js-service';
+import {NormalizedFieldsClause} from './filter.js';
+
+/**
+ * Field clause tool.
+ */
+export declare class FieldsClauseTool extends Service {
+  /**
+   * Filter.
+   *
+   * @param entities
+   * @param modelName
+   * @param clause
+   */
+  filter<T extends ModelData | ModelData[]>(
+    entities: T,
+    modelName: string,
+    clause: FieldsClause | undefined,
+  ): T;
+
+  /**
+   * Validate fields clause.
+   *
+   * @param clause
+   */
+  static validateFieldsClause(clause: FieldsClause | undefined): void;
+
+  /**
+   * Normalize fields clause.
+   *
+   * @param clause
+   */
+  static normalizeFieldsClause(
+    clause: FieldsClause | undefined,
+  ): NormalizedFieldsClause | undefined;
+}

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

@@ -0,0 +1,88 @@
+import {Service} from '@e22m4u/js-service';
+import {selectObjectKeys} from '../utils/index.js';
+import {InvalidArgumentError} from '../errors/index.js';
+import {ModelDefinitionUtils} from '../definition/index.js';
+
+/**
+ * Field clause tool.
+ */
+export class FieldsClauseTool extends Service {
+  /**
+   * Filter.
+   *
+   * @param {object|object[]} entities
+   * @param {string} modelName
+   * @param {string|string[]|undefined} clause
+   * @returns {object|object[]}
+   */
+  filter(entities, modelName, clause) {
+    const isArray = Array.isArray(entities);
+    entities = isArray ? entities : [entities];
+    entities.forEach(entity => {
+      if (!entity || typeof entity !== 'object' || Array.isArray(entity))
+        throw new InvalidArgumentError(
+          'A first argument of FieldClauseTool.filter should be an Object or ' +
+            'an Array of Object, but %v given.',
+          entity,
+        );
+    });
+
+    if (!clause) return entities;
+    const fields = Array.isArray(clause) ? clause.slice() : [clause];
+    fields.forEach(field => {
+      if (!field || typeof field !== 'string')
+        throw new InvalidArgumentError(
+          'The provided option "fields" should be a String ' +
+            'or an Array of String, but %v given.',
+          field,
+        );
+    });
+
+    const pkPropName =
+      this.getService(ModelDefinitionUtils).getPrimaryKeyAsPropertyName(
+        modelName,
+      );
+    if (fields.indexOf(pkPropName) === -1) fields.push(pkPropName);
+
+    entities = entities.map(entity => selectObjectKeys(entity, fields));
+    return isArray ? entities : entities[0];
+  }
+
+  /**
+   * Validate fields clause.
+   *
+   * @param {string|string[]|undefined} clause
+   */
+  static validateFieldsClause(clause) {
+    if (!clause) return;
+    const tempClause = Array.isArray(clause) ? clause : [clause];
+    tempClause.forEach(key => {
+      if (!key || typeof key !== 'string')
+        throw new InvalidArgumentError(
+          'The provided option "fields" should be a non-empty String ' +
+            'or an Array of String, but %v given.',
+          key,
+        );
+    });
+  }
+
+  /**
+   * Normalize fields clause.
+   *
+   * @param {string|string[]|undefined} clause
+   * @returns {string[]|undefined}
+   */
+  static normalizeFieldsClause(clause) {
+    if (!clause) return;
+    clause = Array.isArray(clause) ? clause : [clause];
+    clause.forEach(key => {
+      if (!key || typeof key !== 'string')
+        throw new InvalidArgumentError(
+          'The provided option "fields" should be a non-empty String ' +
+            'or an Array of String, but %v given.',
+          key,
+        );
+    });
+    return clause;
+  }
+}

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

@@ -0,0 +1,133 @@
+import {expect} from 'chai';
+import {Schema} from '../schema.js';
+import {format} from '@e22m4u/js-format';
+import {FieldsClauseTool} from './fields-clause-tool.js';
+import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '../definition/index.js';
+
+const S = new Schema();
+const MODEL_NAME = 'model';
+S.defineModel({name: MODEL_NAME});
+const T = S.getService(FieldsClauseTool);
+
+describe('FieldsClauseTool', function () {
+  describe('filter', function () {
+    it('returns an object with selected fields', function () {
+      const value = {foo: 'fooVal', bar: 'barVal', baz: 'bazVal'};
+      const fields = ['bar', 'baz'];
+      const result = T.filter(value, MODEL_NAME, fields);
+      expect(result).to.be.eql({bar: 'barVal', baz: 'bazVal'});
+    });
+
+    it('returns an array with selected fields', function () {
+      const value = [
+        {foo: 'fooVal', bar: 'barVal', baz: 'bazVal'},
+        {foo: 'fooVal', bar: 'barVal', baz: 'bazVal'},
+        {foo: 'fooVal', bar: 'barVal', baz: 'bazVal'},
+      ];
+      const fields = ['bar', 'baz'];
+      const result = T.filter(value, MODEL_NAME, fields);
+      expect(result[0]).to.be.eql({bar: 'barVal', baz: 'bazVal'});
+      expect(result[1]).to.be.eql({bar: 'barVal', baz: 'bazVal'});
+      expect(result[2]).to.be.eql({bar: 'barVal', baz: 'bazVal'});
+    });
+
+    it('includes a primary key', function () {
+      const value = {[DEF_PK]: 10, foo: 'fooVal', bar: 'barVal', baz: 'bazVal'};
+      const fields = ['bar', 'baz'];
+      const result = T.filter(value, MODEL_NAME, fields);
+      expect(result).to.be.eql({[DEF_PK]: 10, bar: 'barVal', baz: 'bazVal'});
+    });
+
+    it('throws an error if a first argument is not an object', function () {
+      const throwable = () => T.filter(10, MODEL_NAME, ['bar']);
+      expect(throwable).to.throw(
+        'A first argument of FieldClauseTool.filter should be an Object or ' +
+          'an Array of Object, but 10 given.',
+      );
+    });
+
+    it('throws an error if elements of a first argument is not an object', function () {
+      const throwable = () => T.filter([10], MODEL_NAME, ['bar']);
+      expect(throwable).to.throw(
+        'A first argument of FieldClauseTool.filter should be an Object or ' +
+          'an Array of Object, but 10 given.',
+      );
+    });
+
+    it('throws an error if a second argument is not a string', function () {
+      const throwable = () => T.filter({}, MODEL_NAME, 10);
+      expect(throwable).to.throw(
+        'The provided option "fields" should be a String ' +
+          'or an Array of String, but 10 given.',
+      );
+    });
+
+    it('throws an error if elements of a second argument is not a string', function () {
+      const throwable = () => T.filter({}, MODEL_NAME, [10]);
+      expect(throwable).to.throw(
+        'The provided option "fields" should be a String ' +
+          'or an Array of String, but 10 given.',
+      );
+    });
+  });
+
+  describe('validateFieldsClause', function () {
+    it('requires a non-empty string or an array of non-empty strings', function () {
+      const validate = v => () => FieldsClauseTool.validateFieldsClause(v);
+      const error = v =>
+        format(
+          'The provided option "fields" should be a non-empty String ' +
+            'or an Array of String, but %s given.',
+          v,
+        );
+      expect(validate(10)).to.throw(error('10'));
+      expect(validate(true)).to.throw(error('true'));
+      expect(validate({})).to.throw(error('Object'));
+      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([undefined])).to.throw(error('undefined'));
+      expect(validate([null])).to.throw(error('null'));
+      validate('')();
+      validate(false)();
+      validate(undefined)();
+      validate(null)();
+      validate('foo')();
+      validate(['foo'])();
+    });
+  });
+
+  describe('normalizeFieldsClause', function () {
+    it('returns an array of strings', function () {
+      const fn = FieldsClauseTool.normalizeFieldsClause;
+      expect(fn('foo')).to.be.eql(['foo']);
+      expect(fn(['foo'])).to.be.eql(['foo']);
+    });
+
+    it('requires a non-empty string or an array of non-empty strings', function () {
+      const fn = clause => () => FieldsClauseTool.normalizeFieldsClause(clause);
+      const error = v =>
+        format(
+          'The provided option "fields" should be a non-empty String ' +
+            'or an Array of String, but %s given.',
+          v,
+        );
+      expect(fn(10)).to.throw(error('10'));
+      expect(fn(true)).to.throw(error('true'));
+      expect(fn({})).to.throw(error('Object'));
+      expect(fn([''])).to.throw(error('""'));
+      expect(fn([10])).to.throw(error('10'));
+      expect(fn([true])).to.throw(error('true'));
+      expect(fn([false])).to.throw(error('false'));
+      expect(fn([undefined])).to.throw(error('undefined'));
+      expect(fn([null])).to.throw(error('null'));
+      expect(fn('')()).to.be.undefined;
+      expect(fn(false)()).to.be.undefined;
+      expect(fn(undefined)()).to.be.undefined;
+      expect(fn(null)()).to.be.undefined;
+      expect(fn('foo')()).to.be.eql(['foo']);
+      expect(fn(['foo'])()).to.be.eql(['foo']);
+    });
+  });
+});