Use edge-server-tools utilities for db inits

Author: samholmes

package.json

@@ -49,6 +49,7 @@
     "csv-stringify": "^6.2.0",
     "date-fns": "^2.16.1",
     "date-fns-tz": "^1.1.4",
+    "edge-server-tools": "^0.2.19",
     "express": "^4.17.3",
     "nano": "^10.1.0",
     "node-fetch": "^2.6.7",

src/initDbs.ts

@@ -1,126 +1,104 @@
-import nano from 'nano'
+import {
+  DatabaseSetup,
+  JsDesignDocument,
+  makeMangoIndex,
+  MangoDesignDocument,
+  setupDatabase
+} from 'edge-server-tools'
 
 import { config } from './config'
-import { datelog } from './util'
 
-const nanoDb = nano(config.couchDbFullpath)
-
-const transactionIndexFields: string[][] = [
-  ['isoDate'],
-  ['status'],
-  ['status', 'depositCurrency', 'isoDate'],
-  ['status', 'depositCurrency', 'payoutCurrency', 'isoDate'],
-  ['status', 'isoDate'],
-  ['status', 'payoutAmount', 'depositAmount'],
-  ['status', 'payoutCurrency', 'isoDate'],
-  ['status', 'usdValue'],
-  ['status', 'usdValue', 'timestamp'],
-  ['usdValue'],
-  ['timestamp']
-]
-
-const transactionIndexFieldsNoPartition: string[][] = [
-  ['depositAddress'],
-  ['payoutAddress']
-]
-
-interface Index {
-  index: { fields: string[] }
-  ddoc: string
-  name: string
-  type: 'json'
-  partitioned: boolean
+interface DesignDocumentMap {
+  [designDocName: string]: MangoDesignDocument | JsDesignDocument
 }
 
-const transactionIndexes: Index[] = []
-
-transactionIndexFields.forEach(index => {
-  const indexLower = index.map(i => i.toLowerCase())
-  const out: Index = {
-    index: { fields: index },
-    ddoc: indexLower.join('-'),
-    name: indexLower.join('-'),
-    type: 'json',
+function fieldsToDesign(
+  fields: string[],
+  withPartitionVariant: boolean = true
+): DesignDocumentMap {
+  const indexLower = fields.map(i => i.toLowerCase())
+  const name = indexLower.join('-')
+  const out: DesignDocumentMap = {}
+  out[`_design/${name}`] = makeMangoIndex(name, fields, {
     partitioned: false
+  })
+  if (withPartitionVariant) {
+    out[`_design/${name}-p`] = makeMangoIndex(`${name}-p`, fields, {
+      partitioned: true
+    })
   }
-  transactionIndexes.push(out)
-  const out2 = { ...out }
-  out2.ddoc += '-p'
-  out2.name += '-p'
-  out2.partitioned = true
-  transactionIndexes.push(out2)
-})
+  return out
+}
 
-transactionIndexFieldsNoPartition.forEach(index => {
-  const indexLower = index.map(i => i.toLowerCase())
-  const out: Index = {
-    index: { fields: index },
-    ddoc: indexLower.join('-'),
-    name: indexLower.join('-'),
-    type: 'json',
-    partitioned: false
-  }
-  transactionIndexes.push(out)
-})
+const transactionIndexes: DesignDocumentMap = {
+  ...fieldsToDesign(['isoDate']),
+  ...fieldsToDesign(['status']),
+  ...fieldsToDesign(['status', 'depositCurrency', 'isoDate']),
+  ...fieldsToDesign(['status', 'depositCurrency', 'payoutCurrency', 'isoDate']),
+  ...fieldsToDesign(['status', 'isoDate']),
+  ...fieldsToDesign(['status', 'payoutAmount', 'depositAmount']),
+  ...fieldsToDesign(['status', 'payoutCurrency', 'isoDate']),
+  ...fieldsToDesign(['status', 'usdValue']),
+  ...fieldsToDesign(['status', 'usdValue', 'timestamp']),
+  ...fieldsToDesign(['usdValue']),
+  ...fieldsToDesign(['timestamp']),
+  ...fieldsToDesign(['depositAddress'], false),
+  ...fieldsToDesign(['payoutAddress'], false)
+}
 
-const cacheIndexes: Index[] = [
-  {
-    index: { fields: ['timestamp'] },
-    ddoc: 'timestamp-p',
-    name: 'timestamp-p',
-    type: 'json' as 'json',
+const cacheIndexes: DesignDocumentMap = {
+  '_design/timestamp-p': makeMangoIndex('timestamp-p', ['timestamp'], {
     partitioned: true
-  }
-]
-
-const options = { partitioned: true }
+  })
+}
 
-const DB_NAMES = [
-  { name: 'reports_apps' },
-  { name: 'reports_settings' },
-  {
-    name: 'reports_transactions',
-    options,
-    indexes: transactionIndexes
-  },
-  { name: 'reports_progresscache', options },
-  {
-    name: 'reports_hour',
-    options,
-    indexes: cacheIndexes
-  },
-  {
-    name: 'reports_day',
-    options,
-    indexes: cacheIndexes
-  },
-  {
-    name: 'reports_month',
-    options,
-    indexes: cacheIndexes
+const appsDatabaseSetup: DatabaseSetup = {
+  name: 'reports_apps'
+}
+const settingsDatabaseSetup: DatabaseSetup = {
+  name: 'reports_settings'
+}
+const transactionsDatabaseSetup: DatabaseSetup = {
+  name: 'reports_transactions',
+  options: { partitioned: true },
+  documents: {
+    ...transactionIndexes
   }
+}
+const progressCacheDatabaseSetup: DatabaseSetup = {
+  name: 'reports_progresscache',
+  options: { partitioned: true }
+}
+const hourDatabaseSetup: DatabaseSetup = {
+  name: 'reports_hour',
+  options: { partitioned: true },
+  documents: cacheIndexes
+}
+const dayDatabaseSetup: DatabaseSetup = {
+  name: 'reports_day',
+  options: { partitioned: true },
+  documents: cacheIndexes
+}
+const monthDatabaseSetup: DatabaseSetup = {
+  name: 'reports_month',
+  options: { partitioned: true },
+  documents: cacheIndexes
+}
+
+const databases = [
+  appsDatabaseSetup,
+  settingsDatabaseSetup,
+  transactionsDatabaseSetup,
+  progressCacheDatabaseSetup,
+  hourDatabaseSetup,
+  dayDatabaseSetup,
+  monthDatabaseSetup
 ]
 
 export async function initDbs(): Promise<void> {
-  // get a list of all databases within couchdb
-  const result = await nanoDb.db.list()
-  datelog(result)
-  // if database does not exist, create it
-  for (const dbName of DB_NAMES) {
-    if (!result.includes(dbName.name)) {
-      await nanoDb.db.create(dbName.name, dbName.options)
-    }
-    if (dbName.indexes !== undefined) {
-      const currentDb = nanoDb.db.use(dbName.name)
-      for (const dbIndex of dbName.indexes) {
-        try {
-          await currentDb.get(`_design/${dbIndex.ddoc}`)
-          datelog(`${dbName.name} already has '${dbIndex.name}' index.`)
-        } catch {
-          await currentDb.createIndex(dbIndex)
-          datelog(`Created '${dbIndex.name}' index for ${dbName.name}.`)
-        }
-      }
-    }
-  }
+  await Promise.all(
+    databases.map(
+      async setup => await setupDatabase(config.couchDbFullpath, setup)
+    )
+  )
 }