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

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

@@ -0,0 +1,207 @@
+import { Document, Schema } from 'mongoose';
+import { AUTOMATION_STATUSES } from '../constants';
+
+export type IAutomationActionsMap = { [key: string]: IAutomationAction };
+
+// type for values
+type TAutomationStatus =
+  (typeof AUTOMATION_STATUSES)[keyof typeof AUTOMATION_STATUSES];
+
+export interface IAutomationAction<TConfig = any> {
+  id: string;
+  type: string;
+  nextActionId?: string;
+  config?: TConfig;
+  style?: any;
+  icon?: string;
+  label?: string;
+  description?: string;
+  workflowId?: string;
+  targetActionId?: string;
+}
+
+export interface IAutomationTrigger<TConfig = any> {
+  id: string;
+  type: string;
+  actionId?: string;
+  config: {
+    contentId: string;
+    reEnrollment: boolean;
+    reEnrollmentRules: string[];
+    dateConfig: any;
+    [key: string]: any;
+  } & TConfig;
+  style?: any;
+  icon?: string;
+  label?: string;
+  description?: string;
+  isCustom?: boolean;
+  workflowId?: string;
+}
+
+export interface IAutomationWorkflow {
+  id: string;
+  // Empty for converted (containment) workflows that own their actions;
+  // set when the node references another automation.
+  automationId?: string;
+  // Source template when inserted from one
+  templateId?: string;
+  name: string;
+  description?: string;
+  nextActionId?: string;
+  config?: {
+    entryActionId?: string;
+    // name -> default binding expression, e.g. { customerId: "{{ trigger.customerId }}" }
+    inputs?: Record<string, string>;
+    [key: string]: any;
+  };
+  actions?: IAutomationAction[];
+  icon?: string;
+  position?: any;
+}
+
+export interface IAutomationNote {
+  id: string;
+  content: string;
+  position?: any;
+  width?: number;
+  height?: number;
+  color?: string;
+}
+
+export interface IAutomation {
+  name: string;
+  status: TAutomationStatus;
+  edgeType?: string;
+  flowDirection?: string;
+  triggers: IAutomationTrigger[];
+  actions: IAutomationAction[];
+  workflows?: IAutomationWorkflow[];
+  // Canvas annotations. Deliberately outside actions so the executor and the
+  // builder's flow validation never see them.
+  notes?: IAutomationNote[];
+  /**
+   * Set when another module owns this automation and drives its lifecycle, so
+   * it stays out of the automations list the way an automation-owned segment
+   * stays out of the segments list. Never set through `automationsEdit`.
+   */
+  ownedBy?: 'broadcast';
+  ownerContentId?: string;
+  duplicatedFrom?: string;
+  createdAt: Date;
+  createdBy: string;
+  updatedAt: Date;
+  updatedBy: string;
+  /**
+   * Whose automation this is: the records it creates are made on this
+   * person's behalf. Taken by whoever first puts it live, and moved only by
+   * consent — never derived from who edited it last, because editing a flow
+   * is not the same as answering for what it does.
+   */
+  ownerId?: string;
+  /** Who last put it live, and when. Audit, not ownership. */
+  activatedBy?: string;
+  activatedAt?: Date;
+  tagIds: string[];
+}
+
+export interface IAutomationDoc extends IAutomation {
+  _id?: string;
+}
+
+export interface IAutomationDocument extends IAutomation, Document {
+  _id: string;
+}
+
+const triggerSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    type: { type: String, required: true },
+    actionId: { type: String },
+    config: { type: Object },
+    style: { type: Object },
+    position: { type: Object },
+    icon: { type: String, optional: true },
+    label: { type: String, optional: true },
+    description: { type: String, optional: true },
+    isCustom: { type: Boolean, optional: true },
+    workflowId: { type: String, optional: true },
+  },
+  { _id: false },
+);
+
+const actionSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    type: { type: String, required: true },
+    nextActionId: { type: String },
+    config: { type: Object },
+    style: { type: Object },
+    position: { type: Object },
+    icon: { type: String, optional: true },
+    label: { type: String, optional: true },
+    description: { type: String, optional: true },
+    workflowId: { type: String, optional: true },
+    targetActionId: { type: String, optional: true },
+  },
+  { _id: false },
+);
+
+const workflowSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    // Empty for converted (containment) workflows that own their actions;
+    // set when the node references another automation.
+    automationId: { type: String },
+    // Source template when inserted from one; lets edits offer to update it
+    templateId: { type: String },
+    name: { type: String, required: true },
+    description: { type: String },
+    nextActionId: { type: String },
+    config: { type: Object },
+    actions: { type: [actionSchema], optional: true },
+    icon: { type: String, optional: true },
+    position: { type: Object },
+  },
+  { _id: false },
+);
+
+const noteSchema = new Schema(
+  {
+    id: { type: String, required: true },
+    content: { type: String, default: '' },
+    position: { type: Object },
+    width: { type: Number, optional: true },
+    height: { type: Number, optional: true },
+    color: { type: String, optional: true },
+  },
+  { _id: false },
+);
+
+export const automationSchema = new Schema({
+  name: { type: String, required: true },
+  status: { type: String, default: AUTOMATION_STATUSES.DRAFT },
+  edgeType: { type: String, optional: true },
+  flowDirection: { type: String, optional: true },
+  triggers: { type: [triggerSchema] },
+  actions: { type: [actionSchema] },
+  workflows: { type: [workflowSchema] },
+  notes: { type: [noteSchema], optional: true },
+  ownedBy: { type: String, optional: true, label: 'Owned by' },
+  ownerContentId: { type: String, optional: true, label: 'Owner content id' },
+  duplicatedFrom: { type: String, optional: true },
+  createdAt: {
+    type: Date,
+    default: new Date(),
+    label: 'Created date',
+  },
+  createdBy: { type: String },
+  updatedAt: { type: Date, default: new Date(), label: 'Updated date' },
+  updatedBy: { type: String },
+  ownerId: { type: String, label: 'Owner', optional: true },
+  activatedBy: { type: String, optional: true },
+  activatedAt: { type: Date, optional: true },
+  tagIds: { type: [String], label: 'Tag Ids', optional: true },
+});
+
+automationSchema.index({ ownedBy: 1, ownerContentId: 1 });

package/src/core-modules/automations/definitions/executions.ts

@@ -0,0 +1,190 @@
+import { TCreatedVia } from '../../../core-types/common';
+import { Document, Schema } from 'mongoose';
+
+export interface IAutomationExecAction {
+  createdAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  durationMs?: number;
+  status?:
+    | 'success'
+    | 'skipped'
+    | 'error'
+    | 'waiting'
+    | 'queued'
+    | 'standby'
+    | 'dropped';
+  actionId: string;
+  actionType: string;
+  actionConfig?: any;
+  nextActionId?: string;
+  result?: any;
+  // Why the action failed, from AUTOMATION_ERROR_CODES. Only set on errors.
+  errorCode?: string;
+  // Why the action deliberately did nothing. Only set on skipped actions.
+  skipReason?: string;
+  // Which try this row is. 1 unless an error policy asked for another one.
+  attempt?: number;
+  // Set on workflow node actions: links to the child execution for drill-in
+  childExecutionId?: string;
+  // Deferred actions only: matches the completion callback to this attempt so
+  // a stale or retried job can never overwrite a newer one.
+  jobId?: string;
+  // Date in-process, an ISO string once the execution crosses a producer
+  // boundary — both shapes reach this type.
+  queuedAt?: Date | string;
+  // When the sweep gives up on a deferred action that never reported back.
+  expiresAt?: Date | string;
+}
+
+export interface IAutomationExecution {
+  createdAt?: string;
+  modifiedAt?: string;
+  automationId: string;
+  triggerId: string;
+  triggerType: string;
+  triggerConfig: any;
+  /**
+   * What set this run going. A caller that addressed the automation on
+   * someone's behalf declares its own — a campaign names itself and whoever
+   * put it live — and the runner stamps the run's own id onto it. Records the
+   * run creates carry it onward.
+   */
+  createdVia?: TCreatedVia;
+  nextActionId?: string;
+  targetId: string;
+  target: any;
+  // Relation measures the trigger's re-enrollment watches, by rule.
+  watched?: Record<string, unknown>;
+  status: string;
+  description: string;
+  actions?: IAutomationExecAction[];
+  failedActionId?: string;
+  failedActionType?: string;
+  errorCode?: string;
+  // Actions that failed while the run itself carried on: a deferred 'ignore'
+  // action reporting late, or a failure taken by an error branch. The run is
+  // complete, so without this the failure would vanish with it.
+  handledFailureActionIds?: string[];
+  startWaitingDate?: Date;
+  waitingActionId?: string;
+  objToCheck?: any;
+  responseActionId?: string;
+  // Workflow child executions: run a workflow's member actions on behalf of
+  // a parent execution that waits on the workflow node.
+  parentExecutionId?: string;
+  workflowId?: string;
+  // Input values frozen when the workflow was entered; members resolve
+  // {{ input.* }} from here.
+  inputs?: Record<string, any>;
+  depth?: number;
+}
+
+export interface IAutomationExecutionDocument
+  extends IAutomationExecution,
+    Document {
+  _id: string;
+}
+
+export const AUTOMATION_EXECUTION_STATUS = {
+  ACTIVE: 'active',
+  WAITING: 'waiting',
+  // Paused on a deferred action the flow still needs the result of.
+  STANDBY: 'standby',
+  ERROR: 'error',
+  MISSID: 'missed',
+  COMPLETE: 'complete',
+  ALL: ['active', 'waiting', 'standby', 'error', 'missed', 'complete'],
+};
+
+const execActionSchema = new Schema({
+  createdAt: { type: Date, default: Date.now, required: true },
+  startedAt: { type: Date },
+  finishedAt: { type: Date },
+  durationMs: { type: Number },
+  status: {
+    type: String,
+    enum: [
+      'success',
+      'skipped',
+      'error',
+      'waiting',
+      'queued',
+      'standby',
+      'dropped',
+    ],
+  },
+  actionId: { type: String },
+  actionType: { type: String },
+  actionConfig: { type: Object },
+  nextActionId: { type: String },
+  result: { type: Object },
+  childExecutionId: { type: String },
+  errorCode: { type: String },
+  skipReason: { type: String },
+  attempt: { type: Number },
+  jobId: { type: String },
+  queuedAt: { type: Date },
+  expiresAt: { type: Date },
+});
+
+export const automationExecutionSchema = new Schema({
+  createdAt: { type: Date, default: Date.now, required: true },
+  modifiedAt: { type: Date, default: Date.now, required: true },
+  automationId: { type: String, required: true },
+  triggerId: { type: String, required: true },
+  triggerType: { type: String },
+  triggerConfig: { type: Object },
+  createdVia: { type: Object },
+  nextActionId: { type: String },
+  targetId: { type: String, required: true, index: true },
+  target: { type: Object },
+  watched: { type: Object },
+  status: {
+    type: String,
+    enum: AUTOMATION_EXECUTION_STATUS.ALL,
+    default: AUTOMATION_EXECUTION_STATUS.ACTIVE,
+    label: 'Status',
+    index: true,
+  },
+  description: { type: String, required: true },
+  actions: { type: [execActionSchema] },
+  failedActionId: { type: String },
+  failedActionType: { type: String },
+  errorCode: { type: String },
+  handledFailureActionIds: { type: [String] },
+  startWaitingDate: { type: Date },
+  waitingActionId: { type: String },
+  responseActionId: { type: String },
+  objToCheck: { type: Object, optional: true },
+  parentExecutionId: { type: String, index: true },
+  workflowId: { type: String },
+  inputs: { type: Object },
+  depth: { type: Number, default: 0 },
+});
+
+// Executions are write-heavy, so only the compound indexes the real queries
+// need. The `automationId` / `triggerId` prefixes cover single-field lookups.
+
+// History list and stats: match by automation, order/range by createdAt.
+automationExecutionSchema.index({ automationId: 1, createdAt: -1 });
+
+// Status-filtered list and the status breakdown.
+automationExecutionSchema.index({ automationId: 1, status: 1, createdAt: -1 });
+
+// Engine hot path: latest execution of a target for re-enrollment checks.
+automationExecutionSchema.index({
+  automationId: 1,
+  triggerId: 1,
+  targetId: 1,
+  createdAt: -1,
+});
+
+automationExecutionSchema.index(
+  { automationId: 1, failedActionId: 1, createdAt: -1 },
+  { sparse: true },
+);
+automationExecutionSchema.index(
+  { automationId: 1, errorCode: 1, createdAt: -1 },
+  { sparse: true },
+);

package/src/core-modules/automations/definitions/index.ts

@@ -0,0 +1,3 @@
+export * from './automations';
+export * from './executions';
+export * from './aiAgents';

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

@@ -0,0 +1,49 @@
+import { getValueByPath } from './outputResolvers';
+
+describe('getValueByPath', () => {
+  it('walks a plain path', () => {
+    expect(
+      getValueByPath(
+        { propertiesData: { plan: 'pro' } },
+        'propertiesData.plan',
+      ),
+    ).toEqual({
+      found: true,
+      value: 'pro',
+    });
+  });
+
+  it('collects the leaf value of every row in a repeating group', () => {
+    const source = {
+      propertiesData: {
+        'g:edu': [
+          { _id: 'r1', school: 'MUIS', year: 2018 },
+          { _id: 'r2', school: 'SUIS' },
+          { _id: 'r3', year: 2022 },
+        ],
+      },
+    };
+
+    expect(getValueByPath(source, 'propertiesData.g:edu/school')).toEqual({
+      found: true,
+      value: ['MUIS', 'SUIS'],
+    });
+  });
+
+  it('finds nothing when no row holds the field', () => {
+    const source = { propertiesData: { 'g:edu': [{ _id: 'r1', year: 2018 }] } };
+
+    expect(getValueByPath(source, 'propertiesData.g:edu/school')).toEqual({
+      found: false,
+    });
+  });
+
+  it('finds nothing when the group holds no rows', () => {
+    expect(
+      getValueByPath(
+        { propertiesData: { plan: 'pro' } },
+        'propertiesData.g:edu/school',
+      ),
+    ).toEqual({ found: false });
+  });
+});

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

@@ -0,0 +1,13 @@
+export * from './utils';
+export * from './setupAutomationProducers';
+export * from './actionErrorPolicy';
+export * from './actionOutcome';
+export * from './constants';
+export * from './types';
+export * from './definitions';
+export * from './outputResolvers';
+export * from './workflowValidation';
+export * from './zodTypes';
+export * from './sendAutomationMessage';
+export * from './segmentMembership';
+export * from './reEnrollment';

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

@@ -0,0 +1,97 @@
+import { resolveRecordReferenceValue } from '../common/references';
+import { resolveOutputPathsByNodeType } from './outputResolvers';
+
+jest.mock('../common/references', () => ({
+  resolveRecordReferenceValue: jest.fn(),
+}));
+
+const mockedResolveRecordReferenceValue = jest.mocked(
+  resolveRecordReferenceValue,
+);
+
+describe('resolveOutputPathsByNodeType', () => {
+  beforeEach(() => {
+    mockedResolveRecordReferenceValue.mockReset();
+  });
+
+  it('resolves action-created targets from their current entity state', async () => {
+    mockedResolveRecordReferenceValue.mockImplementation(async (input) => {
+      if (input.type === 'frontline:ticket' && input.path === 'description') {
+        return 'Resolved complaint';
+      }
+
+      if (input.type === 'frontline:ticket' && input.path === 'assigneeId') {
+        return 'user-1';
+      }
+
+      if (input.type === 'core:user' && input.path === 'displayName') {
+        return 'Support Agent';
+      }
+
+      return input.defaultValue;
+    });
+
+    const result = await resolveOutputPathsByNodeType({
+      subdomain: 'test',
+      nodeType: 'frontline:tickets.tickets.create',
+      source: {
+        targetId: 'ticket-1',
+        description: 'Original complaint',
+        assigneeId: 'user-old',
+      },
+      paths: ['description', 'assigneeId.displayName'],
+      runtimeOutputs: {
+        'frontline:tickets.tickets.create': {
+          variables: [
+            { key: 'description', label: 'Description' },
+            {
+              key: 'assigneeId',
+              label: 'Assignee',
+              exposure: 'reference',
+              referenceType: 'core:user',
+            },
+          ],
+          propertySource: {
+            key: 'properties',
+            label: 'Ticket properties',
+            propertyType: 'frontline:ticket',
+          },
+        },
+      },
+    });
+
+    expect(result).toEqual({
+      description: 'Resolved complaint',
+      'assigneeId.displayName': 'Support Agent',
+    });
+    expect(mockedResolveRecordReferenceValue).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'frontline:ticket',
+        targetId: 'ticket-1',
+        path: 'description',
+      }),
+    );
+  });
+
+  it('keeps resolving root execution sources directly', async () => {
+    const result = await resolveOutputPathsByNodeType({
+      subdomain: 'test',
+      nodeType: 'frontline:tickets.tickets',
+      source: { description: 'Trigger description' },
+      paths: ['description'],
+      runtimeOutputs: {
+        'frontline:tickets.tickets': {
+          variables: [{ key: 'description', label: 'Description' }],
+          propertySource: {
+            key: 'properties',
+            label: 'Ticket properties',
+            propertyType: 'frontline:ticket',
+          },
+        },
+      },
+    });
+
+    expect(result).toEqual({ description: 'Trigger description' });
+    expect(mockedResolveRecordReferenceValue).not.toHaveBeenCalled();
+  });
+});