fix: set manuallyChangedFields on member attributes update

Author: skwowet

backend/src/database/repositories/member/memberAttributesRepository.ts

@@ -1,8 +1,12 @@
 /* eslint-disable no-continue */
 import { LoggerBase } from '@crowd/logging'
 import { IAttributes } from '@crowd/types'
+import * as lodash from 'lodash'
 
-import MemberAttributesRepository from '@/database/repositories/member/memberAttributesRepository'
+import { captureApiChange, memberEditProfileAction } from '@crowd/audit-logs'
+import { Error404 } from '@crowd/common'
+import { fetchMemberAttributes, getMemberManuallyChangedFields, setMemberManuallyChangedFields, updateMemberAttributes } from '@crowd/data-access-layer/src/members'
+import SequelizeRepository from '@/database/repositories/sequelizeRepository'
 
 import { IServiceOptions } from '../IServiceOptions'
 
@@ -16,11 +20,58 @@ export default class MemberAttributesService extends LoggerBase {
 
   // Member attributes
   async list(memberId: string): Promise<IAttributes> {
-    return MemberAttributesRepository.list(memberId, this.options)
+    const qx = SequelizeRepository.getQueryExecutor(this.options)
+
+    // Get member attributes
+    const result = await fetchMemberAttributes(qx, memberId)
+    if (!result.length) {
+      throw new Error404('Attributes not found for the given member!')
+    }
+
+    return result
   }
 
   // Update member attributes
   async update(memberId: string, data: IAttributes): Promise<IAttributes> {
-    return MemberAttributesRepository.update(memberId, data, this.options)
+    const qx = SequelizeRepository.getQueryExecutor(this.options)
+
+    const currentMemberAttributes = await fetchMemberAttributes(qx, memberId)
+    if (!currentMemberAttributes) {
+      throw new Error404('Attributes not found for the given member!')
+    }
+
+    const existingManuallyChangedFields = (await getMemberManuallyChangedFields(qx, memberId)) || []
+
+    const updatedManuallyChangedFields = [...existingManuallyChangedFields]
+
+    const result = await captureApiChange(
+      this.options,
+      memberEditProfileAction(memberId, async (captureOldState, captureNewState) => {
+        captureOldState({ attributes: currentMemberAttributes })
+
+        for (const key of Object.keys(data)) {
+          if (
+            !currentMemberAttributes[key] ||
+            !lodash.isEqual(currentMemberAttributes[key].default, data[key].default)
+          ) {
+            const fieldName = `attributes.${key}`
+            if (!updatedManuallyChangedFields.includes(fieldName)) {
+              updatedManuallyChangedFields.push(fieldName)
+            }
+          }
+        }
+
+        await updateMemberAttributes(qx, memberId, data)
+
+        await setMemberManuallyChangedFields(qx, memberId, updatedManuallyChangedFields)
+
+        captureNewState({ attributes: data })
+
+        // Get updated member attributes
+        return fetchMemberAttributes(qx, memberId)
+      }),
+    )
+
+    return result
   }
 }

backend/src/services/member/memberAttributesService.ts

@@ -59,7 +59,6 @@ export const connectSocket = (token) => {
   });
 
   socketIoClient.on(SocketEvents.memberMerge, (data) => {
-    console.info('Member merge done', data);
     const parsedData = JSON.parse(data);
     if (!parsedData.success) {
       return;

frontend/src/modules/auth/auth.socket.ts

@@ -604,17 +604,18 @@ export default class MemberService extends LoggerBase {
     let attributes: Record<string, unknown> | undefined
     if (member.attributes) {
       const temp = mergeWith({}, dbMember.attributes, member.attributes)
-
       const manuallyChangedFields: string[] = dbMember.manuallyChangedFields || []
+
       if (manuallyChangedFields.length > 0) {
-        const attrColumn = 'attributes'
-        const manuallyChangedAttributes = (dbMember.manuallyChangedFields || [])
-          .filter((f) => f.startsWith(attrColumn))
-          .map((f) => f.substring(attrColumn.length))
+        const prefix = 'attributes.'
+
+        const manuallyChangedAttributes = manuallyChangedFields
+          .filter((f) => f.startsWith(prefix))
+          .map((f) => f.slice(prefix.length))
 
         // Preserve manually changed attributes
         for (const key of manuallyChangedAttributes) {
-          if (dbMember.attributes[key] !== undefined) {
+          if (dbMember.attributes?.[key] !== undefined) {
             temp[key] = dbMember.attributes[key]
           }
         }

services/apps/data_sink_worker/src/service/member.service.ts

@@ -1,12 +1,12 @@
-import { IAttributes, IMember } from '@crowd/types'
+import { IAttributes } from '@crowd/types'
 
 import { QueryExecutor } from '../queryExecutor'
 
 export async function fetchMemberAttributes(
   qx: QueryExecutor,
   memberId: string,
-): Promise<Partial<IMember>[]> {
-  return qx.select(
+): Promise<IAttributes> {
+  const result = await qx.select(
     `
       SELECT attributes
       FROM "members"
@@ -17,6 +17,8 @@ export async function fetchMemberAttributes(
       memberId,
     },
   )
+
+  return result[0]?.attributes
 }
 
 export async function updateMemberAttributes(

services/libs/data-access-layer/src/members/attributes.ts

@@ -82,3 +82,38 @@ export async function updateMemberReach(
 export async function touchMemberUpdatedAt(qx: QueryExecutor, memberId: string): Promise<void> {
   return qx.result(`UPDATE members SET "updatedAt" = NOW() WHERE id = $(memberId)`, { memberId })
 }
+
+export async function getMemberManuallyChangedFields(
+  qx: QueryExecutor,
+  memberId: string,
+): Promise<string[]> {
+  return qx.select(
+    `
+      SELECT "manuallyChangedFields"
+      FROM "members"
+      WHERE "id" = $(memberId)
+      LIMIT 1;
+    `,
+    {
+      memberId,
+    },
+  )
+}
+
+export async function setMemberManuallyChangedFields(
+  qx: QueryExecutor,
+  memberId: string,
+  fields: string[],
+): Promise<void> {
+  return qx.result(
+    `
+      UPDATE "members"
+      SET "manuallyChangedFields" = $(fields)
+      WHERE "id" = $(memberId)
+    `,
+    {
+      memberId,
+      fields,
+    },
+  )
+}