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

package/src/core-modules/common/eventHandlers/types.ts

@@ -0,0 +1,97 @@
+import { LogEventInput } from './schemas';
+import { INotificationData } from '../../notifications';
+export enum DbLogActions {
+  CREATE = 'create',
+  UPDATE = 'update',
+  DELETE = 'delete',
+  UPDATE_MANY = 'updateMany',
+  BULK_WRITE = 'bulkWrite',
+  DELETE_MANY = 'deleteMany',
+}
+
+export type ActivityLogInput = {
+  activityType: string;
+  sourcePlugin?: string;
+  target: any;
+  /** What the entry happened inside of: a campaign, an automation. */
+  contextType?: string;
+  context?: any;
+  action: any;
+  changes: any;
+  metadata?: any;
+};
+
+export type EventDispatcherReturn = {
+  /**
+   * Send log event for document operations (single or bulk).
+   *
+   * @param input - Event input with action-specific structure:
+   *   - create: `{ action: 'create', docId: string, currentDocument: any, prevDocument?: any }`
+   *   - update: `{ action: 'update', docId: string, currentDocument: any, prevDocument: any }`
+   *   - delete: `{ action: 'delete', docId: string }`
+   *   - deleteMany: `{ action: 'deleteMany', docIds: string[] }`
+   *   - updateMany: `{ action: 'updateMany', docIds: string | string[], updateDescription: Record<string, any> }`
+   *   - bulkWrite: `{ action: 'bulkWrite', docIds: string | string[], updateDescription: Record<string, any> }`
+   *
+   * @example
+   * ```ts
+   * sendDbEventLog({ action: 'create', docId: '123', currentDocument: {...} })
+   * sendDbEventLog({ action: 'update', docId: '123', currentDocument: {...}, prevDocument: {...} })
+   * ```
+   */
+  sendDbEventLog: (input: LogEventInput) => void;
+  /**
+   * Send automation trigger for document changes.
+   *
+   * @param params - Configuration object
+   * @param params.targets - Single document or array of documents to trigger automation for
+   * @param params.recordType - Operation type: 'new' for created records, 'existing' for updated records
+   */
+  sendAutomationTriggerTarget: (params: {
+    targets: any[];
+    recordType: 'new' | 'existing';
+  }) => any;
+  createActivityLog: (
+    input: ActivityLogInput | ActivityLogInput[],
+    duserId?: string,
+  ) => any;
+  sendNotificationMessage: (
+    notificationData: { userIds: string[] } & Partial<INotificationData>,
+  ) => any;
+
+  getContext: () => {
+    subdomain: string;
+    processId?: string;
+    userId?: string;
+  };
+};
+
+export interface ICreateEventHandlersParams {
+  subdomain: string;
+  pluginName: string;
+  moduleName: string;
+  collectionName: string;
+  getContext: () => {
+    subdomain: string;
+    processId: string;
+    userId: string;
+  };
+}
+
+export type ScopedEventHandlers = (
+  pluginName: string,
+) => (moduleName: string, collectionName: string) => EventDispatcherReturn;
+
+export type TLogEventPayload = {
+  docIds?: string | string[];
+  docId?: string;
+  updateDescription?: Record<string, any>;
+  processId?: string;
+  userId?: string;
+  source: string;
+  action: string;
+  status: string;
+  contentType: string;
+  subdomain: string;
+  payload?: any;
+};

package/src/core-modules/common/eventHandlers/utils.ts

@@ -0,0 +1,113 @@
+import { getDiffObjects } from '../../../utils/utils';
+import { LogEventInput } from './schemas';
+
+export const normalizeLogEventInput = (input: any): any => {
+  if (!input || typeof input !== 'object') {
+    return input;
+  }
+
+  const toIdString = (v: any) => {
+    if (v == null) return v;
+    if (typeof v === 'string') return v;
+    if (typeof v === 'number') return String(v);
+    if (typeof v === 'object' && typeof v.toString === 'function') {
+      return String(v.toString());
+    }
+    return String(v);
+  };
+
+  const out: any = { ...input };
+
+  if ('docId' in out) {
+    out.docId = toIdString(out.docId);
+  }
+
+  if ('docIds' in out) {
+    if (Array.isArray(out.docIds)) {
+      out.docIds = out.docIds.map(toIdString);
+    } else {
+      out.docIds = toIdString(out.docIds);
+    }
+  }
+
+  return out;
+};
+
+export const generateDbEventPayload = (
+  input: LogEventInput,
+  collectionName: string,
+) => {
+  if (input.action === 'create') {
+    return {
+      ...input,
+      collectionName: collectionName,
+      fullDocument: input.currentDocument,
+    };
+  }
+
+  if (input.action === 'update') {
+    return {
+      ...input,
+      collectionName: collectionName,
+      updateDescription: getDiffObjects(
+        input.prevDocument,
+        input.currentDocument,
+      ),
+    };
+  }
+  if (input.action === 'delete') {
+    return {
+      collectionName: collectionName,
+      docId: input.docId,
+      prevDocument: input.prevDocument,
+    };
+  }
+  if (input.action === 'updateMany') {
+    return {
+      collectionName: collectionName,
+      updateDescription: input.updateDescription,
+    };
+  }
+  if (input.action === 'bulkWrite') {
+    return {
+      collectionName: collectionName,
+      updateDescription: input.updateDescription,
+    };
+  }
+  if (input.action === 'deleteMany') {
+    return {
+      collectionName: collectionName,
+      prevDocuments: input.prevDocuments,
+    };
+  }
+};
+
+export const generateAutomationTriggerPayload = (
+  input: LogEventInput,
+  contentType: string,
+  eventUpdateDescription?: Record<string, any>,
+):
+  | {
+      type: string;
+      targets: any[];
+      recordType: 'new' | 'existing';
+      eventUpdateDescription?: Record<string, any>;
+    }
+  | undefined => {
+  if (input.action === 'create') {
+    return {
+      type: contentType,
+      targets: [input.currentDocument],
+      recordType: 'new',
+      eventUpdateDescription,
+    };
+  }
+  if (input.action === 'update') {
+    return {
+      type: contentType,
+      targets: [input.currentDocument],
+      recordType: 'existing',
+      eventUpdateDescription,
+    };
+  }
+};

package/src/core-modules/common/index.ts

@@ -0,0 +1,4 @@
+export * from './db/definitions/common';
+export * from './references';
+export * from './routeToModuleProducer';
+export * from './eventHandlers';

package/src/core-modules/common/references/fetchRecordReferenceTargets.ts

@@ -0,0 +1,43 @@
+import { TRecordReferencesConfig } from './types';
+import { asArray, getLocalRecordReferenceType } from './utils';
+
+export const fetchRecordReferenceTargets = async ({
+  config,
+  models,
+  pluginName,
+  subdomain,
+  type,
+  targetId,
+  targetIds,
+}: {
+  config: TRecordReferencesConfig;
+  models: any;
+  pluginName: string;
+  subdomain: string;
+  type: string;
+  targetId?: string;
+  targetIds?: string[];
+}) => {
+  const localType = getLocalRecordReferenceType(pluginName, type);
+  const fetcher = config.fetchers?.[localType];
+
+  if (!fetcher) {
+    return [];
+  }
+
+  const ids = targetIds?.length ? targetIds : targetId ? [targetId] : [];
+
+  if (!ids.length) {
+    return [];
+  }
+
+  const result = await fetcher({
+    models,
+    subdomain,
+    type: localType,
+    id: ids[0],
+    ids,
+  });
+
+  return asArray(result);
+};

package/src/core-modules/common/references/getRecordReferenceFields.ts

@@ -0,0 +1,243 @@
+import { propertyDataPath, toPropertyRowKey } from '../../properties/keys';
+import { getPlugin, getPlugins } from '../../../utils';
+import {
+  normalizeRecordReferenceExtensions,
+  normalizeRecordReferenceTypes,
+} from './normalizeRecordReferenceConfig';
+import {
+  TRecordReferenceExtension,
+  TRecordReferenceField,
+  TRecordReferenceType,
+} from './types';
+import { isSameRecordReferenceType } from './utils';
+
+type TRecordReferenceMetadata = {
+  types: TRecordReferenceType[];
+  extensions: TRecordReferenceExtension[];
+};
+
+export type TRecordReferenceOutputField = {
+  key: string;
+  label: string;
+  type?: string;
+  field?: string;
+  exposure?: 'reference';
+  referenceType?: string;
+  sourceType?: string;
+  referenceFields?: TRecordReferenceOutputField[];
+};
+
+type TPropertyField = {
+  _id: string | { toString: () => string };
+  code?: string;
+  label?: string;
+  name?: string;
+  text?: string;
+  type?: string;
+  groupId?: string;
+};
+
+type TPropertyGroup = {
+  _id: string | { toString: () => string };
+  name?: string;
+};
+
+type TPropertyFieldsQuery = {
+  sort: (sort: { order: 1; code: 1 }) => {
+    lean: () => Promise<TPropertyField[]>;
+  };
+};
+
+type TReferenceFieldsModels = {
+  Fields?: {
+    find: (filter: { contentType: string }) => TPropertyFieldsQuery;
+  };
+  FieldsGroups?: {
+    find: (filter: { contentType: string; 'configs.isMultiple': true }) => {
+      lean: () => Promise<TPropertyGroup[]>;
+    };
+  };
+};
+
+type TRecordReferencesConfigMetadata = {
+  types?: TRecordReferenceType[];
+  extensions?: TRecordReferenceExtension[];
+};
+
+type TGetRecordReferenceFieldsProps = {
+  models?: TReferenceFieldsModels;
+  type: string;
+};
+
+const findRecordReferenceType = (
+  referenceTypes: TRecordReferenceType[],
+  type: string,
+) =>
+  referenceTypes.find((referenceType) =>
+    isSameRecordReferenceType(referenceType.type, type),
+  );
+
+const getRecordReferenceMetadata =
+  async (): Promise<TRecordReferenceMetadata> => {
+    const types: TRecordReferenceType[] = [];
+    const extensions: TRecordReferenceExtension[] = [];
+    const plugins = await getPlugins();
+
+    for (const pluginName of plugins) {
+      const plugin = await getPlugin(pluginName);
+      const references = plugin.config?.meta
+        ?.references as TRecordReferencesConfigMetadata;
+
+      types.push(
+        ...normalizeRecordReferenceTypes(pluginName, references?.types || []),
+      );
+      extensions.push(
+        ...normalizeRecordReferenceExtensions(
+          pluginName,
+          references?.extensions || [],
+        ),
+      );
+    }
+
+    return { types, extensions };
+  };
+
+const applyRecordReferenceExtensions = ({
+  extensions,
+  types,
+}: TRecordReferenceMetadata): TRecordReferenceType[] => {
+  const referenceTypes = types.map((referenceType) => ({
+    ...referenceType,
+    fields: [...(referenceType.fields || [])],
+  }));
+
+  for (const extension of extensions) {
+    const referenceType = referenceTypes.find((item) =>
+      isSameRecordReferenceType(item.type, extension.type),
+    );
+
+    if (referenceType) {
+      referenceType.fields.push(...(extension.fields || []));
+      continue;
+    }
+
+    referenceTypes.push({
+      type: extension.type,
+      label: extension.type,
+      fields: [...(extension.fields || [])],
+    });
+  }
+
+  return referenceTypes;
+};
+
+const toRecordReferenceOutputField = (
+  field: TRecordReferenceField,
+  referenceTypes: TRecordReferenceType[],
+  sourceType?: string,
+): TRecordReferenceOutputField => {
+  const referenceType = field.reference?.type
+    ? findRecordReferenceType(referenceTypes, field.reference.type)?.type ||
+      field.reference.type
+    : undefined;
+
+  return {
+    key: field.key,
+    label: field.label,
+    exposure: field.reference || field.fields?.length ? 'reference' : undefined,
+    field: field.reference?.path || field.path || field.key,
+    referenceFields: field.fields?.map((nestedField) =>
+      toRecordReferenceOutputField(nestedField, referenceTypes),
+    ),
+    referenceType,
+    sourceType,
+  };
+};
+
+const getCustomRecordReferenceFields = async (
+  models: TReferenceFieldsModels | undefined,
+  referenceType: string,
+): Promise<TRecordReferenceOutputField[]> => {
+  if (!models?.Fields) {
+    return [];
+  }
+
+  const fields = await models.Fields.find({ contentType: referenceType })
+    .sort({ order: 1, code: 1 })
+    .lean();
+
+  const repeatingGroups = models.FieldsGroups
+    ? await models.FieldsGroups.find({
+        contentType: referenceType,
+        'configs.isMultiple': true,
+      }).lean()
+    : [];
+
+  const groupNameById = new Map(
+    repeatingGroups.map((group) => [String(group._id), group.name || '']),
+  );
+
+  return fields.map((field) => {
+    const fieldId = String(field._id);
+    const groupId = field.groupId ? String(field.groupId) : '';
+    const groupName = groupNameById.get(groupId);
+    const label =
+      field.label || field.text || field.name || field.code || fieldId;
+
+    if (groupName !== undefined) {
+      return {
+        key: propertyDataPath(toPropertyRowKey(groupId, fieldId)),
+        label: groupName ? `${groupName} / ${label}` : label,
+        type: field.type,
+      };
+    }
+
+    return {
+      key: propertyDataPath(fieldId),
+      label,
+      type: field.type,
+    };
+  });
+};
+
+const uniqRecordReferenceOutputFields = (
+  fields: TRecordReferenceOutputField[],
+) =>
+  fields.filter(
+    (field, index, array) =>
+      array.findIndex((candidate) => candidate.key === field.key) === index,
+  );
+
+export const getRecordReferenceFields = async ({
+  models,
+  type,
+}: TGetRecordReferenceFieldsProps): Promise<TRecordReferenceOutputField[]> => {
+  const referenceTypes = applyRecordReferenceExtensions(
+    await getRecordReferenceMetadata(),
+  );
+  const referenceType = findRecordReferenceType(referenceTypes, type);
+
+  if (!referenceType) {
+    return [];
+  }
+
+  const baseFields = referenceType.fields
+    .filter((field) => {
+      if (!field.reference?.type) {
+        return true;
+      }
+
+      const fieldReferenceType =
+        findRecordReferenceType(referenceTypes, field.reference.type)?.type ||
+        field.reference.type;
+
+      return !isSameRecordReferenceType(fieldReferenceType, referenceType.type);
+    })
+    .map((field) => toRecordReferenceOutputField(field, referenceTypes));
+  const customFields = await getCustomRecordReferenceFields(
+    models,
+    referenceType.type,
+  );
+
+  return uniqRecordReferenceOutputFields([...baseFields, ...customFields]);
+};

package/src/core-modules/common/references/index.ts

@@ -0,0 +1,9 @@
+export * from './initRecordReferences';
+export * from './getRecordReferenceFields';
+export * from './resolveRecordReferencePlaceholders';
+export * from './resolveRecordReferenceValue';
+export type {
+  TRecordReferenceExtension,
+  TRecordReferenceResolveInput,
+  TRecordReferencesConfig,
+} from './types';

package/src/core-modules/common/references/initRecordReferences.ts

@@ -0,0 +1,84 @@
+import { AnyProcedure, initTRPC } from '@trpc/server';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import { Express } from 'express';
+import { createTRPCContext } from '../../../utils/trpc';
+import { initializePluginConfig as initializeServiceConfig } from '../../../utils/service-discovery';
+import { fetchRecordReferenceTargets } from './fetchRecordReferenceTargets';
+import { normalizeRecordReferenceConfig } from './normalizeRecordReferenceConfig';
+import { resolveRecordReferencePath } from './resolveRecordReferencePath';
+import { TRecordReferenceProducers, TRecordReferencesConfig } from './types';
+import { RecordReferenceResolveInput } from './zodInputs';
+import { isBlankReferenceValue } from './utils';
+
+export const initRecordReferences = async (
+  app: Express,
+  pluginName: string,
+  config: TRecordReferencesConfig,
+) => {
+  await initializeServiceConfig(
+    pluginName,
+    'references',
+    normalizeRecordReferenceConfig(pluginName, config),
+  );
+
+  const t = initTRPC.context<any>().create();
+  const procedures: Record<string, AnyProcedure> = {
+    [TRecordReferenceProducers.RESOLVE]: t.procedure
+      .input(RecordReferenceResolveInput)
+      .mutation(async ({ input }) => {
+        const { subdomain, data } = input;
+        const { defaultValue, path, target, targetId, targetIds, type } = data;
+        const models = await config.generateModels(subdomain);
+        const targets = target
+          ? [target]
+          : await fetchRecordReferenceTargets({
+              config,
+              models,
+              pluginName,
+              subdomain,
+              type,
+              targetId,
+              targetIds,
+            });
+
+        if (!targets.length) {
+          return defaultValue;
+        }
+
+        const values = await Promise.all(
+          targets.map((currentTarget) =>
+            resolveRecordReferencePath({
+              config,
+              defaultValue,
+              models,
+              path,
+              pluginName,
+              subdomain,
+              target: currentTarget,
+              type,
+            }),
+          ),
+        );
+
+        const resolvedValues = values
+          .flat()
+          .filter((value) => !isBlankReferenceValue(value));
+
+        if (targetIds?.length) {
+          return resolvedValues;
+        }
+
+        return resolvedValues.length > 1
+          ? resolvedValues
+          : (resolvedValues[0] ?? defaultValue);
+      }),
+  };
+
+  app.use(
+    '/references',
+    trpcExpress.createExpressMiddleware({
+      router: t.router(procedures),
+      createContext: createTRPCContext(async (_subdomain, context) => context),
+    }),
+  );
+};

package/src/core-modules/common/references/normalizeRecordReferenceConfig.ts

@@ -0,0 +1,59 @@
+import {
+  TRecordReferenceExtension,
+  TRecordReferenceField,
+  TRecordReferenceType,
+  TRecordReferencesConfig,
+} from './types';
+import { normalizeRecordReferenceType } from './utils';
+
+export const normalizeRecordReferenceField = (
+  pluginName: string,
+  field: TRecordReferenceField,
+): TRecordReferenceField => ({
+  ...field,
+  fields: (field.fields || []).map((nestedField) =>
+    normalizeRecordReferenceField(pluginName, nestedField),
+  ),
+  reference: field.reference
+    ? {
+        ...field.reference,
+        type: normalizeRecordReferenceType(pluginName, field.reference.type),
+      }
+    : undefined,
+});
+
+export const normalizeRecordReferenceTypes = (
+  pluginName: string,
+  types: TRecordReferenceType[] = [],
+): TRecordReferenceType[] =>
+  types.map((referenceType) => ({
+    ...referenceType,
+    type: normalizeRecordReferenceType(pluginName, referenceType.type),
+    fields: (referenceType.fields || []).map((field) =>
+      normalizeRecordReferenceField(pluginName, field),
+    ),
+  }));
+
+export const normalizeRecordReferenceExtensions = (
+  pluginName: string,
+  extensions: TRecordReferenceExtension[] = [],
+): TRecordReferenceExtension[] =>
+  extensions.map((extension) => ({
+    ...extension,
+    type: normalizeRecordReferenceType(pluginName, extension.type),
+    fields: (extension.fields || []).map((field) =>
+      normalizeRecordReferenceField(pluginName, field),
+    ),
+  }));
+
+export const normalizeRecordReferenceConfig = (
+  pluginName: string,
+  config: TRecordReferencesConfig,
+) => ({
+  types: normalizeRecordReferenceTypes(pluginName, config.types || []),
+
+  extensions: normalizeRecordReferenceExtensions(
+    pluginName,
+    config.extensions || [],
+  ),
+});