@toa.io/storages.mongodb 1.0.0-alpha.0 → 1.0.0-alpha.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/storages.mongodb",
-  "version": "1.0.0-alpha.0",
+  "version": "1.0.0-alpha.107",
   "description": "Toa MongoDB Storage Connector",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -19,12 +19,13 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "@toa.io/console": "1.0.0-alpha.0",
-    "@toa.io/core": "1.0.0-alpha.0",
-    "@toa.io/generic": "1.0.0-alpha.0",
-    "@toa.io/pointer": "1.0.0-alpha.0",
-    "mongodb": "5.9.1",
+    "@toa.io/conveyor": "1.0.0-alpha.93",
+    "@toa.io/core": "1.0.0-alpha.107",
+    "@toa.io/generic": "1.0.0-alpha.93",
+    "@toa.io/pointer": "1.0.0-alpha.93",
+    "mongodb": "6.7.0",
+    "openspan": "1.0.0-alpha.93",
     "saslprep": "1.0.3"
   },
-  "gitHead": "06c64546f6292cc07c52f74b31415101037f7616"
+  "gitHead": "0c69afa09e2515ed76f88eaa9c9f5e5c97d8c5db"
 }

package/src/client.js

@@ -0,0 +1,160 @@
+'use strict'
+
+/**
+ * @typedef {import('mongodb').MongoClient} MongoClient
+ * @typedef {{ count: number, client: MongoClient }} Instance
+ * @typedef {import('@toa.io/core').Locator} Locator
+ */
+
+const { console } = require('openspan')
+const { Connector } = require('@toa.io/core')
+const { resolve } = require('@toa.io/pointer')
+const { ID } = require('./deployment')
+const { MongoClient } = require('mongodb')
+
+/**
+ * @type {Record<string, Promise<Instance>>}
+ */
+const INSTANCES = {}
+
+class Client extends Connector {
+  name
+
+  /**
+   * @public
+   * @type {import('mongodb').Collection}
+   */
+  collection
+
+  /**
+   * @private
+   * @type {Locator}
+   */
+  locator
+
+  /**
+   * @private
+   * @type {Instance}
+   */
+  instance
+
+  /**
+   * @private
+   * @type {string}
+   */
+  key
+
+  /**
+   * @param {Locator} locator
+   */
+  constructor (locator) {
+    super()
+
+    this.locator = locator
+  }
+
+  /**
+   * @protected
+   * @override
+   * @return {Promise<void>}
+   */
+  async open () {
+    const urls = await this.resolveURLs()
+    const dbname = this.resolveDB()
+
+    this.name = this.locator.lowercase
+    this.key = getKey(dbname, urls)
+
+    INSTANCES[this.key] ??= this.createInstance(urls)
+
+    this.instance = await INSTANCES[this.key]
+    this.instance.count++
+
+    const db = this.instance.client.db(dbname)
+
+    try {
+      this.collection = await db.createCollection(this.name)
+    } catch (e) {
+      if (e.code !== ALREADY_EXISTS) {
+        throw e
+      }
+
+      this.collection = db.collection(this.name)
+    }
+  }
+
+  /**
+   * @protected
+   * @override
+   * @return {Promise<void>}
+   */
+  async close () {
+    const instance = await INSTANCES[this.key]
+
+    instance.count--
+
+    if (instance.count === 0) {
+      await instance.client.close()
+      delete INSTANCES[this.key]
+    }
+  }
+
+  /**
+   * @private
+   * @param {string[]} urls
+   * @return {Promise<Instance>}
+   */
+  async createInstance (urls) {
+    const client = new MongoClient(urls.join(','), OPTIONS)
+    const hosts = urls.map((str) => new URL(str).host)
+
+    console.info('Connecting to MongoDB', { address: hosts.join(', ') })
+
+    await client.connect()
+
+    return {
+      count: 0,
+      client
+    }
+  }
+
+  /**
+   * @private
+   * @return {Promise<string[]>}
+   */
+  async resolveURLs () {
+    if (process.env.TOA_DEV === '1') {
+      return ['mongodb://developer:secret@localhost']
+    } else {
+      return await resolve(ID, this.locator.id)
+    }
+  }
+
+  /**
+   * @private
+   * @return {string}
+   */
+  resolveDB () {
+    if (process.env.TOA_CONTEXT !== undefined) {
+      return process.env.TOA_CONTEXT
+    }
+
+    if (process.env.TOA_DEV === '1') {
+      return 'toa-dev'
+    }
+
+    throw new Error('Environment variable TOA_CONTEXT is not defined')
+  }
+}
+
+function getKey (db, urls) {
+  return db + ':' + urls.sort().join(' ')
+}
+
+const OPTIONS = {
+  ignoreUndefined: true
+}
+
+const ALREADY_EXISTS = 48
+
+exports.Client = Client

package/src/factory.js

@@ -1,13 +1,13 @@
 'use strict'
 
-const { Connection } = require('./connection')
+const { Client } = require('./client')
 const { Storage } = require('./storage')
 
 class Factory {
-  storage (locator) {
-    const connection = new Connection(locator)
+  storage (locator, entity) {
+    const client = new Client(locator)
 
-    return new Storage(connection)
+    return new Storage(client, entity)
   }
 }
 

package/src/record.js

@@ -1,21 +1,14 @@
 'use strict'
 
-/**
- * @param {toa.core.storages.Record} entity
- * @returns {toa.mongodb.Record}
- */
-const to = (entity) => {
-  const { id, _version, ...rest } = entity
+function to (entity) {
+  const { id, ...rest } = entity
 
-  return /** @type {toa.mongodb.Record} */ { _id: id, _version: _version + 1, ...rest }
+  return /** @type {toa.mongodb.Record} */ { _id: id, ...rest }
 }
 
-/**
- * @param {toa.mongodb.Record} record
- * @returns {toa.core.storages.Record}
- */
-const from = (record) => {
-  if (record === undefined || record === null) return null
+function from (record) {
+  if (record === undefined || record === null)
+    return null
 
   const { _id, ...rest } = record
 

package/src/storage.js

@@ -1,82 +1,259 @@
 'use strict'
 
-const { Connector } = require('@toa.io/core')
-
+const { Connector, exceptions } = require('@toa.io/core')
+const { console } = require('openspan')
 const { translate } = require('./translate')
 const { to, from } = require('./record')
+const { ReturnDocument } = require('mongodb')
 
-/**
- * @implements {toa.core.Storage}
- */
 class Storage extends Connector {
-  /** @type {toa.mongodb.Connection} */
-  #connection
+  #client
+
+  /** @type {import('mongodb').Collection} */
+  #collection
+  #entity
 
-  /**
-   * @param {toa.mongodb.Connection} connection
-   */
-  constructor (connection) {
+  constructor (client, entity) {
     super()
 
-    this.#connection = connection
+    this.#client = client
+    this.#entity = entity
+
+    this.depends(client)
+  }
+
+  async open () {
+    this.#collection = this.#client.collection
 
-    this.depends(connection)
+    await this.index()
   }
 
   async get (query) {
     const { criteria, options } = translate(query)
 
-    const record = await this.#connection.get(criteria, options)
+    this.debug('findOne', { criteria, options })
+
+    const record = await this.#collection.findOne(criteria, options)
 
     return from(record)
   }
 
   async find (query) {
     const { criteria, options } = translate(query)
-    const recordset = await this.#connection.find(criteria, options)
+
+    criteria._deleted = null
+
+    this.debug('find', { criteria, options })
+
+    const recordset = await this.#collection.find(criteria, options).toArray()
 
     return recordset.map((item) => from(item))
   }
 
+  async stream (query = undefined) {
+    const { criteria, options } = translate(query)
+
+    this.debug('find (stream)', { criteria, options })
+
+    return this.#collection.find(criteria, options).stream({ transform: from })
+  }
+
   async add (entity) {
     const record = to(entity)
 
-    return await this.#connection.add(record)
+    this.debug('insertOne', { record })
+
+    const result = await this.#collection.insertOne(record)
+
+    return result.acknowledged
   }
 
   async set (entity) {
-    const criteria = { _id: entity.id, _version: entity._version }
-    const result = await this.#connection.replace(criteria, to(entity))
+    const criteria = {
+      _id: entity.id,
+      _version: entity._version - 1
+    }
 
-    return result.value !== null
+    const record = to(entity)
+
+    this.debug('findOneAndReplace', { criteria, record })
+
+    const result = await this.#collection.findOneAndReplace(criteria, record)
+
+    return result !== null
   }
 
-  async store (entity) {
-    if (entity._version === 0) return this.add(entity)
-    else return this.set(entity)
+  async store (entity, attempt = 0) {
+    try {
+      if (entity._version === 1)
+        return await this.add(entity)
+      else
+        return await this.set(entity)
+    } catch (error) {
+      if (error.code === ERR_DUPLICATE_KEY) {
+        const id = error.keyPattern === undefined
+          ? error.message.includes(' index: _id_ ') // AWS DocumentDB
+          : error.keyPattern._id === 1
+
+        if (id)
+          return false
+        else
+          throw new exceptions.DuplicateException(this.#client.name, entity)
+      } else if (error.cause?.code === 'ECONNREFUSED') {
+        // This is temporary and should be replaced with a class decorator.
+        if (attempt > 10)
+          throw error
+
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+
+        return this.store(entity)
+      } else
+        throw error
+    }
   }
 
-  async upsert (query, changeset, insert) {
+  async upsert (query, changeset) {
     const { criteria, options } = translate(query)
-    const update = { $set: { ...changeset }, $inc: { _version: 1 } }
 
-    if (insert !== undefined) {
-      delete insert._version
+    if (!('_deleted' in changeset) || changeset._deleted === null) {
+      delete criteria._deleted
+      changeset._deleted = null
+    }
+
+    const update = {
+      $set: { ...changeset },
+      $inc: { _version: 1 }
+    }
+
+    options.returnDocument = ReturnDocument.AFTER
+
+    this.debug('findOneAndUpdate', { criteria, update, options })
+
+    const result = await this.#collection.findOneAndUpdate(criteria, update, options)
+
+    return from(result)
+  }
+
+  async ensure (query, properties, state) {
+    let { criteria, options } = translate(query)
+
+    if (query === undefined)
+      criteria = properties
 
-      options.upsert = true
+    const update = { $setOnInsert: to(state) }
 
-      if (criteria._id !== undefined) insert._id = criteria._id
-      else return null // this shouldn't ever happen
+    options.upsert = true
+    options.returnDocument = ReturnDocument.AFTER
 
-      if (Object.keys(insert) > 0) update.$setOnInsert = insert
+    console.debug('Database query', { method: 'findOneAndUpdate', criteria, update, options })
+
+    const result = await this.#collection.findOneAndUpdate(criteria, update, options)
+
+    if (result._deleted !== undefined && result._deleted !== null)
+      return null
+    else
+      return from(result)
+  }
+
+  async index () {
+    const indexes = []
+
+    if (this.#entity.unique !== undefined) {
+      for (const [name, fields] of Object.entries(this.#entity.unique)) {
+        const sparse = this.checkFields(fields)
+        const unique = await this.uniqueIndex(name, fields, sparse)
+
+        indexes.push(unique)
+      }
+    }
+
+    if (this.#entity.index !== undefined) {
+      for (const [suffix, declaration] of Object.entries(this.#entity.index)) {
+        const name = 'index_' + suffix
+        const fields = Object.fromEntries(Object.entries(declaration)
+          .map(([name, type]) => [name, INDEX_TYPES[type]]))
+
+        const sparse = this.checkFields(Object.keys(fields))
+
+        await this.#collection.createIndex(fields, { name, sparse })
+          .catch((e) => console.warn('Index creation failed', { name, fields, error: e }))
+
+        indexes.push(name)
+      }
     }
 
-    options.returnDocument = 'after'
+    await this.removeObsoleteIndexes(indexes)
+  }
+
+  async uniqueIndex (name, properties, sparse = false) {
+    const fields = properties.reduce((acc, property) => {
+      acc[property] = 1
+      return acc
+    }, {})
+
+    name = 'unique_' + name
 
-    const result = await this.#connection.update(criteria, update, options)
+    await this.#collection.createIndex(fields, { name, unique: true, sparse })
+      .catch((e) => console.warn('Unique index creation failed', { name, fields, error: e }))
 
-    return from(result.value)
+    return name
   }
+
+  async removeObsoleteIndexes (desired) {
+    const current = await this.getCurrentIndexes()
+    const obsolete = current.filter((name) => !desired.includes(name))
+
+    if (obsolete.length > 0) {
+      console.info('Removing obsolete indexes', { indexes: obsolete.join(', ') })
+
+      await Promise.all(obsolete.map((name) => this.#collection.dropIndex(name)))
+    }
+  }
+
+  async getCurrentIndexes () {
+    try {
+      const array = await this.#collection.listIndexes().toArray()
+
+      return array.map(({ name }) => name).filter((name) => name !== '_id_')
+    } catch {
+      return []
+    }
+  }
+
+  checkFields (fields) {
+    const optional = []
+
+    for (const field of fields) {
+      if (!(field in this.#entity.schema.properties))
+        throw new Error(`Index field '${field}' is not defined.`)
+
+      if (!this.#entity.schema.required?.includes(field))
+        optional.push(field)
+    }
+
+    if (optional.length > 0) {
+      console.info('Index fields are optional, creating sparse index', { fields: optional.join(', ') })
+
+      return true
+    } else
+      return false
+  }
+
+  debug (method, attributes) {
+    console.debug('Database query', {
+      collection: this.#client.name,
+      method,
+      ...attributes
+    })
+  }
+}
+
+const INDEX_TYPES = {
+  'asc': 1,
+  'desc': -1,
+  'hash': 'hashed'
 }
 
+const ERR_DUPLICATE_KEY = 11000
+
 exports.Storage = Storage

package/src/translate.js

@@ -7,12 +7,16 @@ const parse = { ...require('./translate/criteria'), ...require('./translate/opti
  * @returns {{criteria: Object, options: Object}}
  */
 const translate = (query) => {
-  const result = { criteria: {}, options: {} }
+  const result = {
+    criteria: query?.criteria === undefined ? {} : parse.criteria(query.criteria),
+    options: query?.options === undefined ? {} : parse.options(query.options)
+  }
 
-  if (query.criteria !== undefined) result.criteria = parse.criteria(query.criteria)
-  if (query.options !== undefined) result.options = parse.options(query.options)
-  if (query.id !== undefined) result.criteria._id = query.id
-  if (query.version !== undefined) result.criteria._version = query.version
+  if (query?.id !== undefined)
+    result.criteria._id = query.id
+
+  if (query?.version !== undefined)
+    result.criteria._version = query.version
 
   return result
 }

package/test/record.test.js

@@ -1,12 +1,17 @@
 'use strict'
 
-const { to, from } = require('../src/record')
-const { random } = require('@toa.io/generic')
+const {
+  to,
+  from
+} = require('../src/record')
 
 describe('to', () => {
   it('should rename id to _id', () => {
     /** @type {toa.core.storages.Record} */
-    const entity = { id: '1', _version: 0 }
+    const entity = {
+      id: '1',
+      _version: 0
+    }
     const record = to(entity)
 
     expect(record).toMatchObject({ _id: '1' })
@@ -14,37 +19,32 @@ describe('to', () => {
 
   it('should not modify argument', () => {
     /** @type {toa.core.storages.Record} */
-    const entity = { id: '1', _version: 0 }
+    const entity = {
+      id: '1',
+      _version: 0
+    }
 
     to(entity)
 
-    expect(entity).toStrictEqual({ id: '1', _version: 0 })
-  })
-
-  it('should increment _version', () => {
-    /** @type {toa.core.storages.Record} */
-    const entity = { id: '1', _version: random() }
-    const record = to(entity)
-
-    expect(record).toMatchObject({ _version: entity._version + 1 })
+    expect(entity).toStrictEqual({
+      id: '1',
+      _version: 0
+    })
   })
 })
 
 describe('from', () => {
   it('should rename _id to id', () => {
     /** @type {toa.mongodb.Record} */
-    const record = { _id: '1', _version: 0 }
+    const record = {
+      _id: '1',
+      _version: 0
+    }
     const entity = from(record)
 
-    expect(entity).toStrictEqual({ id: '1', _version: 0 })
-  })
-
-  it('should not modify argument', () => {
-    /** @type {toa.mongodb.Record} */
-    const record = { _id: '1', _version: 0 }
-
-    from(record)
-
-    expect(record).toStrictEqual({ _id: '1', _version: 0 })
+    expect(entity).toStrictEqual({
+      id: '1',
+      _version: 0
+    })
   })
 })

package/types/connection.d.ts

@@ -1,29 +1,31 @@
 // noinspection ES6UnusedImports
 
 import type {
-    Document,
-    Filter,
-    FindOneAndReplaceOptions,
-    FindOneAndUpdateOptions,
-    FindOptions,
-    UpdateFilter
+  Document,
+  Filter,
+  FindOneAndReplaceOptions,
+  FindOneAndUpdateOptions,
+  FindOptions,
+  UpdateFilter,
 } from 'mongodb'
 
 import type { Connector } from '@toa.io/core'
 import type { Record } from './record'
 
-declare namespace toa.mongodb {
+declare namespace toa.mongodb{
 
-    interface Connection extends Connector {
-        get(query: Filter<Record>, options?: FindOptions<Record>): Promise<Record>
+  interface Connection extends Connector{
+    get (query: Filter<Record>, options?: FindOptions<Record>): Promise<Record>
 
-        find(query: Filter<Record>, options?: FindOptions<Record>): Promise<Record[]>
+    find (query: Filter<Record>, options?: FindOptions<Record>): Promise<Record[]>
 
-        add(record: Record): Promise<boolean>
+    add (record: Record): Promise<boolean>
 
-        replace(query: Filter<Record>, record: UpdateFilter<Record>, options?: FindOneAndReplaceOptions): Promise<any>
+    addMany (records: Record[]): Promise<boolean>
 
-        update(query: Filter<Record>, update: UpdateFilter<Record>, options?: FindOneAndUpdateOptions): Promise<any>
-    }
+    replace (query: Filter<Record>, record: UpdateFilter<Record>, options?: FindOneAndReplaceOptions): Promise<any>
+
+    update (query: Filter<Record>, update: UpdateFilter<Record>, options?: FindOneAndUpdateOptions): Promise<any>
+  }
 
 }

package/src/connection.js

@@ -1,95 +0,0 @@
-// noinspection JSCheckFunctionSignatures
-
-'use strict'
-
-const { MongoClient } = require('mongodb')
-const { Connector } = require('@toa.io/core')
-const { console } = require('@toa.io/console')
-const { resolve } = require('@toa.io/pointer')
-const { ID } = require('./deployment')
-
-class Connection extends Connector {
-  #locator
-  /** @type {import('mongodb').MongoClient} */
-  #client
-  /** @type {import('mongodb').Collection<toa.mongodb.Record>} */
-  #collection
-
-  constructor (locator) {
-    super()
-
-    this.#locator = locator
-  }
-
-  async open () {
-    const urls = await this.#resolveURLs()
-    const db = this.#locator.namespace
-    const collection = this.#locator.name
-
-    this.#client = new MongoClient(urls[0], OPTIONS)
-
-    await this.#client.connect()
-
-    this.#collection = this.#client.db(db).collection(collection)
-
-    console.info('Storage Mongo connected')
-  }
-
-  async close () {
-    await this.#client?.close()
-
-    console.info('Storage Mongo disconnected')
-  }
-
-  /** @hot */
-  async get (query, options) {
-    return /** @type {toa.mongodb.Record} */ this.#collection.findOne(query, options)
-  }
-
-  /** @hot */
-  async find (query, options) {
-    const cursor = await this.#collection.find(query, options)
-
-    return cursor.toArray()
-  }
-
-  /** @hot */
-  async add (record) {
-    /** @type {boolean} */
-    let result
-
-    try {
-      const response = await this.#collection.insertOne(record)
-
-      result = response.acknowledged
-    } catch (e) {
-      if (e.code === 11000) result = false // duplicate id
-      else throw e
-    }
-
-    return result
-  }
-
-  /** @hot */
-  async replace (query, record, options) {
-    return await this.#collection.findOneAndReplace(query, record, options)
-  }
-
-  /** @hot */
-  async update (query, update, options) {
-    return this.#collection.findOneAndUpdate(query, update, options)
-  }
-
-  async #resolveURLs () {
-    if (process.env.TOA_DEV === '1') return ['mongodb://developer:secret@localhost']
-    else return await resolve(ID, this.#locator.id)
-  }
-}
-
-const OPTIONS = {
-  useNewUrlParser: true,
-  useUnifiedTopology: true,
-  ignoreUndefined: true
-}
-
-exports.Connection = Connection