@pipedream/salesforce_rest_api 0.3.3

package/sources/object-deleted/object-deleted.mjs

@@ -0,0 +1,52 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common.mjs";
+
+export default {
+  ...common,
+  type: "source",
+  name: "Object Deleted (of Selectable Type)",
+  key: "salesforce_rest_api-object-deleted",
+  description: "Emit new event (at regular intervals) when an object of arbitrary type (selected as an input parameter by the user) is deleted. [See the docs](https://sforce.co/3msDDEE) for more information.",
+  version: "0.0.5",
+  methods: {
+    ...common.methods,
+    generateMeta(item) {
+      const {
+        id,
+        deletedDate,
+      } = item;
+      const entityType = startCase(this.objectType);
+      const summary = `${entityType} deleted: ${id}`;
+      const ts = Date.parse(deletedDate);
+      return {
+        id,
+        summary,
+        ts,
+      };
+    },
+    async processEvent(eventData) {
+      const {
+        startTimestamp,
+        endTimestamp,
+      } = eventData;
+      const {
+        deletedRecords,
+        latestDateCovered,
+      } = await this.salesforce.getDeletedForObjectType(
+        this.objectType,
+        startTimestamp,
+        endTimestamp,
+      );
+
+      // When a record is deleted, the `getDeleted` API only shows the ID of the
+      // deleted item and the date in which it was deleted.
+      deletedRecords.forEach((item) => {
+        const meta = this.generateMeta(item);
+        this.$emit(item, meta);
+      });
+
+      this.setLatestDateCovered(latestDateCovered);
+    },
+  },
+};

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

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

package/sources/object-updated/object-updated.mjs

@@ -0,0 +1,63 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common.mjs";
+
+export default {
+  ...common,
+  type: "source",
+  name: "Object Updated (of Selectable Type)",
+  key: "salesforce_rest_api-object-updated",
+  description: "Emit new event (at regular intervals) when an object of arbitrary type (selected as an input parameter by the user) is updated. [See the docs](https://sforce.co/3yPSJZy) for more information.",
+  version: "0.0.5",
+  methods: {
+    ...common.methods,
+    generateMeta(item) {
+      const nameField = this.getNameField();
+      const {
+        LastModifiedDate: lastModifiedDate,
+        Id: id,
+        [nameField]: name,
+      } = item;
+      const entityType = startCase(this.objectType);
+      const summary = `${entityType} updated: ${name}`;
+      const ts = Date.parse(lastModifiedDate);
+      const compositeId = `${id}-${ts}`;
+      return {
+        id: compositeId,
+        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)
+        .forEach((item) => {
+          const meta = this.generateMeta(item);
+          this.$emit(item, meta);
+        });
+
+      this.setLatestDateCovered(latestDateCovered);
+    },
+  },
+};

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

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

package/sources/updated-field-on-record/updated-field-on-record.mjs

@@ -0,0 +1,179 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common.mjs";
+const { salesforce } = common.props;
+
+/**
+ * Uses the Salesforce REST API's [sObject Get Updated endpoint](https://sforce.co/3yPSJZy) on the
+ * [StandardObjectNamedHistory model](https://sforce.co/3Fn4lWB) to get changes to field values of
+ * an sObject type. Associated sObject records are retrieved and emitted for history object records
+ * matching configured `field` and `fieldUpdatedTo` prop values.
+ */
+export default {
+  ...common,
+  type: "source",
+  name: "Updated Field on Record (of Selectable Type)",
+  key: "salesforce_rest_api-updated-field-on-record",
+  description: "Emit new event (at regular intervals) when a field of your choosing is updated on any record of a specified Salesforce object. Field history tracking must be enabled for the chosen field. See the docs on [field history tracking](https://sforce.co/3mtj0rF) and [history objects](https://sforce.co/3Fn4lWB) for more information.",
+  version: "0.0.1",
+  props: {
+    ...common.props,
+    objectType: {
+      ...common.props.objectType,
+      label: common.props.objectType.label,
+      description: common.props.objectType.description,
+      async options(context) {
+        const { page } = context;
+        if (page !== 0) {
+          return {
+            options: [],
+          };
+        }
+
+        const { sobjects } = await this.salesforce.listSObjectTypes();
+        // Filter options to include only sObjects with associated
+        // [history](https://sforce.co/3Fn4lWB) objects
+        const options = sobjects
+          .filter(this.isValidSObject)
+          .map((sobject) => ({
+            label: sobjects.find((o) => o.name === sobject.associateParentEntity).label,
+            value: sobject.associateParentEntity,
+          }));
+        return {
+          options,
+        };
+      },
+    },
+    field: {
+      propDefinition: [
+        salesforce,
+        "field",
+        ({ objectType }) => ({
+          objectType,
+        }),
+      ],
+    },
+    fieldUpdatedTo: {
+      propDefinition: [
+        salesforce,
+        "fieldUpdatedTo",
+      ],
+    },
+  },
+  hooks: {
+    ...common.hooks,
+    async activate() {
+      await common.hooks.activate.call(this);
+      const historyObject = await this.salesforce.getHistorySObjectForObjectType(this.objectType);
+      if (!historyObject) {
+        throw new Error(`History object not found for "${this.objectType}"`);
+      }
+      this._setHistoryObjectType(historyObject.name);
+    },
+  },
+  methods: {
+    ...common.methods,
+    _getHistoryObjectType() {
+      return this.db.get("historyObjectType");
+    },
+    _setHistoryObjectType(historyObjectType) {
+      this.db.set("historyObjectType", historyObjectType);
+    },
+    _getParentId(item) {
+      const parentIdKey = `${this.objectType}Id`;
+      return item[parentIdKey] ?? item["ParentId"];
+    },
+    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 && this.salesforce.isHistorySObject(sobject);
+    },
+    isRelevant(item) {
+      const isFieldRelevant = item.Field === this.field;
+      const isFieldValueRelevant = !this.fieldUpdatedTo || item.NewValue === this.fieldUpdatedTo;
+      return isFieldRelevant && isFieldValueRelevant;
+    },
+    generateMeta(event) {
+      const nameField = this.getNameField();
+      const {
+        record: item = {},
+        update,
+      } = event;
+      const { [nameField]: name } = item;
+      const {
+        Id: id,
+        CreatedDate: createdDate,
+      } = update;
+      const entityType = startCase(this.objectType);
+      const summary = `${this.field} on ${entityType}: ${name}`;
+      const ts = Date.parse(createdDate);
+      const compositeId = `${id}-${ts}`;
+      return {
+        id: compositeId,
+        summary,
+        ts,
+      };
+    },
+    async processEvent(eventData) {
+      const {
+        startTimestamp,
+        endTimestamp,
+      } = eventData;
+      const historyObjectType = this._getHistoryObjectType();
+      const {
+        ids,
+        latestDateCovered,
+      } = await this.salesforce.getUpdatedForObjectType(
+        historyObjectType,
+        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 historyItemRetrievals = await Promise.allSettled(
+        ids.map((id) => this.salesforce.getSObject(historyObjectType, id)),
+      );
+      const historyItems = historyItemRetrievals
+        .filter((result) => result.status === "fulfilled")
+        .map((result) => result.value)
+        .filter(this.isRelevant);
+
+      // To fetch associated sObject records only once, create a set of the "parent IDs" of the
+      // history object records
+      const parentIdSet = new Set(
+        historyItems
+          .map(this._getParentId)
+          .filter((id) => id),
+      );
+      const parentIds = Array.from(parentIdSet);
+
+      const itemRetrievals = await Promise.allSettled(
+        parentIds.map((id) => this.salesforce.getSObject(this.objectType, id)),
+      );
+      const itemsById = itemRetrievals
+        .filter((result) => result.status === "fulfilled")
+        .map((result) => result.value)
+        .reduce((acc, item) => {
+          acc[item.Id] = item;
+          return acc;
+        }, {});
+
+      const events = historyItems.map((item) => ({
+        update: item,
+        record: itemsById[this._getParentId(item)],
+      }));
+
+      events.forEach((event) => {
+        const meta = this.generateMeta(event);
+        this.$emit(event, meta);
+      });
+
+      this.setLatestDateCovered(latestDateCovered);
+    },
+  },
+};

package/sources/updated-field-on-record-instant/updated-field-on-record-instant.mjs

@@ -0,0 +1,76 @@
+import startCase from "lodash/startCase.js";
+
+import common from "../common-instant.mjs";
+const { salesforce } = common.props;
+
+export default {
+  ...common,
+  type: "source",
+  name: "Updated Field on Record (Instant, of Selectable Type)",
+  key: "salesforce_rest_api-updated-field-on-record-instant",
+  description: "Emit new event immediately after a field of your choosing is updated on any record of a specified Salesforce object",
+  version: "0.0.1",
+  props: {
+    ...common.props,
+    field: {
+      propDefinition: [
+        salesforce,
+        "field",
+        ({ objectType }) => ({
+          objectType,
+        }),
+      ],
+    },
+    fieldUpdatedTo: {
+      propDefinition: [
+        salesforce,
+        "fieldUpdatedTo",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    isEventRelevant(event) {
+      if (!this.fieldUpdatedTo) {
+        return true;
+      }
+      const { New: newObject } = event.body;
+      const { [this.field]: newFieldValue } = newObject;
+      return !this.fieldUpdatedTo || this.fieldUpdatedTo === newFieldValue;
+    },
+    generateMeta(data) {
+      const nameField = this.getNameField();
+      const { New: newObject } = data.body;
+      const {
+        LastModifiedDate: lastModifiedDate,
+        Id: id,
+        [nameField]: name,
+      } = newObject;
+      const entityType = startCase(this.objectType);
+      const summary = `${this.field} on ${entityType}: ${name}`;
+      const ts = Date.parse(lastModifiedDate);
+      const compositeId = `${id}-${ts}`;
+      return {
+        id: compositeId,
+        summary,
+        ts,
+      };
+    },
+    processEvent(event) {
+      const { body } = event;
+      if (!this.isEventRelevant(event)) {
+        return;
+      }
+      const meta = this.generateMeta(event);
+      this.$emit(body, meta);
+    },
+    getEventType() {
+      return "updated";
+    },
+    getFieldsToCheck() {
+      return [
+        this.field,
+      ];
+    },
+  },
+};

package/utils.mjs

@@ -0,0 +1,27 @@
+/**
+ * A utility function that accepts a string as an argument and reformats it in
+ * order to remove newline characters and consecutive spaces. Useful when
+ * dealing with very long templated strings that are split into multiple lines.
+ *
+ * @example
+ * // returns "This is a much cleaner string"
+ * toSingleLineString(`
+ *   This is a much
+ *   cleaner string
+ * `);
+ *
+ * @param {string}  multiLineString the input string to reformat
+ * @returns a formatted string based on the content of the input argument,
+ * without newlines and multiple spaces
+ * Source: {@linkcode ../aws/sources/common/utils.mjs utils.mjs}
+ */
+function toSingleLineString(multiLineString) {
+  return multiLineString
+    .trim()
+    .replace(/\n/g, " ")
+    .replace(/\s{2,}/g, " ");
+}
+
+export {
+  toSingleLineString,
+};