mia-platform / crud-service / 8941506258

/*

 * Copyright 2023 Mia s.r.l.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

'use strict'

const assert = require('assert')

const { get: lget, unset: lunset } = require('lodash')

const {

  UPDATERID,

  UPDATEDAT,

  CREATORID,

  CREATEDAT,

  __STATE__,

  STATES: { PUBLIC, DRAFT, TRASH, DELETED },

  textScore,

  SETCMD,

  UNSETCMD,

  INCCMD,

  MULCMD,

  CURDATECMD,

  SETONINSERTCMD,

  PUSHCMD,

  ADDTOSETCMD,

  PULLCMD,

  QUERY,

  STATE,

} = require('./consts')

const { getStateQuery } = require('./CrudService.utils')

const { JSONPath } = require('jsonpath-plus')

const { getPathFromPointer } = require('./JSONPath.utils')

const resolveMongoQuery = require('./resolveMongoQuery')

const ALLOWED_COMMANDS = [

  SETCMD,

  INCCMD,

  MULCMD,

  CURDATECMD,

  SETONINSERTCMD,

  UNSETCMD,

  PUSHCMD,

  PULLCMD,

  ADDTOSETCMD,

]

const STANDARD_FIELDS = [

  UPDATERID,

  UPDATEDAT,

  CREATORID,

  CREATEDAT,

]

/**

 * List of states available for a document managed by the CRUD Service

 * and the possible states it can start from, based on requested operations

 */

const STATES_FINITE_STATE_MACHINE = {

  [PUBLIC]: [DRAFT],

  [DRAFT]: [PUBLIC, TRASH],

  [TRASH]: [PUBLIC, DRAFT, DELETED],

  [DELETED]: [TRASH],

}

/**

 * List of status available for a document managed by the CRUD Service

 * and the possible states it can move to, based on the requested operations

 */

const ALLOWED_STATES_MAP = {

  [PUBLIC]: [DRAFT, PUBLIC, TRASH],

  [DRAFT]: [DRAFT, PUBLIC, TRASH],

  [TRASH]: [DELETED, DRAFT, TRASH],

  [DELETED]: [DELETED, TRASH],

}

const NO_DOCUMENT_FOUND = '<no document found>'

function getQueryOptions(crudServiceOptions) {

  const options = {}

  if (crudServiceOptions.allowDiskUse !== undefined) {

    options.allowDiskUse = crudServiceOptions.allowDiskUse

  }

  return options

}

class CrudService {

  constructor(mongoCollection, stateOnInsert, defaultSorting, options = {}) {

    assert(STATES_FINITE_STATE_MACHINE[stateOnInsert], 'Invalid `stateOnInsert`')

    /**

     * @type {import('mongodb').Collection} collection used by this CRUD instance

     */

    this._mongoCollection = mongoCollection

    this._stateOnInsert = stateOnInsert

    this._defaultSorting = defaultSorting

    this._options = options

  }

  findAll(context, query, projection, sort, skip, limit, _states, isTextSearchQuery) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    if (isTextSearchQuery) {

      addTextScoreProjection(projection)

    }

    const sortConfig = getSorting({

      defaultSorting: this._defaultSorting, sort, isTextSearchQuery,

    })

    const searchQuery = isQueryValid ? { $and: [query, stateQuery] } : stateQuery

    const options = getQueryOptions(this._options)

    context.log.debug({ query: searchQuery, projection, sort: sortConfig, skip, limit, options }, 'findAll operation requested')

    let cursor = this._mongoCollection

      .find(searchQuery, options)

      .project(projection)

    if (sortConfig !== undefined && sortConfig !== null) { cursor = cursor.sort(sortConfig) }

    if (skip !== undefined && skip !== null) { cursor = cursor.skip(skip) }

    if (limit !== undefined && limit !== null) { cursor = cursor.limit(limit) }

    return cursor

  }

  findById(context, id, query, projection, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid

      ? { $and: [query, { _id: id }, stateQuery] }

      : { $and: [{ _id: id }, stateQuery] }

    const options = getQueryOptions(this._options)

    context.log.debug({ query: searchQuery, projection, options }, 'findById operation requested')

    return this._mongoCollection.findOne(searchQuery, {

      projection, ...options,

    })

  }

  aggregate(context, query, projection, sort, skip, limit, _states, isTextSearchQuery) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const sortConfig = getSorting({ defaultSorting: this._defaultSorting, sort, isTextSearchQuery })

    let textSearchQuery = {}

    const searchQuery = isQueryValid ? { $and: [query, stateQuery] } : stateQuery

    const options = getQueryOptions(this._options)

    context.log.debug({ query: searchQuery, projection, sort: sortConfig, skip, limit, options }, 'aggregate operation requested')

    const pipeline = [

      { $match: { ...textSearchQuery, ...stateQuery } },

      { $project: projection },

      { $match: query },

    ]

    if (sortConfig !== undefined && sortConfig !== null) { pipeline.push({ $sort: sortConfig }) }

    if (skip !== undefined && skip !== null) { pipeline.push({ $skip: Number(skip) }) }

    if (limit !== undefined && limit !== null) { pipeline.push({ $limit: Number(limit) }) }

    const cursor = this._mongoCollection.aggregate(pipeline)

    return cursor

  }

  async insertOne(context, doc) {

    context.log.debug({ doc }, 'insertOne operation requested')

    assertDocHasNotStandardField(doc)

    doc[CREATORID] = context.userId

    doc[UPDATERID] = context.userId

    doc[UPDATEDAT] = context.now

    doc[CREATEDAT] = context.now

    doc[__STATE__] = doc[__STATE__] || this._stateOnInsert

    const writeOpResult = await this._mongoCollection.insertOne(doc)

    context.log.debug({ docId: writeOpResult.insertedId }, 'insertOne operation executed')

    return {

      _id: writeOpResult.insertedId,

      ...doc,

    }

  }

  async insertOneWithId(context, id, doc) {

    context.log.debug({ doc }, 'insertOneWithId operation requested')

    assert.ok(!doc._id, 'doc._id already exists')

    assertDocHasNotStandardField(doc)

    doc._id = id

    doc[CREATORID] = context.userId

    doc[UPDATERID] = context.userId

    doc[UPDATEDAT] = context.now

    doc[CREATEDAT] = context.now

    doc[__STATE__] = doc[__STATE__] || this._stateOnInsert

    await this._mongoCollection.insertOne(doc)

    context.log.debug({ docId: id }, 'insertOneWithId operation executed')

    return doc

  }

  /**

   * performs a insert many operation over a CRUD resource

   * @param {unknown} context context of http handler

   * @param {unknown[]} docs array of documents

   * @param {import('./QueryParser')} queryParser QueryParser instance

   * @param {{ idOnly: boolean}?} opts

   * @returns {Promise<unknown[] | import('mongodb').ObjectId[]>} if flag idOnly is set to true,

   * returns just the mongodb object ids

   */

  async insertMany(context, docs, queryParser, opts = {}) {

    const { idOnly } = opts

    context.log.debug({ docs }, 'insertMany operation requested')

    assert(docs.length > 0, 'At least one element is required')

    for (const doc of docs) {

      queryParser.parseAndCastBody(doc)

      assertDocHasNotStandardField(doc)

      doc[CREATORID] = context.userId

      doc[UPDATERID] = context.userId

      doc[UPDATEDAT] = context.now

      doc[CREATEDAT] = context.now

      doc[__STATE__] = doc[__STATE__] || this._stateOnInsert

    }

    const writeOpResult = await this._mongoCollection.insertMany(docs)

    context.log.debug({ docIds: writeOpResult.insertedIds }, 'insertMany operation executed')

    if (!idOnly) {

      for (const indexKey of Object.keys(writeOpResult.insertedIds)) {

        docs[indexKey] = {

          _id: writeOpResult.insertedIds[indexKey],

          ...docs[indexKey],

        }

      }

      return docs

    }

    return Object.values(writeOpResult.insertedIds).map((_id) => ({ _id }))

  }

  async deleteById(context, id, query, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid

      ? { $and: [query, { _id: id }, stateQuery] }

      : { $and: [{ _id: id }, stateQuery] }

    context.log.debug({ query: searchQuery }, 'deleteById operation requested')

    const writeOpResult = await this._mongoCollection.findOneAndDelete(searchQuery)

    context.log.debug({ docId: writeOpResult?._id || NO_DOCUMENT_FOUND }, 'deleteById operation executed')

    return writeOpResult

  }

  async patchById(context, id, commands, query, projection, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid

      ? { $and: [query, { _id: id }, stateQuery] }

      : { $and: [{ _id: id }, stateQuery] }

    context.log.debug({ query: searchQuery, commands, projection }, 'patchById operation requested')

    assertCommands(commands)

    commands.$set = commands.$set || {}

    commands.$set[UPDATERID] = context.userId

    commands.$set[UPDATEDAT] = context.now

    const writeOpResult = await this._mongoCollection.findOneAndUpdate(

      searchQuery,

      commands,

      {

        returnDocument: 'after',

        projection,

      }

    )

    context.log.debug({ docId: writeOpResult?._id || NO_DOCUMENT_FOUND }, 'patchById operation executed')

    return writeOpResult

  }

  async patchMany(context, commands, query, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid ? { $and: [query, stateQuery] } : stateQuery

    context.log.debug({ query: searchQuery, commands }, 'patchMany operation requested')

    assertCommands(commands)

    commands.$set = commands.$set || {}

    commands.$set[UPDATERID] = context.userId

    commands.$set[UPDATEDAT] = context.now

    const { matchedCount, modifiedCount } = await this._mongoCollection.updateMany(searchQuery, commands)

    context.log.debug({ matchedCount, modifiedCount }, 'patchMany operation executed')

    return modifiedCount

  }

  async upsertOne(context, commands, query, projection, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    context.log.debug({ query: searchQuery, commands, projection }, 'upsertOne operation requested')

    assertCommands(commands)

    commands.$set = commands.$set || {}

    commands.$set[UPDATERID] = context.userId

    commands.$set[UPDATEDAT] = context.now

    commands.$setOnInsert = commands.$setOnInsert || {}

    commands.$setOnInsert[CREATORID] = context.userId

    commands.$setOnInsert[CREATEDAT] = context.now

    commands.$setOnInsert[__STATE__] = this._stateOnInsert

    const writeOpResult = await this._mongoCollection.findOneAndUpdate(

      searchQuery,

      commands,

      {

        returnDocument: 'after',

        upsert: true,

        projection,

      }

    )

    context.log.debug({ docId: writeOpResult._id }, 'upsertOne operation executed')

    return writeOpResult

  }

  async upsertMany(context, documents, queryParser) {

    context.log.debug(documents, 'upsertMany operation requested')

    assert(documents.length > 0, 'At least one element is required')

    const operations = []

    for (const document of documents) {

      queryParser.parseAndCastBody(document)

      assertDocHasNotStandardField(document)

      const operation = {

        updateOne: {

          filter: document._id ? { _id: document._id } : document,

          update: {

            $set: {

              ...document,

              [UPDATERID]: context.userId,

              [UPDATEDAT]: context.now,

            },

            $setOnInsert: {

              [CREATORID]: document[CREATORID] || context.userId,

              [CREATEDAT]: document[CREATEDAT] || context.now,

            },

          },

          upsert: true,

        },

      }

      operations.push(operation)

    }

    const { ok, modifiedCount, upsertedCount } = await this._mongoCollection.bulkWrite(operations)

    context.log.debug({ ok, modifiedCount, upsertedCount }, 'upsertMany operation executed')

    return upsertedCount

  }

  /**

   * Performs a patch bulk operation over the CRUD resource

   * @param {unknown} context

   * @param {unknown[]} filterUpdateCommands list of commands that needs to be executed

   * @param {import('./QueryParser')} queryParser

   * @param {Function} castCollectionId function that casts _id field (if defined in commands)

   * @param {*} editableFields

   * @param {*} aclRows

   * @returns {Promise<number>} the number of modified documents

   */

  // eslint-disable-next-line max-statements

  async patchBulk(

    context, filterUpdateCommands, queryParser, castCollectionId, editableFields, aclRows

  ) {

    context.log.debug(filterUpdateCommands, 'patchBulk operation requested')

    assert(filterUpdateCommands.length > 0, 'At least one element is required')

    const unorderedBulkOp = this._mongoCollection.initializeUnorderedBulkOp()

    const parsedAndCastedCommands = new Array(filterUpdateCommands.length)

    for (let i = 0; i < filterUpdateCommands.length; i++) {

      const { filter, update } = filterUpdateCommands[i]

      const {

        _id,

        [QUERY]: clientQueryString,

        [STATE]: state,

        ...otherParams

      } = filter

      const commands = update

      const mongoQuery = resolveMongoQuery(queryParser, clientQueryString, aclRows, otherParams, false)

      queryParser.parseAndCastCommands(commands, editableFields)

      const allowedStates = state.split(',')

      parsedAndCastedCommands[i] = {

        commands,

        state: allowedStates,

        query: mongoQuery,

      }

      const stateQuery = getStateQuery(allowedStates)

      const isQueryValid = mongoQuery && Object.keys(mongoQuery).length > 0

      const searchQuery = isQueryValid ? { $and: [mongoQuery, stateQuery] } : { $and: [stateQuery] }

      if (_id) {

        searchQuery.$and.push({ _id: castCollectionId(_id) })

      }

      assertCommands(commands)

      commands.$set = commands.$set || {}

      commands.$set.updaterId = context.userId

      commands.$set.updatedAt = context.now

      unorderedBulkOp.find(searchQuery).updateOne(commands)

    }

    const { ok, modifiedCount } = await unorderedBulkOp.execute()

    context.log.debug({ ok, modifiedCount }, 'patchBulk operation executed')

    return modifiedCount

  }

  async count(context, query, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid ? { $and: [query, stateQuery] } : stateQuery

    const options = getQueryOptions(this._options)

    context.log.debug({ query: searchQuery, options }, 'count operation requested')

    return this._mongoCollection.countDocuments(searchQuery, options)

  }

  async estimatedDocumentCount(context) {

    context.log.debug({}, 'estimatedDocumentCount operation requested')

    return this._mongoCollection.estimatedDocumentCount()

  }

  async deleteAll(context, query, _states) {

    const stateQuery = getStateQuery(_states)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid ? { $and: [query, stateQuery] } : stateQuery

    context.log.debug({ query: searchQuery }, 'deleteAll operation requested')

    const writeOpResult = await this._mongoCollection.deleteMany(searchQuery)

    context.log.debug({ docNumber: writeOpResult.deletedCount }, 'deleteAll operation executed')

    return writeOpResult.deletedCount

  }

  async changeStateById(context, id, stateTo, query) {

    context.log.debug({ query, stateTo }, 'changeStateById operation requested')

    assert.ok(stateTo in STATES_FINITE_STATE_MACHINE, `Invalid current \`stateTo\` parameter: ${stateTo}`)

    const isQueryValid = query && Object.keys(query).length > 0

    const searchQuery = isQueryValid

      ? { $and: [query, { _id: id }] }

      : { _id: id }

    const documentToUpdate = await this._mongoCollection.findOne(searchQuery)

    if (!documentToUpdate) {

      return null

    }

    const currentState = documentToUpdate[__STATE__]

    const allowedStates = ALLOWED_STATES_MAP[currentState]

    // this check on current state existence of allows this API

    // to assign a __STATE__ to documents that does not have the field

    // (no current state means that any transition is valid)

    if (currentState && !allowedStates.includes(stateTo)) {

      context.log.debug({ _id: documentToUpdate._id, from: currentState, to: stateTo }, 'transition from states not allowed')

      const error = new Error(`transition from ${currentState} to ${stateTo} not allowed.`)

      error.statusCode = 400

      throw error

    }

    const commands = {

      $set: {

        [__STATE__]: stateTo,

        [UPDATERID]: context.userId,

        [UPDATEDAT]: context.now,

      },

    }

    // adding current document state to the search filter of the operation ensure

    // that the state has not changed since the find operation executed above

    const { modifiedCount } = await this._mongoCollection.updateOne(

      { $and: [searchQuery, { __STATE__: currentState }] },

      commands

    )

    context.log.debug({ modifiedCount }, 'changeStateById operation executed')

    return modifiedCount

  }

  async changeStateMany(context, filterUpdateCommands) {

    context.log.debug({ filterUpdateCommands }, 'changeStateMany operation requested')

    assert(filterUpdateCommands.length > 0, 'At least one element is required')

    const unorderedBulkOp = this._mongoCollection.initializeUnorderedBulkOp()

    for (let i = 0; i < filterUpdateCommands.length; i++) {

      const { query, stateTo } = filterUpdateCommands[i]

      const currentState = STATES_FINITE_STATE_MACHINE[stateTo]

      assert(currentState, `Invalid current \`stateTo\` parameter: ${stateTo}`)

      const stateQuery = { [__STATE__]: { $in: currentState } }

      const isQueryValid = query && Object.keys(query).length > 0

      const commands = {

        $set: {

          __STATE__: stateTo,

          updaterId: context.userId,

          updatedAt: context.now,

        },

      }

      context.log.debug({ query: searchQuery, commands }, `changeStateMany - step #${i + 1} executed`)

      unorderedBulkOp.find(searchQuery).update(commands)

    }

    const res = await unorderedBulkOp.execute()

    const { ok, modifiedCount } = res

    context.log.debug({ ok, modifiedCount }, 'changeStateMany operation executed')

    return modifiedCount

  }

}

function addTextScoreProjection(projection) {

  if (!Object.keys(projection).includes('score')) {

    projection.score = textScore

  }

}

function getSorting({ defaultSorting, sort, isTextSearchQuery }) {

  if (isTextSearchQuery && !sort) {

    return { score: textScore }

  }

  if (defaultSorting && !sort) {

    return defaultSorting

  }

  return sort

}

function assertDocHasNotStandardField(doc) {

  STANDARD_FIELDS.forEach(field => {

    assert.ok(!doc[field], `${field} cannot be specified`)

  })

}

function assertCommands(command) {

  if (command.$set) {

    assertDocHasNotStandardField(command.$set)

  }

  if (command.$inc) {

    assertDocHasNotStandardField(command.$inc)

  }

  if (command.$mul) {

    assertDocHasNotStandardField(command.$mul)

  }

  if (command.$currentDate) {

    assertDocHasNotStandardField(command.$currentDate)

  }

  if (command.$setOnInsert) {

    assertDocHasNotStandardField(command.$setOnInsert)

  }

  if (command.$unset) {

    assertDocHasNotStandardField(command.$unset)

  }

  if (command.$push) {

    assertDocHasNotStandardField(command.$push)

  }

  if (command.$addToSet) {

    assertDocHasNotStandardField(command.$addToSet)

  }

  if (command.$pull) {

    assertDocHasNotStandardField(command.$pull)

  }

  for (const key of Object.keys(command)) {

    if (!ALLOWED_COMMANDS.includes(key)) {

      assert.fail(`Unknown operator: ${key}`)

    }

  }

}

CrudService.STANDARD_FIELDS = STANDARD_FIELDS

module.exports = CrudService