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

package/src/core-modules/automations/reEnrollment.ts

@@ -0,0 +1,34 @@
+/** The re-enrollment rule that matches every new event, not a field change. */
+export const AUTOMATION_RE_ENROLL_EVERY_TIME = '*';
+
+type TReEnrollmentConfig = {
+  reEnrollment?: boolean;
+  reEnrollmentRules?: string[];
+  once?: boolean;
+} | null;
+
+/** Whether a trigger's config asks to run again on every event. */
+export const reEnrollsEveryTime = (config?: TReEnrollmentConfig) =>
+  !!config?.reEnrollment &&
+  !!config.reEnrollmentRules?.includes(AUTOMATION_RE_ENROLL_EVERY_TIME);
+
+/**
+ * Segment membership runs every time unless told otherwise. Before the shared
+ * re-enrollment setting it was told with `once`, which still counts while the
+ * automation has not been saved with the new setting.
+ */
+export const segmentMembershipRunsEveryTime = (config?: TReEnrollmentConfig) =>
+  config?.reEnrollment === undefined
+    ? !config?.once
+    : reEnrollsEveryTime(config);
+
+/**
+ * A rule watching one of the trigger segment's relation conditions — a sum
+ * of the customer's deals — by its place in the tree: `relation:children.0`.
+ */
+export const AUTOMATION_RE_ENROLL_RELATION_PREFIX = 'relation:';
+
+export const reEnrollmentRelationPaths = (rules: string[] = []) =>
+  rules
+    .filter((rule) => rule.startsWith(AUTOMATION_RE_ENROLL_RELATION_PREFIX))
+    .map((rule) => rule.slice(AUTOMATION_RE_ENROLL_RELATION_PREFIX.length));

package/src/core-modules/automations/segmentMembership.ts

@@ -0,0 +1,34 @@
+import { sendWorkerQueue } from '../../utils/mq-worker';
+import { SegmentMembershipTransition } from '../segments/types';
+
+/**
+ * A trigger that fires when a record enters or leaves a materialized segment.
+ * Its type stays the record's own type, so every action reads the target as
+ * usual; the marker and the two exits live in the config.
+ */
+export const AUTOMATION_SEGMENT_MEMBERSHIP_EVENT = 'segmentMembership';
+
+export const AUTOMATION_SEGMENT_MEMBERSHIP_FOLKS = ['joined', 'left'] as const;
+
+export type TAutomationSegmentMembershipFolk =
+  (typeof AUTOMATION_SEGMENT_MEMBERSHIP_FOLKS)[number];
+
+export type TAutomationSegmentMembershipJob = {
+  contentType: string;
+  transitions: SegmentMembershipTransition[];
+};
+
+export const isSegmentMembershipTrigger = (trigger?: {
+  config?: Record<string, any>;
+}) => trigger?.config?.event === AUTOMATION_SEGMENT_MEMBERSHIP_EVENT;
+
+/** Hands the segment worker's joins and leaves to the automations service. */
+export const sendSegmentMembershipToAutomations = (
+  subdomain: string,
+  data: TAutomationSegmentMembershipJob,
+) =>
+  sendWorkerQueue('automations', 'segmentMembership')
+    .add('segmentMembership', { subdomain, data })
+    .catch((error) => {
+      console.error('Error adding segment membership job:', error);
+    });

package/src/core-modules/automations/sendAutomationMessage.ts

@@ -0,0 +1,219 @@
+import { TCreatedVia } from '../../core-types/common';
+import { sendWorkerQueue } from '../../utils/mq-worker';
+import type { DefaultJobOptions } from 'bullmq';
+import { createTRPCUntypedClient, httpBatchLink } from '@trpc/client';
+import {
+  encodeTRPCContextHeader,
+  trpcContextHeaderName,
+} from '../../utils/trpc';
+import { redis } from '../../utils/redis';
+
+type TSendAutomationTriggerProps = {
+  transport?: 'bullmq' | 'trpc';
+  jobOptions?: DefaultJobOptions;
+};
+
+export const sendAutomationTrigger = (
+  subdomain: string,
+  {
+    type,
+    targets,
+    repeatOptions,
+    recordType,
+    eventUpdateDescription,
+  }: {
+    type: string;
+    targets: any;
+    repeatOptions?: {
+      executionId: string;
+      actionId: string;
+      optionalConnectId?: string;
+    };
+    recordType?: 'new' | 'existing';
+    eventUpdateDescription?: Record<string, any>;
+  },
+  { transport = 'bullmq', jobOptions }: TSendAutomationTriggerProps = {},
+): void => {
+  const automtionTriggerPayload = {
+    type,
+    targets,
+    repeatOptions,
+    recordType,
+    eventUpdateDescription,
+  };
+
+  if (transport === 'trpc') {
+    redis
+      .get('erxes-service-automations')
+      .then((address) => {
+        const trpcUrl = address ? `${address}/trpc` : null;
+
+        if (!trpcUrl) {
+          throw new Error(
+            'Missing trpcUrl for sendAutomationTrigger. Provide props.trpcUrl or ensure service discovery has erxes-service-automations set.',
+          );
+        }
+
+        const contextHeader = encodeTRPCContextHeader(
+          subdomain,
+          'mutation',
+          {},
+        );
+
+        const client = createTRPCUntypedClient({
+          links: [
+            httpBatchLink({
+              url: trpcUrl,
+              headers: () => ({
+                [trpcContextHeaderName]: contextHeader,
+              }),
+            }),
+          ],
+        });
+
+        client
+          .mutation('automations.trigger', automtionTriggerPayload)
+          .catch((error) => {
+            console.error('Error sending  trpc request ', error);
+          });
+      })
+      .catch((error) => {
+        console.error('Error sending  trpc request ', error);
+      });
+    return;
+  }
+
+  const queue = sendWorkerQueue('automations', 'trigger');
+
+  queue
+    .add(
+      'trigger',
+      {
+        subdomain,
+        data: automtionTriggerPayload,
+      },
+      jobOptions,
+    )
+    .catch((error) => {
+      console.error('Error adding job to queue:', error);
+    });
+};
+
+/**
+ * Runs one named automation against one target the caller already chose.
+ *
+ * Unlike `sendAutomationTrigger`, which announces an event and lets the
+ * service decide which automations enrol which targets, this addresses an
+ * automation directly. The caller is responsible for choosing the target and
+ * for its own idempotency.
+ */
+export const sendAutomationRun = (
+  subdomain: string,
+  {
+    automationId,
+    target,
+    triggerId,
+    createdVia,
+  }: {
+    automationId: string;
+    target: Record<string, any>;
+    triggerId?: string;
+    /**
+     * What is asking for this run — the caller's own configuration and whoever
+     * set it going. Only the caller knows: to the automations service this is
+     * just an automation being addressed.
+     */
+    createdVia?: TCreatedVia;
+  },
+  { transport = 'bullmq', jobOptions }: TSendAutomationTriggerProps = {},
+): void => {
+  const payload = { automationId, target, triggerId, createdVia };
+
+  if (transport === 'trpc') {
+    redis
+      .get('erxes-service-automations')
+      .then((address) => {
+        const trpcUrl = address ? `${address}/trpc` : null;
+
+        if (!trpcUrl) {
+          throw new Error(
+            'Missing trpcUrl for sendAutomationRun. Ensure service discovery has erxes-service-automations set.',
+          );
+        }
+
+        const contextHeader = encodeTRPCContextHeader(
+          subdomain,
+          'mutation',
+          {},
+        );
+
+        const client = createTRPCUntypedClient({
+          links: [
+            httpBatchLink({
+              url: trpcUrl,
+              headers: () => ({
+                [trpcContextHeaderName]: contextHeader,
+              }),
+            }),
+          ],
+        });
+
+        client.mutation('automations.runForTarget', payload).catch((error) => {
+          console.error('Error sending trpc request ', error);
+        });
+      })
+      .catch((error) => {
+        console.error('Error sending trpc request ', error);
+      });
+    return;
+  }
+
+  sendWorkerQueue('automations', 'runForTarget')
+    .add('runForTarget', { subdomain, data: payload }, jobOptions)
+    .catch((error) => {
+      console.error('Error adding job to queue:', error);
+    });
+};
+
+export type TDeferredCompletion = {
+  executionId: string;
+  actionId: string;
+  jobId: string;
+  status: 'success' | 'error' | 'dropped';
+  result?: any;
+};
+
+/**
+ * Reports a deferred action back to the automations service. The plugin that
+ * queued the work owns the callback, so this is the other half of the marker
+ * returned from `receiveActions`.
+ */
+export const sendAutomationDeferredCompletion = async (
+  subdomain: string,
+  completion: TDeferredCompletion,
+): Promise<void> => {
+  const address = await redis.get('erxes-service-automations');
+
+  if (!address) {
+    throw new Error(
+      'Missing address for sendAutomationDeferredCompletion. Ensure service discovery has erxes-service-automations set.',
+    );
+  }
+
+  const client = createTRPCUntypedClient({
+    links: [
+      httpBatchLink({
+        url: `${address}/trpc`,
+        headers: () => ({
+          [trpcContextHeaderName]: encodeTRPCContextHeader(
+            subdomain,
+            'mutation',
+            {},
+          ),
+        }),
+      }),
+    ],
+  });
+
+  await client.mutation('automations.completeDeferredAction', completion);
+};

package/src/core-modules/automations/setPropertyOutcome.test.ts

@@ -0,0 +1,105 @@
+import { sendTRPCMessage } from '../../utils/trpc';
+import {
+  BROADCAST_TARGET_TYPE,
+  BROADCAST_TRIGGER_TYPE,
+  getTriggerTargetType,
+} from './constants';
+import { setProperty } from './utils';
+
+jest.mock('../../utils/trpc', () => ({ sendTRPCMessage: jest.fn() }));
+
+const mockedSendTRPCMessage = jest.mocked(sendTRPCMessage);
+
+type TSetPropertyArgs = Parameters<typeof setProperty>[0];
+
+const execution = {} as TSetPropertyArgs['execution'];
+
+const run = (overrides: Partial<TSetPropertyArgs>) =>
+  setProperty({
+    models: {},
+    subdomain: 'test',
+    module: 'core:contacts.customers',
+    rules: [{ field: 'propertiesData.plan', operator: 'set', value: 'pro' }],
+    execution,
+    ...overrides,
+  } as TSetPropertyArgs);
+
+describe('setProperty · outcome', () => {
+  beforeEach(() => {
+    mockedSendTRPCMessage.mockReset();
+    // validateFieldValues echoes what it was given
+    mockedSendTRPCMessage.mockImplementation(
+      async ({ input }: never) => (input as { data: unknown }).data,
+    );
+  });
+
+  it('marks the change updated when a record matched', async () => {
+    const result = await run({
+      selector: { _id: 'c1' },
+      update: async () => ({ matchedCount: 1 }),
+    });
+
+    expect(result.target?.count).toBe(1);
+    expect(result.changes?.map(({ status }) => status)).toEqual(['updated']);
+  });
+
+  it('marks the change skipped when nothing matched', async () => {
+    const result = await run({
+      selector: { _id: { $in: [] } },
+      update: async () => ({ matchedCount: 0 }),
+    });
+
+    expect(result.target?.count).toBe(0);
+    expect(result.changes?.map(({ status }) => status)).toEqual(['skipped']);
+  });
+
+  it('marks every rule skipped when a current-value rule finds no record', async () => {
+    const update = jest.fn();
+
+    const result = await run({
+      rules: [{ field: 'propertiesData.score', operator: 'add', value: '5' }],
+      selector: { _id: 'missing' },
+      fetchItems: async () => [],
+      update,
+    });
+
+    expect(update).not.toHaveBeenCalled();
+    expect(result.target?.count).toBe(0);
+    expect(result.changes?.map(({ status }) => status)).toEqual(['skipped']);
+  });
+
+  it('skips only the item a per-record update did not reach', async () => {
+    const update = jest
+      .fn()
+      .mockResolvedValueOnce({ matchedCount: 1 })
+      .mockResolvedValueOnce({ matchedCount: 0 });
+
+    const result = await run({
+      rules: [{ field: 'propertiesData.score', operator: 'add', value: '5' }],
+      selector: { _id: { $in: ['a', 'b'] } },
+      fetchItems: async () => [
+        { _id: 'a', propertiesData: { score: 1 } },
+        { _id: 'b', propertiesData: { score: 2 } },
+      ],
+      update,
+    });
+
+    expect(result.target?.count).toBe(1);
+    expect(result.changes?.map(({ status }) => status)).toEqual([
+      'updated',
+      'skipped',
+    ]);
+  });
+});
+
+describe('getTriggerTargetType', () => {
+  it('runs a broadcast against the customer it hands each run', () => {
+    expect(getTriggerTargetType(BROADCAST_TRIGGER_TYPE)).toBe(
+      BROADCAST_TARGET_TYPE,
+    );
+  });
+
+  it('keeps any other trigger as its own target type', () => {
+    expect(getTriggerTargetType('sales:sales.deals')).toBe('sales:sales.deals');
+  });
+});

package/src/core-modules/automations/setPropertyRows.test.ts

@@ -0,0 +1,61 @@
+import { sendTRPCMessage } from '../../utils/trpc';
+import { buildSetPropertyModifier } from './utils';
+
+jest.mock('../../utils/trpc', () => ({ sendTRPCMessage: jest.fn() }));
+jest.mock('nanoid', () => ({
+  ...jest.requireActual('nanoid'),
+  nanoid: () => 'row1',
+}));
+
+const mockedSendTRPCMessage = jest.mocked(sendTRPCMessage);
+
+const execution = {} as Parameters<
+  typeof buildSetPropertyModifier
+>[0]['execution'];
+
+const build = (rules: { field: string; operator: string; value?: unknown }[]) =>
+  buildSetPropertyModifier({ subdomain: 'test', rules, execution });
+
+describe('buildSetPropertyModifier · repeating groups', () => {
+  beforeEach(() => {
+    mockedSendTRPCMessage.mockReset();
+    // validateFieldValues echoes what it was given
+    mockedSendTRPCMessage.mockImplementation(
+      async ({ input }: never) => (input as { data: unknown }).data,
+    );
+  });
+
+  it('appends one row carrying every rule of the same group', async () => {
+    const modifier = await build([
+      { field: 'propertiesData.g:edu/school', operator: 'set', value: 'MUIS' },
+      { field: 'propertiesData.g:edu/year', operator: 'set', value: '2020' },
+    ]);
+
+    expect(modifier).toEqual({
+      $push: {
+        // a numeric string is evaluated to a number before it is stored
+        'propertiesData.g:edu': { school: 'MUIS', year: 2020, _id: 'row1' },
+      },
+    });
+  });
+
+  it('keeps a plain field on $set beside an appended row', async () => {
+    const modifier = await build([
+      { field: 'propertiesData.plan', operator: 'set', value: 'pro' },
+      { field: 'propertiesData.g:edu/school', operator: 'set', value: 'MUIS' },
+    ]);
+
+    expect(modifier.$set).toEqual({ 'propertiesData.plan': 'pro' });
+    expect(modifier.$push).toEqual({
+      'propertiesData.g:edu': { school: 'MUIS', _id: 'row1' },
+    });
+  });
+
+  it('appends nothing when every rule of the group resolves empty', async () => {
+    const modifier = await build([
+      { field: 'propertiesData.g:edu/school', operator: 'set', value: '' },
+    ]);
+
+    expect(modifier.$push).toBeUndefined();
+  });
+});

package/src/core-modules/automations/setupAutomationProducers.ts

@@ -0,0 +1,187 @@
+import { AnyProcedure, initTRPC } from '@trpc/server';
+import * as trpcExpress from '@trpc/server/adapters/express';
+import { Express } from 'express';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+import { initializePluginConfig } from '../../utils';
+import { createTRPCContext } from '../../utils/trpc';
+import {
+  buildRuntimeOutputsIndex,
+  normalizeAutomationConstantsForTransport,
+  resolveOutputPathsByNodeType,
+} from './outputResolvers';
+import {
+  AutomationConfigs,
+  IAutomationContext,
+  TAutomationProducers,
+} from './types';
+import {
+  CheckCustomTriggerInput,
+  FindObjectInput,
+  GenerateAiContextInput,
+  LoadAiKnowledgeDocumentBatchInput,
+  LookupAiToolInput,
+  ReceiveActionsInput,
+  ResolveOutputPathsInput,
+  SetPropertiesInput,
+} from './zodTypes';
+
+const generateRuntimeResolveOutputPaths = (
+  pluginName: string,
+  config: AutomationConfigs,
+) => {
+  const { resolveOutputPaths, constants } = config || {};
+
+  if (resolveOutputPaths) {
+    return resolveOutputPaths;
+  }
+
+  const runtimeOutputs = buildRuntimeOutputsIndex(pluginName, constants);
+  const runtimeOutputKeys = Object.keys(runtimeOutputs);
+
+  if (!runtimeOutputKeys?.length) {
+    return null;
+  }
+  return async (
+    { subdomain, data }: z.infer<typeof ResolveOutputPathsInput>,
+    _context: IAutomationContext,
+  ) => {
+    if (!runtimeOutputs[data.nodeType]) {
+      return {};
+    }
+
+    const resolvedValues = await resolveOutputPathsByNodeType({
+      subdomain,
+      nodeType: data.nodeType,
+      source: data.source || {},
+      paths: data.paths || [],
+      defaultValue: data.defaultValue,
+      runtimeOutputs,
+    });
+
+    return Object.fromEntries(
+      (data.paths || []).map((path) => {
+        const resolvedValue = resolvedValues?.[path];
+
+        return [
+          path,
+          resolvedValue === undefined ? data.defaultValue : resolvedValue,
+        ];
+      }),
+    );
+  };
+};
+
+export const startAutomations = async (
+  app: Express,
+  pluginName: string,
+  config: AutomationConfigs,
+) => {
+  const transportConfig = {
+    ...config,
+    constants: normalizeAutomationConstantsForTransport(
+      pluginName,
+      config.constants,
+    ),
+  };
+
+  await initializePluginConfig(pluginName, 'automations', transportConfig);
+  const t = initTRPC.context<IAutomationContext>().create();
+
+  const {
+    receiveActions,
+    setProperties,
+    checkCustomTrigger,
+    findObject,
+    generateAiContext,
+    loadAiKnowledgeDocumentBatch,
+    lookupAiTool,
+  } = config || {};
+
+  const automationProcedures: Partial<
+    Record<TAutomationProducers, AnyProcedure>
+  > = {};
+
+  if (receiveActions) {
+    automationProcedures[TAutomationProducers.RECEIVE_ACTIONS] = t.procedure
+      .input(ReceiveActionsInput)
+      .mutation(async ({ ctx, input }) => receiveActions(input, ctx));
+  }
+
+  if (setProperties) {
+    automationProcedures[TAutomationProducers.SET_PROPERTIES] = t.procedure
+      .input(SetPropertiesInput)
+      .mutation(async ({ ctx, input }) => setProperties(input, ctx));
+  }
+
+  if (generateAiContext) {
+    automationProcedures[TAutomationProducers.GENERATE_AI_CONTEXT] = t.procedure
+      .input(GenerateAiContextInput)
+      .mutation(async ({ ctx, input }) =>
+        generateAiContext(
+          { subdomain: input.subdomain, data: input.data },
+          ctx,
+        ),
+      );
+  }
+
+  if (loadAiKnowledgeDocumentBatch) {
+    automationProcedures[
+      TAutomationProducers.LOAD_AI_KNOWLEDGE_DOCUMENT_BATCH
+    ] = t.procedure
+      .input(LoadAiKnowledgeDocumentBatchInput)
+      .mutation(async ({ ctx, input }) =>
+        loadAiKnowledgeDocumentBatch(input, ctx),
+      );
+  }
+
+  if (lookupAiTool) {
+    automationProcedures[TAutomationProducers.LOOKUP_AI_TOOL] = t.procedure
+      .input(LookupAiToolInput)
+      .mutation(async ({ ctx, input }) => lookupAiTool(input, ctx));
+  }
+
+  const runtimeResolveOutputPaths = generateRuntimeResolveOutputPaths(
+    pluginName,
+    config,
+  );
+
+  if (runtimeResolveOutputPaths) {
+    automationProcedures[TAutomationProducers.RESOLVE_OUTPUT_PATHS] =
+      t.procedure
+        .input(ResolveOutputPathsInput)
+        .mutation(async ({ ctx, input }) =>
+          runtimeResolveOutputPaths(input, ctx),
+        );
+  }
+
+  if (checkCustomTrigger) {
+    automationProcedures[TAutomationProducers.CHECK_CUSTOM_TRIGGER] =
+      t.procedure
+        .input(CheckCustomTriggerInput)
+        .mutation(async ({ ctx, input }) => checkCustomTrigger(input, ctx));
+  }
+
+  if (findObject) {
+    automationProcedures[TAutomationProducers.FIND_OBJECT] = t.procedure
+      .input(FindObjectInput)
+      .mutation(async ({ ctx, input }) => findObject(input, ctx));
+  }
+
+  const automationsRouter = t.router(automationProcedures);
+
+  const trpcMiddleware = trpcExpress.createExpressMiddleware({
+    router: automationsRouter,
+    createContext: createTRPCContext<IAutomationContext>(
+      async (_subdomain, context) => {
+        const processId = nanoid(12);
+
+        context.processId = processId;
+
+        return context;
+      },
+    ),
+  });
+
+  app.use('/automations', trpcMiddleware);
+};

package/src/core-modules/automations/typeUtils.ts

@@ -0,0 +1,3 @@
+export const splitType = (type: string) => {
+  return type.replace(/\./g, ':').split(':');
+};