@e22m4u/js-repository-mongodb-adapter 0.0.14

package/src/utils/create-mongodb-url.js

@@ -0,0 +1,87 @@
+import {InvalidArgumentError} from '@e22m4u/js-repository';
+
+/**
+ * Generate the mongodb URL from the options.
+ */
+export function createMongodbUrl(options = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options))
+    throw new InvalidArgumentError(
+      'The first argument of "createMongodbUrl" must be an Object, but %v given.',
+      options,
+    );
+  if (options.protocol && typeof options.protocol !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "protocol" must be a string, but %v given.',
+      options.protocol,
+    );
+  if (options.hostname && typeof options.hostname !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "hostname" must be a String, but %v given.',
+      options.hostname,
+    );
+  if (options.host && typeof options.host !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "host" must be a String, but %v given.',
+      options.host,
+    );
+  if (
+    options.port &&
+    typeof options.port !== 'number' &&
+    typeof options.port !== 'string'
+  ) {
+    throw new InvalidArgumentError(
+      'MongoDB option "port" must be a Number or a String, but %v given.',
+      options.port,
+    );
+  }
+  if (options.database && typeof options.database !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "database" must be a String, but %v given.',
+      options.database,
+    );
+  if (options.db && typeof options.db !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "db" must be a String, but %v given.',
+      options.db,
+    );
+  if (options.username && typeof options.username !== 'string')
+    throw new InvalidArgumentError(
+      'MongoDB option "username" must be a String, but %v given.',
+      options.username,
+    );
+  if (
+    options.password &&
+    typeof options.password !== 'string' &&
+    typeof options.password !== 'number'
+  ) {
+    throw new InvalidArgumentError(
+      'MongoDB option "password" must be a String or a Number, but %v given.',
+      options.password,
+    );
+  }
+  if (
+    options.pass &&
+    typeof options.pass !== 'string' &&
+    typeof options.pass !== 'number'
+  ) {
+    throw new InvalidArgumentError(
+      'MongoDB option "pass" must be a String or a Number, but %v given.',
+      options.pass,
+    );
+  }
+  const protocol = options.protocol || 'mongodb';
+  const hostname = options.hostname || options.host || '127.0.0.1';
+  const port = options.port || 27017;
+  const database = options.database || options.db || 'database';
+  const username = options.username || options.user;
+  const password = options.password || options.pass || undefined;
+  let portUrl = '';
+  if (protocol !== 'mongodb+srv') {
+    portUrl = ':' + port;
+  }
+  if (username && password) {
+    return `${protocol}://${username}:${password}@${hostname}${portUrl}/${database}`;
+  } else {
+    return `${protocol}://${hostname}${portUrl}/${database}`;
+  }
+}

package/src/utils/create-mongodb-url.spec.js

@@ -0,0 +1,29 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {createMongodbUrl} from './create-mongodb-url.js';
+
+describe('createMongodbUrl', function () {
+  it('returns a string representation of default values', function () {
+    const value = createMongodbUrl();
+    expect(value).to.be.eq('mongodb://127.0.0.1:27017/database');
+  });
+
+  it('throws an error when the first argument is a non-object value', function () {
+    const throwable = v => () => createMongodbUrl(v);
+    const error = v =>
+      format(
+        'The first argument of "createMongodbUrl" must be an Object, but %s given.',
+        v,
+      );
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable('str')).to.throw(error('"str"'));
+    expect(throwable(0)).to.throw(error('0'));
+    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'));
+    throwable(undefined)();
+    throwable({})();
+  });
+});

package/src/utils/index.js

@@ -0,0 +1,3 @@
+export * from './is-object-id.js';
+export * from './create-mongodb-url.js';
+export * from './transform-values-deep.js';

package/src/utils/is-iso-date.js

@@ -0,0 +1,13 @@
+/**
+ * Is iso date string.
+ *
+ * @param value
+ * @return {boolean}
+ */
+export function isIsoDate(value) {
+  if (!value) return false;
+  if (value instanceof Date) return true;
+  if (!/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z/.test(value)) return false;
+  const d = new Date(value);
+  return d instanceof Date && !isNaN(d.getTime()) && d.toISOString() === value;
+}

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

@@ -0,0 +1,14 @@
+import {ObjectId} from 'mongodb';
+
+/**
+ * Is object id.
+ *
+ * @param value
+ * @return {boolean}
+ */
+export function isObjectId(value) {
+  if (!value) return false;
+  if (value instanceof ObjectId) return true;
+  if (typeof value !== 'string') return false;
+  return value.match(/^[a-fA-F0-9]{24}$/) != null;
+}

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

@@ -0,0 +1,24 @@
+import {expect} from 'chai';
+import {isObjectId} from './is-object-id.js';
+import {ObjectId} from 'mongodb';
+
+describe('isObjectId', function () {
+  it('returns true for a valid ObjectId string or an instance', function () {
+    expect(isObjectId('')).to.be.false;
+    expect(isObjectId('123')).to.be.false;
+    expect(isObjectId(0)).to.be.false;
+    expect(isObjectId(10)).to.be.false;
+    expect(isObjectId(true)).to.be.false;
+    expect(isObjectId(false)).to.be.false;
+    expect(isObjectId({})).to.be.false;
+    expect(isObjectId({foo: 'bar'})).to.be.false;
+    expect(isObjectId([])).to.be.false;
+    expect(isObjectId(['foo'])).to.be.false;
+    expect(isObjectId(new Date())).to.be.false;
+    expect(isObjectId(null)).to.be.false;
+    expect(isObjectId(undefined)).to.be.false;
+    //
+    expect(isObjectId(new ObjectId())).to.be.true;
+    expect(isObjectId(String(new ObjectId()))).to.be.true;
+  });
+});

package/src/utils/transform-values-deep.js

@@ -0,0 +1,38 @@
+import {InvalidArgumentError} from '@e22m4u/js-repository';
+
+/**
+ * Transform values deep.
+ *
+ * @param value
+ * @param transformer
+ * @return {*}
+ */
+export function transformValuesDeep(value, transformer) {
+  if (!transformer || typeof transformer !== 'function')
+    throw new InvalidArgumentError(
+      'The second argument of "transformValuesDeep" ' +
+        'must be a Function, but %s given.',
+      transformer,
+    );
+  if (Array.isArray(value)) {
+    value.forEach((v, i) => (value[i] = transformValuesDeep(v, transformer)));
+    return value;
+  } else if (value && typeof value === 'object') {
+    // pure object
+    if (
+      !value.constructor ||
+      (value.constructor && value.constructor.name === 'Object')
+    ) {
+      Object.keys(value).forEach(key => {
+        if (Object.prototype.hasOwnProperty.call(value, key))
+          value[key] = transformValuesDeep(value[key], transformer);
+      });
+      return value;
+      // Date, ObjectId etc..
+    } else {
+      return transformer(value);
+    }
+  } else {
+    return transformer(value);
+  }
+}

package/src/utils/transform-values-deep.spec.js

@@ -0,0 +1,47 @@
+import {expect} from 'chai';
+import {transformValuesDeep} from './transform-values-deep.js';
+
+describe('transformValuesDeep', function () {
+  it('transforms property values of an object', function () {
+    const object = {
+      foo: 1,
+      bar: {
+        baz: 2,
+        qux: {
+          qwe: 3,
+        },
+      },
+    };
+    const result = transformValuesDeep(object, String);
+    expect(result).to.be.eql({
+      foo: '1',
+      bar: {
+        baz: '2',
+        qux: {
+          qwe: '3',
+        },
+      },
+    });
+  });
+
+  it('transforms elements of an array', function () {
+    const object = [1, 2, 3, [4, 5, 6, [7, 8, 9]]];
+    const result = transformValuesDeep(object, String);
+    expect(result).to.be.eql(['1', '2', '3', ['4', '5', '6', ['7', '8', '9']]]);
+  });
+
+  it('transforms non-pure objects', function () {
+    const date = new Date();
+    const str = String(date);
+    const result1 = transformValuesDeep(date, String);
+    const result2 = transformValuesDeep([date], String);
+    const result3 = transformValuesDeep([[date]], String);
+    const result4 = transformValuesDeep({date}, String);
+    const result5 = transformValuesDeep({foo: {date}}, String);
+    expect(result1).to.be.eql(str);
+    expect(result2).to.be.eql([str]);
+    expect(result3).to.be.eql([[str]]);
+    expect(result4).to.be.eql({date: str});
+    expect(result5).to.be.eql({foo: {date: str}});
+  });
+});

package/test.env

@@ -0,0 +1,4 @@
+MONGODB_CONTAINER=mongodb_c
+MONGODB_HOST=localhost
+MONGODB_PORT=27017
+MONGODB_DATABASE=test