@pipedream/spreadsheet_com 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,11 @@
+# Overview
+
+The Spreadsheet.com API provides programmatic access to manage sheets, rows, and other data within Spreadsheet.com. Integrating this API into Pipedream allows you to automate tasks like updating rows based on external triggers, syncing data between multiple platforms, or even processing data using custom logic. With Pipedream, you can craft workflows that react in real-time to events, schedule data manipulation tasks, and connect to countless other services via their APIs.
+
+# Example Use Cases
+
+- **Sync Spreadsheet.com with Google Calendar**: When a new event is scheduled in Google Calendar, a Pipedream workflow can trigger to create or update a corresponding row in a Spreadsheet.com sheet, keeping a detailed log of your events and their details for easy tracking and analysis.
+
+- **Manage Customer Support Tickets**: When a new support ticket is submitted through a platform like Zendesk, trigger a Pipedream workflow to add the ticket details to Spreadsheet.com. Further automation can notify support staff via Slack or email and update the ticket status in Spreadsheet.com based on follow-up actions.
+
+- **Process E-commerce Orders**: Connect Spreadsheet.com to an e-commerce platform like Shopify. Each time an order is placed, a Pipedream workflow fires, adding order details to a sheet. It can also perform inventory checks, update stock levels, and send a restock request to your supplier if inventory runs low.

package/actions/create-rows/create-rows.mjs

@@ -0,0 +1,66 @@
+import { parseArray } from "../../common/utils.mjs";
+import spreadsheetCom from "../../spreadsheet_com.app.mjs";
+
+export default {
+  key: "spreadsheet_com-create-rows",
+  name: "Create Rows",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  description: "Adds new row(s) after last row that has data. Empty data sets are ignored. Provide data for at least 1 column. [See the documentation](https://developer.spreadsheet.com/#tag/Rows/operation/createRows)",
+  type: "action",
+  props: {
+    spreadsheetCom,
+    workbookId: {
+      propDefinition: [
+        spreadsheetCom,
+        "workbookId",
+      ],
+    },
+    worksheetId: {
+      propDefinition: [
+        spreadsheetCom,
+        "worksheetId",
+        ({ workbookId }) => ({
+          workbookId,
+        }),
+      ],
+    },
+    position: {
+      type: "string",
+      label: "Position",
+      description: "Position at which the row is to be added in the worksheet. If not specified, row is added after the last non-empty row in the worksheet. E.g. `S3vBb3FZRQuFtW1mrj0U2g:before`. [Where to find row Ids](https://developer.spreadsheet.com/#section/Using-the-API/Extract-Resource-IDs)",
+      optional: true,
+    },
+    rowsData: {
+      type: "string[]",
+      label: "Rows Data",
+      description: "Data row(s) to add. Each entry have the following sample format: `{ \"cellData\": [ { \"field\": \"A\", \"data\": \"Person\" }, { \"field\": \"B\", \"data\": \"Region\" } ] }`. Rows without any column data will be ignored. Maximum of 100 entries can be provided. [See the documentation](https://developer.spreadsheet.com/#tag/Rows/operation/createRows).",
+    },
+  },
+  async run({ $ }) {
+    const {
+      spreadsheetCom,
+      worksheetId,
+      position,
+      rowsData,
+    } = this;
+
+    const response = await spreadsheetCom.createRows({
+      $,
+      worksheetId,
+      params: {
+        position,
+      },
+      data: parseArray(rowsData),
+    });
+
+    $.export("$summary", `New row(s) with Id(s): ${(response.ids).toString()} ${response.ids.length > 1
+      ? "were"
+      : "was"} successfully created!`);
+    return response;
+  },
+};

package/actions/list-workbook-id-options/list-workbook-id-options.mjs

@@ -0,0 +1,34 @@
+import spreadsheet_com from "../../spreadsheet_com.app.mjs";
+
+export default {
+  key: "spreadsheet_com-list-workbook-id-options",
+  name: "List Workbook Id Options",
+  description: "Retrieves available options for the Workbook Id field.",
+  version: "0.0.1",
+  type: "action",
+  annotations: {
+    destructiveHint: false,
+    openWorldHint: true,
+    readOnlyHint: true,
+  },
+  props: {
+    spreadsheet_com,
+    page: {
+      type: "integer",
+      label: "Page",
+      description: "The page of results to retrieve.",
+      min: 0,
+      default: 0,
+    },
+  },
+  async run({ $ }) {
+    const options = await spreadsheet_com.propDefinitions.workbookId.options
+      .call(this.spreadsheet_com, {
+        page: this.page,
+      });
+    $.export("$summary", `Successfully retrieved ${options.length} option${options.length === 1
+      ? ""
+      : "s"}`);
+    return options;
+  },
+};

package/actions/update-rows/update-rows.mjs

@@ -0,0 +1,58 @@
+import { parseArray } from "../../common/utils.mjs";
+import spreadsheetCom from "../../spreadsheet_com.app.mjs";
+
+export default {
+  key: "spreadsheet_com-update-rows",
+  name: "Update Rows",
+  version: "0.0.2",
+  annotations: {
+    destructiveHint: true,
+    openWorldHint: true,
+    readOnlyHint: false,
+  },
+  description: "Update existing row(s). [See the documentation](https://developer.spreadsheet.com/#tag/Rows/operation/updateRows)",
+  type: "action",
+  props: {
+    spreadsheetCom,
+    workbookId: {
+      propDefinition: [
+        spreadsheetCom,
+        "workbookId",
+      ],
+    },
+    worksheetId: {
+      propDefinition: [
+        spreadsheetCom,
+        "worksheetId",
+        ({ workbookId }) => ({
+          workbookId,
+        }),
+      ],
+    },
+    rowsData: {
+      type: "string[]",
+      label: "Rows Data",
+      description: "Data row(s) to update. Each entry have the following sample format: `{ \"_id\": \"WTwPho0VQp-goWf_xtSMgQ\", \"cellData\": [ { \"field\": \"A\", \"data\": \"Person\" }, { \"field\": \"B\", \"data\": \"Region\" } ] }`. Response will contain list of row ids for which the operation was successful. Maximum of 100 entries can be provided. [Where to find row Ids](https://developer.spreadsheet.com/#section/Using-the-API/Extract-Resource-IDs)",
+    },
+  },
+  async run({ $ }) {
+    const {
+      spreadsheetCom,
+      worksheetId,
+      rowsData,
+    } = this;
+
+    const parsedData = parseArray(rowsData);
+
+    const response = await spreadsheetCom.updateRows({
+      $,
+      worksheetId,
+      data: parsedData,
+    });
+
+    $.export("$summary", `The row${parsedData.length > 1
+      ? "s were"
+      : " was"} successfully updated!`);
+    return response;
+  },
+};

package/common/utils.mjs

@@ -0,0 +1,13 @@
+export const LIMIT = 100;
+
+export const parseArray = (array) => {
+  if (Array.isArray(array)) {
+    return array.map((item) => {
+      if (typeof item != "object") {
+        return JSON.parse(item);
+      }
+      return item;
+    });
+  }
+  return JSON.parse(array);
+};

package/package.json

@@ -1,18 +1,19 @@
 {
   "name": "@pipedream/spreadsheet_com",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Spreadsheet.com Components",
-  "main": "dist/app/spreadsheet_com.app.mjs",
+  "main": "spreadsheet_com.app.mjs",
   "keywords": [
     "pipedream",
     "spreadsheet_com"
   ],
-  "files": [
-    "dist"
-  ],
   "homepage": "https://pipedream.com/apps/spreadsheet_com",
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "moment": "^2.29.4",
+    "@pipedream/platform": "^1.6.8"
   }
 }

package/sources/row-updated/row-updated.mjs

@@ -0,0 +1,125 @@
+import {
+  ConfigurationError, DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+} from "@pipedream/platform";
+import moment from "moment";
+import spreadsheetCom from "../../spreadsheet_com.app.mjs";
+import sampleEmit from "./test-event.mjs";
+
+export default {
+  key: "spreadsheet_com-row-updated",
+  name: "New Row Updated",
+  version: "0.0.1",
+  description: "Emit new event when a row is updated.",
+  type: "source",
+  dedupe: "unique",
+  props: {
+    spreadsheetCom,
+    db: "$.service.db",
+    timer: {
+      label: "Polling interval",
+      description: "Pipedream will poll the Spreadsheet.com on this schedule",
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: DEFAULT_POLLING_SOURCE_TIMER_INTERVAL,
+      },
+    },
+    workbookId: {
+      propDefinition: [
+        spreadsheetCom,
+        "workbookId",
+      ],
+    },
+    worksheetId: {
+      propDefinition: [
+        spreadsheetCom,
+        "worksheetId",
+        ({ workbookId }) => ({
+          workbookId,
+        }),
+      ],
+    },
+  },
+  methods: {
+    _getLastDate() {
+      return this.db.get("lastDate") || 0;
+    },
+    _setLastDate(lastDate) {
+      this.db.set("lastDate", lastDate);
+    },
+    _getSortColumn() {
+      return this.db.get("sortColumn");
+    },
+    _setSortColumn(sortColumn) {
+      this.db.set("sortColumn", sortColumn);
+    },
+    async startEvent(maxResults = 0) {
+      const {
+        spreadsheetCom,
+        worksheetId,
+      } = this;
+
+      const lastDate = this._getLastDate();
+      const items = spreadsheetCom.paginate({
+        fn: spreadsheetCom.listRows,
+        maxResults,
+        worksheetId,
+        params: {
+          sort: {
+            "options": [
+              {
+                "column": this._getSortColumn(),
+                "sortType": "desc",
+              },
+            ],
+          },
+        },
+      });
+
+      let responseArray = [];
+
+      for await (const item of items) {
+        if (moment(item.updatedAt).isSameOrBefore(lastDate)) break;
+        responseArray.push(item);
+      }
+      if (responseArray.length) this._setLastDate(responseArray[0].updatedAt);
+
+      for (const item of responseArray.reverse()) {
+        this.$emit(
+          item,
+          {
+            id: item._id + item.updatedAt,
+            summary: `The row with id: "${item._id}" was updated!`,
+            ts: item.updatedAt,
+          },
+        );
+      }
+    },
+    async getUpdatedAtColumn() {
+      const { spreadsheetCom } = this;
+      const columns = spreadsheetCom.paginate({
+        fn: spreadsheetCom.listColumns,
+        worksheetId: this.worksheetId,
+      });
+
+      let sortColumn;
+      for await (const column of columns) {
+        if (column.dataType === "UPDATED_AT") {
+          sortColumn = column.field;
+          this._setSortColumn(column.field);
+          break;
+        }
+      }
+      if (!sortColumn) throw new ConfigurationError("This worksheet doesn't have a column of type UPDATED_AT.");
+    },
+  },
+  hooks: {
+    async deploy() {
+      await this.getUpdatedAtColumn();
+      await this.startEvent(25);
+    },
+  },
+  async run() {
+    await this.startEvent();
+  },
+  sampleEmit,
+};

package/sources/row-updated/test-event.mjs

@@ -0,0 +1,19 @@
+export default {
+  "_id": "S3vBb3FZRQuFtW1mrj0U2g",
+  "createdAt": "2022-08-03T19:00:54.620Z",
+  "updatedAt": "2022-08-03T19:00:54.620Z",
+  "createdBy": "ocxAVW3oRSajt9yOKg7B-Q",
+  "updatedBy": "ocxAVW3oRSajt9yOKg7B-Q",
+  "cellData": [
+    {
+      "field": "col_1",
+      "data": "Person",
+      "dataType": "AUTOMATIC"
+    },
+    {
+      "field": "col_2",
+      "data": "Region",
+      "dataType": "AUTOMATIC"
+    }
+  ]
+}

package/spreadsheet_com.app.mjs

@@ -0,0 +1,170 @@
+import { axios } from "@pipedream/platform";
+import { LIMIT } from "./common/utils.mjs";
+
+export default {
+  type: "app",
+  app: "spreadsheet_com",
+  propDefinitions: {
+    columnId: {
+      type: "string",
+      label: "Column Id",
+      description: "Unique column identifier in the worksheet.",
+      async options({
+        page, worksheetId,
+      }) {
+        const { items } = await this.listColumns({
+          worksheetId,
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+          },
+        });
+
+        return items.map(({ field }) => field);
+      },
+    },
+    workbookId: {
+      type: "string",
+      label: "Workbook Id",
+      description: "ID of the workbook.",
+      async options({ page }) {
+        const { items } = await this.listWorkbooks({
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+          },
+        });
+
+        return items.map(({
+          _id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    worksheetId: {
+      type: "string",
+      label: "Worksheet Id",
+      description: "ID of the worksheet.",
+      async options({
+        page, workbookId,
+      }) {
+        const { items } = await this.listWorksheets({
+          workbookId,
+          params: {
+            limit: LIMIT,
+            offset: LIMIT * page,
+          },
+        });
+
+        return items.map(({
+          _id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+  },
+  methods: {
+    _apiUrl() {
+      return "https://api.spreadsheet.com/v1";
+    },
+    _getHeaders() {
+      return {
+        "Authorization": `Bearer ${this.$auth.api_key}`,
+        "Content-Type": "application/json",
+      };
+    },
+    _makeRequest({
+      $ = this, path, ...opts
+    }) {
+      const config = {
+        url: `${this._apiUrl()}/${path}`,
+        headers: this._getHeaders(),
+        ...opts,
+      };
+
+      return axios($, config);
+    },
+    createRows({
+      worksheetId, ...args
+    }) {
+      return this._makeRequest({
+        method: "POST",
+        path: `worksheets/${worksheetId}/rows`,
+        ...args,
+      });
+    },
+    updateRows({
+      worksheetId, ...args
+    }) {
+      return this._makeRequest({
+        method: "PUT",
+        path: `worksheets/${worksheetId}/rows`,
+        ...args,
+      });
+    },
+    listColumns({
+      worksheetId, ...args
+    }) {
+      return this._makeRequest({
+        path: `worksheets/${worksheetId}/columns`,
+        ...args,
+      });
+    },
+    listRows({
+      worksheetId, ...args
+    }) {
+      return this._makeRequest({
+        path: `worksheets/${worksheetId}/rows`,
+        ...args,
+      });
+    },
+    listWorkbooks(args = {}) {
+      return this._makeRequest({
+        path: "workbooks",
+        ...args,
+      });
+    },
+    listWorksheets({
+      workbookId, ...args
+    }) {
+      return this._makeRequest({
+        path: `workbooks/${workbookId}/worksheets`,
+        ...args,
+      });
+    },
+    async *paginate({
+      fn, params = {}, maxResults = null, ...args
+    }) {
+      let hasMore = false;
+      let count = 0;
+      let page = 0;
+
+      do {
+        params.limit = LIMIT;
+        params.offset = LIMIT * page;
+        page++;
+        const {
+          items,
+          hasMore: hasMoreItems,
+        } = await fn({
+          params,
+          ...args,
+        });
+        for (const d of items) {
+          yield d;
+
+          if (maxResults && ++count === maxResults) {
+            return count;
+          }
+        }
+
+        hasMore = hasMoreItems;
+
+      } while (hasMore);
+    },
+  },
+};