@pipedream/brevo 0.0.1 → 0.1.0

package/actions/add-or-update-contact/add-or-update-contact.mjs

@@ -0,0 +1,100 @@
+import brevo from "../../brevo.app.mjs";
+
+export default {
+  key: "brevo-add-or-update-contact",
+  name: "Add or Update a contact",
+  description: "Add or Update a contact",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    brevo,
+    providedIdentifier: {
+      type: "string",
+      label: "Contact",
+      description: "Email OR ID of the contact, if not present the contact will be inserted, it will be used to search the contact, if it can be found the contact will be updated else it will be inserted",
+      optional: true,
+      reloadProps: true,
+      async options({ prevContext }) {
+        return this.brevo.getContactsPaginated(prevContext, false);
+      },
+    },
+    email: {
+      type: "string",
+      label: "Email",
+      description: "To either be inserted or updated",
+    },
+  },
+  async additionalProps() {
+    const attributesList = await this.brevo.getContactAttributes(this);
+    const attributesFields = attributesList.attributes
+      .filter((attr) => attr.category === "normal")
+      .reduce((acc, actual) => {
+        acc[`attribute-${actual.name}`] = {
+          type: "string",
+          label: actual.name.replace(/(^\w|\s\w)(\S*)/g, (_, m1, m2) => m1.toUpperCase() + m2.toLowerCase()),
+          description: "To either be inserted or updated",
+          optional: true,
+        };
+        return acc;
+      }, {});
+    const dynamicProps = {
+      ...attributesFields,
+      listIds: {
+        type: "string[]",
+        label: "Lists",
+        description: "Array with ids of each list to be either inserted or updated,\n\n**On update the contact will be removed from previous lists**",
+        options: async ({ prevContext }) => {
+          return this.brevo.getListsPaginated(prevContext);
+        },
+      },
+    };
+    return dynamicProps;
+  },
+  async run({ $ }) {
+    let identifier = this.providedIdentifier;
+    const listIds = Object.keys(this.listIds).map((key) => parseInt(this.listIds[key], 10));
+    let contact = null;
+    if (identifier) {
+      contact = await this.brevo.existingContactByIdentifier(
+        $,
+        encodeURIComponent(identifier),
+      );
+    }
+
+    const attributes = {
+      EMAIL: this.email,
+    };
+    for (let key of Object.keys(this).filter((k) => k.startsWith("attribute-"))) {
+      const attribute = this[key];
+      if (attribute) {
+        attributes[key.replace("attribute-", "")] = attribute;
+      }
+    }
+    $.export("Defined attributes", attributes);
+
+    if (contact) {
+      identifier = contact.id;
+      const unlinkListIds = contact.listIds.filter((el) => !listIds.includes(el));
+      await this.brevo.updateContact(
+        $,
+        identifier,
+        attributes,
+        listIds,
+        unlinkListIds,
+      );
+      $.export("$summary", `Successfully updated contact "${identifier}"`);
+    } else {
+      const inserted = await this.brevo.addContact(
+        $,
+        attributes,
+        listIds,
+      );
+      identifier = inserted.id;
+      $.export("$summary", `Successfully inserted contact "${identifier}"`);
+    }
+    return this.brevo.existingContactByIdentifier(
+      $,
+      encodeURIComponent(identifier),
+    );
+  },
+};

package/actions/send-transactional-email/send-transactional-email.mjs

@@ -0,0 +1,171 @@
+import brevo from "../../brevo.app.mjs";
+
+export default {
+  key: "brevo-send-transactional-email",
+  name: "Send Transactional Email",
+  description: "Send transactional email. [See the docs](https://developers.brevo.com/reference/sendtransacemail) for more information.",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    brevo,
+    useTemplate: {
+      type: "boolean",
+      label: "Use Template",
+      description: "Should use template?",
+      reloadProps: true,
+    },
+  },
+  async additionalProps() {
+    const dynamicProps = {};
+    if (this.useTemplate) {
+      dynamicProps.templateId = {
+        label: "Template Id",
+        type: "integer",
+        min: 0,
+        max: Number.MAX_SAFE_INTEGER,
+        description: "Id of the template.",
+        options: async ({ prevContext }) => {
+          return this.brevo.getTemplatesPaginated(prevContext);
+        },
+      };
+    } else {
+      dynamicProps.sender = {
+        type: "string",
+        label: "Sender",
+        description: "Pass name (optional) and email or id of sender from which emails will be sent.\nName will be ignored if passed along with sender id.\n**Example:** `{ \"name\": \"John Doe\", \"email\": \"john@doe.com\" }` or `{ \"id\": 1 }`",
+        options: async ({ prevContext }) => {
+          return this.brevo.getSendersFormattedOptions(prevContext);
+        },
+      };
+      dynamicProps.subject = {
+        type: "string",
+        label: "Subject",
+        description: "Subject of the message.",
+      };
+      dynamicProps.htmlContent = {
+        type: "string",
+        label: "Html Content",
+        description: "HTML body of the message.",
+      };
+      dynamicProps.textContent = {
+        type: "string",
+        label: "Text Content",
+        optional: true,
+        description: "Plain Text body of the message.",
+      };
+    }
+    const props = {
+      ...dynamicProps,
+      replyTo: {
+        type: "string",
+        label: "Reply To",
+        optional: false,
+        description: "Email (required), along with name (optional), on which transactional mail recipients will be able to reply back.\n\n**Example:** `{ \"name\": \"John Doe\", \"email\": \"john@doe.com\" }`",
+        options: async ({ prevContext }) => {
+          return this.brevo.getSendersFormattedOptions(prevContext);
+        },
+      },
+      to: {
+        type: "string[]",
+        label: "To",
+        description: "List of email addresses and names (optional) of the recipients.\n\n**Example:** `[{ \"name\": \"John Doe\", \"email\": \"john@doe.com\" }, { \"name\": \"Jane Doe\", \"email\": \"jane@doe.com\" }]`",
+        optional: false,
+        options: async ({ prevContext }) => {
+          return this.brevo.getContactsPaginated(prevContext, true);
+        },
+      },
+      cc: {
+        type: "string[]",
+        label: "CC",
+        optional: true,
+        description: "List of email addresses and names (optional) of the recipients in cc.\n\n**Example:** `[{ \"name\": \"John Doe\", \"email\": \"john@doe.com\" }, { \"name\": \"Jane Doe\", \"email\": \"jane@doe.com\" }]`",
+        options: async ({ prevContext }) => {
+          return this.brevo.getContactsPaginated(prevContext, true);
+        },
+      },
+      bcc: {
+        type: "string[]",
+        label: "BCC",
+        optional: true,
+        description: "List of email addresses and names (optional) of the recipients in bcc.\n\n**Example:** `[{ \"name\": \"John Doe\", \"email\": \"john@doe.com\" }, { \"name\": \"Jane Doe\", \"email\": \"jane@doe.com\" }]`",
+        options: async ({ prevContext }) => {
+          return this.brevo.getContactsPaginated(prevContext, true);
+        },
+      },
+      tags: {
+        type: "string[]",
+        label: "Tags",
+        optional: true,
+        description: "Tag your emails to find them more easily.",
+      },
+      params: {
+        type: "string",
+        label: "Params",
+        description: "All key-value properties that will be replaced in the template e.g. `{\"ORDER\": 12345, \"DATE\": \"12/06/2019\"}`",
+        optional: true,
+      },
+    };
+
+    return props;
+  },
+  methods: {
+    formatEmailProp(prop, field) {
+      if (typeof (prop) === "string") {
+        prop = JSON.parse(prop);
+      }
+      if (!Array.isArray(prop)) {
+        throw new Error(`Field "${field}" should be an array`, prop);
+      }
+      if (typeof prop[0] === "string") {
+        return Object.keys(prop).map((key) => JSON.parse(prop[key]));
+      }
+      return prop;
+    },
+  },
+  async run({ $ }) {
+    const sender = this.sender ?
+      JSON.parse(this.sender) :
+      null;
+    const replyTo = this.replyTo ?
+      JSON.parse(this.replyTo) :
+      null;
+    const params = this.params ?
+      JSON.parse(this.params) :
+      null;
+
+    const tags = this.tags ?
+      Object.keys(this.tags).map((key) => this.tags[key])
+      : null;
+    const to = this.to
+      ? this.formatEmailProp(this.to, "To")
+      : null;
+    const cc = this.cc
+      ? this.formatEmailProp(this.cc, "CC")
+      : null;
+    const bcc = this.bcc
+      ? this.formatEmailProp(this.bcc, "BCC")
+      : null;
+
+    if (!Array.isArray(to) || to.length === 0) {
+      throw new Error("Must provide field \"To\".");
+    }
+
+    const emailSent = await this.brevo.sendTransactionalEmail(
+      $,
+      this.useTemplate,
+      this.templateId,
+      sender,
+      replyTo,
+      to,
+      this.subject,
+      this.htmlContent,
+      this.textContent,
+      tags,
+      cc,
+      bcc,
+      params,
+    );
+    $.export("$summary", "Transactional email successfully sent");
+    return emailSent;
+  },
+};

package/brevo.app.mjs

@@ -0,0 +1,247 @@
+import { axios } from "@pipedream/platform";
+
+export default {
+  type: "app",
+  app: "brevo",
+  propDefinitions: {},
+  methods: {
+    _getBaseUrl() {
+      return "https://api.brevo.com/v3";
+    },
+    _getHeaders() {
+      return {
+        "content-type": "application/json",
+        "api-key": `${this.$auth.api_key}`,
+      };
+    },
+    _getRequestParams(opts = {}) {
+      return {
+        ...opts,
+        url: this._getBaseUrl() + opts.path,
+        headers: this._getHeaders(),
+      };
+    },
+    async createHook(ctx = this, createWebhookData) {
+      return await axios(ctx, this._getRequestParams({
+        method: "POST",
+        path: "/webhooks",
+        data: createWebhookData,
+      }));
+    },
+    async deleteHook(ctx = this, hookId) {
+      return await axios(ctx, this._getRequestParams({
+        method: "DELETE",
+        path: `/webhooks/${hookId}`,
+      }));
+    },
+    async existingContactByIdentifier(ctx = this, identifier) {
+      try {
+        return await axios(ctx, this._getRequestParams({
+          method: "GET",
+          path: `/contacts/${identifier}`,
+        }));
+      } catch (exception) {
+        if (exception.status === 404) {
+          return false;
+        }
+        throw exception;
+      }
+    },
+    async getContactsPaginated(prevContext, serializedValue = false) {
+      const limit = 20;
+      const offset = prevContext?.total
+        ? prevContext?.offset + limit
+        : 0;
+      const contactsLists = await this.getContacts(prevContext, limit, offset);
+      const options = contactsLists.contacts.map((element) => {
+        const elementSerializedValue = {
+          id: element.id,
+          email: element.email,
+          name: element.attributes.NAME || element.attributes.FIRSTNAME || element.attributes.FNAME || "contact",
+        };
+        return {
+          label: element.email,
+          value: serializedValue ?
+            JSON.stringify(elementSerializedValue) :
+            element.id,
+        };
+      });
+      return {
+        options,
+        context: {
+          offset: offset,
+          total: contactsLists.count,
+        },
+      };
+    },
+    async getContacts(ctx = this, limit, offset) {
+      try {
+        return await axios(ctx, this._getRequestParams({
+          method: "GET",
+          path: `/contacts?limit=${limit}&offset=${offset}`,
+        }));
+      } catch (exception) {
+        if (exception.status === 404) {
+          return false;
+        }
+        throw exception;
+      }
+    },
+    async getContactAttributes(ctx = this) {
+      return await axios(ctx, this._getRequestParams({
+        method: "GET",
+        path: "/contacts/attributes",
+      }));
+    },
+    async getListsPaginated(prevContext) {
+      const limit = 20;
+      const offset = prevContext?.total
+        ? prevContext?.offset + limit
+        : 0;
+      const emailLists = await this.getLists(prevContext, limit, offset);
+      const options = emailLists.lists.map((element) => {
+        return {
+          label: element.name,
+          value: element.id,
+        };
+      });
+      return {
+        options,
+        context: {
+          offset: offset,
+          total: emailLists.count,
+        },
+      };
+    },
+    async getLists(ctx = this, limit, offset) {
+      return await axios(ctx, this._getRequestParams({
+        method: "GET",
+        path: `/contacts/lists?limit=${limit}&offset=${offset}&sort=desc`,
+      }));
+    },
+    async getSendersFormattedOptions(prevContext) {
+      const sendersList = await this.getSenders(prevContext);
+      const options = sendersList.senders.map((element) => {
+        return {
+          label: element.name,
+          value: JSON.stringify({
+            name: element.name,
+            email: element.email,
+          }),
+        };
+      });
+      return {
+        options,
+      };
+    },
+    async getSenders(ctx = this) {
+      return await axios(ctx, this._getRequestParams({
+        method: "GET",
+        path: "/senders",
+      }));
+    },
+    async getTemplatesPaginated(prevContext) {
+      const limit = 20;
+      const offset = prevContext?.total
+        ? prevContext?.offset + limit
+        : 0;
+      const templatesList = await this.getTemplates(prevContext, limit, offset);
+      const options = templatesList.templates.map((element) => {
+        return {
+          label: element.name,
+          value: element.id,
+        };
+      });
+      return {
+        options,
+        context: {
+          offset: offset,
+          total: templatesList.count,
+        },
+      };
+    },
+    async getTemplates(ctx = this, limit, offset) {
+      return await axios(ctx, this._getRequestParams({
+        method: "GET",
+        path: `/smtp/templates?limit=${limit}&offset=${offset}&sort=desc`,
+      }));
+    },
+    async addContact(ctx = this, attributes, listIds) {
+      const newContactData = {
+        email: attributes.EMAIL,
+        attributes,
+      };
+      if (listIds) {
+        newContactData.listIds = listIds;
+      }
+      return axios(ctx, this._getRequestParams({
+        method: "POST",
+        path: "/contacts",
+        data: newContactData,
+      }));
+    },
+    async updateContact(ctx = this, identifier, attributes, listIds, unlinkListIds) {
+      const updateContactData = {
+        attributes,
+      };
+      if (listIds) {
+        updateContactData.listIds = listIds;
+      }
+      if (unlinkListIds) {
+        updateContactData.unlinkListIds = unlinkListIds;
+      }
+      return axios(ctx, this._getRequestParams({
+        method: "PUT",
+        path: `/contacts/${identifier}`,
+        data: updateContactData,
+      }));
+    },
+    async sendTransactionalEmail(
+      ctx = this,
+      useTemplate,
+      templateId,
+      sender,
+      replyTo,
+      to,
+      subject,
+      htmlContent,
+      textContent,
+      tags,
+      cc,
+      bcc,
+      params,
+    ) {
+      const emailData = {
+        to,
+        replyTo,
+      };
+      if (useTemplate) {
+        emailData.templateId = templateId;
+      } else {
+        emailData.sender = sender;
+        emailData.subject = subject;
+        emailData.htmlContent = htmlContent;
+      }
+      if (Array.isArray(tags) && tags.length > 0) {
+        emailData.tags = tags;
+      }
+      if (Array.isArray(cc) && cc.length > 0) {
+        emailData.cc = cc;
+      }
+      if (Array.isArray(bcc) && bcc.length > 0) {
+        emailData.bcc = bcc;
+      }
+      if (textContent) {
+        emailData.textContent = textContent;
+      }
+      if (params) {
+        emailData.params = params;
+      }
+      return axios(ctx, this._getRequestParams({
+        method: "POST",
+        path: "/smtp/email",
+        data: emailData,
+      }));
+    },
+  },
+};

package/common/options.mjs

@@ -0,0 +1,26 @@
+export default {
+  marketingEventOptions: [
+    "spam",
+    "opened",
+    "click",
+    "hardBounce",
+    "softBounce",
+    "unsubscribed",
+    "listAddition",
+    "delivered",
+  ],
+  transactionalEventOptions: [
+    "sent",
+    "delivered",
+    "hardBounce",
+    "softBounce",
+    "blocked",
+    "spam",
+    "invalid",
+    "deferred",
+    "click",
+    "opened",
+    "uniqueOpened",
+    "unsubscribed",
+  ],
+};

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@pipedream/brevo",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Brevo Components",
-  "main": "dist/app/brevo.app.mjs",
+  "main": "brevo.app.mjs",
   "keywords": [
     "pipedream",
     "brevo"
   ],
-  "files": [
-    "dist"
-  ],
   "homepage": "https://pipedream.com/apps/brevo",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.5.1"
   }
 }

package/sources/common-webhook.mjs

@@ -0,0 +1,52 @@
+import brevo from "../brevo.app.mjs";
+
+export default {
+  props: {
+    brevo,
+    http: "$.interface.http",
+    db: "$.service.db",
+  },
+  methods: {
+    emitEvent(body) {
+      const meta = this.generateMeta(body);
+      this.$emit(meta, {
+        id: meta.ts,
+        summary: meta.event,
+        ts: meta.ts,
+      });
+    },
+    setHookId(hookId) {
+      this.db.set("hookId", hookId);
+    },
+    getHookId() {
+      return this.db.get("hookId");
+    },
+  },
+  hooks: {
+    async activate() {
+      const eventNames = this.getEventNames();
+      const description = this.getHookDescription();
+      const type = this.getEventType();
+      const createHookData = {
+        description: description,
+        url: this.http.endpoint,
+        events: eventNames,
+        type: type,
+      };
+      const { id } = await this.brevo.createHook(this, createHookData);
+      this.setHookId(id);
+    },
+    async deactivate() {
+      const hookId = this.getHookId();
+      await this.brevo.deleteHook(this, hookId);
+    },
+  },
+  async run(event) {
+    const { body } = event;
+    const hookId = this.getHookId();
+    if (body.id !== hookId) {
+      throw new Error("The request was aborted: registered and requested webhook's id doesn't match.");
+    }
+    this.emitEvent(body);
+  },
+};

package/sources/marketing-webhook/marketing-webhook.mjs

@@ -0,0 +1,46 @@
+import options from "../../common/options.mjs";
+import common from "../common-webhook.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "brevo-marketing-webhook",
+  name: "New Marketing Webhook (Instant)",
+  description: "Emit new event when triggered by a marketing event",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    description: {
+      type: "string",
+      label: "Description",
+      description: "Description of the webhook.",
+    },
+    events: {
+      type: "string[]",
+      label: "Events",
+      description: "Events triggering the webhook.",
+      options: options.marketingEventOptions,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getEventNames() {
+      return this.events;
+    },
+    getHookDescription() {
+      return this.description;
+    },
+    getEventType() {
+      return "marketing";
+    },
+    generateMeta(body) {
+      const meta = {
+        ...body,
+      };
+      return meta;
+    },
+  },
+  sampleEmit,
+};

package/sources/marketing-webhook/test-event.mjs

@@ -0,0 +1,18 @@
+export default {
+  "id": 123,
+  "email": "email@test.com",
+  "message-id": "<2017962224.4320228221195@smtp-relay.mailin.fr>",
+  "date": "2024-01-20 12:17:34",
+  "tags": [
+    "tagTest",
+  ],
+  "tag": "[\"tagTest\"]",
+  "event": "request",
+  "subject": "You have been unsubscribed successfully",
+  "ts_event": 123456789,
+  "ts": 123456789,
+  "template_id": 1,
+  "reason": "sent",
+  "ts_epoch": 123456789,
+  "sender_email": "sender@email.com"
+}

package/sources/transactional-webhook/test-event.mjs

@@ -0,0 +1,18 @@
+export default {
+  "id": 123,
+  "email": "email@test.com",
+  "message-id": "<2017962224.4320228221195@smtp-relay.mailin.fr>",
+  "date": "2024-01-20 12:17:34",
+  "tags": [
+    "tagTest",
+  ],
+  "tag": "[\"tagTest\"]",
+  "event": "request",
+  "subject": "You have been unsubscribed successfully",
+  "ts_event": 123456789,
+  "ts": 123456789,
+  "template_id": 1,
+  "reason": "sent",
+  "ts_epoch": 123456789,
+  "sender_email": "sender@email.com"
+}

package/sources/transactional-webhook/transactional-webhook.mjs

@@ -0,0 +1,46 @@
+import options from "../../common/options.mjs";
+import common from "../common-webhook.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "brevo-transactional-webhook",
+  name: "New Transactional Webhook (Instant)",
+  description: "Emit new event when triggered by a transactional event",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    ...common.props,
+    description: {
+      type: "string",
+      label: "Description",
+      description: "Description of the webhook.",
+    },
+    events: {
+      type: "string[]",
+      label: "Events",
+      description: "Events triggering the webhook.",
+      options: options.transactionalEventOptions,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getEventNames() {
+      return this.events;
+    },
+    getHookDescription() {
+      return this.description;
+    },
+    getEventType() {
+      return "transactional";
+    },
+    generateMeta(body) {
+      const meta = {
+        ...body,
+      };
+      return meta;
+    },
+  },
+  sampleEmit,
+};