@pipedream/salesforce_rest_api 1.2.1 → 1.3.0

package/sources/common-instant.mjs

@@ -1,146 +0,0 @@
-import { v4 as uuidv4 } from "uuid";
-import salesforce from "../salesforce_rest_api.app.mjs";
-import salesforceWebhooks from "salesforce-webhooks";
-
-const { SalesforceClient } = salesforceWebhooks;
-
-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,
-    },
-    objectType: {
-      label: "Object Type",
-      description: "The type of object for which to monitor events",
-      propDefinition: [
-        salesforce,
-        "objectType",
-      ],
-    },
-  },
-  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.createWebhook({
-          endpointUrl: this.http.endpoint,
-          sObjectType: this.objectType,
-          event: this.getEventType(),
-          secretToken,
-          fieldsToCheck: this.getFieldsToCheck(),
-          fieldsToCheckMode: this.getFieldsToCheckMode(),
-          skipValidation: true, // neccessary for custom objects
-        });
-      } catch (err) {
-        console.log("Create webhook error:", err);
-        throw err;
-      }
-      this._setSecretToken(secretToken);
-      this._setWebhookData(webhookData);
-    },
-    async deactivate() {
-      // Create the webhook from the Salesforce platform
-      const webhookData = this._getWebhookData();
-      await this.deleteWebhook(webhookData);
-    },
-  },
-  methods: {
-    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);
-    },
-    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/new-record/new-record.mjs

@@ -1,91 +0,0 @@
-import startCase from "lodash/startCase.js";
-
-import common from "../common.mjs";
-
-export default {
-  ...common,
-  type: "source",
-  name: "New Record (of Selectable Type)",
-  key: "salesforce_rest_api-new-record",
-  description: "Emit new event (at regular intervals) when a record of arbitrary object type (selected as an input parameter by the user) is created. See [the docs](https://sforce.co/3yPSJZy) for more information.",
-  version: "0.0.6",
-  hooks: {
-    ...common.hooks,
-    async activate() {
-      const {
-        objectType,
-        getObjectTypeDescription,
-        setObjectTypeColumns,
-      } = this;
-
-      await common.hooks.activate.call(this);
-
-      const { fields } = await getObjectTypeDescription(objectType);
-      const columns = fields.map(({ name }) => name);
-
-      setObjectTypeColumns(columns);
-    },
-  },
-  methods: {
-    ...common.methods,
-    generateMeta(item, fieldName) {
-      const { objectType } = this;
-      const {
-        CreatedDate: createdDate,
-        [fieldName]: name,
-        Id: id,
-      } = item;
-      const entityType = startCase(objectType);
-      const summary = `New ${entityType} created: ${name}`;
-      const ts = Date.parse(createdDate);
-      return {
-        id,
-        summary,
-        ts,
-      };
-    },
-    async processEvent(eventData) {
-      const {
-        paginate,
-        objectType,
-        setLatestDateCovered,
-        getObjectTypeColumns,
-        getNameField,
-        generateMeta,
-        $emit: emit,
-      } = this;
-
-      const {
-        startTimestamp,
-        endTimestamp,
-      } = eventData;
-
-      const fieldName = getNameField();
-      const columns = getObjectTypeColumns();
-
-      const events = await paginate({
-        objectType,
-        startTimestamp,
-        endTimestamp,
-        columns,
-      });
-
-      const [
-        latestEvent,
-      ] = events;
-
-      if (latestEvent?.CreatedDate) {
-        const latestDateCovered = new Date(latestEvent.CreatedDate);
-        latestDateCovered.setSeconds(0);
-        setLatestDateCovered(latestDateCovered.toISOString());
-      }
-
-      Array.from(events)
-        .reverse()
-        .forEach((item) => {
-          const meta = generateMeta(item, fieldName);
-          emit(item, meta);
-        });
-    },
-  },
-};

package/sources/record-deleted/record-deleted.mjs

@@ -1,51 +0,0 @@
-import startCase from "lodash/startCase.js";
-
-import common from "../common.mjs";
-
-export default {
-  ...common,
-  type: "source",
-  name: "New Deleted Record (of Selectable Type)",
-  key: "salesforce_rest_api-record-deleted",
-  description: "Emit new event (at regular intervals) when a record of arbitrary object type (selected as an input parameter by the user) is deleted. [See the docs](https://sforce.co/3msDDEE) for more information.",
-  version: "0.0.4",
-  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,
-      );
-      this.setLatestDateCovered(latestDateCovered);
-
-      // 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);
-      });
-    },
-  },
-};

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

@@ -1,94 +0,0 @@
-import startCase from "lodash/startCase.js";
-import common from "../common.mjs";
-import constants from "../../common/constants.mjs";
-
-export default {
-  ...common,
-  type: "source",
-  name: "New Updated Record (of Selectable Type)",
-  key: "salesforce_rest_api-record-updated",
-  description: "Emit new event (at regular intervals) when a record 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.1.12",
-  hooks: {
-    ...common.hooks,
-    async activate() {
-      const {
-        objectType,
-        getObjectTypeDescription,
-        setObjectTypeColumns,
-      } = this;
-
-      await common.hooks.activate.call(this);
-
-      const { fields } = await getObjectTypeDescription(objectType);
-      const columns = fields.map(({ name }) => name);
-
-      setObjectTypeColumns(columns);
-    },
-  },
-  methods: {
-    ...common.methods,
-    generateMeta(item, fieldName) {
-      const { objectType } = this;
-
-      const {
-        LastModifiedDate: lastModifiedDate,
-        [fieldName]: name,
-        Id: id,
-      } = item;
-
-      const entityType = startCase(objectType);
-      const summary = `${entityType} updated: ${name}`;
-      const ts = Date.parse(lastModifiedDate);
-      return {
-        id: `${id}-${ts}`,
-        summary,
-        ts,
-      };
-    },
-    async processEvent(eventData) {
-      const {
-        getNameField,
-        getObjectTypeColumns,
-        paginate,
-        objectType,
-        setLatestDateCovered,
-        generateMeta,
-        $emit: emit,
-      } = this;
-
-      const {
-        startTimestamp,
-        endTimestamp,
-      } = eventData;
-
-      const fieldName = getNameField();
-      const columns = getObjectTypeColumns();
-
-      const events = await paginate({
-        objectType,
-        startTimestamp,
-        endTimestamp,
-        columns,
-        dateFieldName: constants.FIELD_NAME.LAST_MODIFIED_DATE,
-      });
-
-      const [
-        latestEvent,
-      ] = events;
-
-      if (latestEvent?.LastModifiedDate) {
-        const latestDateCovered = new Date(latestEvent.LastModifiedDate);
-        latestDateCovered.setSeconds(0);
-        setLatestDateCovered(latestDateCovered.toISOString());
-      }
-
-      Array.from(events)
-        .reverse()
-        .forEach((item) => {
-          const meta = generateMeta(item, fieldName);
-          emit(item, meta);
-        });
-    },
-  },
-};

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

@@ -1,161 +0,0 @@
-import words from "lodash/words.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,
-  dedupe: "greatest",
-  type: "source",
-  name: "New 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.1.11",
-  props: {
-    ...common.props,
-    objectType: {
-      type: common.props.objectType.type,
-      label: common.props.objectType.label,
-      description: common.props.objectType.description,
-      propDefinition: [
-        salesforce,
-        "objectType",
-        () => ({
-          filter: ({
-            replicateable,
-            associateEntityType,
-          }) => replicateable && associateEntityType === "History",
-          mapper: ({ associateParentEntity: value }) => words(value).join(" "),
-        }),
-      ],
-    },
-    field: {
-      propDefinition: [
-        salesforce,
-        "field",
-        ({ objectType }) => ({
-          objectType,
-          filter: ({ updateable }) => updateable,
-        }),
-      ],
-    },
-    fieldUpdatedTo: {
-      propDefinition: [
-        salesforce,
-        "fieldUpdatedTo",
-      ],
-    },
-  },
-  hooks: {
-    ...common.hooks,
-    async activate() {
-      const {
-        objectType,
-        getObjectTypeDescription,
-        setHistoryObjectType,
-        setObjectTypeColumns,
-      } = this;
-
-      await common.hooks.activate.call(this);
-
-      const historyObjectType = `${objectType}History`;
-
-      const { fields } = await getObjectTypeDescription(historyObjectType);
-      const columns = fields.map(({ name }) => name);
-
-      setHistoryObjectType(historyObjectType);
-      setObjectTypeColumns(columns);
-    },
-  },
-  methods: {
-    ...common.methods,
-    getHistoryObjectType() {
-      return this.db.get("historyObjectType");
-    },
-    setHistoryObjectType(historyObjectType) {
-      this.db.set("historyObjectType", historyObjectType);
-    },
-    isRelevant(item) {
-      const {
-        field,
-        fieldUpdatedTo,
-      } = this;
-
-      const isFieldRelevant =
-        item.Field === field
-        || item.Field === `${item.DataType}${field}`;
-
-      const isFieldValueRelevant =
-        !fieldUpdatedTo
-        || item.NewValue === fieldUpdatedTo;
-
-      return isFieldRelevant && isFieldValueRelevant;
-    },
-    generateMeta(event) {
-      const {
-        objectType,
-        field,
-      } = this;
-
-      const {
-        CreatedDate: createdDate,
-        Id: id,
-        [`${objectType}Id`]: objectId,
-      } = event;
-
-      const ts = Date.parse(createdDate);
-      return {
-        id: `${id}-${ts}`,
-        summary: `${field} on ${objectType}: ${objectId}`,
-        ts,
-      };
-    },
-    async processEvent({
-      startTimestamp, endTimestamp,
-    }) {
-      const {
-        getHistoryObjectType,
-        getObjectTypeColumns,
-        setLatestDateCovered,
-        isRelevant,
-        paginate,
-        generateMeta,
-        $emit: emit,
-      } = this;
-
-      const objectType = getHistoryObjectType();
-      const columns = getObjectTypeColumns();
-
-      const events = await paginate({
-        objectType,
-        startTimestamp,
-        endTimestamp,
-        columns,
-      });
-
-      const [
-        latestEvent,
-      ] = events;
-
-      if (latestEvent?.CreatedDate) {
-        const latestDateCovered = new Date(latestEvent.CreatedDate);
-        latestDateCovered.setSeconds(0);
-        setLatestDateCovered(latestDateCovered.toISOString());
-      }
-
-      Array.from(events)
-        .reverse()
-        .filter(isRelevant)
-        .forEach((event) => {
-          const meta = generateMeta(event);
-          emit(event, meta);
-        });
-    },
-  },
-};

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

@@ -1,76 +0,0 @@
-import startCase from "lodash/startCase.js";
-
-import common from "../common-instant.mjs";
-const { salesforce } = common.props;
-
-export default {
-  ...common,
-  type: "source",
-  name: "New 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.1.6",
-  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,
-      ];
-    },
-  },
-};