@erxes/api-shared 0.0.0-stage → 3.2.19-1

package/src/core-modules/logs/activityLog/builder.ts

@@ -0,0 +1,232 @@
+import { sendTRPCMessage } from '../../../utils/trpc';
+import { normalizeDiffs } from '../activityLogUtils';
+import { Config } from './types';
+import {
+  detectAssignmentDelta,
+  findResolver,
+  getSnapshot,
+  logActivityLogError,
+  matchesFieldPattern,
+} from './utils';
+
+const PROPERTIES_DATA_PREFIX = 'propertiesData.';
+
+function resolveActivityTarget(document: any, config: Config, ctx: any) {
+  try {
+    if (typeof config?.buildTarget === 'function') {
+      return config.buildTarget(document, ctx);
+    }
+  } catch (error) {
+    logActivityLogError('resolveActivityTarget', error, {
+      subdomain: ctx?.subdomain,
+      targetId: document?._id,
+    });
+  }
+
+  return ctx?.activityTarget ?? ctx?.target;
+}
+
+async function buildPropertiesDataActivities(
+  changes: {
+    field: string;
+    prev: unknown;
+    current: unknown;
+    kind: 'set' | 'update' | 'array' | 'unset';
+  }[],
+  ctx: any,
+): Promise<any[]> {
+  try {
+    const propChanges = changes.filter(({ field }) =>
+      field.startsWith(PROPERTIES_DATA_PREFIX),
+    );
+    const activityTarget = ctx?.activityTarget ?? ctx?.target;
+
+    if (!propChanges.length || !ctx?.subdomain || !activityTarget) {
+      return [];
+    }
+
+    const fieldIds = propChanges.map(({ field }) =>
+      field.slice(PROPERTIES_DATA_PREFIX.length),
+    );
+
+    const fields: any[] = await sendTRPCMessage({
+      subdomain: ctx.subdomain,
+      pluginName: 'core',
+      method: 'query',
+      module: 'fields',
+      action: 'find',
+      input: {
+        query: { _id: { $in: fieldIds } },
+        projection: { name: 1, type: 1, options: 1 },
+        sort: {},
+      },
+      defaultValue: [],
+    });
+
+    const fieldMap = new Map(fields.map((f: any) => [String(f._id), f]));
+
+    const activities: any[] = [];
+
+    for (const { field, prev, current, kind } of propChanges) {
+      const fieldId = field.slice(PROPERTIES_DATA_PREFIX.length);
+      const fieldDef = fieldMap.get(fieldId);
+
+      if (!fieldDef) {
+        continue;
+      }
+
+      const isMultiSelectOrCheckbox = ['multiselect', 'checkbox'].includes(
+        fieldDef.type?.toLowerCase(),
+      );
+
+      if (isMultiSelectOrCheckbox && kind === 'array') {
+        const { added, removed } = detectAssignmentDelta(prev, current);
+
+        if (!added.length && !removed.length) {
+          continue;
+        }
+
+        activities.push({
+          activityType: 'property.field_changed',
+          target: activityTarget,
+          action: {
+            type: 'array',
+            description: `changed ${fieldDef.name}`,
+          },
+          changes: {
+            fieldId,
+            fieldName: fieldDef.name,
+            fieldType: fieldDef.type,
+            fieldOptions: fieldDef.options || [],
+            added,
+            removed,
+          },
+        });
+      } else {
+        activities.push({
+          activityType: 'property.field_changed',
+          target: activityTarget,
+          action: {
+            type: kind,
+            description:
+              kind === 'set'
+                ? `set ${fieldDef.name}`
+                : kind === 'unset'
+                  ? `cleared ${fieldDef.name}`
+                  : `changed ${fieldDef.name}`,
+          },
+          changes: {
+            fieldId,
+            fieldName: fieldDef.name,
+            fieldType: fieldDef.type,
+            fieldOptions: fieldDef.options || [],
+            prev,
+            current,
+          },
+        });
+      }
+    }
+
+    return activities;
+  } catch (error) {
+    logActivityLogError('buildPropertiesDataActivities', error, {
+      subdomain: ctx?.subdomain,
+      targetId: ctx?.activityTarget?._id ?? ctx?.target?._id,
+    });
+    return [];
+  }
+}
+
+export async function activityBuilder<TResult = any>(
+  prevDocument: any,
+  currentDocument: any,
+  config: Config<TResult>,
+  ctx: any,
+): Promise<TResult[]> {
+  const activities: TResult[] = [];
+  let changes: ReturnType<typeof normalizeDiffs> = [];
+  let assignmentFields: string[] = [];
+  let commonFields: string[] = [];
+  let resolvers: Record<string, any> = {};
+
+  try {
+    const prevSnapshot = getSnapshot(prevDocument);
+    const currentSnapshot = getSnapshot(currentDocument);
+
+    changes = normalizeDiffs(prevSnapshot, currentSnapshot);
+
+    ({
+      assignmentFields = [],
+      commonFields = [],
+      resolvers = {},
+    } = config || {});
+  } catch (error) {
+    logActivityLogError('activityBuilder setup', error, {
+      subdomain: ctx?.subdomain,
+      targetId: currentDocument?._id ?? prevDocument?._id,
+    });
+    return activities;
+  }
+
+  const activityTarget = resolveActivityTarget(currentDocument, config, ctx);
+
+  for (const change of changes) {
+    const { field, prev, current, kind } = change;
+
+    try {
+      const resolver = findResolver(field, resolvers);
+      if (!resolver) {
+        continue;
+      }
+
+      if (kind === 'array' && assignmentFields.includes(field)) {
+        const { added, removed } = detectAssignmentDelta(prev, current);
+
+        if (!added.length && !removed.length) {
+          continue;
+        }
+
+        const result = await resolver(
+          { field, added, removed },
+          { ...ctx, target: currentDocument, activityTarget },
+        );
+
+        if (Array.isArray(result) && result.length) {
+          activities.push(...result);
+        }
+
+        continue;
+      }
+
+      const isCommonField = commonFields.some((pattern) =>
+        matchesFieldPattern(pattern, field),
+      );
+
+      if (!isCommonField) {
+        continue;
+      }
+
+      const result = await resolver({ field, prev, current }, ctx);
+
+      if (Array.isArray(result) && result.length) {
+        activities.push(...result);
+      }
+    } catch (error) {
+      logActivityLogError('activityBuilder change', error, {
+        field,
+        subdomain: ctx?.subdomain,
+        targetId: activityTarget?._id ?? currentDocument?._id,
+      });
+    }
+  }
+
+  const propActivities = await buildPropertiesDataActivities(changes, {
+    ...ctx,
+    activityTarget,
+  });
+  if (propActivities.length) {
+    activities.push(...(propActivities as TResult[]));
+  }
+
+  return activities;
+}

package/src/core-modules/logs/activityLog/index.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './utils';
+export * from './builder';
+export * from './sharedBuilders';

package/src/core-modules/logs/activityLog/sharedBuilders.ts

@@ -0,0 +1,95 @@
+import { ActivityLogInput } from '../../common/eventHandlers';
+
+type AssignmentActivityType =
+  | 'branch.assigned'
+  | 'branch.unassigned'
+  | 'department.assigned'
+  | 'department.unassigned'
+  | 'position.assigned'
+  | 'position.unassigned'
+  | 'permission_group.assigned'
+  | 'permission_group.unassigned';
+
+type BuildEntityAssignmentActivityParams = {
+  activityType: AssignmentActivityType;
+  target: any;
+  context?: any;
+  ids: string[];
+  labels: string[];
+  entityLabel: string;
+  field: string;
+  metadata?: Record<string, any>;
+};
+
+const buildEntityAssignmentActivity = ({
+  activityType,
+  target,
+  context,
+  ids,
+  labels,
+  entityLabel,
+  field,
+  metadata,
+}: BuildEntityAssignmentActivityParams): ActivityLogInput => {
+  const [, action] = (activityType || '').split('.');
+  const isAssigned = action === 'assigned';
+
+  return {
+    activityType,
+    target,
+    context,
+    action: {
+      type: activityType,
+      description: isAssigned
+        ? `assigned ${entityLabel}`
+        : `removed ${entityLabel}`,
+    },
+    changes: {
+      [isAssigned ? 'added' : 'removed']: {
+        ids,
+        labels,
+      },
+    },
+    metadata: {
+      field,
+      entityLabel,
+      ...metadata,
+    },
+  };
+};
+
+export const buildBranchAssignmentActivity = (
+  params: Omit<BuildEntityAssignmentActivityParams, 'entityLabel' | 'field'>,
+) =>
+  buildEntityAssignmentActivity({
+    ...params,
+    entityLabel: 'branch',
+    field: 'branchIds',
+  });
+
+export const buildDepartmentAssignmentActivity = (
+  params: Omit<BuildEntityAssignmentActivityParams, 'entityLabel' | 'field'>,
+) =>
+  buildEntityAssignmentActivity({
+    ...params,
+    entityLabel: 'department',
+    field: 'departmentIds',
+  });
+
+export const buildPositionAssignmentActivity = (
+  params: Omit<BuildEntityAssignmentActivityParams, 'entityLabel' | 'field'>,
+) =>
+  buildEntityAssignmentActivity({
+    ...params,
+    entityLabel: 'position',
+    field: 'positionIds',
+  });
+
+export const buildPermissionGroupAssignmentActivity = (
+  params: Omit<BuildEntityAssignmentActivityParams, 'entityLabel' | 'field'>,
+) =>
+  buildEntityAssignmentActivity({
+    ...params,
+    entityLabel: 'permission group',
+    field: 'permissionGroupIds',
+  });

package/src/core-modules/logs/activityLog/types.ts

@@ -0,0 +1,26 @@
+export type Change = {
+  field: string;
+  prev: unknown;
+  current: unknown;
+  kind?: 'array' | 'value' | 'set' | 'unset' | 'update';
+};
+
+export type ResolverParams = {
+  field: string;
+  prev?: unknown;
+  current?: unknown;
+  added?: string[];
+  removed?: string[];
+};
+
+export type Resolver<TResult = any> = (
+  params: ResolverParams,
+  ctx: any,
+) => TResult[] | void | Promise<TResult[] | void>;
+
+export type Config<TResult = any> = {
+  assignmentFields?: string[];
+  commonFields: string[];
+  resolvers: Record<string, Resolver<TResult>>;
+  buildTarget?: (document: any, ctx: any) => any;
+};

package/src/core-modules/logs/activityLog/utils.ts

@@ -0,0 +1,61 @@
+import { Resolver } from './types';
+
+export function logActivityLogError(
+  scope: string,
+  error: unknown,
+  metadata?: Record<string, unknown>,
+) {
+  if (metadata && Object.keys(metadata).length > 0) {
+    console.error(`[activity-log] ${scope}`, error, metadata);
+    return;
+  }
+
+  console.error(`[activity-log] ${scope}`, error);
+}
+
+export function matchesFieldPattern(pattern: string, field: string) {
+  if (pattern === field) {
+    return true;
+  }
+
+  if (pattern.endsWith('.*')) {
+    const prefix = pattern.slice(0, -2);
+    return field.startsWith(`${prefix}.`);
+  }
+
+  return false;
+}
+
+export function findResolver<TResult = any>(
+  field: string,
+  resolvers: Record<string, Resolver<TResult>>,
+): Resolver<TResult> | undefined {
+  for (const key of Object.keys(resolvers)) {
+    if (key === '$default') {
+      continue;
+    }
+
+    if (matchesFieldPattern(key, field)) {
+      return resolvers[key];
+    }
+  }
+
+  return resolvers.$default;
+}
+
+export function detectAssignmentDelta(prev: unknown, current: unknown) {
+  const prevIds = Array.isArray(prev) ? prev.map(String) : [];
+  const currentIds = Array.isArray(current) ? current.map(String) : [];
+
+  const prevSet = new Set(prevIds);
+  const currentSet = new Set(currentIds);
+
+  return {
+    added: currentIds.filter((id) => !prevSet.has(id)),
+    removed: prevIds.filter((id) => !currentSet.has(id)),
+  };
+}
+
+export function getSnapshot(doc: any) {
+  return typeof doc?.toObject === 'function' ? doc.toObject() : doc;
+}