@pipedream/selzy 0.0.1 → 0.1.0

package/actions/create-campaign/create-campaign.mjs

@@ -0,0 +1,127 @@
+import { ConfigurationError } from "@pipedream/platform";
+import { clearEmpty } from "../../common/utils.mjs";
+import selzy from "../../selzy.app.mjs";
+
+export default {
+  key: "selzy-create-campaign",
+  name: "Create Campaign",
+  description: "Creates a new campaign. [See the documentation](https://selzy.com/en/support/api/messages/createcampaign/)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    selzy,
+    messageId: {
+      type: "string",
+      label: "Message ID",
+      description: "Code of the message to be sent. The code returned by the **Create Email Message** method should be transferred.",
+      optional: true,
+    },
+    startTime: {
+      type: "string",
+      label: "Start Time",
+      description: "Campaign launch date and time in the \"YYYY-MM-DD hh:mm\" format, which do not exceed 100 days from the current date. If the argument is not set, the campaign starts immediately. The time zone specified in the settings of the user's personal account is applied. To explicitly specify a time zone, use the **Timezone** argument. To provide additional error protection, you should not schedule two sendings of the same message within an hour.",
+      optional: true,
+    },
+    trackRead: {
+      type: "boolean",
+      label: "Track Read",
+      description: "Whether to track the fact of reading the email message. The default value is `false` (do not track). If `true`, a link to a small image tracking the reference will be added to the email. The **Track Read** argument is ignored for SMS messages.",
+      optional: true,
+    },
+    trackLinks: {
+      type: "boolean",
+      label: "Track Links",
+      description: "To track whether there are any click-throughs in email messages, the default value is `false` (do not track). If `true`, all external links will be replaced with special ones that allow you to track the fact of a click-through, and then forward the user to the desired page. The **Track Links** argument is ignored for SMS messages.",
+      optional: true,
+    },
+    contactsUrl: {
+      type: "string",
+      label: "Contacts URL",
+      description: "Instead of the contacts parameter containing the actual email addresses or phone numbers, in this parameter you can specify the URL of the file from which the addresses (phone numbers) will be read. The URL must start with \"http://\", \"https://\" or \"ftp://\". The file must contain one contact per string, without commas; strings must be separated by \"n\" or \"rn\" (Mac format — only \"r\" — not supported). The file can be deleted after the campaign has shifted to the 'scheduled' status.",
+      optional: true,
+    },
+    trackGa: {
+      type: "boolean",
+      label: "Track GA",
+      description: "Whether to enable Google Analytics integration for this campaign. Only explicitly indicated values are valid, default usage parameters are not applied. The default value is `false` (disabled).",
+      optional: true,
+      reloadProps: true,
+    },
+    gaMedium: {
+      type: "string",
+      label: "GA Medium",
+      description: "Integration parameters with Google Analytics (valid if track_ga=1). Only explicitly indicated values are valid, default usage parameters are not applied.",
+      optional: true,
+      hidden: true,
+    },
+    gaSource: {
+      type: "string",
+      label: "GA Source",
+      description: "Integration parameters with Google Analytics (valid if track_ga=1). Only explicitly indicated values are valid, default usage parameters are not applied.",
+      optional: true,
+      hidden: true,
+    },
+    gaCampaign: {
+      type: "string",
+      label: "GA Campaign",
+      description: "Integration parameters with Google Analytics (valid if track_ga=1). Only explicitly indicated values are valid, default usage parameters are not applied.",
+      optional: true,
+      hidden: true,
+    },
+    gaContent: {
+      type: "string",
+      label: "GA Content",
+      description: "Integration parameters with Google Analytics (valid if track_ga=1). Only explicitly indicated values are valid, default usage parameters are not applied.",
+      optional: true,
+      hidden: true,
+    },
+    gaTerm: {
+      type: "string",
+      label: "GA Term",
+      description: "Integration parameters with Google Analytics (valid if track_ga=1). Only explicitly indicated values are valid, default usage parameters are not applied.",
+      optional: true,
+      hidden: true,
+    },
+  },
+  async additionalProps(props) {
+    const gaAllowed = this.trackGa;
+    props.gaMedium.hidden = !gaAllowed;
+    props.gaSource.hidden = !gaAllowed;
+    props.gaCampaign.hidden = !gaAllowed;
+    props.gaContent.hidden = !gaAllowed;
+    props.gaTerm.hidden = !gaAllowed;
+
+    return {};
+  },
+  async run({ $ }) {
+    if (this.contacts && this.contactsUrl) {
+      throw new ConfigurationError("You can't set both contacts and contactsUrl parameters at the same time");
+    }
+
+    const response = await this.selzy.createCampaign({
+      $,
+      params: clearEmpty({
+        message_id: this.messageId,
+        start_time: this.startTime,
+        track_read: this.trackRead
+          ? 1
+          : 0,
+        track_links: this.trackLinks
+          ? 1
+          : 0,
+        contacts_url: this.contactsUrl,
+        track_ga: this.trackGa && +this.trackGa,
+        ga_medium: this.gaMedium,
+        ga_source: this.gaSource,
+        ga_campaign: this.gaCampaign,
+        ga_content: this.gaContent,
+        ga_term: this.gaTerm,
+      }),
+    });
+
+    if (response.error) throw new ConfigurationError(response.error);
+
+    $.export("$summary", `Successfully created email campaign with ID: ${response.result.campaign_id}`);
+    return response;
+  },
+};

package/actions/create-email-message/create-email-message.mjs

@@ -0,0 +1,135 @@
+import { ConfigurationError } from "@pipedream/platform";
+import {
+  MESSAGE_FORMAT_OPTIONS, WRAP_TYPE_OPTIONS,
+} from "../../common/constants.mjs";
+import { parseObject } from "../../common/utils.mjs";
+import selzy from "../../selzy.app.mjs";
+
+export default {
+  key: "selzy-create-email-message",
+  name: "Create Email Message",
+  description: "Adds a new email message. [See the documentation](https://selzy.com/en/support/category/api/messages/)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    selzy,
+    senderName: {
+      type: "string",
+      label: "Sender's name",
+      description: "It is a string that does not match the email address (the sender_email argument).",
+    },
+    senderEmail: {
+      type: "string",
+      label: "Sender's email address",
+      description: "This email must be checked (to do this, you need to manually create at least one email with this return address via the web interface, then click on the \"send the confirmation request\" link and follow the link from the email).",
+    },
+    subject: {
+      type: "string",
+      label: "Subject",
+      description: "String with the letter subject. It may include substitution fields. If you wish to use substitution fields, specify a string within a Pipedream Custom Expression and escape the curly brackets with a backslash. For example: `{{ \"Welcome to Our Newsletter, \\{\\{Name\\}\\}!\" }}`. The parameter is optional if Template Id is indicated.",
+    },
+    body: {
+      type: "string",
+      label: "Body",
+      description: "HTML body of the letter. It may include substitution fields. If you wish to use substitution fields, specify an HTML string within a Pipedream Custom Expression and escape the curly brackets with a backslash. For example: `{{ \"<p>Hello \\{\\{Name\\}\\},</p><p>Here is your update.</p>\" }}`.",
+    },
+    listId: {
+      propDefinition: [
+        selzy,
+        "listId",
+      ],
+    },
+    textBody: {
+      type: "string",
+      label: "Text Body",
+      description: "Text body of the letter. It may include substitution fields. If you wish to use substitution fields, specify a text string within a Pipedream Custom Expression and escape the curly brackets with a backslash. For example: `{{ \"Hello \\{\\{Name\\}\\},\\nHere is your update.\" }}`.",
+      optional: true,
+    },
+    generateText: {
+      type: "boolean",
+      label: "Generate Text",
+      description: "`True` means that the text part of the letter will be generated automatically based on the HTML part. If you do not provide the text version along with the HTML version, you are recommended to set the **Generate Text** parameter to `true` for automatic generation of the text part of the letter. If the text variant of the letter is provided using the **Text Body** parameter, the **Generate Text** parameter is ignored. Thus, if the **Generate Text** value has been set to `true`, the server's response will contain a warning.",
+    },
+    rawBody: {
+      type: "string",
+      label: "Raw Body",
+      description: "It is intended to save the json structure of the block editor data structure (if the value is **Message Format** = block) The parameter obtains only the JSON structure, otherwise it will not be transferred.",
+      optional: true,
+    },
+    messageFormat: {
+      type: "string",
+      label: "Message Format",
+      description: `It defines the manner of creating a letter.
+        \n 1 - If you transfer the \`text\` value in this parameter and both the body and **Text Body** parameters are filled, the body parameter will be ignored, and the letter will be created from the data, transferred in the **Text Body** parameter.
+        \n 2 - If you transfer the \`block\` value in this parameter but do not specify **Raw Body**, the letter will be saved as **Raw HTML**.
+        \n 3 - If you transfer the \`block\` value in this parameter, the **body** and **Raw Body** parameters must be transferred so taht you can save the message in the block editor format.`,
+      options: MESSAGE_FORMAT_OPTIONS,
+      optional: true,
+    },
+    lang: {
+      type: "string",
+      label: "Lang",
+      description: `Two-letter language code for the string with the unsubscribe link that is added to each letter automatically.
+        If it is not specified, the language code from the API URL is used.
+        In addition to the string with the unsubscribe link, this language also affects the interface of the unsubscribe page. Languages en, it, ua and ru are fully supported, and in case of some other languages (da, de, es, fr, nl, pl, pt, tr), the string with a link will be translated, and the control interface will be in English.`,
+      optional: true,
+    },
+    templateId: {
+      propDefinition: [
+        selzy,
+        "templateId",
+      ],
+      optional: true,
+    },
+    systemTemplateId: {
+      propDefinition: [
+        selzy,
+        "systemTemplateId",
+      ],
+      optional: true,
+    },
+    wrapType: {
+      type: "string",
+      label: "Wrap Type",
+      description: "Alignment of the message text on the specified side. If the argument is missing, the text will not be aligned.",
+      options: WRAP_TYPE_OPTIONS,
+      optional: true,
+    },
+    categories: {
+      type: "string[]",
+      label: "Categories",
+      description: "A list of letter categories.",
+      optional: true,
+    },
+  },
+  async run({ $ }) {
+    if (this.templateId && this.systemTemplateId) {
+      throw new ConfigurationError("You can only use one of the Template Id or System Template Id parameters.");
+    }
+    const response = await this.selzy.createEmailMessage({
+      $,
+      params: {
+        sender_name: this.senderName,
+        sender_email: this.senderEmail,
+        subject: this.subject,
+        body: this.body,
+        list_id: this.listId,
+
+        text_body: this.textBody,
+        generate_text: +this.generateText,
+        raw_body: this.rawBody,
+        message_format: this.messageFormat,
+        lang: this.lang,
+        template_id: this.templateId,
+        system_template_id: this.systemTemplateId,
+        wrap_type: this.wrapType,
+        categories: parseObject(this.categories)?.join(","),
+      },
+    });
+
+    if (response.error) throw new ConfigurationError(response.error);
+
+    $.export("$summary", `Email message created successfully with ID ${response.result.message_id}.`);
+    return response;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,35 @@
+export const LIMIT = 100;
+
+export const MESSAGE_FORMAT_OPTIONS = [
+  {
+    label: "Raw HTML",
+    value: "raw_html",
+  },
+  {
+    label: "Block",
+    value: "block",
+  },
+  {
+    label: "Text",
+    value: "text",
+  },
+];
+
+export const WRAP_TYPE_OPTIONS = [
+  {
+    label: "Skip (Do not apply)",
+    value: "skip",
+  },
+  {
+    label: "Right (Right alignment)",
+    value: "right",
+  },
+  {
+    label: "Left (Left alignment)",
+    value: "left",
+  },
+  {
+    label: "Center (Center alignment)",
+    value: "center",
+  },
+];

package/common/utils.mjs

@@ -0,0 +1,38 @@
+export const parseObject = (obj) => {
+  if (!obj) return undefined;
+
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (typeof item === "string") {
+        try {
+          return JSON.parse(item);
+        } catch (e) {
+          return item;
+        }
+      }
+      return item;
+    });
+  }
+  if (typeof obj === "string") {
+    try {
+      return JSON.parse(obj);
+    } catch (e) {
+      return obj;
+    }
+  }
+  return obj;
+};
+
+export const clearEmpty = (obj) => {
+  if (!obj) return undefined;
+
+  const newObj = {
+    ...obj,
+  };
+  Object.keys(newObj).forEach((key) => {
+    if (newObj[key] === "" || newObj[key] === null || newObj[key] === undefined) {
+      delete newObj[key];
+    }
+  });
+  return newObj;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/selzy",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Pipedream Selzy Components",
   "main": "selzy.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^3.0.3"
   }
 }

package/selzy.app.mjs

@@ -1,11 +1,198 @@
+import { axios } from "@pipedream/platform";
+import { LIMIT } from "./common/constants.mjs";
+
 export default {
   type: "app",
   app: "selzy",
-  propDefinitions: {},
+  propDefinitions: {
+    listId: {
+      type: "string",
+      label: "List ID",
+      description: "Code of the list on which the mailing will be sent.",
+      async options() {
+        const { result } = await this.listLists();
+
+        return result.map(({
+          id: value, title: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    templateId: {
+      type: "string",
+      label: "Template Id",
+      description: "ID of the user letter template created before, on the basis of which a letter can be created. If you have transferred this parameter, you may skip the mandatory **Subject**, **Body**, as well as **Text Body** and **Lang** parameters. These values will be taken from the corresponding parameters of the template the id of which was specified. If any of the above parameters is still transferred, the system will ignore the parameter that is taken from the template parameters, and the parameter explicitly transferred in this method will be used.",
+      async options({ page }) {
+        const { result } = await this.listTemplates({
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+            type: "user",
+          },
+        });
+
+        return result.map(({
+          id: value, title: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    systemTemplateId: {
+      type: "string",
+      label: "System Template Id",
+      description: "ID of the system letter template created before, on the basis of which a letter can be created. If you have transferred this parameter, you may skip the mandatory **Subject**, **Body**, as well as **Text Body** and **Lang** parameters. These values will be taken from the corresponding parameters of the template the id of which was specified. If any of the above parameters is still transferred, the system will ignore the parameter that is taken from the template parameters, and the parameter explicitly transferred in this method will be used. If none of the **Template Id** or **System Template Id** parameters is specified, templates will not be used to create the letter.",
+      async options({ page }) {
+        const { result } = await this.listTemplates({
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+            type: "system",
+          },
+        });
+
+        return result.map(({
+          id: value, title: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    messageId: {
+      type: "string",
+      label: "Message Id",
+      description: "Code of the message to be sent.",
+      async options({ page }) {
+        const { result } = await this.listTemplates({
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+            type: "system",
+          },
+        });
+
+        return result.map(({
+          id: value, title: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+
+    campaignId: {
+      type: "string",
+      label: "Campaign ID",
+      description: "Select or enter the Campaign ID to monitor",
+      async options() {
+        const campaigns = await this.getCampaigns();
+        return campaigns.map((campaign) => ({
+          label: campaign.name,
+          value: campaign.id,
+        }));
+      },
+    },
+    messageContent: {
+      type: "string",
+      label: "Message Content",
+      description: "Content of the email message",
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    _baseUrl() {
+      return "https://api.selzy.com/en/api";
+    },
+    _params(params = {}) {
+      return {
+        api_key: `${this.$auth.api_key}`,
+        format: "json",
+        ...params,
+      };
+    },
+    _makeRequest({
+      $ = this, path, params, ...opts
+    }) {
+      return axios($, {
+        url: this._baseUrl() + path,
+        params: this._params(params),
+        ...opts,
+      });
+    },
+    listLists(opts = {}) {
+      return this._makeRequest({
+        path: "/getLists",
+        ...opts,
+      });
+    },
+    listTemplates(opts = {}) {
+      return this._makeRequest({
+        path: "/listTemplates",
+        ...opts,
+      });
+    },
+    getCampaigns(opts = {}) {
+      return this._makeRequest({
+        path: "/getCampaigns",
+        ...opts,
+      });
+    },
+    createEmailMessage(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/createEmailMessage",
+        ...opts,
+      });
+    },
+    createCampaign(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/createCampaign",
+        ...opts,
+      });
+    },
+    createWebhook(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/setHook",
+        ...opts,
+      });
+    },
+    deleteWebhook(opts = {}) {
+      return this._makeRequest({
+        method: "POST",
+        path: "/removeHook",
+        ...opts,
+      });
+    },
+    async *paginate({
+      fn, params = {}, maxResults = null, ...opts
+    }) {
+      let hasMore = false;
+      let count = 0;
+      let page = 0;
+
+      do {
+        params.limit = LIMIT;
+        params.offset = LIMIT * page++;
+        const { result } = await fn({
+          params,
+          ...opts,
+        });
+        for (const d of result) {
+          yield d;
+
+          if (maxResults && ++count === maxResults) {
+            return count;
+          }
+        }
+
+        hasMore = result.length;
+
+      } while (hasMore);
     },
   },
-};
+};

package/sources/common/base.mjs

@@ -0,0 +1,49 @@
+import selzy from "../../selzy.app.mjs";
+
+export default {
+  props: {
+    selzy,
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
+    db: "$.service.db",
+  },
+  hooks: {
+    async activate() {
+      await this.selzy.createWebhook({
+        params: {
+          hook_url: this.http.endpoint,
+          event_format: "json_post",
+          ...this.getEventType(),
+          single_event: 1,
+          status: "active",
+        },
+      });
+    },
+    async deactivate() {
+      await this.selzy.deleteWebhook({
+        params: {
+          hook_url: this.http.endpoint,
+        },
+      });
+    },
+  },
+  async run({
+    body, method,
+  }) {
+    if (method === "GET") {
+      this.http.respond({
+        status: 200,
+      });
+      return true;
+    }
+
+    const ts = Date.parse(body.event_time);
+    this.$emit(body, {
+      id: `${body.campaign_id || body.email}-${ts}`,
+      summary: this.getSummary(body),
+      ts: ts,
+    });
+  },
+};

package/sources/new-campaign/new-campaign.mjs

@@ -0,0 +1,67 @@
+import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
+import selzy from "../../selzy.app.mjs";
+
+export default {
+  key: "selzy-new-campaign",
+  name: "New Campaign Created",
+  description: "Emit new event when a new email campaign is created. Useful for monitoring campaign creation activity.",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    selzy,
+    db: "$.service.db",
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+  },
+  methods: {
+    _getLastId() {
+      return this.db.get("lastId") || 0;
+    },
+    _setLastId(lastId) {
+      this.db.set("lastId", lastId);
+    },
+    async emitEvent(maxResults = false) {
+      const lastId = this._getLastId();
+
+      const response = this.selzy.paginate({
+        fn: this.selzy.getCampaigns,
+      });
+
+      let responseArray = [];
+      for await (const item of response) {
+        responseArray.push(item);
+      }
+
+      responseArray = responseArray.filter((item) => item.id > lastId).sort((a, b) => b.id - a.id);
+
+      if (responseArray.length) {
+        if (maxResults && (responseArray.length > maxResults)) {
+          responseArray.length = maxResults;
+        }
+
+        this._setLastId(responseArray[0].id);
+      }
+
+      for (const item of responseArray.reverse()) {
+        this.$emit(item, {
+          id: item.id,
+          summary: `New campaign created: ${item.id}`,
+          ts: Date.now(),
+        });
+      }
+    },
+  },
+  hooks: {
+    async deploy() {
+      await this.emitEvent(25);
+    },
+  },
+  async run() {
+    await this.emitEvent();
+  },
+};

package/sources/new-campaign/test-event.mjs

@@ -0,0 +1,11 @@
+export default {
+  "id": 326794048,
+  "start_time": "2025-06-10 18:12:00",
+  "status": "waits_schedule",
+  "message_id": 230193688,
+  "list_id": 1,
+  "subject": "Subject Name",
+  "sender_name": "Sender Name",
+  "sender_email": "sender@email.com.br",
+  "stats_url": "https://api.selzy.com/en/v5/campaigns/123456789"
+}

package/sources/new-campaign-status-instant/new-campaign-status-instant.mjs

@@ -0,0 +1,24 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "selzy-new-campaign-status-instant",
+  name: "New Campaign Status (Instant)",
+  description: "Emit new event when the status of a campaign changes.",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getEventType() {
+      return {
+        "events[campaign_status]": "*",
+      };
+    },
+    getSummary(body) {
+      return `Campaign status updated to ${body.status}`;
+    },
+  },
+  sampleEmit,
+};

package/sources/new-campaign-status-instant/test-event.mjs

@@ -0,0 +1,13 @@
+export default {
+  "auth": "974d2fec2b89aeb00195ab4419371b09",
+  "login": "ID7208007",
+  "event_name": "campaign_status",
+  "event_time": "2025-05-16 19:55:56",
+  "campaign_id": 326794044,
+  "status": "canceled",
+  "contact_count": 0,
+  "period_messages": 0,
+  "prepaid_messages": 0,
+  "pay_sum": 0,
+  "currency": "USD"
+}

package/sources/new-subscriber-instant/new-subscriber-instant.mjs

@@ -0,0 +1,37 @@
+import common from "../common/base.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  ...common,
+  key: "selzy-new-subscriber-instant",
+  name: "New Subscriber (Instant)",
+  description: "Emit new event when a new contact subscribes to a specified list.",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    	...common.props,
+    listId: {
+      propDefinition: [
+        common.props.selzy,
+        "listId",
+      ],
+      description: "Code of the list you want to monitor.",
+      optional: true,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getEventType() {
+      return {
+        "events[subscribe]": this.listId
+          ? this.listId
+          : "*",
+      };
+    },
+    getSummary(body) {
+      return `New subscriber: ${body.email}`;
+    },
+  },
+  sampleEmit,
+};

package/sources/new-subscriber-instant/test-event.mjs

@@ -0,0 +1,10 @@
+export default {
+  "auth": "21f6bf566f216300c5a6080ecfa89b75",
+  "login": "ID2070078",
+  "event_name": "subscribe",
+  "event_time": "2025-05-16 20:23:28",
+  "email": "subscriber@email.com",
+  "subscribed_list_ids": [
+    3
+  ]
+}