fixup! Create couch cleanup files for Device and User models

Author: GoodluckH

src/db/couchDevices.ts

@@ -1,9 +1,12 @@
 import { asNumber, asObject, asOptional, asString } from 'cleaners'
-import { asCouchDoc, asMaybeNotFoundError } from 'edge-server-tools'
+import {
+  asCouchDoc,
+  asMaybeNotFoundError,
+  DatabaseSetup
+} from 'edge-server-tools'
 import { ServerScope } from 'nano'
 
 import { Device } from '../types/pushTypes'
-import { devicesSetup } from './couchSetup'
 import { saveToDB } from './utils/couchOps'
 
 export const asCouchDevice = asCouchDoc<Omit<Device, 'deviceId'>>(
@@ -18,6 +21,7 @@ export const asCouchDevice = asCouchDoc<Omit<Device, 'deviceId'>>(
 )
 
 type CouchDevice = ReturnType<typeof asCouchDevice>
+export const devicesSetup: DatabaseSetup = { name: 'db_devices' }
 
 export const fetchDevice = async (
   connection: ServerScope,

src/db/couchSetup.ts

@@ -1,13 +1,14 @@
 import {
   DatabaseSetup,
-  makeJsDesign,
   setupDatabase,
   SetupDatabaseOptions
 } from 'edge-server-tools'
 import { ServerScope } from 'nano'
 
 import { serverConfig } from '../serverConfig'
+import { devicesSetup } from './couchDevices'
 import { settingsSetup, syncedReplicators } from './couchSettings'
+import { usersSetup } from './couchUsers'
 
 // ---------------------------------------------------------------------------
 // Databases
@@ -17,42 +18,6 @@ export const apiKeysSetup: DatabaseSetup = { name: 'db_api_keys' }
 
 export const thresholdsSetup: DatabaseSetup = { name: 'db_currency_thresholds' }
 
-export const devicesSetup: DatabaseSetup = { name: 'db_devices' }
-
-export const usersSetup: DatabaseSetup = {
-  name: 'db_user_settings',
-  documents: {
-    '_design/filter': makeJsDesign('by-currency', ({ emit }) => ({
-      map: function (doc) {
-        const notifs = doc.notifications
-        if (notifs?.enabled && notifs.currencyCodes) {
-          const codes = notifs.currencyCodes
-          for (const currencyCode in codes) {
-            for (const hours in codes[currencyCode]) {
-              const enabled = codes[currencyCode][hours]
-              if (enabled) {
-                emit([currencyCode, hours], doc.devices)
-              }
-            }
-          }
-        }
-      }
-    })),
-    '_design/map': makeJsDesign('currency-codes', ({ emit }) => ({
-      map: function (doc) {
-        if (doc.notifications?.currencyCodes) {
-          for (const code in doc.notifications.currencyCodes) {
-            emit(null, code)
-          }
-        }
-      },
-      reduce: function (keys, values, rereduce) {
-        return Array.from(new Set(values))
-      }
-    }))
-  }
-}
-
 export const defaultsSetup: DatabaseSetup = {
   name: 'defaults'
   // syncedDocuments: ['thresholds']

src/db/couchUsers.ts

@@ -1,17 +1,20 @@
 import { asBoolean, asMap, asObject, asOptional, Cleaner } from 'cleaners'
-import { asCouchDoc, asMaybeNotFoundError } from 'edge-server-tools'
+import {
+  asCouchDoc,
+  asMaybeNotFoundError,
+  DatabaseSetup,
+  makeJsDesign
+} from 'edge-server-tools'
 import { ServerScope } from 'nano'
 
 import {
-  Device,
   User,
   UserCurrencyCodes,
   UserCurrencyHours,
   UserDevices,
   UserNotifications
 } from '../types/pushTypes'
-import { asCouchDevice, unpackDevice } from './couchDevices'
-import { devicesSetup, usersSetup } from './couchSetup'
+import { asCouchDevice, devicesSetup, unpackDevice } from './couchDevices'
 import { saveToDB } from './utils/couchOps'
 
 export const asUserDevices: Cleaner<UserDevices> = asObject(asBoolean)
@@ -39,39 +42,44 @@ export const asCouchUser = asCouchDoc<Omit<User, 'userId'>>(
 
 type CouchUser = ReturnType<typeof asCouchUser>
 
+export const usersSetup: DatabaseSetup = {
+  name: 'db_user_settings',
+  documents: {
+    '_design/filter': makeJsDesign('by-currency', ({ emit }) => ({
+      map: function (doc) {
+        const notifs = doc.notifications
+        if (notifs?.enabled && notifs.currencyCodes) {
+          const codes = notifs.currencyCodes
+          for (const currencyCode in codes) {
+            for (const hours in codes[currencyCode]) {
+              const enabled = codes[currencyCode][hours]
+              if (enabled) {
+                emit([currencyCode, hours], doc.devices)
+              }
+            }
+          }
+        }
+      }
+    })),
+    '_design/map': makeJsDesign('currency-codes', ({ emit }) => ({
+      map: function (doc) {
+        if (doc.notifications?.currencyCodes) {
+          for (const code in doc.notifications.currencyCodes) {
+            emit(null, code)
+          }
+        }
+      },
+      reduce: function (keys, values, rereduce) {
+        return Array.from(new Set(values))
+      }
+    }))
+  }
+}
+
 // ------------------------------------------------------------------------------
 // Functions associated with User
 // ------------------------------------------------------------------------------
 
-export const registerNotifications = async (
-  connection: ServerScope,
-  userId: string,
-  currencyCodes: string[]
-): Promise<void> => {
-  const db = connection.db.use(usersSetup.name)
-  const raw = await db.get(userId).catch(error => {
-    if (asMaybeNotFoundError(error) != null) return
-    throw error
-  })
-  const user = asCouchUser(raw)
-
-  const currencyCodesToUnregister = Object.keys(
-    user.doc.notifications.currencyCodes
-  ).filter(code => !currencyCodes.includes(code))
-  for (const code of currencyCodesToUnregister) {
-    delete user.doc.notifications.currencyCodes[code]
-  }
-
-  for (const code of currencyCodes) {
-    if (code in user.doc.notifications.currencyCodes) continue
-
-    user.doc.notifications.currencyCodes[code] = {
-      '1': true,
-      '24': true
-    }
-  }
-  await saveToDB(db, user, asCouchUser)
-}
 export const devicesByCurrencyHours = async (
   connection: ServerScope,
   hours: string,
@@ -124,41 +132,6 @@ export const saveUserToDB = async (
   await saveToDB(db, userDoc, asCouchUser)
 }
 
-export const fetchDevices = async (
-  connection: ServerScope,
-  userId: string
-): Promise<Device[]> => {
-  const db = connection.db.use(usersSetup.name)
-  const deviceConnection = connection.db.use(devicesSetup.name)
-  const raw = await db.get(userId).catch(error => {
-    if (asMaybeNotFoundError(error) != null) return
-    throw error
-  })
-  const userDoc = asCouchUser(raw)
-  const devices: Device[] = []
-
-  let updated = false
-  for (const deviceId in userDoc.doc.devices) {
-    const raw = await deviceConnection.get(deviceId).catch(error => {
-      if (asMaybeNotFoundError(error) != null) return
-      throw error
-    })
-    const deviceDoc = asCouchDevice(raw)
-    const device = unpackDevice(deviceDoc)
-    if (device != null) {
-      devices.push(device)
-      continue
-    }
-
-    delete userDoc.doc.devices[deviceId]
-    updated = true
-  }
-
-  if (updated) await saveToDB(db, userDoc, asCouchUser)
-
-  return devices
-}
-
 export const fetchUser = async (
   connection: ServerScope,
   userId: string

src/price-script/checkPriceChanges.ts

@@ -2,7 +2,7 @@ import io from '@pm2/io'
 import { MetricType } from '@pm2/io/build/main/services/metrics'
 import { ServerScope } from 'nano'
 
-import { devicesSetup } from '../db/couchSetup'
+import { devicesSetup } from '../db/couchDevices'
 import { devicesByCurrencyHours } from '../db/couchUsers'
 import { CurrencyThreshold } from '../models/CurrencyThreshold'
 import { NotificationManager } from '../NotificationManager'

src/server/controllers/NotificationController.ts

@@ -1,11 +1,18 @@
 /* eslint-disable @typescript-eslint/no-misused-promises */
 import { asMap, asObject, asOptional, asString, asUnknown } from 'cleaners'
+import { asMaybeNotFoundError } from 'edge-server-tools'
 import express from 'express'
 import nano from 'nano'
 
-import { fetchDevices, fetchUser } from '../../db/couchUsers'
+import {
+  asCouchDevice,
+  devicesSetup,
+  unpackDevice
+} from '../../db/couchDevices'
+import { fetchUser, saveUserToDB } from '../../db/couchUsers'
 import { NotificationManager } from '../../NotificationManager'
 import { serverConfig } from '../../serverConfig'
+import { Device } from '../../types/pushTypes'
 
 export const NotificationController = express.Router()
 const { couchUri } = serverConfig
@@ -30,7 +37,30 @@ NotificationController.post('/send', async (req, res) => {
     if (user == null) return res.status(404).send('User does not exist.')
 
     const tokens: string[] = []
-    const devices = await fetchDevices(connection, userId)
+    const devices: Device[] = []
+
+    let updated = false
+    for (const deviceId in user.devices) {
+      const raw = await connection.db
+        .use(devicesSetup.name)
+        .get(deviceId)
+        .catch(error => {
+          if (asMaybeNotFoundError(error) != null) return
+          throw error
+        })
+      const deviceDoc = asCouchDevice(raw)
+      const device = unpackDevice(deviceDoc)
+      if (device != null) {
+        devices.push(device)
+        continue
+      }
+
+      delete user.devices[deviceId]
+      updated = true
+    }
+
+    if (updated) await saveUserToDB(connection, user)
+
     for (const device of devices) {
       if (device.tokenId != null) {
         tokens.push(device.tokenId)

src/server/controllers/UserController.ts

@@ -7,7 +7,6 @@ import {
   attachDevice,
   fetchUser,
   packUser,
-  registerNotifications,
   saveUserToDB
 } from '../../db/couchUsers'
 import { serverConfig } from '../../serverConfig'
@@ -87,7 +86,23 @@ UserController.post('/notifications', async (req, res) => {
 
     const user = await fetchUser(connection, userId)
 
-    await registerNotifications(connection, userId, currencyCodes)
+    const currencyCodesToUnregister = Object.keys(
+      user.notifications.currencyCodes
+    ).filter(code => !currencyCodes.includes(code))
+    for (const code of currencyCodesToUnregister) {
+      delete user.notifications.currencyCodes[code]
+    }
+
+    for (const code of currencyCodes) {
+      if (code in user.notifications.currencyCodes) continue
+
+      user.notifications.currencyCodes[code] = {
+        '1': true,
+        '24': true
+      }
+    }
+
+    await saveUserToDB(connection, user)
 
     console.log(
       `Registered notifications for user ${userId}: ${String(currencyCodes)}`