@toa.io/storages.mongodb 0.1.0-dev.0

package/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020-present Artem Gurtovoi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/deploy/service.yaml

@@ -0,0 +1,21 @@
+apiVersion: v1
+kind: Service
+metadata:
+  name: messages-mongodb
+spec:
+  selector:
+    app.kubernetes.io/name: rabbitmq
+  ports:
+    - port: 27017
+      targetPort: 27017
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: credits-mongodb
+spec:
+  selector:
+    app.kubernetes.io/name: rabbitmq
+  ports:
+    - port: 27017
+      targetPort: 27017

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@toa.io/storages.mongodb",
+  "version": "0.1.0-dev.0",
+  "description": "Toa MongoDB Storage Connector",
+  "author": "temich <tema.gurtovoy@gmail.com>",
+  "homepage": "https://github.com/toa-io/toa#readme",
+  "main": "src/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toa-io/toa.git"
+  },
+  "bugs": {
+    "url": "https://github.com/toa-io/toa/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "dependencies": {
+    "mongodb": "4.1.4"
+  },
+  "peerDependencies": {
+    "@toa.io/core": "^0.0.0",
+    "@toa.io/gears": "^0.0.0"
+  },
+  "gitHead": "632df6cead03909ad2cfb8852e178914ac4ab5d2"
+}

package/src/client.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const { MongoClient } = require('mongodb')
+const { Connector } = require('@toa.io/core')
+const { console } = require('@toa.io/gears')
+
+class Client extends Connector {
+  #connection
+
+  #client
+  #collection
+
+  constructor (host, db, collection) {
+    super()
+
+    this.#connection = { host, db, collection }
+
+    const url = this.#url()
+    this.#client = new MongoClient(url, OPTIONS)
+  }
+
+  async connection () {
+    await this.#client.connect()
+
+    this.#collection = this.#client.db(this.#connection.db).collection(this.#connection.collection)
+
+    console.info(`Storage MongoDB connected to ${this.#url()}`)
+  }
+
+  async disconnection () {
+    await this.#client.close()
+
+    console.info('Storage MongoDB disconnected from ' +
+      `${this.#url}/${this.#connection.db}/${this.#connection.collection}`)
+  }
+
+  async add (record) {
+    const { acknowledged } = await this.#collection.insertOne(record)
+
+    return acknowledged
+  }
+
+  async get (query, options) {
+    return await this.#collection.findOne(query, options)
+  }
+
+  async replace (query, record, options) {
+    return this.#collection.findOneAndReplace(query, record, options)
+  }
+
+  async update (query, update, options) {
+    return this.#collection.findOneAndUpdate(query, update, options)
+  }
+
+  async find (query, options) {
+    const cursor = await this.#collection.find(query, options)
+
+    return cursor.toArray()
+  }
+
+  #url () {
+    // TODO: see ./deployment.js
+    const user = 'user'
+    const password = 'password'
+
+    return `mongodb://${user}:${password}@${this.#connection.host}:27017/?authSource=${this.#connection.db}&readPreference=primary&appname=svc&ssl=false`
+  }
+}
+
+const OPTIONS = {
+  useNewUrlParser: true,
+  useUnifiedTopology: true,
+  ignoreUndefined: true
+}
+
+exports.Client = Client

package/src/deployments.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const deployments = (values) => {
+  const domains = new Set(values.map((value) => value.domain))
+
+  return [...domains].map(deployment)
+}
+
+const deployment = (domain) => {
+  const alias = domain + '-mongodb'
+
+  // TODO: credentials management
+  const usernames = ['user']
+  const passwords = ['password']
+  const databases = [domain]
+
+  return {
+    chart: {
+      name: 'mongodb',
+      version: '10.29.2',
+      repository: 'https://charts.bitnami.com/bitnami',
+      alias
+    },
+    values: {
+      architecture: 'standalone',
+      fullnameOverride: alias,
+      auth: {
+        usernames,
+        passwords,
+        databases
+      }
+    }
+  }
+}
+
+exports.deployments = deployments

package/src/index.js

@@ -0,0 +1,5 @@
+const { Storage } = require('./storage')
+const { deployments } = require('./deployments')
+
+exports.Storage = Storage
+exports.deployments = deployments

package/src/record.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const to = (entity) => {
+  const { id, _version, ...rest } = entity
+
+  return { _id: id, _version: _version === undefined ? 1 : _version + 1, ...rest }
+}
+
+const from = (record) => {
+  if (record === undefined || record === null) return null
+
+  const { _id, ...rest } = record
+
+  return { id: _id, ...rest }
+}
+
+exports.to = to
+exports.from = from

package/src/storage.js

@@ -0,0 +1,84 @@
+'use strict'
+
+const { Connector } = require('@toa.io/core')
+
+const { Client } = require('./client')
+const { translate } = require('./translate')
+const { to, from } = require('./record')
+
+class Storage extends Connector {
+  #client
+
+  constructor (locator) {
+    super()
+
+    const host = locator.host('mongodb')
+
+    // TODO: create Factory, add test for host
+    this.#client = new Client(host, locator.domain, locator.name)
+    this.depends(this.#client)
+  }
+
+  async get (query) {
+    const { criteria, options } = translate(query)
+
+    const record = await this.#client.get(criteria, options)
+
+    return from(record)
+  }
+
+  async add (entity) {
+    let result
+
+    try {
+      result = await this.#client.add(to(entity))
+    } catch (e) {
+      if (e.code === 11000) result = false // duplicate id
+      else throw e
+    }
+
+    return result
+  }
+
+  async set (entity) {
+    const criteria = { _id: entity.id, _version: entity._version }
+    const result = await this.#client.replace(criteria, to(entity))
+
+    return result.value !== null
+  }
+
+  async store (entity) {
+    return entity._version === 0 ? this.add(entity) : this.set(entity)
+  }
+
+  async upsert (query, changeset, insert) {
+    const { criteria, options } = translate(query)
+    const update = { $set: { ...changeset }, $inc: { _version: 1 } }
+
+    if (insert !== undefined) {
+      delete insert._version
+
+      options.upsert = true
+
+      if (criteria._id !== undefined) insert._id = criteria._id
+      else return null // this shouldn't ever happen
+
+      if (Object.keys(insert) > 0) update.$setOnInsert = insert
+    }
+
+    options.returnDocument = 'after'
+
+    const result = await this.#client.update(criteria, update, options)
+
+    return from(result.value)
+  }
+
+  async find (query) {
+    const { criteria, options } = translate(query)
+    const recordset = await this.#client.find(criteria, options)
+
+    return recordset.map(from)
+  }
+}
+
+exports.Storage = Storage

package/src/translate/criteria.js

@@ -0,0 +1,48 @@
+'use strict'
+
+const { rename } = require('./rename')
+const criteria = (node) => {
+  if (!TYPES[node.type]) { throw new Error('Query criteria AST parse error') }
+
+  return TYPES[node.type](node)
+}
+
+const OPERATORS = {
+  LOGIC: {
+    and: '$and',
+    ';': '$and',
+    or: '$or',
+    ',': '$or'
+  },
+  COMPARISON: {
+    '==': '$eq',
+    '>': '$gt',
+    '>=': '$gte',
+    '=in=': '$in',
+    '<': '$lt',
+    '<=': '$lte',
+    '!=': '$ne',
+    '=out=': '$nin'
+  }
+}
+
+const TYPES = {}
+
+TYPES.LOGIC = (expression) => {
+  const left = criteria(expression.left)
+  const right = criteria(expression.right)
+
+  return { [OPERATORS.LOGIC[expression.operator]]: [left, right] }
+}
+
+TYPES.COMPARISON = (expression) => {
+  const left = criteria(expression.left)
+  const right = criteria(expression.right)
+
+  return { [left]: { [OPERATORS.COMPARISON[expression.operator]]: right } }
+}
+
+TYPES.SELECTOR = (expression) => rename(expression.selector)
+TYPES.VALUE = (expression) => expression.value
+
+exports.criteria = criteria

package/src/translate/options.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { rename } = require('./rename')
+
+const options = (options) => {
+  const result = {}
+
+  if (options.omit) { result.skip = options.omit }
+  if (options.limit) { result.limit = options.limit }
+  if (options.sort) { result.sort = sort(options.sort) }
+  if (options.projection) { result.projection = projection(options.projection) }
+
+  return result
+}
+
+const sort = (sort) => {
+  return sort.map(([property, direction]) => [rename(property), DIRECTIONS[direction]])
+}
+
+const projection = (projection) => {
+  const result = {}
+
+  for (const property of projection) { result[rename(property)] = 1 }
+
+  return result
+}
+
+const DIRECTIONS = {
+  asc: 1,
+  desc: -1
+}
+
+exports.options = options

package/src/translate/rename.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const rename = (name) => {
+  return RENAME[name] || name
+}
+
+const RENAME = { id: '_id' }
+
+exports.rename = rename

package/src/translate.js

@@ -0,0 +1,16 @@
+'use strict'
+
+const parse = { ...require('./translate/criteria'), ...require('./translate/options') }
+
+const translate = (query) => {
+  const result = { criteria: {}, options: {} }
+
+  if (query.criteria) result.criteria = parse.criteria(query.criteria)
+  if (query.options) result.options = parse.options(query.options)
+  if (query.id) result.criteria._id = query.id
+  if (query.version) result.criteria._version = query.version
+
+  return result
+}
+
+exports.translate = translate

package/test/client.fixtures.js

@@ -0,0 +1,46 @@
+'use strict'
+
+const MongoClient = jest.fn().mockImplementation(function () {
+  this.db = jest.fn(() => new DB())
+
+  this.connect = jest.fn()
+  this.close = jest.fn()
+})
+
+const DB = jest.fn().mockImplementation(function () {
+  this.collection = jest.fn(() => new Collection())
+})
+
+const results = {
+  insertOne: { acknowledged: 1 }
+}
+
+const Collection = jest.fn().mockImplementation(function () {
+  this.find = jest.fn(() => ({
+    toArray: jest.fn(() => ({ id: 1, foo: 'bar' }))
+  }))
+  this.findOne = jest.fn(() => ({ id: 1, foo: 'bar' }))
+  this.insertOne = jest.fn(() => results.insertOne)
+  this.findOneAndReplace = jest.fn(() => ({ ok: 1 }))
+})
+
+const OPTIONS = {
+  useNewUrlParser: true,
+  useUnifiedTopology: true,
+  ignoreUndefined: true
+}
+
+const query = {
+  criteria: {
+    id: 1
+  },
+  options: {
+    limit: 1
+  }
+}
+
+exports.mock = { MongoClient }
+exports.OPTIONS = OPTIONS
+exports.locator = { host: 'bar.foo', db: 'foo', collection: 'bar' }
+exports.object = { id: '1', foo: 'bar' }
+exports.query = query

package/test/client.test.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const fixtures = require('./client.fixtures')
+const mock = fixtures.mock
+
+jest.mock('mongodb', () => ({ MongoClient: mock.MongoClient }))
+
+const { Client } = require('../src/client')
+
+let instance, client, collection
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  const env = process.env.TOA_ENV
+
+  delete process.env.TOA_ENV
+
+  instance = new Client(fixtures.locator.host, fixtures.locator.db, fixtures.locator.collection)
+  await instance.connect()
+
+  process.env.TOA_ENV = env
+
+  client = fixtures.mock.MongoClient.mock.instances[0]
+
+  collection = fixtures.mock.MongoClient.mock.instances[0]
+    .db.mock.results[0].value
+    .collection.mock.results[0].value
+})
+
+it('should create client', () => {
+  expect(client).toBeDefined()
+  expect(fixtures.mock.MongoClient).toHaveBeenCalledWith(
+    expect.any(String),
+    fixtures.OPTIONS
+  )
+})
+
+it('should connect', async () => {
+  expect(client.connect).toHaveBeenCalled()
+  expect(client.db).toHaveBeenCalledWith(fixtures.locator.db)
+
+  const db = client.db.mock.results[0].value
+
+  expect(db.collection).toHaveBeenCalledWith(fixtures.locator.collection)
+})
+
+it('should disconnect', async () => {
+  await instance.disconnect()
+
+  expect(client.connect).toHaveBeenCalled()
+  expect(client.close).toHaveBeenCalled()
+})
+
+it('should add', async () => {
+  const ok = await instance.add(fixtures.object)
+
+  expect(collection.insertOne).toHaveBeenCalledWith(fixtures.object)
+  expect(ok).toBe(collection.insertOne.mock.results[0].value.acknowledged)
+})
+
+it('should get', async () => {
+  const entity = await instance.get(fixtures.query.criteria, fixtures.query.options)
+
+  expect(entity).toBe(collection.findOne.mock.results[0].value)
+  expect(collection.findOne).toHaveBeenCalledWith(fixtures.query.criteria, fixtures.query.options)
+})
+
+it('should replace', async () => {
+  const update = { ...fixtures.object, foo: 'foo' }
+  await instance.replace(fixtures.query.criteria, update, fixtures.query.options)
+
+  expect(collection.findOneAndReplace).toHaveBeenCalledWith(fixtures.query.criteria, update, fixtures.query.options)
+})
+
+it('should find', async () => {
+  const set = await instance.find(fixtures.query.criteria, fixtures.query.options)
+
+  expect(set).toStrictEqual(collection.find.mock.results[0].value.toArray.mock.results[0].value)
+  expect(collection.find).toHaveBeenCalledWith(fixtures.query.criteria, fixtures.query.options)
+})

package/test/entry.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const { to, from } = require('../src/record')
+const { random } = require('@toa.io/gears')
+
+describe('to', () => {
+  it('should rename id to _id', () => {
+    const entity = { id: 1 }
+    const record = to(entity)
+
+    expect(record).toMatchObject({ _id: 1 })
+  })
+
+  it('should not modify argument', () => {
+    const entity = { id: 1 }
+
+    to(entity)
+
+    expect(entity).toStrictEqual({ id: 1 })
+  })
+
+  it('should increment _version', () => {
+    const entity = { _version: random() }
+    const record = to(entity)
+
+    expect(record).toMatchObject({ _version: entity._version + 1 })
+  })
+})
+
+describe('from', () => {
+  it('should rename _id to id', () => {
+    const record = { _id: 1 }
+    const entity = from(record)
+
+    expect(entity).toStrictEqual({ id: 1 })
+  })
+
+  it('should not modify argument', () => {
+    const record = { _id: 1 }
+
+    from(record)
+
+    expect(record).toStrictEqual({ _id: 1 })
+  })
+})

package/test/query/criteria.fixtures.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const ast = {
+  left: {
+    type: 'SELECTOR',
+    selector: 'id'
+  },
+  type: 'COMPARISON',
+  operator: '==',
+  right: {
+    type: 'VALUE',
+    value: 100500
+  }
+}
+
+const criteria = {
+  _id: { $eq: 100500 }
+}
+
+exports.ast = ast
+exports.criteria = criteria

package/test/query/criteria.test.js

@@ -0,0 +1,10 @@
+'use strict'
+
+const fixtures = require('./criteria.fixtures')
+const { criteria } = require('../../src/translate/criteria')
+
+it('should translate', () => {
+  const result = criteria(fixtures.ast)
+
+  expect(result).toStrictEqual(fixtures.criteria)
+})

package/test/storage.fixtures.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const Client = jest.fn().mockImplementation(function () {
+  this.connect = jest.fn()
+  this.disconnect = jest.fn()
+  this.add = jest.fn(() => true)
+  this.get = jest.fn(() => ({ foo: 'bar' }))
+  this.replace = jest.fn(() => ({ ok: 1 }))
+  this.find = jest.fn(() => [{ foo: 'bar' }, { bar: 'foo' }])
+})
+
+const query = {
+  criteria: {},
+  options: {}
+}
+
+const translate = jest.fn(() => ({ criteria: 'foo', options: 'bar' }))
+
+const to = jest.fn((entity) => entity)
+const from = jest.fn((record) => record)
+
+exports.mock = { Client, translate, to, from }
+exports.locator = { host: jest.fn(() => 'bar.foo.local'), domain: 'foo', name: 'bar' }
+exports.entity = { id: '1', foo: 'bar' }
+exports.query = query

package/test/storage.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const fixtures = require('./storage.fixtures')
+const mock = fixtures.mock
+
+jest.mock('../src/client', () => ({ Client: mock.Client }))
+jest.mock('../src/translate', () => ({ translate: mock.translate }))
+jest.mock('../src/record', () => ({ to: mock.to, from: mock.from }))
+
+const { Storage } = require('../src/storage')
+
+let connector, client
+
+beforeAll(() => {
+  connector = new Storage(fixtures.locator)
+
+  client = fixtures.mock.Client.mock.instances[0]
+
+  expect(client).toBeDefined()
+
+  expect(fixtures.mock.Client).toHaveBeenCalledWith(
+    fixtures.locator.host.mock.results[0].value,
+    fixtures.locator.domain,
+    fixtures.locator.name
+  )
+
+  expect(fixtures.locator.host.mock.calls[0][0].toLowerCase()).toBe('mongodb')
+})
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+it('should add', async () => {
+  const result = await connector.add(fixtures.entity)
+
+  expect(client.add).toHaveBeenCalledWith(mock.to.mock.results[0].value)
+  expect(mock.to).toHaveBeenCalledWith(fixtures.entity)
+  expect(result).toBe(client.add.mock.results[0].value)
+})
+
+it('should get', async () => {
+  const entity = await connector.get(fixtures.query)
+
+  expect(entity).toBe(mock.from.mock.results[0].value)
+  expect(mock.from).toHaveBeenCalledWith(client.get.mock.results[0].value)
+
+  const { criteria, options } = mock.translate.mock.results[0].value
+
+  expect(client.get).toHaveBeenCalledWith(criteria, options)
+  expect(mock.translate).toHaveBeenCalledWith(fixtures.query)
+})
+
+it('should set', async () => {
+  await connector.set(fixtures.entity)
+  const criteria = { _id: fixtures.entity.id }
+
+  expect(client.replace).toHaveBeenCalledWith(criteria, mock.to.mock.results[0].value)
+  expect(mock.to).toHaveBeenCalledWith(fixtures.entity)
+})
+
+it('should find', async () => {
+  const set = await connector.find(fixtures.query)
+  const found = client.find.mock.results[0].value
+
+  const expected = found.map((result, index) => {
+    expect(mock.from).toHaveBeenNthCalledWith(index + 1, result, index, found)
+
+    return mock.from.mock.results[index].value
+  })
+
+  expect(set).toStrictEqual(expected)
+})

package/test/translate.test.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const { translate } = require('../src/translate')
+
+describe('options', () => {
+  it('should translate omit', () => {
+    const options = { omit: 10 }
+    const query = translate({ options })
+
+    expect(query.options.skip).toStrictEqual(options.omit)
+  })
+
+  it('should translate limit', () => {
+    const options = { limit: 10 }
+    const query = translate({ options })
+
+    expect(query.options.limit).toStrictEqual(options.limit)
+  })
+
+  it('should translate sort', () => {
+    const options = { sort: [['a', 'asc'], ['b', 'desc'], ['id', 'asc']] }
+    const query = translate({ options })
+
+    expect(query.options.sort).toStrictEqual([['a', 1], ['b', -1], ['_id', 1]])
+  })
+
+  it('should translate projection', () => {
+    const options = { projection: ['a', 'b', 'c', 'id'] }
+    const query = translate({ options })
+
+    expect(query.options.projection).toStrictEqual({ a: 1, b: 1, c: 1, _id: 1 })
+  })
+})