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

package/src/core-modules/apps/db/definitions/apps.ts

@@ -0,0 +1,30 @@
+import { Schema } from 'mongoose';
+import { mongooseField, schemaWrapper } from '../../../../utils';
+export const appSchema = schemaWrapper(
+  new Schema({
+    _id: mongooseField({ pkey: true }),
+    name: mongooseField({ type: String, label: 'App name' }),
+    createdAt: mongooseField({
+      type: Date,
+      label: 'Created at',
+      default: new Date(),
+    }),
+    accessToken: mongooseField({ type: String, label: 'Access token' }),
+    refreshToken: mongooseField({
+      type: String,
+      label: 'Refresh token used to gain access token',
+    }),
+    isEnabled: mongooseField({ type: Boolean, label: 'Status of the app' }),
+    userGroupId: mongooseField({
+      type: String,
+      label: 'User group id',
+      optional: true,
+    }),
+    expireDate: mongooseField({ type: Date, label: 'Token expire date' }),
+    noExpire: mongooseField({ type: Boolean, label: 'noExpire' }),
+    allowAllPermission: mongooseField({
+      type: Boolean,
+      label: 'allowAllPermission',
+    }),
+  }),
+);

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

@@ -0,0 +1,2 @@
+export * from './@types/app';
+export * from './db/definitions/apps';

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

@@ -0,0 +1,125 @@
+import {
+  actionRetryDelayMs,
+  AUTOMATION_RETRY_LIMITS,
+  resolveActionBranchTarget,
+  resolveActionErrorPolicy,
+} from './actionErrorPolicy';
+
+const policy = (errorPolicy: unknown) =>
+  resolveActionErrorPolicy({ errorPolicy });
+
+describe('resolveActionErrorPolicy', () => {
+  it('defaults to today behaviour: no retry, the run fails', () => {
+    expect(resolveActionErrorPolicy(undefined)).toEqual({
+      attempts: 0,
+      delaySeconds: AUTOMATION_RETRY_LIMITS.DEFAULT_DELAY_SECONDS,
+      backoff: 'none',
+      onError: 'fail',
+    });
+
+    expect(resolveActionErrorPolicy({ url: 'https://example.com' })).toEqual(
+      resolveActionErrorPolicy(undefined),
+    );
+  });
+
+  it('reads a configured policy', () => {
+    expect(
+      policy({
+        retry: { attempts: 3, delaySeconds: 30, backoff: 'exponential' },
+        onError: 'branch',
+      }),
+    ).toEqual({
+      attempts: 3,
+      delaySeconds: 30,
+      backoff: 'exponential',
+      onError: 'branch',
+    });
+  });
+
+  it('never lets a hand-edited automation exceed the ceilings', () => {
+    const { MAX_ATTEMPTS, MAX_DELAY_SECONDS, MIN_DELAY_SECONDS } =
+      AUTOMATION_RETRY_LIMITS;
+
+    expect(
+      policy({ retry: { attempts: 99, delaySeconds: 999999 } }).attempts,
+    ).toBe(MAX_ATTEMPTS);
+    expect(
+      policy({ retry: { attempts: 99, delaySeconds: 999999 } }).delaySeconds,
+    ).toBe(MAX_DELAY_SECONDS);
+    expect(policy({ retry: { attempts: -4, delaySeconds: 0 } })).toMatchObject({
+      attempts: 0,
+      delaySeconds: MIN_DELAY_SECONDS,
+    });
+    expect(policy({ retry: { backoff: 'fibonacci' } }).backoff).toBe('none');
+    expect(policy({ onError: 'explode' }).onError).toBe('fail');
+  });
+});
+
+describe('actionRetryDelayMs', () => {
+  const base = { attempts: 3, delaySeconds: 60, onError: 'fail' } as const;
+
+  it('waits the same amount every time without a backoff', () => {
+    const flat = { ...base, backoff: 'none' } as const;
+
+    expect([2, 3, 4].map((n) => actionRetryDelayMs(flat, n))).toEqual([
+      60_000, 60_000, 60_000,
+    ]);
+  });
+
+  it('grows the wait with each further try', () => {
+    const linear = { ...base, backoff: 'linear' } as const;
+    const exponential = { ...base, backoff: 'exponential' } as const;
+
+    expect([2, 3, 4].map((n) => actionRetryDelayMs(linear, n))).toEqual([
+      60_000, 120_000, 180_000,
+    ]);
+    expect([2, 3, 4].map((n) => actionRetryDelayMs(exponential, n))).toEqual([
+      60_000, 120_000, 240_000,
+    ]);
+  });
+
+  it('caps a growing wait at the ceiling', () => {
+    const exponential = {
+      ...base,
+      delaySeconds: 3000,
+      backoff: 'exponential',
+    } as const;
+
+    expect(actionRetryDelayMs(exponential, 5)).toBe(
+      AUTOMATION_RETRY_LIMITS.MAX_DELAY_SECONDS * 1000,
+    );
+  });
+});
+
+describe('resolveActionBranchTarget', () => {
+  const branching = {
+    nextActionId: 'plain-next',
+    config: {
+      errorPolicy: { onError: 'branch' },
+      onSuccessActionId: 'happy',
+      onErrorActionId: 'sad',
+    },
+  };
+
+  it('reads the plain next action while the policy is off', () => {
+    const action = { nextActionId: 'plain-next', config: {} };
+
+    expect(resolveActionBranchTarget(action, 'success')).toBe('plain-next');
+    expect(resolveActionBranchTarget(action, 'error')).toBeUndefined();
+  });
+
+  it('reads both named exits once the action branches', () => {
+    expect(resolveActionBranchTarget(branching, 'success')).toBe('happy');
+    expect(resolveActionBranchTarget(branching, 'error')).toBe('sad');
+  });
+
+  it('never falls back to the plain next action while branching', () => {
+    const halfWired = {
+      nextActionId: 'plain-next',
+      config: { errorPolicy: { onError: 'branch' } },
+    };
+
+    expect(resolveActionBranchTarget(halfWired, 'success')).toBeUndefined();
+    expect(resolveActionBranchTarget(halfWired, 'error')).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,162 @@
+/**
+ * What an action does when it fails. Written by the builder onto the action's
+ * own config, read by the engine — the default keeps today's behaviour, where
+ * a failed action fails the run.
+ *
+ * 'branch' turns the action's single outgoing edge into a named pair, so a
+ * tolerated failure is something the canvas shows rather than a setting buried
+ * in a dialog.
+ */
+export const AUTOMATION_ERROR_BEHAVIOURS = {
+  FAIL: 'fail',
+  BRANCH: 'branch',
+} as const;
+
+/** Config keys the branch writes its two targets to. */
+export const AUTOMATION_BRANCH_KEYS = {
+  SUCCESS: 'onSuccessActionId',
+  ERROR: 'onErrorActionId',
+} as const;
+
+export type TAutomationErrorBehaviour =
+  (typeof AUTOMATION_ERROR_BEHAVIOURS)[keyof typeof AUTOMATION_ERROR_BEHAVIOURS];
+
+export const AUTOMATION_RETRY_BACKOFFS = {
+  NONE: 'none',
+  LINEAR: 'linear',
+  EXPONENTIAL: 'exponential',
+} as const;
+
+export type TAutomationRetryBackoff =
+  (typeof AUTOMATION_RETRY_BACKOFFS)[keyof typeof AUTOMATION_RETRY_BACKOFFS];
+
+/** A retry parks a live execution, so the ceilings are the platform's. */
+export const AUTOMATION_RETRY_LIMITS = {
+  MAX_ATTEMPTS: 5,
+  DEFAULT_DELAY_SECONDS: 60,
+  MIN_DELAY_SECONDS: 5,
+  MAX_DELAY_SECONDS: 3600,
+} as const;
+
+export type TAutomationActionErrorPolicy = {
+  retry?: {
+    // Extra tries after the first one. 0 means no retry.
+    attempts?: number;
+    delaySeconds?: number;
+    backoff?: TAutomationRetryBackoff;
+  };
+  onError?: TAutomationErrorBehaviour;
+};
+
+export type TAutomationBranchConfig = {
+  errorPolicy?: TAutomationActionErrorPolicy;
+  [AUTOMATION_BRANCH_KEYS.SUCCESS]?: string;
+  [AUTOMATION_BRANCH_KEYS.ERROR]?: string;
+};
+
+export type TResolvedActionErrorPolicy = {
+  attempts: number;
+  delaySeconds: number;
+  backoff: TAutomationRetryBackoff;
+  onError: TAutomationErrorBehaviour;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const asActionId = (value: unknown) =>
+  typeof value === 'string' && value.trim() ? value.trim() : undefined;
+
+const clamp = (value: number, min: number, max: number) =>
+  Math.min(Math.max(value, min), max);
+
+const toCount = (value: unknown, fallback: number) => {
+  const parsed = Number(value);
+
+  return Number.isFinite(parsed) ? Math.floor(parsed) : fallback;
+};
+
+const isBackoff = (value: unknown): value is TAutomationRetryBackoff =>
+  value === AUTOMATION_RETRY_BACKOFFS.NONE ||
+  value === AUTOMATION_RETRY_BACKOFFS.LINEAR ||
+  value === AUTOMATION_RETRY_BACKOFFS.EXPONENTIAL;
+
+/**
+ * Reads the policy off an action config. Anything missing or out of range
+ * falls back to the platform's own values, so a hand-edited automation can
+ * never park an execution for longer than the ceiling allows.
+ */
+export const resolveActionErrorPolicy = (
+  config: unknown,
+): TResolvedActionErrorPolicy => {
+  const policy =
+    isRecord(config) && isRecord(config.errorPolicy)
+      ? (config.errorPolicy as TAutomationActionErrorPolicy)
+      : {};
+  const retry = isRecord(policy.retry) ? policy.retry : {};
+  const {
+    MAX_ATTEMPTS,
+    DEFAULT_DELAY_SECONDS,
+    MIN_DELAY_SECONDS,
+    MAX_DELAY_SECONDS,
+  } = AUTOMATION_RETRY_LIMITS;
+
+  return {
+    attempts: clamp(toCount(retry.attempts, 0), 0, MAX_ATTEMPTS),
+    delaySeconds: clamp(
+      toCount(retry.delaySeconds, DEFAULT_DELAY_SECONDS),
+      MIN_DELAY_SECONDS,
+      MAX_DELAY_SECONDS,
+    ),
+    backoff: isBackoff(retry.backoff)
+      ? retry.backoff
+      : AUTOMATION_RETRY_BACKOFFS.NONE,
+    onError:
+      policy.onError === AUTOMATION_ERROR_BEHAVIOURS.BRANCH
+        ? AUTOMATION_ERROR_BEHAVIOURS.BRANCH
+        : AUTOMATION_ERROR_BEHAVIOURS.FAIL,
+  };
+};
+
+/**
+ * Where the action goes next. A branching action names both of its exits, so
+ * the plain `nextActionId` is only read while the policy is off.
+ */
+export const resolveActionBranchTarget = (
+  action: { nextActionId?: string; config?: unknown },
+  outcome: 'success' | 'error',
+): string | undefined => {
+  const config = isRecord(action?.config) ? action.config : {};
+  const branching =
+    resolveActionErrorPolicy(config).onError ===
+    AUTOMATION_ERROR_BEHAVIOURS.BRANCH;
+
+  if (!branching) {
+    return outcome === 'success' ? action?.nextActionId : undefined;
+  }
+
+  const key =
+    outcome === 'success'
+      ? AUTOMATION_BRANCH_KEYS.SUCCESS
+      : AUTOMATION_BRANCH_KEYS.ERROR;
+
+  return asActionId(config[key]);
+};
+
+/** Wait before attempt `nextAttempt` (2 is the first retry). */
+export const actionRetryDelayMs = (
+  policy: TResolvedActionErrorPolicy,
+  nextAttempt: number,
+) => {
+  const step = Math.max(nextAttempt - 1, 1);
+  const { backoff, delaySeconds } = policy;
+
+  const seconds =
+    backoff === AUTOMATION_RETRY_BACKOFFS.LINEAR
+      ? delaySeconds * step
+      : backoff === AUTOMATION_RETRY_BACKOFFS.EXPONENTIAL
+      ? delaySeconds * Math.pow(2, step - 1)
+      : delaySeconds;
+
+  return clamp(seconds, 0, AUTOMATION_RETRY_LIMITS.MAX_DELAY_SECONDS) * 1000;
+};

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

@@ -0,0 +1,70 @@
+import { getPlugin, sendCoreModuleProducer } from '../../utils';
+import { resolveAutomationActionInputs } from './outputResolvers';
+
+jest.mock('../../utils', () => ({
+  getPlugin: jest.fn(),
+  sendCoreModuleProducer: jest.fn(),
+}));
+
+const mockedGetPlugin = jest.mocked(getPlugin);
+const mockedProducer = jest.mocked(sendCoreModuleProducer);
+
+const pluginWith = (trigger: Record<string, unknown>) =>
+  ({
+    config: { meta: { automations: { constants: { triggers: [trigger] } } } },
+  }) as unknown as Awaited<ReturnType<typeof getPlugin>>;
+
+describe('resolveAutomationActionInputs', () => {
+  beforeEach(() => {
+    mockedGetPlugin.mockReset();
+    mockedProducer.mockReset();
+  });
+
+  it('fills the inputs from the trigger output keys it declared', async () => {
+    mockedGetPlugin.mockResolvedValue(
+      pluginWith({
+        type: 'sales:pos.orders',
+        output: {
+          variables: [
+            { key: 'totalAmount', label: 'Total' },
+            { key: 'paidAmount', label: 'Paid' },
+          ],
+          resolverKeys: ['paidAmount'],
+        },
+        actionInputs: {
+          'loyalty:score.score.create': {
+            totalAmount: 'totalAmount',
+            paidAmount: 'paidAmount',
+          },
+        },
+      }),
+    );
+    // Keys with a resolver are computed by the trigger's own plugin.
+    mockedProducer.mockResolvedValue({ totalAmount: 1000, paidAmount: 800 });
+
+    await expect(
+      resolveAutomationActionInputs({
+        subdomain: 'test',
+        triggerType: 'sales:pos.orders',
+        actionType: 'loyalty:score.score.create',
+        target: { totalAmount: 1000 },
+      }),
+    ).resolves.toEqual({ totalAmount: 1000, paidAmount: 800 });
+  });
+
+  it('gives nothing when the trigger declares nothing for the action', async () => {
+    mockedGetPlugin.mockResolvedValue(
+      pluginWith({ type: 'core:contacts.customers' }),
+    );
+
+    await expect(
+      resolveAutomationActionInputs({
+        subdomain: 'test',
+        triggerType: 'core:contacts.customers',
+        actionType: 'loyalty:score.score.create',
+        target: {},
+      }),
+    ).resolves.toBeUndefined();
+    expect(mockedProducer).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,87 @@
+import {
+  buildFailedAction,
+  buildSkippedAction,
+  isActionOutcomeEnvelope,
+  resolveActionOutcome,
+} from './actionOutcome';
+import { AUTOMATION_ERROR_CODES } from './constants';
+
+describe('resolveActionOutcome', () => {
+  it('reads anything without an envelope as the action payload', () => {
+    expect(resolveActionOutcome({ ok: false, status: 404 })).toEqual({
+      status: 'success',
+      result: { ok: false, status: 404 },
+    });
+
+    expect(resolveActionOutcome(null)).toEqual({
+      status: 'success',
+      result: null,
+    });
+  });
+
+  it('leaves a payload that happens to carry its own outcome field alone', () => {
+    const response = { outcome: { winner: 'a' } };
+
+    expect(resolveActionOutcome(response)).toEqual({
+      status: 'success',
+      result: response,
+    });
+  });
+
+  it('carries the reason of a skipped action', () => {
+    expect(
+      resolveActionOutcome(
+        buildSkippedAction('window-closed', { lastInboundAt: 'yesterday' }),
+      ),
+    ).toEqual({
+      status: 'skipped',
+      reason: 'window-closed',
+      result: { lastInboundAt: 'yesterday' },
+    });
+  });
+
+  it('carries the message, code and evidence of a failed action', () => {
+    expect(
+      resolveActionOutcome(
+        buildFailedAction(
+          'Outgoing webhook responded 404 Not Found',
+          AUTOMATION_ERROR_CODES.WEBHOOK_FAILED,
+          { status: 404 },
+        ),
+      ),
+    ).toEqual({
+      status: 'failed',
+      message: 'Outgoing webhook responded 404 Not Found',
+      code: AUTOMATION_ERROR_CODES.WEBHOOK_FAILED,
+      result: { status: 404 },
+    });
+  });
+
+  it('never silences a malformed declaration into a success', () => {
+    expect(resolveActionOutcome({ outcome: { status: 'skipped' } })).toEqual({
+      status: 'skipped',
+      reason: 'unspecified',
+      result: undefined,
+    });
+
+    expect(resolveActionOutcome({ outcome: { status: 'failed' } })).toEqual({
+      status: 'failed',
+      message: 'Action reported a failure',
+      code: AUTOMATION_ERROR_CODES.UNKNOWN,
+      result: undefined,
+    });
+  });
+});
+
+describe('isActionOutcomeEnvelope', () => {
+  it('recognizes only a declared outcome', () => {
+    expect(isActionOutcomeEnvelope(buildSkippedAction('send-blocked'))).toBe(
+      true,
+    );
+    expect(isActionOutcomeEnvelope({ outcome: { status: 'done' } })).toBe(
+      false,
+    );
+    expect(isActionOutcomeEnvelope({ result: { ok: true } })).toBe(false);
+    expect(isActionOutcomeEnvelope(undefined)).toBe(false);
+  });
+});

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

@@ -0,0 +1,128 @@
+import { AUTOMATION_ERROR_CODES, TAutomationErrorCode } from './constants';
+
+/**
+ * An action states how it went. Without this envelope the engine can only read
+ * "did not throw", which reports a refused send and a deliberate skip alike.
+ */
+export const AUTOMATION_ACTION_OUTCOMES = {
+  SUCCESS: 'success',
+  SKIPPED: 'skipped',
+  FAILED: 'failed',
+} as const;
+
+export type TAutomationActionOutcome =
+  (typeof AUTOMATION_ACTION_OUTCOMES)[keyof typeof AUTOMATION_ACTION_OUTCOMES];
+
+type TOutcomeDeclaration =
+  | { status: typeof AUTOMATION_ACTION_OUTCOMES.SUCCESS }
+  | { status: typeof AUTOMATION_ACTION_OUTCOMES.SKIPPED; reason: string }
+  | {
+      status: typeof AUTOMATION_ACTION_OUTCOMES.FAILED;
+      message: string;
+      code?: TAutomationErrorCode;
+    };
+
+export type TAutomationActionOutcomeEnvelope = {
+  outcome: TOutcomeDeclaration;
+  result?: unknown;
+};
+
+export type TResolvedActionOutcome =
+  | { status: typeof AUTOMATION_ACTION_OUTCOMES.SUCCESS; result: unknown }
+  | {
+      status: typeof AUTOMATION_ACTION_OUTCOMES.SKIPPED;
+      reason: string;
+      result: unknown;
+    }
+  | {
+      status: typeof AUTOMATION_ACTION_OUTCOMES.FAILED;
+      message: string;
+      code: TAutomationErrorCode;
+      result: unknown;
+    };
+
+const UNSPECIFIED_SKIP_REASON = 'unspecified';
+const UNSPECIFIED_FAILURE_MESSAGE = 'Action reported a failure';
+
+/** The work was deliberately not done, and the flow carries on. */
+export const buildSkippedAction = (
+  reason: string,
+  result?: unknown,
+): TAutomationActionOutcomeEnvelope => ({
+  outcome: { status: AUTOMATION_ACTION_OUTCOMES.SKIPPED, reason },
+  result,
+});
+
+/** The work was meant to happen and did not. */
+export const buildFailedAction = (
+  message: string,
+  code?: TAutomationErrorCode,
+  result?: unknown,
+): TAutomationActionOutcomeEnvelope => ({
+  outcome: { status: AUTOMATION_ACTION_OUTCOMES.FAILED, message, code },
+  result,
+});
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isDeclaredStatus = (value: unknown): value is TAutomationActionOutcome =>
+  value === AUTOMATION_ACTION_OUTCOMES.SUCCESS ||
+  value === AUTOMATION_ACTION_OUTCOMES.SKIPPED ||
+  value === AUTOMATION_ACTION_OUTCOMES.FAILED;
+
+/** For callers that forward an action's answer without reading it. */
+export const isActionOutcomeEnvelope = (
+  value: unknown,
+): value is TAutomationActionOutcomeEnvelope =>
+  isRecord(value) &&
+  isRecord(value.outcome) &&
+  isDeclaredStatus(value.outcome.status);
+
+const asString = (value: unknown) =>
+  typeof value === 'string' && value.trim() ? value.trim() : undefined;
+
+/**
+ * Anything that is not a well-formed envelope is the action's own payload, so
+ * every existing action keeps reporting exactly as it does today.
+ */
+export const resolveActionOutcome = (
+  actionResponse: unknown,
+): TResolvedActionOutcome => {
+  const asSuccess = {
+    status: AUTOMATION_ACTION_OUTCOMES.SUCCESS,
+    result: actionResponse,
+  } as const;
+
+  if (!isRecord(actionResponse) || !isRecord(actionResponse.outcome)) {
+    return asSuccess;
+  }
+
+  const { outcome, result } = actionResponse;
+  const status = outcome.status;
+
+  if (status === AUTOMATION_ACTION_OUTCOMES.SKIPPED) {
+    return {
+      status,
+      reason: asString(outcome.reason) ?? UNSPECIFIED_SKIP_REASON,
+      result,
+    };
+  }
+
+  if (status === AUTOMATION_ACTION_OUTCOMES.FAILED) {
+    const code = asString(outcome.code) as TAutomationErrorCode | undefined;
+
+    return {
+      status,
+      message: asString(outcome.message) ?? UNSPECIFIED_FAILURE_MESSAGE,
+      code: code ?? AUTOMATION_ERROR_CODES.UNKNOWN,
+      result,
+    };
+  }
+
+  if (status === AUTOMATION_ACTION_OUTCOMES.SUCCESS) {
+    return { status, result };
+  }
+
+  return asSuccess;
+};