@pipedream/salesforce_rest_api 0.3.3

package/salesforce_rest_api.app.mjs

@@ -0,0 +1,247 @@
+import { axios } from "@pipedream/platform";
+import salesforceWebhooks from "salesforce-webhooks";
+const { SalesforceClient } = salesforceWebhooks;
+
+export default {
+  type: "app",
+  app: "salesforce_rest_api",
+  propDefinitions: {
+    objectType: {
+      type: "string",
+      label: "Object Type",
+      description: "The type of object for which to monitor events",
+      async options(context) {
+        const {
+          page,
+          eventType,
+        } = context;
+        if (page !== 0) {
+          // The list of allowed SObject types is static and exhaustively
+          // provided through a single method call
+          return [];
+        }
+
+        const supportedObjectTypes = this.listAllowedSObjectTypes(eventType);
+        const options = supportedObjectTypes.map((i) => ({
+          label: i.label,
+          value: i.name,
+        }));
+        return {
+          options,
+        };
+      },
+    },
+    field: {
+      type: "string",
+      label: "Field",
+      description: "The object field to watch for changes",
+      async options(context) {
+        const {
+          page,
+          objectType,
+        } = context;
+        if (page !== 0) {
+          return {
+            options: [],
+          };
+        }
+
+        const fields = await this.getFieldsForObjectType(objectType);
+        return fields.map((field) => field.name);
+      },
+    },
+    fieldUpdatedTo: {
+      type: "string",
+      label: "Field Updated to",
+      description: "If provided, the trigger will only fire when the updated field is an EXACT MATCH (including spacing and casing) to the value you provide in this field",
+      optional: true,
+    },
+  },
+  methods: {
+    _authToken() {
+      return this.$auth.oauth_access_token;
+    },
+    _instance() {
+      return this.$auth.yourinstance;
+    },
+    _instanceUrl() {
+      return this.$auth.instance_url;
+    },
+    _subdomain() {
+      return (
+        this._instance() ||
+        this._instanceUrl()
+          .replace("https://", "")
+          .replace(".salesforce.com", "")
+      );
+    },
+    _apiVersion() {
+      return "50.0";
+    },
+    _baseApiUrl() {
+      return (
+        this._instanceUrl() ||
+        `https://${this._subdomain()}.salesforce.com`
+      );
+    },
+    _userApiUrl() {
+      const baseUrl = this._baseApiUrl();
+      return `${baseUrl}/services/oauth2/userinfo`;
+    },
+    _sObjectsApiUrl() {
+      const baseUrl = this._baseApiUrl();
+      const apiVersion = this._apiVersion();
+      return `${baseUrl}/services/data/v${apiVersion}/sobjects`;
+    },
+    _sObjectTypeDescriptionApiUrl(sObjectType) {
+      const baseUrl = this._sObjectsApiUrl();
+      return `${baseUrl}/${sObjectType}/describe`;
+    },
+    _sObjectTypeUpdatedApiUrl(sObjectType) {
+      const baseUrl = this._sObjectsApiUrl();
+      return `${baseUrl}/${sObjectType}/updated`;
+    },
+    _sObjectTypeDeletedApiUrl(sObjectType) {
+      const baseUrl = this._sObjectsApiUrl();
+      return `${baseUrl}/${sObjectType}/deleted`;
+    },
+    _sObjectDetailsApiUrl(sObjectType, id) {
+      const baseUrl = this._sObjectsApiUrl();
+      return `${baseUrl}/${sObjectType}/${id}`;
+    },
+    _makeRequestHeaders() {
+      const authToken = this._authToken();
+      return {
+        "Authorization": `Bearer ${authToken}`,
+        "User-Agent": "@PipedreamHQ/pipedream v0.1",
+      };
+    },
+    _makeRequestConfig() {
+      const headers = this._makeRequestHeaders();
+      return {
+        method: "GET",
+        headers,
+      };
+    },
+    async _makeRequest(opts) {
+      const {
+        $,
+        ...requestOpts
+      } = opts;
+      const baseRequestConfig = this._makeRequestConfig();
+      const requestConfig = {
+        ...baseRequestConfig,
+        ...requestOpts,
+      };
+      return axios($ ?? this, requestConfig);
+    },
+    _formatDateString(dateString) {
+      // Remove milliseconds from date ISO string
+      return dateString.replace(/\.[0-9]{3}/, "");
+    },
+    _getSalesforceClient() {
+      const clientOpts = {
+        apiVersion: this._apiVersion(),
+        authToken: this._authToken(),
+        instance: this._subdomain(),
+      };
+      return new SalesforceClient(clientOpts);
+    },
+    isHistorySObject(sobject) {
+      return sobject.associateEntityType === "History" && sobject.name.includes("History");
+    },
+    listAllowedSObjectTypes(eventType) {
+      const verbose = true;
+      return SalesforceClient.getAllowedSObjects(eventType, verbose);
+    },
+    async createWebhook(endpointUrl, sObjectType, event, secretToken, opts) {
+      const {
+        fieldsToCheck,
+        fieldsToCheckMode,
+      } = opts;
+      const client = this._getSalesforceClient();
+      const webhookOpts = {
+        endpointUrl,
+        sObjectType,
+        event,
+        secretToken,
+        fieldsToCheck,
+        fieldsToCheckMode,
+      };
+      return client.createWebhook(webhookOpts);
+    },
+    async deleteWebhook(webhookData) {
+      const client = this._getSalesforceClient();
+      return client.deleteWebhook(webhookData);
+    },
+    async listSObjectTypes() {
+      const url = this._sObjectsApiUrl();
+      return this._makeRequest({
+        url,
+      });
+    },
+    async getNameFieldForObjectType(objectType) {
+      const url = this._sObjectTypeDescriptionApiUrl(objectType);
+      const data = await this._makeRequest({
+        url,
+      });
+      const nameField = data.fields.find((f) => f.nameField);
+      return nameField !== undefined
+        ? nameField.name
+        : "Id";
+    },
+    async getFieldsForObjectType(objectType) {
+      const url = this._sObjectTypeDescriptionApiUrl(objectType);
+      const data = await this._makeRequest({
+        url,
+      });
+      return data.fields;
+    },
+    async getHistorySObjectForObjectType(objectType) {
+      const { sobjects } = await this.listSObjectTypes();
+      const historyObject = sobjects.find(
+        (sobject) => sobject.associateParentEntity === objectType
+            && this.isHistorySObject(sobject),
+      );
+      return historyObject;
+    },
+    async getSObject(objectType, id) {
+      const url = this._sObjectDetailsApiUrl(objectType, id);
+      return this._makeRequest({
+        url,
+      });
+    },
+    async getUpdatedForObjectType(objectType, start, end) {
+      const url = this._sObjectTypeUpdatedApiUrl(objectType);
+      const params = {
+        start: this._formatDateString(start),
+        end: this._formatDateString(end),
+      };
+      return this._makeRequest({
+        url,
+        params,
+      });
+    },
+    async getDeletedForObjectType(objectType, start, end) {
+      const url = this._sObjectTypeDeletedApiUrl(objectType);
+      const params = {
+        start: this._formatDateString(start),
+        end: this._formatDateString(end),
+      };
+      return this._makeRequest({
+        url,
+        params,
+      });
+    },
+    async getUserInfo(authToken) {
+      const url = this._userApiUrl();
+      return this._makeRequest({
+        url,
+        headers: {
+          ...this._makeRequestHeaders(),
+          "Authorization": `Bearer ${authToken}`,
+        },
+      });
+    },
+  },
+};

package/sources/common-instant.mjs

@@ -0,0 +1,134 @@
+import { v4 as uuidv4 } from "uuid";
+
+import salesforce from "../salesforce_rest_api.app.mjs";
+
+export default {
+  dedupe: "unique",
+  props: {
+    db: "$.service.db",
+    // eslint-disable-next-line pipedream/props-label,pipedream/props-description
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
+    salesforce,
+    // Not inheriting `objectType` propDefinition from salesforce so `this` in async options has
+    // component instance's methods
+    objectType: {
+      ...salesforce.propDefinitions.objectType,
+      label: salesforce.propDefinitions.objectType.label,
+      description: salesforce.propDefinitions.objectType.description,
+      async options(context) {
+        return salesforce.propDefinitions.objectType.options.call(this.salesforce, {
+          ...context,
+          eventType: this.getEventType(),
+        });
+      },
+    },
+  },
+  hooks: {
+    async activate() {
+      // Retrieve metadata about the SObject specified by the user
+      const nameField = await this.salesforce.getNameFieldForObjectType(this.objectType);
+      this.setNameField(nameField);
+
+      // Create the webhook in the Salesforce platform
+      const secretToken = uuidv4();
+      let webhookData;
+      try {
+        webhookData = await this.salesforce.createWebhook(
+          this.http.endpoint,
+          this.objectType,
+          this.getEventType(),
+          secretToken,
+          {
+            fieldsToCheck: this.getFieldsToCheck(),
+            fieldsToCheckMode: this.getFieldsToCheckMode(),
+          },
+        );
+      } catch (err) {
+        console.log("Create webhook error:", err.response?.data ?? err);
+        throw err;
+      }
+      this._setSecretToken(secretToken);
+      this._setWebhookData(webhookData);
+    },
+    async deactivate() {
+      // Create the webhook from the Salesforce platform
+      const webhookData = this._getWebhookData();
+      await this.salesforce.deleteWebhook(webhookData);
+    },
+  },
+  methods: {
+    _getSecretToken() {
+      return this.db.get("secretToken");
+    },
+    _setSecretToken(secretToken) {
+      this.db.set("secretToken", secretToken);
+    },
+    _getWebhookData() {
+      return this.db.get("webhookData");
+    },
+    _setWebhookData(webhookData) {
+      this.db.set("webhookData", webhookData);
+    },
+    getNameField() {
+      return this.db.get("nameField");
+    },
+    setNameField(nameField) {
+      this.db.set("nameField", nameField);
+    },
+    _isValidSource(event) {
+      const webhookToken = event.headers["x-webhook-token"];
+      const secretToken = this._getSecretToken();
+      return webhookToken === secretToken;
+    },
+    processEvent(event) {
+      const { body } = event;
+      const meta = this.generateMeta(event);
+      this.$emit(body, meta);
+    },
+    generateMeta() {
+      throw new Error("generateMeta is not implemented");
+    },
+    getEventType() {
+      throw new Error("getEventType is not implemented");
+    },
+    /**
+     * This method returns the fields in the SObject type (e.g. Account, Lead, etc.) that the event
+     * source should listen for updates to. This base implementation returns `undefined`, to not
+     * necessitate any specific fields to be updated.
+     *
+     * @returns the fields in the SObject type for which to receive updates
+     */
+    getFieldsToCheck() {
+      return undefined;
+    },
+    /**
+     * This method returns whether the event source should listen for updates where `all` the fields
+     * in the SObject are updated, or when `any` of them are. This base implementation returns
+     * `undefined` to use to client's default `fieldToCheckMode` (`any`).
+     *
+     * @returns whether the webhook should receive events when `all` the fields to check are
+     * updated, or when `any` of them are
+     */
+    getFieldsToCheckMode() {
+      return undefined;
+    },
+  },
+  async run(event) {
+    if (!this._isValidSource(event)) {
+      this.http.respond({
+        statusCode: 404,
+      });
+      console.log("Skipping event from unrecognized source");
+      return;
+    }
+
+    this.http.respond({
+      statusCode: 200,
+    });
+
+    await this.processEvent(event);
+  },
+};

package/sources/common.mjs

@@ -0,0 +1,96 @@
+import salesforce from "../salesforce_rest_api.app.mjs";
+
+export default {
+  dedupe: "unique",
+  props: {
+    db: "$.service.db",
+    salesforce,
+    // eslint-disable-next-line pipedream/props-label,pipedream/props-description
+    timer: {
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60 * 15, // 15 minutes
+      },
+    },
+    // Not inheriting `objectType` propDefinition from salesforce so `this` in async options has
+    // component instance's methods
+    objectType: {
+      ...salesforce.propDefinitions.objectType,
+      label: salesforce.propDefinitions.objectType.label,
+      description: salesforce.propDefinitions.objectType.description,
+      async options(context) {
+        const { page } = context;
+        if (page !== 0) {
+          return {
+            options: [],
+          };
+        }
+
+        const { sobjects } = await this.salesforce.listSObjectTypes();
+        const options = sobjects
+          .filter(this.isValidSObject)
+          .map((sobject) => ({
+            label: sobject.label,
+            value: sobject.name,
+          }));
+        return {
+          options,
+        };
+      },
+    },
+  },
+  hooks: {
+    async activate() {
+      const latestDateCovered = this.getLatestDateCovered();
+      if (!latestDateCovered) {
+        const now = new Date().toISOString();
+        this.setLatestDateCovered(now);
+      }
+
+      const nameField = await this.salesforce.getNameFieldForObjectType(this.objectType);
+      this.setNameField(nameField);
+    },
+  },
+  methods: {
+    getLatestDateCovered() {
+      return this.db.get("latestDateCovered");
+    },
+    setLatestDateCovered(latestDateCovered) {
+      this.db.set("latestDateCovered", latestDateCovered);
+    },
+    getNameField() {
+      return this.db.get("nameField");
+    },
+    setNameField(nameField) {
+      this.db.set("nameField", nameField);
+    },
+    isValidSObject(sobject) {
+      // Only the activity of those SObject types that have the `replicateable`
+      // flag set is published via the `getUpdated` API.
+      //
+      // See the API docs here: https://sforce.co/3gDy3uP
+      return sobject.replicateable;
+    },
+    processEvent() {
+      throw new Error("processEvent is not implemented");
+    },
+  },
+  async run(event) {
+    const startTimestamp = this.getLatestDateCovered();
+    const endTimestamp = new Date(event.timestamp * 1000).toISOString();
+    const timeDiffSec = Math.floor(
+      (Date.parse(endTimestamp) - Date.parse(startTimestamp)) / 1000,
+    );
+    if (timeDiffSec < 60) {
+      console.log(`
+        Skipping execution since the last one happened approximately ${timeDiffSec} seconds ago
+      `);
+      return;
+    }
+
+    await this.processEvent({
+      startTimestamp,
+      endTimestamp,
+    });
+  },
+};

package/sources/new-object/new-object.mjs

@@ -0,0 +1,69 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common.mjs";
+
+export default {
+  ...common,
+  type: "source",
+  name: "New Object (of Selectable Type)",
+  key: "salesforce_rest_api-new-object",
+  description: "Emit new event (at regular intervals) when an object of arbitrary type (selected as an input parameter by the user) is created. See [the docs](https://sforce.co/3yPSJZy) for more information.",
+  version: "0.0.5",
+  methods: {
+    ...common.methods,
+    isItemRelevant(item, startTimestamp, endTimestamp) {
+      const startDate = Date.parse(startTimestamp);
+      const endDate = Date.parse(endTimestamp);
+      const createdDate = Date.parse(item.CreatedDate);
+      return startDate <= createdDate && endDate >= createdDate;
+    },
+    generateMeta(item) {
+      const nameField = this.getNameField();
+      const {
+        CreatedDate: createdDate,
+        Id: id,
+        [nameField]: name,
+      } = item;
+      const entityType = startCase(this.objectType);
+      const summary = `New ${entityType} created: ${name}`;
+      const ts = Date.parse(createdDate);
+      return {
+        id,
+        summary,
+        ts,
+      };
+    },
+    async processEvent(eventData) {
+      const {
+        startTimestamp,
+        endTimestamp,
+      } = eventData;
+      const {
+        ids,
+        latestDateCovered,
+      } = await this.salesforce.getUpdatedForObjectType(
+        this.objectType,
+        startTimestamp,
+        endTimestamp,
+      );
+
+      // By the time we try to retrieve an item, it might've been deleted. This
+      // will cause `getSObject` to throw a 404 exception, which will reject its
+      // promise. Hence, we need to filter those items that we still in Salesforce
+      // and exclude those that are not.
+      const itemRetrievals = await Promise.allSettled(
+        ids.map((id) => this.salesforce.getSObject(this.objectType, id)),
+      );
+      itemRetrievals
+        .filter((result) => result.status === "fulfilled")
+        .map((result) => result.value)
+        .filter((item) => this.isItemRelevant(item, startTimestamp, endTimestamp))
+        .forEach((item) => {
+          const meta = this.generateMeta(item);
+          this.$emit(item, meta);
+        });
+
+      this.setLatestDateCovered(latestDateCovered);
+    },
+  },
+};

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

@@ -0,0 +1,35 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common-instant.mjs";
+
+export default {
+  ...common,
+  type: "source",
+  name: "New Object (Instant, of Selectable Type)",
+  key: "salesforce_rest_api-new-object-instant",
+  description: "Emit new event immediately after an object of arbitrary type (selected as an input parameter by the user) is created",
+  version: "0.0.5",
+  methods: {
+    ...common.methods,
+    generateMeta(data) {
+      const nameField = this.getNameField();
+      const { New: newObject } = data.body;
+      const {
+        CreatedDate: createdDate,
+        Id: id,
+        [nameField]: name,
+      } = newObject;
+      const entityType = startCase(this.objectType).toLowerCase();
+      const summary = `New ${entityType} created: ${name}`;
+      const ts = Date.parse(createdDate);
+      return {
+        id,
+        summary,
+        ts,
+      };
+    },
+    getEventType() {
+      return "new";
+    },
+  },
+};

package/sources/new-outbound-message/new-outbound-message.mjs

@@ -0,0 +1,105 @@
+import { XMLParser } from "fast-xml-parser";
+import salesforce from "../../salesforce_rest_api.app.mjs";
+
+export default {
+  type: "source",
+  name: "New Outbound Message (Instant)",
+  key: "salesforce_rest_api-new-outbound-message",
+  description: "Emit new event when a new outbound message is received in Salesforce. See Salesforce's guide on setting up [Outbound Messaging](https://sforce.co/3JbZJom). Set the Outbound Message's Endpoint URL to the endpoint of the created source. The \"Send Session ID\" option must be enabled for validating outbound messages from Salesforce.",
+  version: "0.0.2",
+  dedupe: "unique",
+  props: {
+    db: "$.service.db",
+    // eslint-disable-next-line pipedream/props-label,pipedream/props-description
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
+    salesforce,
+  },
+  methods: {
+    _unwrapMessage(message) {
+      const parser = new XMLParser({
+        removeNSPrefix: true,
+      });
+      const obj = parser.parse(message);
+      const notifications = obj["Envelope"]["Body"].notifications;
+      return notifications;
+    },
+    _sendHttpResponse(successValue = true, status) {
+      // eslint-disable-next-line multiline-ternary
+      status = status ?? (successValue ? 200 : 400);
+      this.http.respond({
+        status,
+        body: `
+          <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+          xmlns:out="http://soap.sforce.com/2005/09/outbound">
+            <soapenv:Header/>
+            <soapenv:Body>
+              <out:notificationsResponse>
+                <out:Ack>${successValue}</out:Ack>
+              </out:notificationsResponse>
+            </soapenv:Body>
+          </soapenv:Envelope>
+        `,
+        headers: {
+          "content-type": "text/xml",
+        },
+      });
+    },
+    async _isValidSessionId(sessionId) {
+      try {
+        const data = await this.salesforce.getUserInfo(sessionId);
+        return Boolean(data);
+      } catch (err) {
+        console.log("Error validating SessionId:", err);
+        return false;
+      }
+    },
+    async _isValidSource(data) {
+      const { SessionId: sessionId } = data;
+      if (!sessionId) {
+        throw new Error("The outbound message is missing a Session ID. Please configure the outbound message to send Session ID to validate the webhook source.");
+      }
+
+      return this._isValidSessionId(sessionId);
+    },
+    generateMeta(data) {
+      const {
+        ActionId: actionId,
+        Notification: { Id: eventId },
+      } = data;
+      const id = `${eventId}-${actionId}`;
+      const summary = JSON.stringify(data);
+      const ts = Date.now();
+      return {
+        id,
+        summary,
+        ts,
+      };
+    },
+  },
+  async run(event) {
+    const { bodyRaw } = event;
+    this._sendHttpResponse(true);
+    const data = this._unwrapMessage(bodyRaw);
+    if (!(await this._isValidSource(data))) {
+      console.log("Skipping event from unrecognized source");
+      return;
+    }
+
+    let notifications = data.Notification;
+    if (!Array.isArray(notifications)) {
+      notifications = [
+        data.Notification,
+      ];
+    }
+
+    notifications.forEach((n) => {
+      const notification = Object.assign(data, {
+        Notification: n,
+      });
+      this.$emit(notification, this.generateMeta(notification));
+    });
+  },
+};