feat: email plugins support

packages/workflow-core/src/lib/plugins/external-plugin/api-plugin.ts

@@ -59,23 +59,23 @@ export class ApiPlugin {
         }
       }
 
-      const urlWithoutPlaceholders = await this.replaceValuePlaceholders(this.url, context);
+      const _url = await this._getPluginUrl(context);
 
       logger.log('API Plugin - Sending API request', {
-        url: urlWithoutPlaceholders,
+        url: _url,
         method: this.method,
       });
 
       const apiResponse = await this.makeApiRequest(
-        urlWithoutPlaceholders,
+        _url,
         this.method,
         requestPayload,
         await this.composeRequestHeaders(this.headers!, context),
       );
 
       logger.log('API Plugin - Received response', {
         status: apiResponse.statusText,
-        url: urlWithoutPlaceholders,
+        url: _url,
       });
 
       if (apiResponse.ok) {
@@ -115,6 +115,10 @@ export class ApiPlugin {
     }
   }
 
+  protected async _getPluginUrl(_: AnyRecord) {
+    return this.url;
+  }
+
   returnSuccessResponse(callbackAction: string, responseBody: AnyRecord) {
     return { callbackAction, responseBody };
   }
@@ -142,11 +146,7 @@ export class ApiPlugin {
     };
 
     if (payload) {
-      for (const key of Object.keys(payload)) {
-        if (typeof payload[key] === 'string') {
-          payload[key] = await this.replaceValuePlaceholders(payload[key] as string, payload);
-        }
-      }
+      payload = await this._onPreparePayload(payload);
 
       // @TODO: Use an enum over string literals for HTTP methods
       if (this.method.toUpperCase() !== 'GET') {
@@ -172,6 +172,18 @@ export class ApiPlugin {
     return res;
   }
 
+  private async _onPreparePayload(_payload: AnyRecord) {
+    const returnObj = JSON.parse(JSON.stringify(_payload));
+
+    for (const key of Object.keys(returnObj)) {
+      if (typeof returnObj[key] === 'string') {
+        returnObj[key] = await this.replaceAllVariables(returnObj[key] as string, returnObj);
+      }
+    }
+
+    return returnObj;
+  }
+
   async transformData(transformers: Transformers | undefined, record: AnyRecord) {
     let mutatedRecord = record;
 
@@ -218,14 +230,25 @@ export class ApiPlugin {
       Object.entries(headers).map(async header => [
         header[0],
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        await this.replaceValuePlaceholders(header[1], context),
+        await this.replaceAllVariables(header[1], context),
       ]),
     );
 
     return Object.fromEntries(headersEntries);
   }
 
-  async replaceValuePlaceholders(content: string, context: TContext) {
+  _onReplaceVariable(variableKey: string, replacedContent: string, placeholder: string) {
+    const replacedCustomerSecrets = this.replaceSecrets(
+      'customer',
+      variableKey,
+      replacedContent,
+      placeholder,
+    );
+
+    return replacedCustomerSecrets;
+  }
+
+  async replaceAllVariables(content: string, context: TContext) {
     const placeholders = content.match(/{(.*?)}/g);
 
     if (!placeholders) return content;
@@ -235,29 +258,38 @@ export class ApiPlugin {
     for (const placeholder of placeholders) {
       const variableKey = placeholder.replace(/{|}/g, '');
 
-      const isSystemSecret = variableKey.includes('secret.');
-      const isSecret = variableKey.includes('secrets.');
-
-      if (isSystemSecret) {
-        const secretKey = variableKey.replace('secret.', '');
-        const secretValue = `${this.getSystemSecret(secretKey)}`;
-
-        replacedContent = replacedContent.replace(placeholder, secretValue);
-      } else if (isSecret) {
-        const secretKey = variableKey.replace('secrets.', '');
-        const secretValue = `${await this.fetchSecret(secretKey)}`;
+      const replacedVariable = this._onReplaceVariable(variableKey, replacedContent, placeholder);
 
-        replacedContent = replacedContent.replace(placeholder, secretValue);
-      } else {
-        const placeholderValue = `${this.fetchObjectPlaceholderValue(context, variableKey)}`;
-
-        replacedContent = replacedContent.replace(placeholder, placeholderValue);
+      if (replacedVariable) {
+        return replacedVariable;
       }
+
+      const placeholderValue = `${this.fetchObjectPlaceholderValue(context, variableKey)}`;
+      replacedContent = replacedContent.replace(placeholder, placeholderValue);
     }
 
     return replacedContent;
   }
 
+  replaceSecrets(
+    provider: 'ballerine' | 'customer',
+    variableKey: string,
+    replacedContent: string,
+    placeholder: string,
+  ): string | undefined {
+    const variableName = `secret${provider === 'ballerine' ? '' : 's'}.`;
+
+    if (variableKey.includes(variableName)) {
+      const secretKey = variableKey.replace(variableName, '');
+      const secretValue = `${this.getSystemSecret(secretKey)}`;
+
+      replacedContent = replacedContent.replace(placeholder, secretValue);
+
+      return replacedContent;
+    }
+    return undefined;
+  }
+
   getSystemSecret(key: string) {
     return process.env[key] || '';
   }

packages/workflow-core/src/lib/plugins/external-plugin/ballerine-email-plugin.ts

@@ -0,0 +1,91 @@
+import { AnyRecord } from '@ballerine/common';
+import { logger } from '../../logger';
+import { IApiPluginParams } from './types';
+import { ApiPlugin } from './api-plugin';
+import { ApiEmailTemplates } from './vendor-consts';
+import { BallerineApiPlugin, IBallerineApiPluginParams } from './ballerine-plugin';
+
+export interface IBallerineEmailPluginParams {
+  pluginKind: 'template-email';
+  template: ApiEmailTemplates;
+  displayName: string | undefined;
+  stateNames: string[];
+}
+
+export class BallerineEmailPlugin extends BallerineApiPlugin {
+  public static pluginType = 'http';
+
+  constructor(params: IBallerineEmailPluginParams & IBallerineApiPluginParams & IApiPluginParams) {
+    super(params);
+  }
+
+  async makeApiRequest(
+    url: string,
+    method: ApiPlugin['method'],
+    payload: AnyRecord,
+    headers: HeadersInit,
+  ) {
+    const from = { from: { email: payload.from, ...(payload.name ? { name: payload.name } : {}) } };
+    const subject = payload.subject
+      ? {
+          subject: await (this as unknown as ApiPlugin).replaceAllVariables(
+            payload.subject as string,
+            payload,
+          ),
+        }
+      : {};
+    const preheader = payload.preheader
+      ? {
+          preheader: await (this as unknown as ApiPlugin).replaceAllVariables(
+            payload.preheader as string,
+            payload,
+          ),
+        }
+      : {};
+    const receivers = (payload.receivers as string[]).map(receiver => {
+      return { email: receiver };
+    });
+    const to = { to: receivers };
+    const templateId = { template_id: payload.templateId };
+
+    for (const key of Object.keys(payload)) {
+      if (typeof payload[key] === 'string') {
+        payload[key] = await (this as unknown as ApiPlugin).replaceAllVariables(
+          payload[key] as string,
+          payload,
+        );
+      }
+    }
+
+    const emailPayload = {
+      ...from,
+      personalizations: [
+        {
+          ...preheader,
+          ...subject,
+          ...to,
+          ...{ dynamic_template_data: payload },
+        },
+      ],
+      ...templateId,
+    };
+
+    payload.adapter ??= 'sendgrid';
+
+    if (payload.adapter === 'log') {
+      logger.warn('No email provider', { emailPayload });
+
+      return {
+        ok: true,
+        json: () => Promise.resolve({}),
+        statusText: 'OK',
+      };
+    }
+
+    return await super.makeApiRequest(url, method, emailPayload, headers);
+  }
+
+  returnSuccessResponse(callbackAction: string, responseBody: AnyRecord) {
+    return super.returnSuccessResponse(callbackAction, {});
+  }
+}

packages/workflow-core/src/lib/plugins/external-plugin/ballerine-plugin.ts

@@ -0,0 +1,96 @@
+import { AnyRecord } from '@ballerine/common';
+import { WorkflowRunner } from '../../workflow-runner';
+import { IBallerineApiPluginParams } from './ballerine-plugin';
+import { ApiPlugin, IApiPluginParams } from '.';
+import { ApiBallerinePlugins, BALLERINE_API_PLUGIN_FACTORY } from './vendor-consts';
+
+export interface IBallerineApiPluginParams {
+  pluginKind: ApiBallerinePlugins;
+  vendor?: string;
+  displayName: string | undefined;
+  stateNames: string[];
+}
+
+const _validatePlugin = (params: IBallerineApiPluginParams & IApiPluginParams) => {
+  let optionsFactoryFn: any = BALLERINE_API_PLUGIN_FACTORY[params.pluginKind];
+
+  if (!optionsFactoryFn) {
+    throw new Error(`Unknown plugin kind: ${params.pluginKind}`);
+  }
+};
+
+const _getPluginOptions = (params: IBallerineApiPluginParams & IApiPluginParams) => {
+  _validatePlugin(params);
+  let optionsFactoryFn;
+
+  const pluginOptionFactoryFn = BALLERINE_API_PLUGIN_FACTORY[params.pluginKind] as any;
+
+  if (
+    params.pluginKind === 'individual-sanctions' ||
+    params.pluginKind === 'company-sanctions' ||
+    params.pluginKind === 'ubo'
+  ) {
+    if (!params.vendor) {
+      throw new Error(`Missed vendor for: ${params.pluginKind}`);
+    }
+    optionsFactoryFn = pluginOptionFactoryFn[params.vendor];
+  }
+
+  if (params.pluginKind === 'template-email') {
+    if (!params.template) {
+      throw new Error(`Missed templateName for: ${params.pluginKind}`);
+    }
+    optionsFactoryFn = pluginOptionFactoryFn[params.template];
+  }
+
+  if (!optionsFactoryFn) {
+    throw new Error(`Unknown plugin kind: ${params.pluginKind}, params: ${JSON.stringify(params)}`);
+  }
+
+  return optionsFactoryFn(params as any);
+};
+
+export class BallerineApiPlugin extends ApiPlugin {
+  public static pluginType = 'http';
+
+  constructor(params: IBallerineApiPluginParams & IApiPluginParams) {
+    let options = _getPluginOptions(params);
+
+    let { requestTransformer, requestValidator, responseTransformer, responseValidator } =
+      WorkflowRunner.reqResTransformersObj({
+        params,
+        ...options,
+      });
+
+    super({
+      persistResponseDestination: undefined,
+      ...params,
+      ...options,
+      request: { transformers: requestTransformer, schemaValidator: requestValidator } as any,
+      response: { transformers: responseTransformer, schemaValidator: responseValidator } as any,
+    });
+  }
+
+  protected async _getPluginUrl(context: AnyRecord) {
+    return await this.replaceAllVariables(this.url, context);
+  }
+
+  _onReplaceVariable(variableKey: string, replacedContent: string, placeholder: string) {
+    let replacedSecrets = this.replaceSecrets(
+      'ballerine',
+      variableKey,
+      replacedContent,
+      placeholder,
+    );
+
+    if (replacedSecrets) {
+      return replacedSecrets;
+    }
+
+    replacedSecrets = super._onReplaceVariable(variableKey, replacedContent, placeholder);
+
+    if (replacedSecrets) {
+      return replacedSecrets;
+    }
+  }
+}