@e22m4u/js-repository-mongodb-adapter 0.0.15 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e22m4u/js-repository-mongodb-adapter",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "MongoDB адаптер для @e22m4u/js-repository",
   "type": "module",
   "main": "src/index.js",

package/src/mongodb-adapter.js

@@ -1,6 +1,8 @@
 /* eslint no-unused-vars: 0 */
 import {ObjectId} from 'mongodb';
 import {MongoClient} from 'mongodb';
+import {EventEmitter} from 'events';
+import {waitAsync} from './utils/index.js';
 import {isObjectId} from './utils/index.js';
 import {Adapter} from '@e22m4u/js-repository';
 import {DataType} from '@e22m4u/js-repository';
@@ -68,6 +70,41 @@ const MONGODB_OPTION_NAMES = [
   'zlibCompressionLevel',
 ];
 
+/**
+ * Mongo client events.
+ * 5.8.1
+ *
+ * @type {string[]}
+ */
+const MONGO_CLIENT_EVENTS = [
+  'connectionPoolCreated',
+  'connectionPoolReady',
+  'connectionPoolCleared',
+  'connectionPoolClosed',
+  'connectionCreated',
+  'connectionReady',
+  'connectionClosed',
+  'connectionCheckOutStarted',
+  'connectionCheckOutFailed',
+  'connectionCheckedOut',
+  'connectionCheckedIn',
+  'commandStarted',
+  'commandSucceeded',
+  'commandFailed',
+  'serverOpening',
+  'serverClosed',
+  'serverDescriptionChanged',
+  'topologyOpening',
+  'topologyClosed',
+  'topologyDescriptionChanged',
+  'error',
+  'timeout',
+  'close',
+  'serverHeartbeatStarted',
+  'serverHeartbeatSucceeded',
+  'serverHeartbeatFailed',
+];
+
 /**
  * Default settings.
  *
@@ -132,6 +169,29 @@ export class MongodbAdapter extends Adapter {
     return this._connecting;
   }
 
+  /**
+   * Event emitter.
+   *
+   * @private
+   */
+  _emitter;
+
+  /**
+   * Event emitter.
+   *
+   * @returns {EventEmitter}
+   */
+  get emitter() {
+    if (this._emitter) return this._emitter;
+    this._emitter = new EventEmitter();
+    const emit = this._emitter.emit;
+    this._emitter.emit = function (name, ...args) {
+      emit.call(this, '*', name, ...args);
+      return emit.call(this, name, ...args);
+    };
+    return this._emitter;
+  }
+
   /**
    * Constructor.
    *
@@ -140,11 +200,11 @@ export class MongodbAdapter extends Adapter {
    */
   constructor(container, settings) {
     settings = Object.assign({}, DEFAULT_SETTINGS, settings || {});
-    super(container, settings);
     settings.protocol = settings.protocol || 'mongodb';
     settings.hostname = settings.hostname || settings.host || '127.0.0.1';
     settings.port = settings.port || 27017;
-    settings.database = settings.database || settings.db || 'test';
+    settings.database = settings.database || settings.db || 'database';
+    super(container, settings);
   }
 
   /**
@@ -155,8 +215,7 @@ export class MongodbAdapter extends Adapter {
    */
   async connect() {
     if (this._connecting) {
-      const tryAgainAfter = 500;
-      await new Promise(r => setTimeout(() => r(), tryAgainAfter));
+      await waitAsync(500);
       return this.connect();
     }
 
@@ -167,53 +226,69 @@ export class MongodbAdapter extends Adapter {
     const url = createMongodbUrl(this.settings);
 
     // console.log(`Connecting to ${url}`);
+    if (this._client) {
+      this._client.removeAllListeners();
+      this._client.close(true);
+    }
     this._client = new MongoClient(url, options);
+    for (const event of MONGO_CLIENT_EVENTS) {
+      const listener = (...args) => this.emitter.emit(event, ...args);
+      this._client.on(event, listener);
+    }
 
     const {reconnectInterval} = this.settings;
     const connectFn = async () => {
+      if (this._connecting === false) return;
+      this.emitter.emit('connecting');
       try {
         await this._client.connect();
       } catch (e) {
+        this.emitter.emit('error', e);
         console.error(e);
         // console.log('MongoDB connection failed!');
         // console.log(`Reconnecting after ${reconnectInterval} ms.`);
-        await new Promise(r => setTimeout(() => r(), reconnectInterval));
+        await waitAsync(reconnectInterval);
         return connectFn();
       }
       // console.log('MongoDB is connected.');
       this._connected = true;
       this._connecting = false;
+      reconnectOnClose();
+      this.emitter.emit('connected');
     };
 
-    await connectFn();
+    const reconnectOnClose = () =>
+      this._client.once('serverClosed', event => {
+        this.emitter.emit('disconnected', event);
+        if (this._connected) {
+          this._connected = false;
+          this._connecting = true;
+          // console.log('MongoDB lost connection!');
+          // console.log(event);
+          // console.log(`Reconnecting after ${reconnectInterval} ms.`);
+          setTimeout(() => connectFn(), reconnectInterval);
+        } else {
+          // console.log('MongoDB connection closed.');
+        }
+      });
 
-    this._client.once('serverClosed', event => {
-      if (this._connected) {
-        this._connected = false;
-        // console.log('MongoDB lost connection!');
-        console.log(event);
-        // console.log(`Reconnecting after ${reconnectInterval} ms.`);
-        setTimeout(() => connectFn(), reconnectInterval);
-      } else {
-        // console.log('MongoDB connection closed.');
-      }
-    });
+    return connectFn();
   }
 
   /**
    * Disconnect.
    *
-   * @return {Promise<*|undefined>}
+   * @return {Promise<undefined>}
    */
   async disconnect() {
-    if (this._connecting) {
-      const tryAgainAfter = 500;
-      await new Promise(r => setTimeout(() => r(), tryAgainAfter));
-      return this.disconnect();
-    }
-    if (!this._connected) return;
     this._connected = false;
-    if (this._client) await this._client.close();
+    this._connecting = false;
+    if (this._client) {
+      const client = this._client;
+      this._client = undefined;
+      await client.close();
+      client.removeAllListeners();
+    }
   }
 
   /**

package/src/mongodb-adapter.spec.js

@@ -1,3 +1,5 @@
+import net from 'net';
+import chai from 'chai';
 import {expect} from 'chai';
 import {ObjectId} from 'mongodb';
 import {MongoClient} from 'mongodb';
@@ -9,6 +11,7 @@ import {createMongodbUrl} from './utils/index.js';
 import {MongodbAdapter} from './mongodb-adapter.js';
 import {AdapterRegistry} from '@e22m4u/js-repository';
 import {DEFAULT_PRIMARY_KEY_PROPERTY_NAME as DEF_PK} from '@e22m4u/js-repository';
+const sandbox = chai.spy.sandbox();
 
 const CONFIG = {
   host: process.env.MONGODB_HOST || 'localhost',
@@ -32,6 +35,7 @@ describe('MongodbAdapter', function () {
   this.timeout(15000);
 
   afterEach(async function () {
+    sandbox.restore();
     await MDB_CLIENT.db(CONFIG.database).dropDatabase();
   });
 
@@ -42,12 +46,149 @@ describe('MongodbAdapter', function () {
     await MDB_CLIENT.close(true);
   });
 
-  it('able to connect and disconnect', async function () {
+  it('updates "connected" and "connecting" properties', async function () {
     const S = new Service();
+    const events = [];
     const adapter = new MongodbAdapter(S.container, CONFIG);
-    await adapter.connect();
+    adapter.emitter.addListener('*', name => events.push(name));
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.be.empty;
+    const promise = adapter.connect();
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.true;
+    expect(events).to.include('serverOpening');
+    expect(events).to.not.include('connectionPoolReady');
+    expect(events).to.not.include('serverClosed');
+    await promise;
     expect(adapter.connected).to.be.true;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.include('connectionPoolReady');
+    expect(events).to.not.include('serverClosed');
     await adapter.disconnect();
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.include('serverClosed');
+  });
+
+  it('emits "connecting", "connected" and "disconnected" events', async function () {
+    const S = new Service();
+    const events = [];
+    const adapter = new MongodbAdapter(S.container, CONFIG);
+    adapter.emitter.addListener('*', name => events.push(name));
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.be.empty;
+    const promise = adapter.connect();
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.true;
+    expect(events).to.include('connecting');
+    expect(events).to.not.include('connected');
+    expect(events).to.not.include('disconnected');
+    await promise;
+    expect(adapter.connected).to.be.true;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.include('connected');
+    expect(events).to.not.include('disconnected');
+    await adapter.disconnect();
+    expect(adapter.connected).to.be.false;
+    expect(adapter.connecting).to.be.false;
+    expect(events).to.include('disconnected');
+  });
+
+  it('reconnects on server selection error', function (done) {
+    const S = new Service();
+    const server = net.createServer();
+    let startupCounter = 0;
+    server.listen(0, 'localhost', 2, () => {
+      startupCounter++;
+      expect(startupCounter).to.be.eq(1);
+      const {address, port} = server.address();
+      const attemptsLimit = 3;
+      const serverSelectionTimeoutMS = 50;
+      const adapter = new MongodbAdapter(S.container, {
+        port,
+        host: address,
+        reconnectInterval: 0,
+        serverSelectionTimeoutMS,
+      });
+      let attempts = 0;
+      const startTime = new Date();
+      adapter.emitter.addListener('connecting', () => {
+        ++attempts;
+        if (attempts !== attemptsLimit) return;
+        const duration = new Date() - startTime;
+        const accuracy = 10;
+        server.close();
+        adapter.disconnect();
+        expect(adapter.connect).to.have.been.called.once;
+        const attemptMs = duration / (attemptsLimit - 1);
+        expect(attemptMs).to.be.gte(serverSelectionTimeoutMS - accuracy);
+        expect(attemptMs).to.be.lte(serverSelectionTimeoutMS + accuracy);
+        done();
+      });
+      adapter.emitter.addListener('error', error => {
+        expect(error.message).to.be.eq(
+          'Server selection timed out after 50 ms',
+        );
+      });
+      sandbox.on(adapter, 'connect');
+      adapter.connect();
+    });
+  });
+
+  it('reconnects on implicit disconnect', function (done) {
+    const S = new Service();
+    const reconnectsLimit = 2;
+    const reconnectInterval = 50;
+    const adapter = new MongodbAdapter(S.container, {
+      ...CONFIG,
+      reconnectInterval,
+    });
+    let startTime;
+    let connects = 0;
+    let reconnects = 0;
+    adapter.emitter.on('connected', () => {
+      ++connects;
+      if (connects === 1) {
+        adapter._client.close();
+        return;
+      }
+      ++reconnects;
+      if (startTime == null) startTime = new Date();
+      if (reconnects < reconnectsLimit) {
+        adapter._client.close();
+        return;
+      }
+      const duration = new Date() - startTime;
+      const accuracy = 10;
+      adapter.disconnect();
+      expect(adapter.connect).to.have.been.called.once;
+      const attemptMs = duration / (reconnectsLimit - 1);
+      expect(attemptMs).to.be.gt(reconnectInterval - accuracy);
+      expect(attemptMs).to.be.lt(reconnectInterval + accuracy);
+      expect(connects).to.be.eq(reconnectsLimit + 1);
+      done();
+    });
+    sandbox.on(adapter, 'connect');
+    adapter.connect();
+  });
+
+  it('does not reconnect on explicit disconnect', function (done) {
+    const S = new Service();
+    const reconnectInterval = 0;
+    const adapter = new MongodbAdapter(S.container, {
+      ...CONFIG,
+      reconnectInterval,
+    });
+    adapter.emitter.once('connected', () => {
+      adapter.emitter.once('connecting', () => {
+        throw new Error('Unexpected reconnection');
+      });
+      adapter.emitter.once('disconnected', () => setTimeout(() => done(), 50));
+      adapter.disconnect();
+    });
+    adapter.connect();
   });
 
   describe('create', function () {

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

@@ -11,7 +11,7 @@ export function createMongodbUrl(options = {}) {
     );
   if (options.protocol && typeof options.protocol !== 'string')
     throw new InvalidArgumentError(
-      'MongoDB option "protocol" must be a string, but %v given.',
+      'MongoDB option "protocol" must be a String, but %v given.',
       options.protocol,
     );
   if (options.hostname && typeof options.hostname !== 'string')

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

@@ -8,11 +8,12 @@ describe('createMongodbUrl', function () {
     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 () {
+  it('requires the first argument to be an object', function () {
     const throwable = v => () => createMongodbUrl(v);
     const error = v =>
       format(
-        'The first argument of "createMongodbUrl" must be an Object, but %s given.',
+        'The first argument of "createMongodbUrl" must be ' +
+          'an Object, but %s given.',
         v,
       );
     expect(throwable('')).to.throw(error('""'));
@@ -26,4 +27,257 @@ describe('createMongodbUrl', function () {
     throwable(undefined)();
     throwable({})();
   });
+
+  it('requires the "protocol" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({protocol: v});
+    const error = v =>
+      format(
+        'MongoDB option "protocol" must be ' + 'a String, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('mongodb')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "hostname" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({hostname: v});
+    const error = v =>
+      format(
+        'MongoDB option "hostname" must be ' + 'a String, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('127.0.0.1')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "host" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({host: v});
+    const error = v =>
+      format('MongoDB option "host" must be ' + 'a String, but %s given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('127.0.0.1')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "port" option to be a number or a string', function () {
+    const throwable = v => () => createMongodbUrl({port: v});
+    const error = v =>
+      format(
+        'MongoDB option "port" must be a Number ' +
+          'or a String, but %s given.',
+        v,
+      );
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('127.0.0.1')();
+    throwable('')();
+    throwable(10)();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "database" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({database: v});
+    const error = v =>
+      format(
+        'MongoDB option "database" must be ' + 'a String, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('database')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "db" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({db: v});
+    const error = v =>
+      format('MongoDB option "db" must be ' + 'a String, but %s given.', v);
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('database')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "username" option to be a string', function () {
+    const throwable = v => () => createMongodbUrl({username: v});
+    const error = v =>
+      format(
+        'MongoDB option "username" must be ' + 'a String, but %s given.',
+        v,
+      );
+    expect(throwable(10)).to.throw(error('10'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('username')();
+    throwable('')();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "password" option to be a string or a number', function () {
+    const throwable = v => () => createMongodbUrl({password: v});
+    const error = v =>
+      format(
+        'MongoDB option "password" must be a String ' +
+          'or a Number, but %s given.',
+        v,
+      );
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('password')();
+    throwable('')();
+    throwable(10)();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('requires the "pass" option to be a string or a number', function () {
+    const throwable = v => () => createMongodbUrl({pass: v});
+    const error = v =>
+      format(
+        'MongoDB option "pass" must be a String ' +
+          'or a Number, but %s given.',
+        v,
+      );
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    throwable('pass')();
+    throwable('')();
+    throwable(10)();
+    throwable(0)();
+    throwable(false)();
+    throwable(undefined)();
+    throwable(null)();
+  });
+
+  it('sets the given "protocol" option', function () {
+    const res = createMongodbUrl({protocol: 'value'});
+    expect(res).to.be.eq('value://127.0.0.1:27017/database');
+  });
+
+  it('sets the given "hostname" option', function () {
+    const res = createMongodbUrl({hostname: 'value'});
+    expect(res).to.be.eq('mongodb://value:27017/database');
+  });
+
+  it('sets the given "host" option', function () {
+    const res = createMongodbUrl({host: 'value'});
+    expect(res).to.be.eq('mongodb://value:27017/database');
+  });
+
+  it('sets the given "port" option as a number', function () {
+    const res = createMongodbUrl({port: 8080});
+    expect(res).to.be.eq('mongodb://127.0.0.1:8080/database');
+  });
+
+  it('sets the given "port" option as a string', function () {
+    const res = createMongodbUrl({port: '8080'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:8080/database');
+  });
+
+  it('sets the given "database" option', function () {
+    const res = createMongodbUrl({database: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/value');
+  });
+
+  it('sets the given "db" option', function () {
+    const res = createMongodbUrl({db: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/value');
+  });
+
+  it('does not use the provided "username" option without a password', function () {
+    const res = createMongodbUrl({username: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/database');
+  });
+
+  it('does not use the provided "user" option without a password', function () {
+    const res = createMongodbUrl({username: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/database');
+  });
+
+  it('does not use the provided "password" option without a username', function () {
+    const res = createMongodbUrl({password: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/database');
+  });
+
+  it('does not use the provided "pass" option without a username', function () {
+    const res = createMongodbUrl({pass: 'value'});
+    expect(res).to.be.eq('mongodb://127.0.0.1:27017/database');
+  });
+
+  it('sets the given "username" and "password" option', function () {
+    const res = createMongodbUrl({username: 'usr', password: 'pwd'});
+    expect(res).to.be.eq('mongodb://usr:pwd@127.0.0.1:27017/database');
+  });
+
+  it('sets the given "username" and "pass" option', function () {
+    const res = createMongodbUrl({username: 'usr', pass: 'pwd'});
+    expect(res).to.be.eq('mongodb://usr:pwd@127.0.0.1:27017/database');
+  });
+
+  it('sets the given "user" and "password" option', function () {
+    const res = createMongodbUrl({user: 'usr', password: 'pwd'});
+    expect(res).to.be.eq('mongodb://usr:pwd@127.0.0.1:27017/database');
+  });
+
+  it('sets the given "user" and "pass" option', function () {
+    const res = createMongodbUrl({user: 'usr', pass: 'pwd'});
+    expect(res).to.be.eq('mongodb://usr:pwd@127.0.0.1:27017/database');
+  });
+
+  it('does not use the default "port" option for "mongodb+srv" protocol', function () {
+    const res = createMongodbUrl({protocol: 'mongodb+srv'});
+    expect(res).to.be.eq('mongodb+srv://127.0.0.1/database');
+  });
+
+  it('does not use the provided "port" option for "mongodb+srv" protocol', function () {
+    const res = createMongodbUrl({protocol: 'mongodb+srv', port: 8080});
+    expect(res).to.be.eq('mongodb+srv://127.0.0.1/database');
+  });
 });

package/src/utils/index.js

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

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

@@ -0,0 +1,31 @@
+import {expect} from 'chai';
+import {isIsoDate} from './is-iso-date.js';
+
+describe('isIsoDate', function () {
+  it('returns false for an empty value', function () {
+    expect(isIsoDate('')).to.be.false;
+    expect(isIsoDate(0)).to.be.false;
+    expect(isIsoDate(false)).to.be.false;
+    expect(isIsoDate(undefined)).to.be.false;
+    expect(isIsoDate(null)).to.be.false;
+  });
+
+  it('returns false for invalid values', function () {
+    expect(isIsoDate(10)).to.be.false;
+    expect(isIsoDate([])).to.be.false;
+    expect(isIsoDate({})).to.be.false;
+    expect(isIsoDate(new Map())).to.be.false;
+    expect(isIsoDate(NaN)).to.be.false;
+    expect(isIsoDate(Infinity)).to.be.false;
+  });
+
+  it('returns true for the Date instance', function () {
+    expect(isIsoDate(new Date())).to.be.true;
+  });
+
+  it('validates ISO string', function () {
+    expect(isIsoDate('2011-10-05T14:48:00.000Z')).to.be.true;
+    expect(isIsoDate('2018-11-10T11:22:33+00:00')).to.be.false;
+    expect(isIsoDate('2011-10-05T14:99:00.000Z')).to.be.false;
+  });
+});

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

@@ -1,9 +1,14 @@
 import {expect} from 'chai';
-import {isObjectId} from './is-object-id.js';
 import {ObjectId} from 'mongodb';
+import {isObjectId} from './is-object-id.js';
 
 describe('isObjectId', function () {
   it('returns true for a valid ObjectId string or an instance', function () {
+    expect(isObjectId(new ObjectId())).to.be.true;
+    expect(isObjectId(String(new ObjectId()))).to.be.true;
+  });
+
+  it('returns false for invalid values', function () {
     expect(isObjectId('')).to.be.false;
     expect(isObjectId('123')).to.be.false;
     expect(isObjectId(0)).to.be.false;
@@ -17,8 +22,5 @@ describe('isObjectId', function () {
     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

@@ -11,7 +11,7 @@ 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.',
+        'must be a Function, but %v given.',
       transformer,
     );
   if (Array.isArray(value)) {

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

@@ -1,8 +1,9 @@
 import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
 import {transformValuesDeep} from './transform-values-deep.js';
 
 describe('transformValuesDeep', function () {
-  it('transforms property values of an object', function () {
+  it('transforms property values of the given object', function () {
     const object = {
       foo: 1,
       bar: {
@@ -24,13 +25,13 @@ describe('transformValuesDeep', function () {
     });
   });
 
-  it('transforms elements of an array', function () {
+  it('transforms elements of the given 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 () {
+  it('transforms the Date instance', function () {
     const date = new Date();
     const str = String(date);
     const result1 = transformValuesDeep(date, String);
@@ -44,4 +45,26 @@ describe('transformValuesDeep', function () {
     expect(result4).to.be.eql({date: str});
     expect(result5).to.be.eql({foo: {date: str}});
   });
+
+  it('requires the second argument to be a function', function () {
+    const throwable = v => () => transformValuesDeep('val', v);
+    const error = v =>
+      format(
+        'The second argument of "transformValuesDeep" ' +
+          'must be a Function, but %s given.',
+        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('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable(() => undefined)();
+    throwable(function () {})();
+  });
 });

package/src/utils/wait-async.js

@@ -0,0 +1,21 @@
+import {InvalidArgumentError} from '@e22m4u/js-repository';
+
+/**
+ * Wait.
+ *
+ * @example
+ * ```ts
+ * await waitAsync(1000); // 1sec
+ * ```
+ *
+ * @param {number} ms Milliseconds
+ * @returns {Promise<undefined>}
+ */
+export function waitAsync(ms) {
+  if (typeof ms !== 'number')
+    throw new InvalidArgumentError(
+      'The first argument of "waitAsync" must be a Number, but %v given.',
+      ms,
+    );
+  return new Promise(r => setTimeout(() => r(), ms));
+}

package/src/utils/wait-async.spec.js

@@ -0,0 +1,37 @@
+import {expect} from 'chai';
+import {format} from '@e22m4u/js-format';
+import {waitAsync} from './wait-async.js';
+
+describe('wait', function () {
+  it('requires the first argument as a number', function () {
+    const throwable = v => () => waitAsync(v);
+    const error = v =>
+      format(
+        'The first argument of "waitAsync" must be a Number, but %s given.',
+        v,
+      );
+    expect(throwable('string')).to.throw(error('"string"'));
+    expect(throwable('')).to.throw(error('""'));
+    expect(throwable(true)).to.throw(error('true'));
+    expect(throwable(false)).to.throw(error('false'));
+    expect(throwable([])).to.throw(error('Array'));
+    expect(throwable({})).to.throw(error('Object'));
+    expect(throwable(undefined)).to.throw(error('undefined'));
+    expect(throwable(null)).to.throw(error('null'));
+    throwable(10)();
+    throwable(0)();
+  });
+
+  it('returns a promise that resolves after given milliseconds', async function () {
+    const startTime = new Date();
+    const delayMs = 15;
+    const accuracyMs = 5;
+    const promise = waitAsync(delayMs);
+    expect(promise).to.be.instanceof(Promise);
+    await promise;
+    const endTime = new Date();
+    const duration = endTime - startTime;
+    expect(duration).to.be.gte(delayMs - accuracyMs);
+    expect(duration).to.be.lte(delayMs + accuracyMs);
+  });
+});