@pipedream/salesforce_rest_api 1.2.1 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/salesforce_rest_api",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Pipedream Salesforce (REST API) Components",
   "main": "salesforce_rest_api.app.mjs",
   "keywords": [
@@ -10,7 +10,7 @@
   "homepage": "https://pipedream.com/apps/salesforce_rest_api",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "dependencies": {
-    "@pipedream/platform": "^1.2.0",
+    "@pipedream/platform": "^3.0.0",
     "fast-xml-parser": "^4.3.2",
     "handlebars": "^4.7.7",
     "lodash": "^4.17.21",

package/salesforce_rest_api.app.mjs

@@ -4,19 +4,6 @@ export default {
   type: "app",
   app: "salesforce_rest_api",
   propDefinitions: {
-    sobjectId: {
-      type: "string",
-      label: "SObject ID",
-      description: "ID of the Standard object to get field values from",
-      async options(context) {
-        const { objectType } = context;
-        const { recentItems } = await this.listSObjectTypeIds(objectType);
-        return recentItems.map((item) => ({
-          label: item.Name,
-          value: item.Id,
-        }));
-      },
-    },
     objectType: {
       type: "string",
       label: "SObject Type",
@@ -38,6 +25,21 @@ export default {
         return sobjects.filter(filter).map(mapper);
       },
     },
+    recordId: {
+      type: "string",
+      label: "Record ID",
+      description: "The ID of the record of the selected object type.",
+      async options({
+        objType,
+        nameField,
+      }) {
+        if (!nameField) nameField = await this.getNameFieldForObjectType(objType);
+        return this.listRecordOptions({
+          objType,
+          nameField,
+        });
+      },
+    },
     field: {
       type: "string",
       label: "Field",
@@ -53,37 +55,30 @@ export default {
         return fields.filter(filter).map(({ name }) => 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,
-    },
-    fieldSelector: {
+    fieldsToUpdate: {
       type: "string[]",
-      label: "Field Selector",
-      description: "Select fields for the Standard Object",
-      options: () => [], // override options for each object, e.g., () => Object.keys(account)
+      label: "Fields to Update",
+      description: "Select the field(s) you want to update for this record.",
+      async options({ objType }) {
+        const fields = await this.getFieldsForObjectType(objType);
+        return fields.filter((field) => field.updateable).map(({ name }) => name);
+      },
     },
-    AcceptedEventInviteeIds: {
+    fieldsToObtain: {
       type: "string[]",
-      label: "Accepted Event Invitee IDs",
-      async options() {
-        const { recentItems: contacts } = await this.listSObjectTypeIds("Contact");
-        const { recentItems: leads } = await this.listSObjectTypeIds("Lead");
-        const allContacts = [
-          ...contacts,
-          ...leads,
-        ];
-        return allContacts.map(({
-          Name, Id,
-        }) => ({
-          label: Name,
-          value: Id,
-        }));
+      label: "Fields to Obtain",
+      description: "Select the field(s) to obtain for the selected record(s) (or all records).",
+      async options({ objType }) {
+        const fields = await this.getFieldsForObjectType(objType);
+        return fields.map(({ name }) => name);
       },
-      description: "A string array of contact or lead IDs who accepted this event. This JunctionIdList is linked to the AcceptedEventRelation child relationship. Warning Adding a JunctionIdList field name to the fieldsToNull property deletes all related junction records. This action can't be undone.",
+    },
+    useAdvancedProps: {
+      type: "boolean",
+      label: "See All Props",
+      description: "Set to true to see all available props for this object.",
+      optional: true,
+      reloadProps: true,
     },
   },
   methods: {
@@ -138,10 +133,6 @@ export default {
       const baseUrl = this._sObjectTypeApiUrl(sObjectType);
       return `${baseUrl}/describe`;
     },
-    _sObjectTypeUpdatedApiUrl(sObjectType) {
-      const baseUrl = this._sObjectTypeApiUrl(sObjectType);
-      return `${baseUrl}/updated`;
-    },
     _sObjectTypeDeletedApiUrl(sObjectType) {
       const baseUrl = this._sObjectTypeApiUrl(sObjectType);
       return `${baseUrl}/deleted`;
@@ -223,35 +214,32 @@ export default {
       });
       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 createObject(objectType, data) {
-      const url = `${this._sObjectsApiUrl()}/${objectType}`;
+    async createObject({
+      objectType, ...args
+    }) {
       return this._makeRequest({
-        url,
-        data,
+        url: `${this._sObjectsApiUrl()}/${objectType}`,
         method: "POST",
+        ...args,
       });
     },
-    async deleteObject(objectType, sobjectId) {
-      const url = `${this._sObjectsApiUrl()}/${objectType}/${sobjectId}`;
+    async deleteRecord({
+      sobjectType, recordId, ...args
+    }) {
+      const url = `${this._sObjectsApiUrl()}/${sobjectType}/${recordId}`;
       return this._makeRequest({
         url,
         method: "DELETE",
+        ...args,
       });
     },
-    async getRecords(objectType, params) {
+    async getRecords({
+      objectType, ...args
+    }) {
       const url = `${this._sCompositeApiUrl()}/${objectType}`;
       return this._makeRequest({
         url,
-        params,
+        ...args,
       });
     },
     async getSObject(objectType, id, params = null) {
@@ -261,17 +249,6 @@ export default {
         params,
       });
     },
-    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 = {
@@ -293,159 +270,6 @@ export default {
         },
       });
     },
-    async createAccount({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Account");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async updateAccount({
-      $, id, data,
-    }) {
-      const url = this._sObjectDetailsApiUrl("Account", id);
-      return this._makeRequest({
-        $,
-        url,
-        method: "PATCH",
-        data,
-      });
-    },
-    async createAttachment({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Attachment");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createCampaign({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Campaign");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createCase({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Case");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createCaseComment({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("CaseComment");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createContact({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Contact");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async updateContact({
-      $, id, data,
-    }) {
-      const url = this._sObjectDetailsApiUrl("Contact", id);
-      return this._makeRequest({
-        $,
-        url,
-        method: "PATCH",
-        data,
-      });
-    },
-    async createEvent({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Event");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createLead({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Lead");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createNote({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Note");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async createOpportunity({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Opportunity");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async updateOpportunity({
-      $, id, data,
-    }) {
-      const url = this._sObjectDetailsApiUrl("Opportunity", id);
-      return this._makeRequest({
-        $,
-        url,
-        method: "PATCH",
-        data,
-      });
-    },
-    async getRecordFieldValues(sobjectName, {
-      $, id, params,
-    }) {
-      const url = this._sObjectDetailsApiUrl(sobjectName, id);
-      return this._makeRequest({
-        $,
-        url,
-        params,
-      });
-    },
     async createRecord(sobjectName, {
       $, data,
     }) {
@@ -468,27 +292,6 @@ export default {
         data,
       });
     },
-    async createTask({
-      $, data,
-    }) {
-      const url = this._sObjectTypeApiUrl("Task");
-      return this._makeRequest({
-        $,
-        url,
-        method: "POST",
-        data,
-      });
-    },
-    async deleteOpportunity({
-      $, id,
-    }) {
-      const url = this._sObjectDetailsApiUrl("Opportunity", id);
-      return this._makeRequest({
-        $,
-        url,
-        method: "DELETE",
-      });
-    },
     async query({
       $, query,
     }) {
@@ -499,6 +302,26 @@ export default {
         url,
       });
     },
+    async listRecordOptions({
+      objType,
+      nameField = "Id",
+    }) {
+      const fields = [
+        "Id",
+        ...nameField === "Id"
+          ? []
+          : [
+            nameField,
+          ],
+      ];
+      const { records } = await this.query({
+        query: `SELECT ${fields.join(", ")} FROM ${objType}`,
+      });
+      return records?.map?.((item) => ({
+        label: item[nameField],
+        value: item.Id,
+      })) ?? [];
+    },
     async search({
       $, search,
     }) {
@@ -509,14 +332,14 @@ export default {
         url,
       });
     },
-    async parameterizedSearch(params) {
+    async parameterizedSearch(args) {
       const baseUrl = this._baseApiVersionUrl();
       const url = `${baseUrl}/parameterizedSearch/`;
 
       return this._makeRequest({
         url,
         method: "GET",
-        params,
+        ...args,
       });
     },
     async insertBlobData(sobjectName, {
@@ -534,7 +357,7 @@ export default {
       };
       return axios($ ?? this, requestConfig);
     },
-    async postFeed(args = {}) {
+    async postFeed(args) {
       const baseUrl = this._baseApiVersionUrl();
       const url = `${baseUrl}/chatter/feed-elements`;
       return this._makeRequest({

package/sources/common-webhook-methods.mjs

@@ -0,0 +1,71 @@
+import salesforceWebhooks from "salesforce-webhooks";
+
+const { SalesforceClient } = salesforceWebhooks;
+
+export default {
+  getClient() {
+    const { salesforce } = this;
+    return new SalesforceClient({
+      apiVersion: salesforce._apiVersion(),
+      authToken: salesforce._authToken(),
+      instance: salesforce._subdomain(),
+    });
+  },
+  createWebhook(args = {}) {
+    const client = this.getClient();
+    return client.createWebhook(args);
+  },
+  deleteWebhook(args = {}) {
+    const client = this.getClient();
+    return client.deleteWebhook(args);
+  },
+  _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);
+  },
+  _isValidSource(event) {
+    const webhookToken = event.headers["x-webhook-token"];
+    const secretToken = this._getSecretToken();
+    return webhookToken === secretToken;
+  },
+  processWebhookEvent(event) {
+    const { body } = event;
+    const meta = this.generateWebhookMeta(event);
+    this.$emit(body, meta);
+  },
+  generateWebhookMeta() {
+    throw new Error("generateWebhookMeta 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;
+  },
+};

package/sources/common.mjs

@@ -1,21 +1,26 @@
 import { DEFAULT_POLLING_SOURCE_TIMER_INTERVAL } from "@pipedream/platform";
 import salesforce from "../salesforce_rest_api.app.mjs";
 import constants from "../common/constants.mjs";
+import { v4 as uuidv4 } from "uuid";
+import commonWebhookMethods from "./common-webhook-methods.mjs";
 
 export default {
   dedupe: "unique",
   props: {
     salesforce,
     db: "$.service.db",
-    // eslint-disable-next-line pipedream/props-label,pipedream/props-description
+    http: {
+      type: "$.interface.http",
+      customResponse: true,
+    },
     timer: {
       type: "$.interface.timer",
+      description: "The timer is only used as a fallback if instant event delivery (webhook) is not available.",
       default: {
         intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
       },
     },
     objectType: {
-      type: "string",
       label: "Object Type",
       description: "The type of object for which to monitor events",
       propDefinition: [
@@ -26,17 +31,51 @@ export default {
   },
   hooks: {
     async activate() {
-      const latestDateCovered = this.getLatestDateCovered();
-      if (!latestDateCovered) {
-        const now = new Date().toISOString();
-        this.setLatestDateCovered(now);
+      // Attempt to create the webhook
+      const secretToken = uuidv4();
+      let webhookData;
+      try {
+        webhookData = await this.createWebhook({
+          endpointUrl: this.http.endpoint,
+          sObjectType: this.objectType,
+          event: this.getEventType(),
+          secretToken,
+          fieldsToCheck: this.getFieldsToCheck(),
+          fieldsToCheckMode: this.getFieldsToCheckMode(),
+          skipValidation: true, // neccessary for custom objects
+        });
+        console.log("Webhook created successfully");
+      } catch (err) {
+        console.log("Error creating webhook:", err);
+        console.log("The source will operate on the polling schedule instead.");
+
+        const latestDateCovered = this.getLatestDateCovered();
+        if (!latestDateCovered) {
+          const now = new Date().toISOString();
+          this.setLatestDateCovered(now);
+        }
+
+        await this.timerActivateHook?.();
       }
+      this._setSecretToken(secretToken);
+      this._setWebhookData(webhookData);
 
       const nameField = await this.salesforce.getNameFieldForObjectType(this.objectType);
       this.setNameField(nameField);
     },
+    async deactivate() {
+      // Delete the webhook, if it exists
+      const webhookData = this._getWebhookData();
+      if (webhookData) {
+        await this.deleteWebhook(webhookData);
+      }
+    },
   },
   methods: {
+    ...commonWebhookMethods,
+    timerActivateHook() {
+      return null;
+    },
     getObjectTypeColumns() {
       return this.db.get("columns") ?? [];
     },
@@ -55,8 +94,8 @@ export default {
     setNameField(nameField) {
       this.db.set("nameField", nameField);
     },
-    processEvent() {
-      throw new Error("processEvent is not implemented");
+    processTimerEvent() {
+      throw new Error("processTimerEvent is not implemented");
     },
     getObjectTypeDescription(objectType) {
       const { salesforce } = this;
@@ -120,21 +159,45 @@ export default {
     },
   },
   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;
+    // Timer event
+    if (event.timestamp) {
+      if (this._getWebhookData()) {
+        console.log("Ignoring timer event (webhook active)");
+        return;
+      }
+      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 (already executed less than 60 seconds ago)
+        `);
+        return;
+      }
+
+      await this.processTimerEvent({
+        startTimestamp,
+        endTimestamp,
+      });
     }
 
-    await this.processEvent({
-      startTimestamp,
-      endTimestamp,
-    });
+    // Webhook event
+    else {
+      if (!this._isValidSource(event)) {
+        this.http.respond({
+          statusCode: 404,
+        });
+        console.log("Skipping event from unrecognized source");
+        return;
+      }
+
+      this.http.respond({
+        statusCode: 200,
+      });
+
+      await this.processWebhookEvent(event);
+    }
   },
 };

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

@@ -5,17 +5,25 @@ 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.1.6",
+  description: "Emit new event when a new outbound message is received in Salesforce.",
+  version: "0.1.7",
   dedupe: "unique",
   props: {
     db: "$.service.db",
-    // eslint-disable-next-line pipedream/props-label,pipedream/props-description
     http: {
       type: "$.interface.http",
       customResponse: true,
     },
     salesforce,
+    infoBox: {
+      type: "alert",
+      alertType: "info",
+      content: `See Salesforce's guide on [setting up Outbound Messaging](https://sforce.co/3JbZJom).
+\\
+Set the Outbound Message's \`Endpoint URL\` to the endpoint of this source, which you can view after it is created.
+\\
+The \`Send Session ID\` option must be enabled in Salesforce for validating outbound messages.`,
+    },
   },
   methods: {
     _unwrapMessage(message) {