wip: Read+write new vault schema

See TODOs.

Author: ekzyis

api/resolvers/vault.js

@@ -17,6 +17,7 @@ export default {
     getVaultEntries: async (parent, { keysFilter }, { me, models }, info) => {
       if (!me) throw new GqlAuthenticationError()
 
+      // TODO: replace this usage because of new schema
       const entries = await models.vaultEntry.findMany({
         where: {
           userId: me.id,
@@ -52,6 +53,7 @@ export default {
       }
 
       for (const entry of entries) {
+        // TODO: replace this usage because of new schema
         txs.push(models.vaultEntry.update({
           where: { userId_key: { userId: me.id, key: entry.key } },
           data: { value: entry.value, iv: entry.iv }
@@ -67,6 +69,7 @@ export default {
         where: { id: me.id },
         data: { vaultKeyHash: '' }
       }))
+      // TODO: replace this usage because of new schema
       txs.push(models.vaultEntry.deleteMany({ where: { userId: me.id } }))
       await models.$transaction(txs)
       return true

api/resolvers/wallet.js

@@ -29,6 +29,7 @@ import { canReceive, getWalletByType } from '@/wallets/common'
 import performPaidAction from '../paidAction'
 import performPayingAction from '../payingAction'
 import { timeoutSignal, withTimeout } from '@/lib/time'
+import { deleteVault, hasVault, vaultNewSchematoTypedef, vaultPrismaFragments } from '@/wallets/vault'
 
 function injectResolvers (resolvers) {
   console.group('injected GraphQL resolvers:')
@@ -43,6 +44,7 @@ function injectResolvers (resolvers) {
         // this mutation was sent from an unsynced client
         // to pass validation, we need to add the existing vault entries for validation
         // in case the client is removing the receiving config
+        // TODO: replace this usage because of new schema
         existingVaultEntries = await models.vaultEntry.findMany({
           where: {
             walletId: Number(data.id)
@@ -159,17 +161,17 @@ const resolvers = {
         throw new GqlAuthenticationError()
       }
 
-      return await models.wallet.findMany({
-        include: {
-          vaultEntries: true
-        },
+      const wallets = await models.wallet.findMany({
+        include: vaultPrismaFragments().include,
         where: {
           userId: me.id
         },
         orderBy: {
           priority: 'asc'
         }
       })
+
+      return wallets.map(vaultNewSchematoTypedef)
     },
     withdrawl: getWithdrawl,
     direct: async (parent, { id }, { me, models }) => {
@@ -569,7 +571,11 @@ const resolvers = {
       }
 
       const logger = walletLogger({ wallet, models })
-      await models.wallet.delete({ where: { userId: me.id, id: Number(id) } })
+
+      await models.$transaction([
+        deleteVault(models, wallet),
+        models.wallet.delete({ where: { userId: me.id, id: Number(id) } })
+      ])
 
       if (canReceive({ def: getWalletByType(wallet.type), config: wallet.wallet })) {
         logger.info('details for receiving deleted')
@@ -838,15 +844,12 @@ async function upsertWallet (
 
   const txs = []
 
-  if (id) {
-    const oldVaultEntries = await models.vaultEntry.findMany({ where: { userId: me.id, walletId: Number(id) } })
+  const vaultFrags = vaultPrismaFragments({ ...wallet, vaultEntries })
 
-    // createMany is the set difference of the new - old
-    // deleteMany is the set difference of the old - new
-    // updateMany is the intersection of the old and new
-    const difference = (a = [], b = [], key = 'key') => a.filter(x => !b.find(y => y[key] === x[key]))
-    const intersectionMerge = (a = [], b = [], key = 'key') => a.filter(x => b.find(y => y[key] === x[key]))
-      .map(x => ({ [key]: x[key], ...b.find(y => y[key] === x[key]) }))
+  if (id) {
+    const dbWallet = await models.wallet.findUnique({
+      where: { id: Number(id), userId: me.id }
+    })
 
     txs.push(
       models.wallet.update({
@@ -859,57 +862,29 @@ async function upsertWallet (
             ? {
                 [wallet.field]: {
                   upsert: {
-                    create: recvConfig,
-                    update: recvConfig
-                  }
-                }
-              }
-            : {}),
-          ...(vaultEntries
-            ? {
-                vaultEntries: {
-                  deleteMany: difference(oldVaultEntries, vaultEntries, 'key').map(({ key }) => ({
-                    userId: me.id, key
-                  })),
-                  create: difference(vaultEntries, oldVaultEntries, 'key').map(({ key, iv, value }) => ({
-                    key, iv, value, userId: me.id
-                  })),
-                  update: intersectionMerge(oldVaultEntries, vaultEntries, 'key').map(({ key, iv, value }) => ({
-                    where: { userId_key: { userId: me.id, key } },
-                    data: { value, iv }
-                  }))
+                    create: { ...recvConfig, ...vaultFrags?.create },
+                    update: { ...recvConfig, ...vaultFrags?.upsert }
+                  },
+                  // XXX the check is required because the update would fail if there is no row to delete ...
+                  update: await hasVault(models, dbWallet) ? vaultFrags?.deleteOnUpdate : undefined
                 }
               }
             : {})
-
         },
-        include: {
-          vaultEntries: true
-        }
+        include: vaultFrags?.include
       })
     )
   } else {
     txs.push(
       models.wallet.create({
-        include: {
-          vaultEntries: true
-        },
+        include: vaultFrags?.include,
         data: {
           enabled,
           priority,
           userId: me.id,
           type: wallet.type,
           // client only wallets have no receive config and thus don't have their own table
-          ...(Object.keys(recvConfig).length > 0 ? { [wallet.field]: { create: recvConfig } } : {}),
-          ...(vaultEntries
-            ? {
-                vaultEntries: {
-                  createMany: {
-                    data: vaultEntries?.map(({ key, iv, value }) => ({ key, iv, value, userId: me.id }))
-                  }
-                }
-              }
-            : {})
+          ...(Object.keys(recvConfig).length > 0 ? { [wallet.field]: { create: { ...recvConfig, ...vaultFrags?.create } } } : {})
         }
       })
     )
@@ -946,7 +921,9 @@ async function upsertWallet (
   }
 
   const [upsertedWallet] = await models.$transaction(txs)
-  return upsertedWallet
+
+  // migrate from old schema to new schema for vault
+  return vaultNewSchematoTypedef(upsertedWallet)
 }
 
 export async function createWithdrawal (parent, { invoice, maxFee }, { me, models, lnd, headers, wallet, logger }) {

lib/object.js

@@ -0,0 +1,25 @@
+export const get = (obj, path) => {
+  if (!path) return obj
+  const keys = path.split('.')
+  return keys.reduce((obj, key) => obj?.[key], obj)
+}
+
+export const set = (obj, path, value) => {
+  const keys = path.split('.')
+  const lastKey = keys.pop()
+  const parent = get(obj, keys.join('.'))
+  parent[lastKey] = value
+}
+
+export const remove = (obj, path) => {
+  const keys = path.split('.')
+  const lastKey = keys.pop()
+  const parent = get(obj, keys.join('.'))
+  delete parent?.[lastKey]
+}
+
+export const move = (obj, fromPath, toPath) => {
+  const value = get(obj, fromPath)
+  remove(obj, fromPath)
+  set(obj, toPath, value)
+}

lib/object.spec.js

@@ -0,0 +1,47 @@
+/* eslint-env jest */
+
+import { get, move, remove, set } from './object'
+
+describe('object helpers', () => {
+  test.each([
+    [{ a: 'b' }, '', { a: 'b' }],
+    [{ a: 'b' }, 'a', 'b'],
+    [{ a: { b: { c: 'd' } } }, 'a.b', { c: 'd' }]
+  ])(
+    'gets a nested value: get(%p, %p) returns %p',
+    (obj, path, expected) => {
+      expect(get(obj, path)).toEqual(expected)
+    })
+
+  test.each([
+    [{ a: 'b' }, '', { a: 'b' }],
+    [{ a: { b: { c: 'd' } } }, 'a.b.c', 'e', { a: { b: { c: 'e' } } }]
+  ])(
+    'sets a nested value: set(%p, %p, %p) returns %p',
+    () => {
+      const obj = { a: { b: { c: 'd' } } }
+      set(obj, 'a.b.c', 'e')
+      expect(obj).toEqual({ a: { b: { c: 'e' } } })
+    })
+
+  test.each([
+    [{ a: 'b' }, 'a', {}],
+    [{ a: { b: { c: 'd' } } }, 'a.b.c', { a: { b: {} } }]
+  ])(
+    'removes a nested values: remove(%p, %p) returns %p',
+    (obj, path, expected) => {
+      remove(obj, path)
+      expect(obj).toEqual(expected)
+    })
+
+  test.each([
+    [{ a: { b1: { c: 'd' } } }, 'a.b1.c', 'a.b1.d', { a: { b1: { d: 'd' } } }],
+    [{ a: { b1: { c11: 'd1', c12: 'd2' }, b2: { c21: 'd3', c22: 'd4' } } }, 'a.b1.c11', 'a.b2.c22', { a: { b1: { c12: 'd2' }, b2: { c21: 'd3', c22: 'd1' } } }]
+  ])(
+    'moves a nested value: move(%p, %p, %p) returns %p',
+    (obj, fromPath, toPath, expected) => {
+      move(obj, fromPath, toPath)
+      expect(obj).toEqual(expected)
+    }
+  )
+})

wallets/blink/index.js

@@ -16,7 +16,8 @@ export const fields = [
       .matches(/^blink_[A-Za-z0-9]+$/, { message: 'must match pattern blink_A-Za-z0-9' }),
     help: `you can get an API key from [Blink Dashboard](${galoyBlinkDashboardUrl}).\nPlease make sure to select ONLY the 'Read' and 'Write' scopes when generating this API key.`,
     requiredWithout: 'apiKeyRecv',
-    optional: 'for sending'
+    optional: 'for sending',
+    TODO_newName: 'apiKeySend'
   },
   {
     name: 'currency',
@@ -32,7 +33,8 @@ export const fields = [
       .transform(value => value ? value.toUpperCase() : 'BTC')
       .oneOf(['USD', 'BTC'], 'must be BTC or USD'),
     optional: 'for sending',
-    requiredWithout: 'currencyRecv'
+    requiredWithout: 'currencyRecv',
+    TODO_newName: 'currencySend'
   },
   {
     name: 'apiKeyRecv',

wallets/nwc/index.js

@@ -15,7 +15,8 @@ export const fields = [
     optional: 'for sending',
     clientOnly: true,
     requiredWithout: 'nwcUrlRecv',
-    validate: string().nwcUrl()
+    validate: string().nwcUrl(),
+    TODO_newName: 'nwcUrlSend'
   },
   {
     name: 'nwcUrlRecv',