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

package/package.json

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

package/src/mongodb-adapter.js

@@ -1,10 +1,10 @@
 /* eslint no-unused-vars: 0 */
 import {ObjectId} from 'mongodb';
 import {MongoClient} from 'mongodb';
+import {isIsoDate} from './utils/index.js';
 import {isObjectId} from './utils/index.js';
 import {Adapter} from '@e22m4u/js-repository';
 import {DataType} from '@e22m4u/js-repository';
-import {isIsoDate} from './utils/is-iso-date.js';
 import {capitalize} from '@e22m4u/js-repository';
 import {createMongodbUrl} from './utils/index.js';
 import {ServiceContainer} from '@e22m4u/js-service';
@@ -71,12 +71,11 @@ const MONGODB_OPTION_NAMES = [
 /**
  * Default settings.
  *
- * @type {{connectTimeoutMS: number}}
+ * @type {object}
  */
 const DEFAULT_SETTINGS = {
-  reconnectInterval: 2000, // adapter specific option
-  connectTimeoutMS: 2000,
-  serverSelectionTimeoutMS: 2000,
+  //  connectTimeoutMS: 2500,
+  //  serverSelectionTimeoutMS: 2500,
 };
 
 /**
@@ -86,51 +85,27 @@ export class MongodbAdapter extends Adapter {
   /**
    * Mongodb instance.
    *
+   * @type {MongoClient}
    * @private
    */
   _client;
 
   /**
-   * Collections.
-   *
-   * @type {Map<any, any>}
-   * @private
-   */
-  _collections = new Map();
-
-  /**
-   * Connected.
+   * Client.
    *
-   * @type {boolean}
-   * @private
+   * @returns {MongoClient}
    */
-  _connected = false;
-
-  /**
-   * Connected.
-   *
-   * @return {boolean}
-   */
-  get connected() {
-    return this._connected;
+  get client() {
+    return this._client;
   }
 
   /**
-   * Connecting.
+   * Collections.
    *
-   * @type {boolean}
+   * @type {Map<any, any>}
    * @private
    */
-  _connecting = false;
-
-  /**
-   * Connecting.
-   *
-   * @return {boolean}
-   */
-  get connecting() {
-    return this._connecting;
-  }
+  _collections = new Map();
 
   /**
    * Constructor.
@@ -140,80 +115,14 @@ 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';
-  }
-
-  /**
-   * Connect.
-   *
-   * @return {Promise<*|undefined>}
-   * @private
-   */
-  async connect() {
-    if (this._connecting) {
-      const tryAgainAfter = 500;
-      await new Promise(r => setTimeout(() => r(), tryAgainAfter));
-      return this.connect();
-    }
-
-    if (this._connected) return;
-    this._connecting = true;
-
+    settings.database = settings.database || settings.db || 'database';
+    super(container, settings);
     const options = selectObjectKeys(this.settings, MONGODB_OPTION_NAMES);
     const url = createMongodbUrl(this.settings);
-
-    // console.log(`Connecting to ${url}`);
     this._client = new MongoClient(url, options);
-
-    const {reconnectInterval} = this.settings;
-    const connectFn = async () => {
-      try {
-        await this._client.connect();
-      } catch (e) {
-        console.error(e);
-        // console.log('MongoDB connection failed!');
-        // console.log(`Reconnecting after ${reconnectInterval} ms.`);
-        await new Promise(r => setTimeout(() => r(), reconnectInterval));
-        return connectFn();
-      }
-      // console.log('MongoDB is connected.');
-      this._connected = true;
-      this._connecting = false;
-    };
-
-    await connectFn();
-
-    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.');
-      }
-    });
-  }
-
-  /**
-   * Disconnect.
-   *
-   * @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();
   }
 
   /**
@@ -251,19 +160,6 @@ export class MongodbAdapter extends Adapter {
     return value;
   }
 
-  /**
-   * Coerce iso date.
-   *
-   * @param value
-   * @return {*|Date}
-   * @private
-   */
-  _coerceIsoDate(value) {
-    if (value === null) return value;
-    if (isIsoDate(value)) return new Date(value);
-    return value;
-  }
-
   /**
    * To database.
    *
@@ -344,7 +240,7 @@ export class MongodbAdapter extends Adapter {
     if (collection) return collection;
     const tableName =
       this.getService(ModelDefinitionUtils).getTableNameByModelName(modelName);
-    collection = this._client.db(this.settings.database).collection(tableName);
+    collection = this.client.db(this.settings.database).collection(tableName);
     this._collections.set(modelName, collection);
     return collection;
   }
@@ -641,7 +537,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<object>}
    */
   async create(modelName, modelData, filter = undefined) {
-    await this.connect();
     const idPropName = this._getIdPropName(modelName);
     const idValue = modelData[idPropName];
     if (idValue == null) {
@@ -677,7 +572,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<object>}
    */
   async replaceById(modelName, id, modelData, filter = undefined) {
-    await this.connect();
     id = this._coerceId(id);
     const idPropName = this._getIdPropName(modelName);
     modelData[idPropName] = id;
@@ -704,7 +598,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<object>}
    */
   async patchById(modelName, id, modelData, filter = undefined) {
-    await this.connect();
     id = this._coerceId(id);
     const idPropName = this._getIdPropName(modelName);
     delete modelData[idPropName];
@@ -729,7 +622,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<object[]>}
    */
   async find(modelName, filter = undefined) {
-    await this.connect();
     filter = filter || {};
     const query = this._buildQuery(modelName, filter.where);
     const sort = this._buildSort(modelName, filter.order);
@@ -751,7 +643,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<object>}
    */
   async findById(modelName, id, filter = undefined) {
-    await this.connect();
     id = this._coerceId(id);
     const table = this._getCollection(modelName);
     const projection = this._buildProjection(
@@ -772,7 +663,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<number>}
    */
   async delete(modelName, where = undefined) {
-    await this.connect();
     const table = this._getCollection(modelName);
     const query = this._buildQuery(modelName, where);
     const {deletedCount} = await table.deleteMany(query);
@@ -787,7 +677,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<boolean>}
    */
   async deleteById(modelName, id) {
-    await this.connect();
     id = this._coerceId(id);
     const table = this._getCollection(modelName);
     const {deletedCount} = await table.deleteOne({_id: id});
@@ -802,7 +691,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<boolean>}
    */
   async exists(modelName, id) {
-    await this.connect();
     id = this._coerceId(id);
     const table = this._getCollection(modelName);
     const result = await table.findOne({_id: id}, {});
@@ -817,7 +705,6 @@ export class MongodbAdapter extends Adapter {
    * @return {Promise<number>}
    */
   async count(modelName, where = undefined) {
-    await this.connect();
     const query = this._buildQuery(modelName, where);
     const table = this._getCollection(modelName);
     return await table.count(query);

package/src/mongodb-adapter.spec.js

@@ -2,7 +2,6 @@ import {expect} from 'chai';
 import {ObjectId} from 'mongodb';
 import {MongoClient} from 'mongodb';
 import {format} from '@e22m4u/js-format';
-import {Service} from '@e22m4u/js-service';
 import {Schema} from '@e22m4u/js-repository';
 import {DataType} from '@e22m4u/js-repository';
 import {createMongodbUrl} from './utils/index.js';
@@ -37,19 +36,11 @@ describe('MongodbAdapter', function () {
 
   after(async function () {
     for await (const adapter of ADAPTERS_STACK) {
-      await adapter.disconnect();
+      await adapter.client.close(true);
     }
     await MDB_CLIENT.close(true);
   });
 
-  it('able to connect and disconnect', async function () {
-    const S = new Service();
-    const adapter = new MongodbAdapter(S.container, CONFIG);
-    await adapter.connect();
-    expect(adapter.connected).to.be.true;
-    await adapter.disconnect();
-  });
-
   describe('create', function () {
     it('generates a new identifier when a value of a primary key is not provided', async function () {
       const schema = createSchema();

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 './is-iso-date.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 () {})();
+  });
 });