js-repository-mongodb-adapter/src/mongodb-adapter.js

/* eslint no-unused-vars: 0 */
import {ObjectId} from 'mongodb';
import {MongoClient} from 'mongodb';
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';
import {transformValuesDeep} from './utils/index.js';
import {stringToRegexp} from '@e22m4u/js-repository';
import {selectObjectKeys} from '@e22m4u/js-repository';
import {ModelDefinitionUtils} from '@e22m4u/js-repository';
import {InvalidArgumentError} from '@e22m4u/js-repository';
import {InvalidOperatorValueError} from '@e22m4u/js-repository';

/**
 * Mongodb option names.
 * 5.8.1
 *
 * @type {string[]}
 */
const MONGODB_OPTION_NAMES = [
  'appname',
  'authMechanism',
  'authMechanismProperties',
  'authSource',
  'compressors',
  'connectTimeoutMS',
  'directConnection',
  'heartbeatFrequencyMS',
  'journal',
  'loadBalanced',
  'localThresholdMS',
  'maxIdleTimeMS',
  'maxPoolSize',
  'maxConnecting',
  'maxStalenessSeconds',
  'minPoolSize',
  'proxyHost',
  'proxyPort',
  'proxyUsername',
  'proxyPassword',
  'readConcernLevel',
  'readPreference',
  'readPreferenceTags',
  'replicaSet',
  'retryReads',
  'retryWrites',
  'serverSelectionTimeoutMS',
  'serverSelectionTryOnce',
  'socketTimeoutMS',
  'srvMaxHosts',
  'srvServiceName',
  'ssl',
  'timeoutMS',
  'tls',
  'tlsAllowInvalidCertificates',
  'tlsAllowInvalidHostnames',
  'tlsCAFile',
  'tlsCertificateKeyFile',
  'tlsCertificateKeyFilePassword',
  'tlsInsecure',
  'w',
  'waitQueueTimeoutMS',
  'wTimeoutMS',
  'zlibCompressionLevel',
];

/**
 * Default settings.
 *
 * @type {{connectTimeoutMS: number}}
 */
const DEFAULT_SETTINGS = {
  reconnectInterval: 2000, // adapter specific option
  connectTimeoutMS: 2000,
  serverSelectionTimeoutMS: 2000,
};

/**
 * Mongodb adapter.
 */
export class MongodbAdapter extends Adapter {
  /**
   * Mongodb instance.
   *
   * @private
   */
  _client;

  /**
   * Collections.
   *
   * @type {Map<any, any>}
   * @private
   */
  _collections = new Map();

  /**
   * Connected.
   *
   * @type {boolean}
   * @private
   */
  _connected = false;

  /**
   * Connected.
   *
   * @return {boolean}
   */
  get connected() {
    return this._connected;
  }

  /**
   * Connecting.
   *
   * @type {boolean}
   * @private
   */
  _connecting = false;

  /**
   * Connecting.
   *
   * @return {boolean}
   */
  get connecting() {
    return this._connecting;
  }

  /**
   * Constructor.
   *
   * @param {ServiceContainer} container
   * @param settings
   */
  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;

    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();
  }

  /**
   * Get id prop name.
   *
   * @param modelName
   */
  _getIdPropName(modelName) {
    return this.getService(ModelDefinitionUtils).getPrimaryKeyAsPropertyName(
      modelName,
    );
  }

  /**
   * Get id col name.
   *
   * @param modelName
   */
  _getIdColName(modelName) {
    return this.getService(ModelDefinitionUtils).getPrimaryKeyAsColumnName(
      modelName,
    );
  }

  /**
   * Coerce id.
   *
   * @param value
   * @return {ObjectId|*}
   * @private
   */
  _coerceId(value) {
    if (value == null) return value;
    if (isObjectId(value)) return new ObjectId(value);
    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.
   *
   * @param {string} modelName
   * @param {object} modelData
   * @return {object}
   * @private
   */
  _toDatabase(modelName, modelData) {
    const tableData = this.getService(
      ModelDefinitionUtils,
    ).convertPropertyNamesToColumnNames(modelName, modelData);

    const idColName = this._getIdColName(modelName);
    if (idColName !== 'id' && idColName !== '_id')
      throw new InvalidArgumentError(
        'MongoDB is not supporting custom names of the primary key. ' +
          'Do use "id" as a primary key instead of %v.',
        idColName,
      );
    if (idColName in tableData && idColName !== '_id') {
      tableData._id = tableData[idColName];
      delete tableData[idColName];
    }

    return transformValuesDeep(tableData, value => {
      if (value instanceof ObjectId) return value;
      if (value instanceof Date) return value;
      if (isObjectId(value)) return new ObjectId(value);
      if (isIsoDate(value)) return new Date(value);
      return value;
    });
  }

  /**
   * From database.
   *
   * @param {string} modelName
   * @param {object} tableData
   * @return {object}
   * @private
   */
  _fromDatabase(modelName, tableData) {
    if ('_id' in tableData) {
      const idColName = this._getIdColName(modelName);
      if (idColName !== 'id' && idColName !== '_id')
        throw new InvalidArgumentError(
          'MongoDB is not supporting custom names of the primary key. ' +
            'Do use "id" as a primary key instead of %v.',
          idColName,
        );
      if (idColName !== '_id') {
        tableData[idColName] = tableData._id;
        delete tableData._id;
      }
    }

    const modelData = this.getService(
      ModelDefinitionUtils,
    ).convertColumnNamesToPropertyNames(modelName, tableData);

    return transformValuesDeep(modelData, value => {
      if (value instanceof ObjectId) return String(value);
      if (value instanceof Date) return value.toISOString();
      return value;
    });
  }

  /**
   * Get collection.
   *
   * @param {string} modelName
   * @return {*}
   * @private
   */
  _getCollection(modelName) {
    let collection = this._collections.get(modelName);
    if (collection) return collection;
    const tableName =
      this.getService(ModelDefinitionUtils).getTableNameByModelName(modelName);
    collection = this._client.db(this.settings.database).collection(tableName);
    this._collections.set(modelName, collection);
    return collection;
  }

  /**
   * Get id type.
   *
   * @param modelName
   * @return {string|*}
   * @private
   */
  _getIdType(modelName) {
    const utils = this.getService(ModelDefinitionUtils);
    const pkPropName = utils.getPrimaryKeyAsPropertyName(modelName);
    return utils.getDataTypeByPropertyName(modelName, pkPropName);
  }

  /**
   * Build projection.
   *
   * @param {string} modelName
   * @param {string|string[]} fields
   * @return {Record<string, number>|undefined}
   * @private
   */
  _buildProjection(modelName, fields) {
    if (!fields) return;
    fields = Array.isArray(fields) ? fields : [fields];
    if (!fields.length) return;
    if (fields.indexOf('_id') === -1) fields.push('_id');
    return fields.reduce((acc, field) => {
      if (!field || typeof field !== 'string')
        throw new InvalidArgumentError(
          'A field name must be a non-empty String, but %v given.',
          field,
        );
      let colName = this._getColName(modelName, field);
      acc[colName] = 1;
      return acc;
    }, {});
  }

  /**
   * Get col name.
   *
   * @param {string} modelName
   * @param {string} propName
   * @return {string}
   * @private
   */
  _getColName(modelName, propName) {
    if (!propName || typeof propName !== 'string')
      throw new InvalidArgumentError(
        'A property name must be a non-empty String, but %v given.',
        propName,
      );
    const utils = this.getService(ModelDefinitionUtils);
    let colName = propName;
    try {
      colName = utils.getColumnNameByPropertyName(modelName, propName);
    } catch (error) {
      if (
        !(error instanceof InvalidArgumentError) ||
        error.message.indexOf('does not have the property') === -1
      ) {
        throw error;
      }
    }
    return colName;
  }

  /**
   * Build sort.
   *
   * @param {string} modelName
   * @param {string|string[]} clause
   * @return {object|undefined}
   * @private
   */
  _buildSort(modelName, clause) {
    if (!clause) return;
    clause = Array.isArray(clause) ? clause : [clause];
    if (!clause.length) return;
    const utils = this.getService(ModelDefinitionUtils);
    const idPropName = this._getIdPropName(modelName);
    return clause.reduce((acc, order) => {
      if (!order || typeof order !== 'string')
        throw new InvalidArgumentError(
          'A field order must be a non-empty String, but %v given.',
          order,
        );
      const direction = order.match(/\s+(A|DE)SC$/);
      let key = order.replace(/\s+(A|DE)SC$/, '').trim();
      if (key === idPropName) {
        key = '_id';
      } else {
        try {
          key = utils.getColumnNameByPropertyName(modelName, key);
        } catch (error) {
          if (
            !(error instanceof InvalidArgumentError) ||
            error.message.indexOf('does not have the property') === -1
          ) {
            throw error;
          }
        }
      }
      acc[key] = direction && direction[1] === 'DE' ? -1 : 1;
      return acc;
    }, {});
  }

  /**
   * Build query.
   *
   * @param {string} modelName
   * @param {object} clause
   * @return {object}
   * @private
   */
  _buildQuery(modelName, clause) {
    const query = {};
    if (!clause || typeof clause !== 'object') return query;
    const idPropName = this._getIdPropName(modelName);
    Object.keys(clause).forEach(key => {
      let cond = clause[key];
      // and/or/nor clause
      if (key === 'and' || key === 'or' || key === 'nor') {
        if (Array.isArray(cond))
          cond = cond.map(c => this._buildQuery(modelName, c));
        query['$' + key] = cond;
        return;
      }
      // id
      if (key === idPropName) {
        key = '_id';
      } else {
        key = this._getColName(modelName, key);
      }
      // string
      if (typeof cond === 'string') {
        query[key] = this._coerceId(cond);
        return;
      }
      // ObjectId
      if (cond instanceof ObjectId) {
        query[key] = cond;
        return;
      }
      // operator
      if (cond && cond.constructor && cond.constructor.name === 'Object') {
        // eq
        if ('eq' in cond) {
          query[key] = this._coerceId(cond.eq);
        }
        // neq
        if ('neq' in cond) {
          query[key] = {$ne: this._coerceId(cond.neq)};
        }
        // gt
        if ('gt' in cond) {
          query[key] = {$gt: cond.gt};
        }
        // lt
        if ('lt' in cond) {
          query[key] = {$lt: cond.lt};
        }
        // gte
        if ('gte' in cond) {
          query[key] = {$gte: cond.gte};
        }
        // lte
        if ('lte' in cond) {
          query[key] = {$lte: cond.lte};
        }
        // inq
        if ('inq' in cond) {
          if (!cond.inq || !Array.isArray(cond.inq))
            throw new InvalidOperatorValueError(
              'inq',
              'an Array of possible values',
              cond.inq,
            );
          query[key] = {$in: cond.inq.map(v => this._coerceId(v))};
        }
        // nin
        if ('nin' in cond) {
          if (!cond.nin || !Array.isArray(cond.nin))
            throw new InvalidOperatorValueError(
              'nin',
              'an Array of possible values',
              cond,
            );
          query[key] = {$nin: cond.nin.map(v => this._coerceId(v))};
        }
        // between
        if ('between' in cond) {
          if (!Array.isArray(cond.between) || cond.between.length !== 2)
            throw new InvalidOperatorValueError(
              'between',
              'an Array of 2 elements',
              cond.between,
            );
          query[key] = {$gte: cond.between[0], $lte: cond.between[1]};
        }
        // exists
        if ('exists' in cond) {
          if (typeof cond.exists !== 'boolean')
            throw new InvalidOperatorValueError(
              'exists',
              'a Boolean',
              cond.exists,
            );
          query[key] = {$exists: cond.exists};
        }
        // like
        if ('like' in cond) {
          if (typeof cond.like !== 'string' && !(cond.like instanceof RegExp))
            throw new InvalidOperatorValueError(
              'like',
              'a String or RegExp',
              cond.like,
            );
          query[key] = {$regex: stringToRegexp(cond.like)};
        }
        // nlike
        if ('nlike' in cond) {
          if (typeof cond.nlike !== 'string' && !(cond.nlike instanceof RegExp))
            throw new InvalidOperatorValueError(
              'nlike',
              'a String or RegExp',
              cond.nlike,
            );
          query[key] = {$not: stringToRegexp(cond.nlike)};
        }
        // ilike
        if ('ilike' in cond) {
          if (typeof cond.ilike !== 'string' && !(cond.ilike instanceof RegExp))
            throw new InvalidOperatorValueError(
              'ilike',
              'a String or RegExp',
              cond.ilike,
            );
          query[key] = {$regex: stringToRegexp(cond.ilike, 'i')};
        }
        // nilike
        if ('nilike' in cond) {
          if (
            typeof cond.nilike !== 'string' &&
            !(cond.nilike instanceof RegExp)
          ) {
            throw new InvalidOperatorValueError(
              'nilike',
              'a String or RegExp',
              cond.nilike,
            );
          }
          query[key] = {$not: stringToRegexp(cond.nilike, 'i')};
        }
        // regexp and flags (optional)
        if ('regexp' in cond) {
          if (
            typeof cond.regexp !== 'string' &&
            !(cond.regexp instanceof RegExp)
          ) {
            throw new InvalidOperatorValueError(
              'regexp',
              'a String or RegExp',
              cond.regexp,
            );
          }
          const flags = cond.flags || undefined;
          if (flags && typeof flags !== 'string')
            throw new InvalidArgumentError(
              'RegExp flags must be a String, but %v given.',
              cond.flags,
            );
          query[key] = {$regex: stringToRegexp(cond.regexp, flags)};
        }
        return;
      }
      // unknown
      query[key] = cond;
    });
    return query;
  }

  /**
   * Create.
   *
   * @param {string} modelName
   * @param {object} modelData
   * @param {object|undefined} filter
   * @return {Promise<object>}
   */
  async create(modelName, modelData, filter = undefined) {
    await this.connect();
    const idPropName = this._getIdPropName(modelName);
    const idValue = modelData[idPropName];
    if (idValue == null) {
      const pkType = this._getIdType(modelName);
      if (pkType !== DataType.STRING && pkType !== DataType.ANY)
        throw new InvalidArgumentError(
          'MongoDB unable to generate primary keys of %s. ' +
            'Do provide your own value for the %v property ' +
            'or set property type to String.',
          capitalize(pkType),
          idPropName,
        );
      delete modelData[idPropName];
    }
    const tableData = this._toDatabase(modelName, modelData);
    const table = this._getCollection(modelName);
    const {insertedId} = await table.insertOne(tableData);
    const projection = this._buildProjection(
      modelName,
      filter && filter.fields,
    );
    const insertedData = await table.findOne({_id: insertedId}, {projection});
    return this._fromDatabase(modelName, insertedData);
  }

  /**
   * Replace by id.
   *
   * @param {string} modelName
   * @param {string|number} id
   * @param {object} modelData
   * @param {object|undefined} filter
   * @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;
    const tableData = this._toDatabase(modelName, modelData);
    const table = this._getCollection(modelName);
    const {modifiedCount} = await table.replaceOne({_id: id}, tableData);
    if (modifiedCount < 1)
      throw new InvalidArgumentError('Identifier %v is not found.', String(id));
    const projection = this._buildProjection(
      modelName,
      filter && filter.fields,
    );
    const replacedData = await table.findOne({_id: id}, {projection});
    return this._fromDatabase(modelName, replacedData);
  }

  /**
   * Patch by id.
   *
   * @param {string} modelName
   * @param {string|number} id
   * @param {object} modelData
   * @param {object|undefined} filter
   * @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];
    const tableData = this._toDatabase(modelName, modelData);
    const table = this._getCollection(modelName);
    const {modifiedCount} = await table.updateOne({_id: id}, {$set: tableData});
    if (modifiedCount < 1)
      throw new InvalidArgumentError('Identifier %v is not found.', String(id));
    const projection = this._buildProjection(
      modelName,
      filter && filter.fields,
    );
    const patchedData = await table.findOne({_id: id}, {projection});
    return this._fromDatabase(modelName, patchedData);
  }

  /**
   * Find.
   *
   * @param {string} modelName
   * @param {object|undefined} filter
   * @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);
    const limit = filter.limit || undefined;
    const skip = filter.skip || undefined;
    const projection = this._buildProjection(modelName, filter.fields);
    const collection = this._getCollection(modelName);
    const options = {sort, limit, skip, projection};
    const tableItems = await collection.find(query, options).toArray();
    return tableItems.map(v => this._fromDatabase(modelName, v));
  }

  /**
   * Find by id.
   *
   * @param {string} modelName
   * @param {string|number} id
   * @param {object|undefined} filter
   * @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(
      modelName,
      filter && filter.fields,
    );
    const patchedData = await table.findOne({_id: id}, {projection});
    if (!patchedData)
      throw new InvalidArgumentError('Identifier %v is not found.', String(id));
    return this._fromDatabase(modelName, patchedData);
  }

  /**
   * Delete.
   *
   * @param {string} modelName
   * @param {object|undefined} where
   * @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);
    return deletedCount;
  }

  /**
   * Delete by id.
   *
   * @param {string} modelName
   * @param {string|number} id
   * @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});
    return deletedCount > 0;
  }

  /**
   * Exists.
   *
   * @param {string} modelName
   * @param {string|number} id
   * @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}, {});
    return result != null;
  }

  /**
   * Count.
   *
   * @param {string} modelName
   * @param {object|undefined} where
   * @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);
  }
}