@e22m4u/js-repository 0.0.31

package/src/schema.js

@@ -0,0 +1,41 @@
+import {Service} from '@e22m4u/js-service';
+import {Repository} from './repository/index.js';
+import {DefinitionRegistry} from './definition/index.js';
+import {RepositoryRegistry} from './repository/index.js';
+
+/**
+ * Schema.
+ */
+export class Schema extends Service {
+  /**
+   * Define datasource.
+   *
+   * @param {object} datasourceDef
+   * @returns {this}
+   */
+  defineDatasource(datasourceDef) {
+    this.getService(DefinitionRegistry).addDatasource(datasourceDef);
+    return this;
+  }
+
+  /**
+   * Define model.
+   *
+   * @param {object} modelDef
+   * @returns {this}
+   */
+  defineModel(modelDef) {
+    this.getService(DefinitionRegistry).addModel(modelDef);
+    return this;
+  }
+
+  /**
+   * Get repository.
+   *
+   * @param {string} modelName
+   * @returns {Repository}
+   */
+  getRepository(modelName) {
+    return this.getService(RepositoryRegistry).getRepository(modelName);
+  }
+}

package/src/types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Free-form object with open properties.
+ */
+export declare type AnyObject = {
+  [property: string]: unknown;
+};
+
+/**
+ * Makes specific field as optional.
+ */
+export declare type PartialBy<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>;
+
+/**
+ * Model data.
+ */
+export declare type ModelData = {
+  [property: string]: unknown;
+};
+
+/**
+ * Model id.
+ */
+export declare type ModelId = unknown;
+
+/**
+ * Flatten.
+ */
+type Identity<T> = T;
+export declare type Flatten<T> = Identity<{[k in keyof T]: T[k]}>;

package/src/utils/capitalize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Capitalize.
+ *
+ * @param string
+ */
+export declare function capitalize(string: string): string;

package/src/utils/capitalize.js

@@ -0,0 +1,10 @@
+/**
+ * Capitalize.
+ *
+ * @param {string} string
+ * @returns {string}
+ */
+export function capitalize(string) {
+  if (!string || typeof string !== 'string') return string;
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}

package/src/utils/capitalize.spec.js

@@ -0,0 +1,14 @@
+import {expect} from 'chai';
+import {capitalize} from './capitalize.js';
+
+describe('capitalize', function () {
+  it('makes the first letter to upper case', function () {
+    expect(capitalize('foo')).to.be.eq('Foo');
+    expect(capitalize('foo bar')).to.be.eq('Foo bar');
+    expect(capitalize(10)).to.be.eq(10);
+    expect(capitalize(true)).to.be.eq(true);
+    expect(capitalize(false)).to.be.eq(false);
+    expect(capitalize(undefined)).to.be.eq(undefined);
+    expect(capitalize(null)).to.be.eq(null);
+  });
+});

package/src/utils/clone-deep.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Clone deep.
+ *
+ * @param value
+ */
+export declare function cloneDeep<T>(value: T): T;

package/src/utils/clone-deep.js

@@ -0,0 +1,61 @@
+/**
+ * Clone deep.
+ *
+ * @author https://stackoverflow.com/a/4460624
+ * @param {*} value
+ * @returns {*}
+ */
+export function cloneDeep(value) {
+  if (!value) return value; // null, undefined values check
+
+  const types = [Number, String, Boolean];
+  let result;
+
+  // normalizing primitives if someone did new String('aaa'),
+  // or new Number('444');
+  types.forEach(type => {
+    if (value instanceof type) result = type(value);
+  });
+
+  if (result === undefined) {
+    if (Array.isArray(value)) {
+      result = [];
+      value.forEach((child, index) => {
+        result[index] = cloneDeep(child);
+      });
+    } else if (typeof value === 'object') {
+      // testing that this is DOM
+      if (
+        'nodeType' in value &&
+        value.nodeType &&
+        'cloneNode' in value &&
+        typeof value.cloneNode === 'function'
+      ) {
+        result = value.cloneNode(true);
+        // check that this is a literal
+      } else if (!('prototype' in value) || !value.prototype) {
+        if (value instanceof Date) {
+          result = new Date(value);
+        } else if (value.constructor && value.constructor.name === 'Object') {
+          // it is an object literal
+          result = {};
+          for (const key in value) {
+            result[key] = cloneDeep(value[key]);
+          }
+        } else {
+          // just keep the reference,
+          // or create new object
+          result = value;
+        }
+      } else {
+        // just keep the reference,
+        // or create new object
+        result = value;
+      }
+    } else {
+      result = value;
+    }
+  }
+
+  return result;
+}

package/src/utils/clone-deep.spec.js

@@ -0,0 +1,28 @@
+import {expect} from 'chai';
+import {cloneDeep} from './clone-deep.js';
+
+describe('cloneDeep', function () {
+  it('returns a deep copy of a given object', function () {
+    const value = {
+      stringProp: 'string',
+      numberProp: 10,
+      booleanProp: true,
+      arrayProp: [1, 2, 3],
+      objectProp: {
+        foo: 'string',
+        bar: 'string',
+      },
+      dateProp: new Date(),
+      nullProp: null,
+    };
+    const result = cloneDeep(value);
+    expect(result).to.be.eql(value);
+    expect(result).to.be.not.eq(value);
+    expect(result.arrayProp).to.be.not.eq(value.arrayProp);
+    expect(result.arrayProp).to.be.eql(value.arrayProp);
+    expect(result.objectProp).to.be.not.eq(value.objectProp);
+    expect(result.objectProp).to.be.eql(value.objectProp);
+    expect(result.dateProp).to.be.not.eq(value.dateProp);
+    expect(result.dateProp.getTime()).to.be.eq(value.dateProp.getTime());
+  });
+});

package/src/utils/exclude-object-keys.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Exclude object keys.
+ *
+ * @param obj
+ * @param keys
+ */
+export declare function excludeObjectKeys<T extends object>(
+  obj: T,
+  keys: string | string[],
+): Partial<T>;

package/src/utils/exclude-object-keys.js

@@ -0,0 +1,20 @@
+import {InvalidArgumentError} from '../errors/index.js';
+
+/**
+ * Exclude object keys.
+ *
+ * @param {object} obj
+ * @param {string|string[]} keys
+ * @returns {object}
+ */
+export function excludeObjectKeys(obj, keys) {
+  if (typeof obj !== 'object' || !obj || Array.isArray(obj))
+    throw new InvalidArgumentError(
+      'Cannot exclude keys from a non-Object value, %v given.',
+      obj,
+    );
+  const result = {...obj};
+  keys = Array.isArray(keys) ? keys : [keys];
+  keys.forEach(key => delete result[key]);
+  return result;
+}

package/src/utils/exclude-object-keys.spec.js

@@ -0,0 +1,49 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {excludeObjectKeys} from './exclude-object-keys.js';
+
+describe('excludeObjectKeys', function () {
+  it('returns a given object without a specified key', function () {
+    const input = {
+      foo: 'string',
+      bar: 10,
+      baz: true,
+      qux: [1, 2, 3],
+    };
+    const result = excludeObjectKeys(input, 'bar');
+    expect(result).to.be.not.eq(input);
+    expect(result).to.be.eql({
+      foo: 'string',
+      baz: true,
+      qux: [1, 2, 3],
+    });
+  });
+
+  it('returns a given object without a specified keys', function () {
+    const input = {
+      foo: 'string',
+      bar: 10,
+      baz: true,
+      qux: [1, 2, 3],
+    };
+    const result = excludeObjectKeys(input, ['bar', 'qux']);
+    expect(result).to.be.not.eq(input);
+    expect(result).to.be.eql({
+      foo: 'string',
+      baz: true,
+    });
+  });
+
+  it('throws an error for a non-object values', function () {
+    const throwable = v => () => excludeObjectKeys(v, 'key');
+    const error = v =>
+      format('Cannot exclude keys from a non-Object value, %s given.', v);
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable(null)).to.throw(error('null'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+  });
+});

package/src/utils/get-ctor-name.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get ctor name.
+ *
+ * @param value
+ */
+export declare function getCtorName(value: unknown): string | undefined;

package/src/utils/get-ctor-name.js

@@ -0,0 +1,11 @@
+/**
+ * Get ctor name.
+ *
+ * @param {*} value
+ * @returns {string|undefined}
+ */
+export function getCtorName(value) {
+  if (value === null) return 'Null';
+  if (value === undefined) return 'Undefined';
+  return (value.constructor && value.constructor.name) || undefined;
+}

package/src/utils/get-ctor-name.spec.js

@@ -0,0 +1,17 @@
+import {expect} from 'chai';
+import {getCtorName} from './get-ctor-name.js';
+
+describe('getCtorName', function () {
+  it('returns a constructor name of a given value', function () {
+    expect(getCtorName({})).to.be.eq('Object');
+    expect(getCtorName(new Date())).to.be.eq('Date');
+    expect(getCtorName([])).to.be.eq('Array');
+    expect(getCtorName(() => undefined)).to.be.eq('Function');
+    expect(getCtorName('string')).to.be.eq('String');
+    expect(getCtorName(10)).to.be.eq('Number');
+    expect(getCtorName(true)).to.be.eq('Boolean');
+    expect(getCtorName(false)).to.be.eq('Boolean');
+    expect(getCtorName(null)).to.be.eq('Null');
+    expect(getCtorName(undefined)).to.be.eq('Undefined');
+  });
+});

package/src/utils/get-value-by-path.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get value by path.
+ *
+ * @param obj
+ * @param path
+ * @param orElse
+ */
+export declare function getValueByPath(
+  obj: object,
+  path: string,
+  orElse?: unknown,
+): unknown;

package/src/utils/get-value-by-path.js

@@ -0,0 +1,23 @@
+/**
+ * Get value by path.
+ *
+ * @param {object} obj
+ * @param {string} path
+ * @param {*} orElse
+ * @returns {*}
+ */
+export function getValueByPath(obj, path, orElse = undefined) {
+  if (!obj || typeof obj !== 'object') return orElse;
+  if (!path || typeof path !== 'string') return orElse;
+  const keys = path.split('.');
+  let value = obj;
+  for (const key of keys) {
+    if (typeof value === 'object' && value !== null && key in value) {
+      value = value[key];
+    } else {
+      value = orElse;
+      break;
+    }
+  }
+  return value;
+}

package/src/utils/get-value-by-path.spec.js

@@ -0,0 +1,36 @@
+import {expect} from 'chai';
+import {getValueByPath} from './get-value-by-path.js';
+
+const VAL = 'value';
+
+describe('getValueByPath', function () {
+  it('returns undefined if no value', function () {
+    expect(getValueByPath({}, 'foo')).to.be.undefined;
+    expect(getValueByPath({}, 'foo.bar')).to.be.undefined;
+    expect(getValueByPath({foo: {}}, 'foo.bar.baz')).to.be.undefined;
+  });
+
+  it('returns a value by given path', function () {
+    expect(getValueByPath({foo: VAL}, 'foo')).to.be.eq(VAL);
+    expect(getValueByPath({foo: {bar: VAL}}, 'foo.bar')).to.be.eq(VAL);
+    expect(getValueByPath({foo: {bar: {baz: VAL}}}, 'foo.bar.baz')).to.be.eq(
+      VAL,
+    );
+  });
+
+  it('returns a given fallback if no value', function () {
+    expect(getValueByPath({}, 'foo', VAL)).to.be.eq(VAL);
+    expect(getValueByPath({}, 'foo.bar', VAL)).to.be.eq(VAL);
+    expect(getValueByPath({foo: {}}, 'foo.bar.baz', VAL)).to.be.eq(VAL);
+  });
+
+  it('returns a given fallback for null or undefined object', function () {
+    expect(getValueByPath(null, 'foo', VAL)).to.be.eq(VAL);
+    expect(getValueByPath(undefined, 'foo', VAL)).to.be.eq(VAL);
+  });
+
+  it('returns a given fallback for null or undefined key', function () {
+    expect(getValueByPath({}, null, VAL)).to.be.eq(VAL);
+    expect(getValueByPath({}, undefined, VAL)).to.be.eq(VAL);
+  });
+});

package/src/utils/index.d.ts

@@ -0,0 +1,10 @@
+export * from './is-ctor.js';
+export * from './capitalize.js';
+export * from './clone-deep.js';
+export * from './singularize.js';
+export * from './get-ctor-name.js';
+export * from './is-pure-object.js';
+export * from './string-to-regexp.js';
+export * from './get-value-by-path.js';
+export * from './select-object-keys.js';
+export * from './exclude-object-keys.js';

package/src/utils/index.js

@@ -0,0 +1,10 @@
+export * from './is-ctor.js';
+export * from './capitalize.js';
+export * from './clone-deep.js';
+export * from './singularize.js';
+export * from './get-ctor-name.js';
+export * from './is-pure-object.js';
+export * from './string-to-regexp.js';
+export * from './get-value-by-path.js';
+export * from './select-object-keys.js';
+export * from './exclude-object-keys.js';

package/src/utils/is-ctor.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Is ctor.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export declare function isCtor(value: unknown): boolean;

package/src/utils/is-ctor.js

@@ -0,0 +1,10 @@
+/**
+ * Is ctor.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isCtor(value) {
+  if (!value) return false;
+  return typeof value === 'function' && 'prototype' in value;
+}

package/src/utils/is-ctor.spec.js

@@ -0,0 +1,26 @@
+import {expect} from 'chai';
+import {isCtor} from './is-ctor.js';
+
+describe('isConstructor', function () {
+  it('returns true if a given value is a constructor', function () {
+    expect(isCtor(Date)).to.be.true;
+    expect(isCtor(Number)).to.be.true;
+    expect(isCtor(String)).to.be.true;
+    class MyClass {}
+    expect(isCtor(MyClass)).to.be.true;
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function FunctionCtor() {}
+    expect(isCtor(FunctionCtor)).to.be.true;
+  });
+
+  it('returns false if a given value is not a constructor', function () {
+    expect(isCtor(() => undefined)).to.be.false;
+    expect(isCtor('string')).to.be.false;
+    expect(isCtor(10)).to.be.false;
+    expect(isCtor(true)).to.be.false;
+    expect(isCtor({})).to.be.false;
+    expect(isCtor([])).to.be.false;
+    expect(isCtor(undefined)).to.be.false;
+    expect(isCtor(null)).to.be.false;
+  });
+});

package/src/utils/is-pure-object.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Is pure object.
+ *
+ * @param value
+ */
+export declare function isPureObject(value: unknown): boolean;

package/src/utils/is-pure-object.js

@@ -0,0 +1,15 @@
+/**
+ * Is pure object.
+ *
+ * @param {*} value
+ * @returns {boolean}
+ */
+export function isPureObject(value) {
+  return Boolean(
+    typeof value === 'object' &&
+      value &&
+      !Array.isArray(value) &&
+      (!value.constructor ||
+        (value.constructor && value.constructor.name === 'Object')),
+  );
+}

package/src/utils/is-pure-object.spec.js

@@ -0,0 +1,25 @@
+import {expect} from 'chai';
+import {isPureObject} from './is-pure-object.js';
+
+describe('isPureObject', function () {
+  it('returns ture if a pure object given', function () {
+    expect(isPureObject({})).to.be.true;
+    expect(isPureObject({key: 'val'})).to.be.true;
+    expect(isPureObject(Object.create(null))).to.be.true;
+  });
+
+  it('returns false if a non-pure object given', function () {
+    expect(isPureObject(new Date())).to.be.false;
+    expect(isPureObject([])).to.be.false;
+    expect(isPureObject(() => undefined)).to.be.false;
+  });
+
+  it('returns false if a non-object given', function () {
+    expect(isPureObject('string')).to.be.false;
+    expect(isPureObject(10)).to.be.false;
+    expect(isPureObject(true)).to.be.false;
+    expect(isPureObject(false)).to.be.false;
+    expect(isPureObject(null)).to.be.false;
+    expect(isPureObject(undefined)).to.be.false;
+  });
+});

package/src/utils/select-object-keys.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Select object keys.
+ *
+ * @param obj
+ * @param keys
+ */
+export declare function selectObjectKeys<T extends object>(
+  obj: T,
+  keys: string[],
+): Partial<T>;

package/src/utils/select-object-keys.js

@@ -0,0 +1,37 @@
+import {InvalidArgumentError} from '../errors/index.js';
+
+/**
+ * Select object keys.
+ *
+ * @param {object} obj
+ * @param {string[]} keys
+ * @returns {object}
+ */
+export function selectObjectKeys(obj, keys) {
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+    throw new InvalidArgumentError(
+      'A first argument of selectObjectKeys ' +
+        'should be an Object, but %v given.',
+      obj,
+    );
+  if (!Array.isArray(keys))
+    throw new InvalidArgumentError(
+      'A second argument of selectObjectKeys ' +
+        'should be an Array of String, but %v given.',
+      keys,
+    );
+  keys.forEach(key => {
+    if (typeof key !== 'string')
+      throw new InvalidArgumentError(
+        'A second argument of selectObjectKeys ' +
+          'should be an Array of String, but %v given.',
+        key,
+      );
+  });
+  const result = {};
+  const allKeys = Object.keys(obj);
+  allKeys.forEach(key => {
+    if (keys.includes(key)) result[key] = obj[key];
+  });
+  return result;
+}

package/src/utils/select-object-keys.spec.js

@@ -0,0 +1,40 @@
+import {expect} from 'chai';
+import {selectObjectKeys} from './select-object-keys.js';
+
+describe('selectObjectKeys', function () {
+  it('returns a new object with selected fields', function () {
+    const input = {foo: 'foo', bar: 'bar', baz: 'baz'};
+    const result = selectObjectKeys(input, ['bar', 'baz']);
+    expect(result).to.be.eql({bar: 'bar', baz: 'baz'});
+  });
+
+  it('does not throw an error if a selected property is not found', function () {
+    const input = {foo: 'foo', bar: 'bar', baz: 'baz'};
+    const result = selectObjectKeys(input, ['bar', 'qux']);
+    expect(result).to.be.eql({bar: 'bar'});
+  });
+
+  it('throws an error if a given value is not an Object', function () {
+    const throwable = () => selectObjectKeys(10, ['key']);
+    expect(throwable).to.throw(
+      'A first argument of selectObjectKeys ' +
+        'should be an Object, but 10 given.',
+    );
+  });
+
+  it('throws an error if a given keys is not an Array', function () {
+    const throwable = () => selectObjectKeys({});
+    expect(throwable).to.throw(
+      'A second argument of selectObjectKeys ' +
+        'should be an Array of String, but undefined given.',
+    );
+  });
+
+  it('throws an error if a given keys is not an String', function () {
+    const throwable = () => selectObjectKeys({}, [10]);
+    expect(throwable).to.throw(
+      'A second argument of selectObjectKeys ' +
+        'should be an Array of String, but 10 given.',
+    );
+  });
+});

package/src/utils/singularize.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Singularize.
+ *
+ * @param noun
+ */
+export declare function singularize(noun: string): string;

package/src/utils/singularize.js

@@ -0,0 +1,22 @@
+/**
+ * Singularize.
+ *
+ * @param {string} noun
+ * @returns {string}
+ */
+export function singularize(noun) {
+  if (!noun || typeof noun !== 'string') return noun;
+  const endings = {
+    ves: 'fe',
+    ies: 'y',
+    i: 'us',
+    zes: 'ze',
+    ses: 's',
+    es: 'e',
+    s: '',
+  };
+  return noun.replace(
+    new RegExp(`(${Object.keys(endings).join('|')})$`),
+    r => endings[r],
+  );
+}

package/src/utils/singularize.spec.js

@@ -0,0 +1,23 @@
+import {expect} from 'chai';
+import {singularize} from './singularize.js';
+
+describe('singularize', function () {
+  it('returns a singular noun', function () {
+    expect(singularize('papers')).to.be.eq('paper');
+    expect(singularize('strategies')).to.be.eq('strategy');
+    expect(singularize('lives')).to.be.eq('life');
+    expect(singularize('games')).to.be.eq('game');
+    expect(singularize('cacti')).to.be.eq('cactus');
+    expect(singularize('dozes')).to.be.eq('doze');
+  });
+
+  it('returns non-string values as is', function () {
+    expect(singularize(10)).to.be.eq(10);
+    expect(singularize([])).to.be.eql([]);
+    expect(singularize({})).to.be.eql({});
+    expect(singularize(true)).to.be.eq(true);
+    expect(singularize(false)).to.be.eq(false);
+    expect(singularize(undefined)).to.be.eq(undefined);
+    expect(singularize(null)).to.be.eq(null);
+  });
+});