@teamplay/backend 0.3.18 → 0.3.20

package/db/mongo.js

@@ -2,27 +2,32 @@ import fs from 'fs'
 import { MongoClient } from 'mongodb'
 import ShareDbMongo from 'sharedb-mongo'
 
-export const { db, mongo, mongoClient, createMongoIndex } = getMongoDb({
-  url: process.env.MONGO_URL,
-  optsString: process.env.MONGO_OPTS,
-  sslKeyPath: process.env.MONGO_SSL_KEY_PATH,
-  sslCertPath: process.env.MONGO_SSL_CERT_PATH,
-  sslCaPath: process.env.MONGO_SSL_CA_PATH
+export const { db, mongo, mongoClient, createMongoIndex } = getMongoDb(process.env.MONGO_URL, {
+  // ssl key, cert and ca can be provided as paths or base64 or directly as strings
+
+  // ssl as string
+  key: process.env.MONGO_SSL_KEY,
+  cert: process.env.MONGO_SSL_CERT,
+  ca: process.env.MONGO_SSL_CA,
+
+  // ssl as path to the file
+  keyPath: process.env.MONGO_SSL_KEY_PATH,
+  certPath: process.env.MONGO_SSL_CERT_PATH,
+  caPath: process.env.MONGO_SSL_CA_PATH,
+
+  // ssl as base64
+  keyBase64: process.env.MONGO_SSL_KEY_BASE64,
+  certBase64: process.env.MONGO_SSL_CERT_BASE64,
+  caBase64: process.env.MONGO_SSL_CA_BASE64,
+
+  ...(process.env.MONGO_OPTIONS ? JSON.parse(process.env.MONGO_OPTIONS) : undefined)
 })
 
-function getMongoDb ({ url, optsString, sslKeyPath, sslCertPath, sslCaPath }) {
-  const options = { useUnifiedTopology: true }
-
-  if (typeof optsString === 'string') {
-    const { key, cert, ca } = JSON.parse(optsString)
-    options.sslKey = fs.readFileSync(key)
-    options.sslCert = fs.readFileSync(cert)
-    options.sslCA = fs.readFileSync(ca)
-  } else if (sslKeyPath) {
-    options.sslKey = fs.readFileSync(sslKeyPath)
-    options.sslCert = fs.readFileSync(sslCertPath)
-    options.sslCA = fs.readFileSync(sslCaPath)
-  }
+function getMongoDb (url, options = {}) {
+  options = { ...options }
+  options = processSslOptions(options)
+
+  options.useUnifiedTopology ??= true
 
   const mongoClient = new MongoClient(url, options)
   const mongo = mongoClient.db()
@@ -38,3 +43,68 @@ function getMongoDb ({ url, optsString, sslKeyPath, sslCertPath, sslCaPath }) {
     }
   }
 }
+
+function processSslOptions (options = {}) {
+  options = { ...options }
+  let initialized = false
+  if (options.key || options.cert || options.ca) {
+    if (!(options.key && options.cert && options.ca)) {
+      throw Error('[teamplay/mongo] SSL: All 3 strings must be provided: key, cert, ca')
+    }
+    if (!(typeof options.key === 'string' && typeof options.cert === 'string' && typeof options.ca === 'string')) {
+      throw Error('[teamplay/mongo] SSL: All 3 strings must be provided as strings')
+    }
+    options = {
+      ...options,
+      key: Buffer.from(options.key),
+      cert: Buffer.from(options.cert),
+      ca: Buffer.from(options.ca)
+    }
+    initialized = true
+  }
+  if (options.keyPath || options.certPath || options.caPath) {
+    if (initialized) {
+      throw Error('[teamplay/mongo] SSL: Cannot mix paths and strings or base64')
+    }
+    if (!(options.keyPath && options.certPath && options.caPath)) {
+      throw Error('[teamplay/mongo] SSL: All 3 paths to files must be provided: keyPath, certPath, caPath')
+    }
+    options = {
+      ...options,
+      key: fs.readFileSync(options.keyPath),
+      cert: fs.readFileSync(options.certPath),
+      ca: fs.readFileSync(options.caPath)
+    }
+    initialized = true
+  }
+  if (options.keyBase64 || options.certBase64 || options.caBase64) {
+    if (initialized) {
+      throw Error('[teamplay/mongo] SSL: Cannot mix base64 and strings or paths')
+    }
+    if (!(options.keyBase64 && options.certBase64 && options.caBase64)) {
+      throw Error('[teamplay/mongo] SSL: All 3 base64 strings must be provided: keyBase64, certBase64, caBase64')
+    }
+    options = {
+      ...options,
+      key: Buffer.from(options.keyBase64, 'base64'),
+      cert: Buffer.from(options.certBase64, 'base64'),
+      ca: Buffer.from(options.caBase64, 'base64')
+    }
+  }
+  // enable tls mode if certificates are provided (unless explicitly disabled)
+  if (options.key && options.cert && options.ca) {
+    options.tls ??= true
+  }
+  // cleanup options object from the processed keys
+  delete options.keyPath
+  delete options.certPath
+  delete options.caPath
+  delete options.keyBase64
+  delete options.certBase64
+  delete options.caBase64
+  // delete the undefined values if they were not provided
+  if (!options.key) delete options.key
+  if (!options.cert) delete options.cert
+  if (!options.ca) delete options.ca
+  return options
+}

package/index.js

@@ -7,7 +7,7 @@ import initValidateSchema from './features/validateSchema.js'
 import initServerAggregate from './features/serverAggregate.js'
 import initAccessControl from './features/accessControl.js'
 
-export { redis, redlock, Redlock } from './redis/index.js'
+export { redis, redlock, Redlock, getRedis, Redis } from './redis/index.js'
 export { db, mongo, mongoClient, createMongoIndex, sqlite } from './db/index.js'
 
 const usersConnectionCounter = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamplay/backend",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "description": "Create new ShareDB backend instance",
   "type": "module",
   "main": "index.js",
@@ -13,11 +13,11 @@
   },
   "dependencies": {
     "@startupjs/sharedb-mingo-memory": "^4.0.0-1",
-    "@teamplay/schema": "^0.3.18",
-    "@teamplay/server-aggregate": "^0.3.18",
-    "@teamplay/sharedb-access": "^0.3.18",
-    "@teamplay/sharedb-schema": "^0.3.18",
-    "@teamplay/utils": "^0.3.18",
+    "@teamplay/schema": "^0.3.20",
+    "@teamplay/server-aggregate": "^0.3.20",
+    "@teamplay/sharedb-access": "^0.3.20",
+    "@teamplay/sharedb-schema": "^0.3.20",
+    "@teamplay/utils": "^0.3.20",
     "@types/ioredis-mock": "^8.2.5",
     "ioredis": "^5.3.2",
     "ioredis-mock": "^8.9.0",
@@ -29,5 +29,5 @@
     "sharedb-redis-pubsub": "^2.0.1",
     "sqlite3": "^5.1.6"
   },
-  "gitHead": "5c3e2b44f536b53adfc94ead762834ab2e907858"
+  "gitHead": "689f247ff9f21f711737b6625d947c10b9562e3a"
 }

package/redis/getRedis.js

@@ -0,0 +1,49 @@
+import { readFileSync } from 'fs'
+import Redis from 'ioredis'
+import RedisMock from 'ioredis-mock'
+
+export { Redis, RedisMock }
+
+export function getRedis ({ enableRedis = true, redisOpts, redisUrl, keyPrefix }) {
+  if (enableRedis) {
+    if (typeof redisOpts === 'string') {
+      redisOpts = JSON.parse(redisOpts)
+      let tls = {}
+
+      if (redisOpts.key) {
+        tls = {
+          key: readFileSync(redisOpts.key),
+          cert: readFileSync(redisOpts.cert),
+          ca: readFileSync(redisOpts.ca)
+        }
+      }
+
+      const options = {
+        sentinels: redisOpts.sentinels,
+        sslPort: redisOpts.ssl_port || '6380',
+        tls,
+        name: 'mymaster',
+        db: redisOpts.db || 0,
+        password: redisOpts.password
+      }
+
+      _maybeAddKeyPrefixToOptions(options, keyPrefix)
+
+      return new Redis(options)
+    } else if (redisUrl) {
+      const options = {}
+      _maybeAddKeyPrefixToOptions(options, keyPrefix)
+
+      return new Redis(redisUrl, options)
+    }
+  }
+
+  const options = {}
+  _maybeAddKeyPrefixToOptions(options, keyPrefix)
+
+  return new RedisMock(options)
+}
+
+function _maybeAddKeyPrefixToOptions (options, keyPrefix) {
+  if (keyPrefix) options.keyPrefix = keyPrefix
+}

package/redis/index.js

@@ -1,21 +1,24 @@
-import { readFileSync } from 'fs'
-import Redis from 'ioredis'
-import RedisMock from 'ioredis-mock'
 import Redlock from 'redlock'
 import redisPubSub from 'sharedb-redis-pubsub'
+import { getRedis, Redis, RedisMock } from './getRedis.js'
 
-export const {
-  redis,
-  redisObserver
-} = getUniversalRedis({
-  disableRedis: process.env.NO_REDIS,
+const enableRedis = !process.env.NO_REDIS
+
+const getRedisOptions = {
+  enableRedis,
   redisOpts: process.env.REDIS_OPTS,
   redisUrl: process.env.REDIS_URL,
   keyPrefix: generatePrefix({
     mongoUrl: process.env.MONGO_URL,
     baseUrl: process.env.BASE_URL
   })
-})
+}
+
+const RedisClient = enableRedis ? Redis : RedisMock
+export { RedisClient as Redis }
+export { getRedis }
+export const redis = getRedis(getRedisOptions)
+export const redisObserver = getRedis(getRedisOptions)
 
 export const pubsub = redisPubSub({
   client: redis,
@@ -26,47 +29,6 @@ export const redlock = getRedlock(redis)
 
 export { Redlock }
 
-function getUniversalRedis ({ disableRedis, redisOpts, redisUrl, keyPrefix }) {
-  if (!disableRedis) {
-    if (typeof redisOpts === 'string') {
-      redisOpts = JSON.parse(redisOpts)
-      let tls = {}
-
-      if (redisOpts.key) {
-        tls = {
-          key: readFileSync(redisOpts.key),
-          cert: readFileSync(redisOpts.cert),
-          ca: readFileSync(redisOpts.ca)
-        }
-      }
-
-      const options = {
-        sentinels: redisOpts.sentinels,
-        sslPort: redisOpts.ssl_port || '6380',
-        tls,
-        name: 'mymaster',
-        db: redisOpts.db || 0,
-        password: redisOpts.password,
-        keyPrefix
-      }
-
-      return {
-        redis: new Redis(options),
-        redisObserver: new Redis(options)
-      }
-    } else if (redisUrl) {
-      return {
-        redis: new Redis(redisUrl, { keyPrefix }),
-        redisObserver: new Redis(redisUrl, { keyPrefix })
-      }
-    }
-  }
-  return {
-    redis: new RedisMock({ keyPrefix }),
-    redisObserver: new RedisMock({ keyPrefix })
-  }
-}
-
 function getRedlock (redis) {
   return new Redlock([redis], {
     driftFactor: 0.01,