@pipedream/spreadsheet_com 0.0.1 → 0.1.0

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

@@ -0,0 +1,61 @@
+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.1",
+  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/update-rows/update-rows.mjs

@@ -0,0 +1,53 @@
+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.1",
+  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.1.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.5.1"
   }
 }

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);
+    },
+  },
+};