@pipedream/pcloud 0.3.3

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2020 Pipedream, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/actions/common/base.mjs

@@ -0,0 +1,43 @@
+import pcloud from "../../pcloud.app.mjs";
+
+export default {
+  props: {
+    pcloud,
+  },
+  methods: {
+    validateLocationId() {
+      const VALID_LOCATIONS = [
+        "0",
+        "1",
+      ];
+      const locationId = this.pcloud.$auth.locationid;
+
+      if (!VALID_LOCATIONS.includes(locationId)) {
+        return "Unable to retrieve your account's Location ID - try reconnecting your pCloud account to Pipedream";
+      }
+
+      return true;
+    },
+    async validateInputs() {
+      return true;
+    },
+  },
+  async run({ $ }) {
+    const validations = [
+      this.validateLocationId(),
+      await this.validateInputs(),
+    ];
+
+    const errors = validations.filter((result) => result !== true);
+    if (errors.length) {
+      throw new Error(errors.join("; "));
+    }
+
+    const requestMethod = this.requestMethod;
+    const response = await this.pcloud._withRetries(() => requestMethod());
+
+    $.export("$summary", this.getSummary());
+
+    return response;
+  },
+};

package/actions/copy-file/copy-file.mjs

@@ -0,0 +1,76 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "pcloud-copy-file",
+  name: "Copy File",
+  description:
+    "Copy a file to the specified destination. [See the docs here](https://docs.pcloud.com/methods/file/copyfile.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    fileId: {
+      propDefinition: [
+        pcloud,
+        "fileId",
+      ],
+      description: `Select a **File** to copy.
+        \\
+        Alternatively, you can provide a custom *File ID*.`,
+    },
+    toFolderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      label: "Destination Folder ID",
+      description: `Select a **Destination Folder** to receive the copied file.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    name: {
+      propDefinition: [
+        pcloud,
+        "name",
+      ],
+      label: "New File Name",
+      description: "Name of the destination file.",
+    },
+    overwrite: {
+      propDefinition: [
+        pcloud,
+        "overwrite",
+      ],
+    },
+    modifiedTime: {
+      propDefinition: [
+        pcloud,
+        "modifiedTime",
+      ],
+    },
+    createdTime: {
+      propDefinition: [
+        pcloud,
+        "createdTime",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return `Copied file "${this.name}" successfully`;
+    },
+    async requestMethod() {
+      return this.pcloud.copyFile(
+        this.fileId,
+        this.toFolderId,
+        this.name,
+        !this.overwrite,
+        this.modifiedTime,
+        this.createdTime,
+      );
+    },
+  },
+};

package/actions/copy-folder/copy-folder.mjs

@@ -0,0 +1,61 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "pcloud-copy-folder",
+  name: "Copy Folder",
+  description: "Copy a folder to the specified folder. [See the docs here](https://docs.pcloud.com/methods/folder/copyfolder.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to copy.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    toFolderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      label: "Destination Folder ID",
+      description: `Select a **Destination Folder** where the folder will be copied to.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    overwrite: {
+      propDefinition: [
+        pcloud,
+        "overwrite",
+      ],
+    },
+    copyContentOnly: {
+      type: "boolean",
+      label: "Copy Content Only?",
+      description:
+        "If true, only the contents of source folder will be copied, otherwise the folder itself is copied.",
+      default: false,
+      optional: true,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "Copied folder successfully";
+    },
+    async requestMethod() {
+      return this.pcloud.copyFolder(
+        this.folderId,
+        this.toFolderId,
+        !this.overwrite,
+        this.copyContentOnly,
+      );
+    },
+  },
+};

package/actions/create-folder/create-folder.mjs

@@ -0,0 +1,40 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "pcloud-create-folder",
+  name: "Create Folder",
+  description:
+    "Create a folder in the specified folder. [See the docs here](https://docs.pcloud.com/methods/folder/createfolder.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to create the new folder within.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+      label: "Parent Folder ID",
+    },
+    name: {
+      propDefinition: [
+        pcloud,
+        "name",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return `Created folder "${this.name}" successfully`;
+    },
+    async requestMethod() {
+      return this.pcloud.createFolder(this.name, this.folderId);
+    },
+  },
+};

package/actions/download-files/download-files.mjs

@@ -0,0 +1,37 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "pcloud-download-files",
+  name: "Download File(s)",
+  description: "Download one or more files to a folder. [See the docs here](https://docs.pcloud.com/methods/file/downloadfile.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    urls: {
+      type: "string[]",
+      label: "URLs",
+      description: "URL(s) of the files to download.",
+    },
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to receive the downloaded files.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return `Downloaded ${this.urls.length} files successfully`;
+    },
+    async requestMethod() {
+      return this.pcloud.downloadFiles(this.urls, this.folderId);
+    },
+  },
+};

package/actions/list-contents/list-contents.mjs

@@ -0,0 +1,64 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+
+export default {
+  ...common,
+  key: "pcloud-list-contents",
+  name: "List Contents",
+  description: "Get the contents of the specified folder. [See the docs here](https://docs.pcloud.com/methods/folder/listfolder.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to get the contents of.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    recursive: {
+      type: "boolean",
+      label: "Recursive?",
+      description:
+        "If true, returns contents of the folder **and all subfolders,** recursively.",
+      default: false,
+    },
+    showDeleted: {
+      propDefinition: [
+        pcloud,
+        "showDeleted",
+      ],
+    },
+    noFiles: {
+      type: "boolean",
+      label: "Folders Only?",
+      description:
+        "If true, only the **folder** (sub)structure will be returned.",
+      default: false,
+    },
+    noShares: {
+      type: "boolean",
+      label: "Exclude Shares?",
+      description: "If true, excludes shared files and folders.",
+      default: true,
+    },
+  },
+  methods: {
+    ...common.methods,
+    getSummary() {
+      return "Listed folder contents successfully";
+    },
+    async requestMethod() {
+      return this.pcloud.listContents(
+        this.folderId,
+        this.recursive,
+        this.showDeleted,
+        this.noFiles,
+        this.noShares,
+      );
+    },
+  },
+};

package/actions/upload-file/upload-file.mjs

@@ -0,0 +1,80 @@
+import pcloud from "../../pcloud.app.mjs";
+import common from "../common/base.mjs";
+import { promises as fsPromises } from "fs";
+
+export default {
+  ...common,
+  key: "pcloud-upload-file",
+  name: "Upload File",
+  description:
+    "Upload a file to the specified folder. [See the docs here](https://docs.pcloud.com/methods/file/uploadfile.html)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    ...common.props,
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to receive the uploaded file.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    name: {
+      propDefinition: [
+        pcloud,
+        "name",
+      ],
+      description: `Name of the file to upload. This must be a file in the workflow's \`/tmp\` directory.
+        \\
+        [See the docs on how to work with files in your workflow.](https://pipedream.com/docs/code/nodejs/working-with-files/)`,
+    },
+    renameIfExists: {
+      type: "boolean",
+      label: "Rename if Exists",
+      description:
+        "If true, the uploaded file will be renamed, if another file with the requested name already exists in the specified folder.",
+      default: true,
+    },
+    modifiedTime: {
+      propDefinition: [
+        pcloud,
+        "modifiedTime",
+      ],
+    },
+    createdTime: {
+      propDefinition: [
+        pcloud,
+        "createdTime",
+      ],
+    },
+  },
+  methods: {
+    ...common.methods,
+    async validateInputs() {
+      const files = await fsPromises.readdir("/tmp");
+      const fileName = this.name;
+
+      if (!files.includes(fileName)) {
+        return `File "${this.name}" not found in the /tmp directory`;
+      }
+
+      return true;
+    },
+    getSummary() {
+      return `Uploaded file "${this.name}" successfully`;
+    },
+    async requestMethod() {
+      return this.pcloud.uploadFile(
+        this.folderId,
+        this.name,
+        this.noPartial,
+        this.progressHash,
+        this.renameIfExists,
+        this.modifiedTime,
+        this.createdTime,
+      );
+    },
+  },
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pipedream/pcloud",
+  "version": "0.3.3",
+  "description": "Pipedream pCloud Components",
+  "main": "pcloud.app.mjs",
+  "keywords": [
+    "pipedream",
+    "pcloud"
+  ],
+  "homepage": "https://pipedream.com/apps/pcloud",
+  "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
+  "license": "MIT",
+  "dependencies": {
+    "async-retry": "^1.3.1",
+    "lodash": "^4.17.20",
+    "pcloud-sdk-js": "^2.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/pcloud.app.mjs

@@ -0,0 +1,361 @@
+import get from "lodash/get.js";
+import retry from "async-retry";
+import pcloudSdk from "pcloud-sdk-js";
+
+export default {
+  type: "app",
+  app: "pcloud",
+  propDefinitions: {
+    fileId: {
+      type: "integer",
+      label: "File ID",
+      async options() {
+        return this.getFileOptions();
+      },
+    },
+    folderId: {
+      type: "integer",
+      label: "Folder ID",
+      async options() {
+        return this.getFolderOptions();
+      },
+      default: 0,
+    },
+    name: {
+      type: "string",
+      label: "Name",
+      description: "Name of the folder to be created.",
+    },
+    overwrite: {
+      type: "boolean",
+      label: "Overwrite?",
+      description: `If true, and an entry with the same name already exists, it will be overwritten.
+        \\
+        Otherwise, an error \`2004\` will be returned instead.`,
+      default: false,
+      optional: true,
+    },
+    showDeleted: {
+      type: "boolean",
+      label: "Show Deleted?",
+      description:
+        "If true, deleted files and folders that can be undeleted will be displayed.",
+      default: false,
+      optional: true,
+    },
+    modifiedTime: {
+      type: "integer",
+      label: "Modified Time",
+      description: "Must be Unix time (seconds).",
+      optional: true,
+    },
+    createdTime: {
+      type: "integer",
+      label: "Created Time",
+      description: `Must be Unix time (seconds).
+        \\
+        Requires \`Modified Time\` to be set.`,
+      optional: true,
+    },
+  },
+  methods: {
+    async api() {
+      global.locationid = Number(this.$auth.locationid);
+      // eslint-disable-next-line no-unused-vars
+      /*
+      const locations = {
+        1: "api.pcloud.com",
+        2: "eapi.pcloud.com",
+      };
+      */
+      return pcloudSdk.createClient(
+        this.$auth.oauth_access_token,
+        "oauth",
+      );
+    },
+    _isRetriableStatusCode(statusCode) {
+      return [
+        408,
+        429,
+        500,
+      ].includes(statusCode);
+    },
+    async _withRetries(apiCall) {
+      const retryOpts = {
+        retries: 3,
+        factor: 2,
+      };
+      return retry(async (bail) => {
+        try {
+          return await apiCall();
+        } catch (err) {
+          const statusCode = [
+            get(err, [
+              "response",
+              "status",
+            ]),
+          ];
+          if (!this._isRetriableStatusCode(statusCode)) {
+            if (err.result) {
+              bail(`
+                Error processing pCloud request (result: ${err.result}):
+              ${JSON.stringify(err.error)}
+            `);
+            } else {
+              bail(`
+                Unexpected error (status code: ${statusCode}):
+              ${JSON.stringify(err.message)}
+            `);
+              console.warn(`Temporary error: ${err.error}`);
+            }
+          }
+          throw err;
+        }
+      }, retryOpts);
+    },
+    /**
+     * Takes one file and copies it as another file in the user's filesystem.
+     * pCloud API domain URL depends on the location of pCLoud data center associated to the
+     * account.
+     * @params {integer} fileId - ID of the file to copy.
+     * @params {integer} toFolderId - ID of the destination folder.
+     * @params {string} toName - Name of the destination file.
+     * @params {boolean} noOver - If `true` and a file with the specified name already exists,
+     * no overwriting will be performed.
+     * @params {string} modifiedTime - Must be a UNIX timestamp.
+     * seconds.
+     * @params {string} createdTime - If specified, file created time is set. It's required to
+     * provide `modifiedTime` to set `createdTime`. Must be in unix time seconds.
+     * @returns {metadata: array, result: integer } An array with the [metadata](https://docs.pcloud.com/structures/metadata.html) of the newly copied file. A `result` integer that indicates the results of the API operation, 0 means success, a non-zero result means an error occurred, when the result is non-zero an `error` message is included.
+     */
+    async copyFile(
+      fileId,
+      toFolderId,
+      toName,
+      noOver,
+      modifiedTime,
+      createdTime,
+    ) {
+      const params = {
+        fileid: fileId,
+        tofolderid: toFolderId,
+      };
+
+      if (toName) {
+        params.toname = toName;
+      }
+      if (noOver) {
+        params.noover = 1;
+      }
+      if (modifiedTime) {
+        params.mtime = modifiedTime;
+      }
+      if (createdTime) {
+        params.ctime = createdTime;
+      }
+      return (
+        await this.api()
+      ).api("copyfile", {
+        params,
+      });
+    },
+    /**
+     * Copies a folder to the specified folder.
+     *  @params {integer} folderId - ID of the folder to copy.
+     * @params {integer} toFolderId - ID of the destination folder.
+     * @params {boolean} noOver - If `true` and files with the same name already exist it will
+     * return a `2004` error code. Othrwise files will be overwritten.
+     * @params {boolean} copyContentOnly - If set, only the content of source folder will be copied
+     * otherwise the folder itself is copied.
+     * @returns {metadata: array, result: integer } An array with the [metadata](https://docs.pcloud.com/structures/metadata.html) of the newly copied folder. A `result` integer that indicates the results of the API operation, 0 means success, a non-zero result means an error occurred, when the result is non-zero an `error` message is included.
+     */
+    async copyFolder(folderId, toFolderId, noOver, copyContentOnly) {
+      const params = {};
+      params.folderid = folderId;
+      params.tofolderid = toFolderId;
+      if (noOver) {
+        params.noover = 1;
+      }
+      if (copyContentOnly) {
+        params.copycontentonly = 1;
+      }
+      return (
+        await this.api()
+      ).api("copyfolder", {
+        params,
+      });
+    },
+    /**
+     * Creates a folder in the specified folder.
+     * @params {string} name - Name of the folder to be created.
+     * @params {integer} folderId - ID of the parent folder where the new folder will be created.
+     * @returns {metadata: array, result: integer } An array with the [metadata](https://docs.pcloud.com/structures/metadata.html) of the newly created folder. A `result` integer that indicates the results of the API operation, 0 means success, a non-zero result means an error occurred, when the result is non-zero an `error` message is included.
+     */
+    async createFolder(name, folderId) {
+      return (await this.api()).createfolder(name, folderId);
+    },
+    /**
+     * Downloads one or more files from links supplied in the url parameter.
+     * @params {array} urls - URL(s) of the files to download.
+     * @params {integer} folderId - ID of the folder, in which to download the files.
+     * @returns {metadata: array, result: integer } An array with the [metadata]
+     * (https://docs.pcloud.com/structures/metadata.html) of each of the downloaded files. A
+     * `result` integer that indicates the results of the API operation, 0 means success, a
+     * non-zero result means an error occurred, when the result is non-zero an `error` message is
+     * included.
+     */
+    async downloadFiles(urls, folderId) {
+      return (await this.api()).remoteupload(urls.join(" "), folderId);
+    },
+    /**
+     * Gets the dynamically populated options for file related props.
+     * @returns {array} An array to use as dynamically populated options in file ID related
+     * props.
+     */
+    async getFileOptions() {
+      const folderItems = await this._withRetries(() =>
+        this.listContents(
+          0, //0 - ID for the root folder
+          true,
+          null,
+          false,
+        ));
+      let options = [];
+      let name = "";
+      let populateOptions = function (name, folderItem) {
+        if (folderItem.name === "/" || name === "/") {
+          name = `${name}${folderItem.name}`;
+        } else {
+          name = `${name}/${folderItem.name}`;
+        }
+        if (!folderItem.isfolder) {
+          options.push({
+            label: name,
+            value: folderItem.fileid,
+          });
+        }
+        if (folderItem.isfolder && folderItem.contents.length) {
+          folderItem.contents.forEach((content) => {
+            populateOptions(name, content);
+          });
+        } else {
+          return;
+        }
+      };
+      populateOptions(name, folderItems);
+      return options;
+    },
+    /**
+     * Gets the dynamically populated options for folder related props.
+     * @returns {array} An array to use as dynamically populated options in folder ID related
+     * props.
+     */
+    async getFolderOptions() {
+      const folders = await this._withRetries(() =>
+        this.listContents(
+          0, //0 - ID for the root folder
+          true,
+          null,
+          true,
+        ));
+      const options = [];
+      let name = "";
+      let populateOptions = function (name, folder) {
+        if (folder.name === "/" || name === "/") {
+          name = `${name}${folder.name}`;
+        } else {
+          name = `${name}/${folder.name}`;
+        }
+        options.push({
+          label: name,
+          value: folder.folderid,
+        });
+        if (folder.contents.length) {
+          folder.contents.forEach((content) => {
+            populateOptions(name, content);
+          });
+        } else {
+          return;
+        }
+      };
+      populateOptions(name, folders);
+      return options;
+    },
+    /**
+     * Lists the metadata of the specified folder's contents.
+     * pCloud API domain URL depends on the location of pCLoud data center associated to the
+     * account.
+     * @params {integer} folderId - ID of the folder to list contents. If not specified, the root
+     * folder will be used.
+     * @params {boolean} recursive - If is set full directory tree will be returned, which means
+     * that all directories will have contents filed.
+     * @params {boolean} showDeleted - If is set, deleted files and folders that can be undeleted
+     * will be displayed.
+     * @params {boolean} noFiles - If is set, only the folder (sub)structure will be returned.
+     * @params {boolean} noShares - If is set, only user's own folders and files will be displayed.
+     * @returns {metadata: array, result: integer } An array with the [metadata](https://docs.pcloud.com/structures/metadata.html) of each of the retrieved files and folders, if `recursive` is set, an additional `contents` element will be presented for the contents of inner folders. A `result` integer that indicates the results of the API operation, 0 means success, a non-zero result means an error occurred, when the result is non-zero an `error` message is included.
+     */
+    async listContents(folderId, recursive, showDeleted, noFiles, noShares) {
+      const optionalParams = {};
+      if (recursive) {
+        optionalParams.recursive = 1; //Need to use an integer for `recursive`, `showDeleted`, `noFiles`,
+        //and `noShares` if `true`
+      }
+      if (showDeleted) {
+        optionalParams.showdeleted = 1;
+      }
+      if (noFiles) {
+        optionalParams.nofiles = 1;
+      }
+      if (noShares) {
+        optionalParams.noshares = 1;
+      }
+      return (await this.api()).listfolder(folderId, optionalParams);
+    },
+    /**
+     * Uploads a file to the user's filesystem.
+     * @params {integer} folderid - ID of the folder where the file will be uploaded.
+     * @params {string} name - Name of the file to upload.
+     * @params {boolean} renameIfExists - When `true`, the uploaded file will
+     * be renamed, if file with
+     * the requested name exists in the folder.
+     * @params {integer} modifiedTime - If set, file modified time is set. Must be a unix timestamp.
+     * @params {integer} createdTime - If set, file created time is set. Must be a unix timestamp.
+     * It's required to provide `modifiedTime` to set `createdTime`.
+     * @returns {checksums: array, fileids: array, metadata: array, result: integer} A `checksums` array, each element with the file checksums calculated with `md5` and `sha1` algorithms, the `id` of the created file under the one element `fileids` array, and an array with the [metadata](https://docs.pcloud.com/structures/metadata.html) of the newly uploaded file.  A `result` integer that indicates the results of the API operation, 0 means success, a non-zero result means an error occurred, when the result is non-zero an `error` message is included.
+     */
+    async uploadFile(
+      folderid,
+      name,
+      renameIfExists,
+      modifiedTime,
+      createdTime,
+    ) {
+      const params = {
+        folderid,
+      };
+      const files = [
+        {
+          name,
+          file: `/tmp/${name}`,
+        },
+      ];
+      if (renameIfExists) {
+        params.renameifexists = 1;
+      }
+      if (modifiedTime) {
+        params.mtime = modifiedTime;
+      }
+      if (createdTime) {
+        params.ctime = createdTime;
+      }
+      return (
+        await this.api()
+      ).api("uploadfile", {
+        method: "post",
+        params,
+        files,
+      });
+    },
+  },
+};

package/sources/watch-folder/watch-folder.mjs

@@ -0,0 +1,120 @@
+import pcloud from "../../pcloud.app.mjs";
+import get from "lodash/get.js";
+
+export default {
+  key: "pcloud-watch-folder",
+  name: "Watch Folder",
+  description:
+    "Emit new event when a file is created or modified in the specified folder.",
+  version: "0.0.1",
+  type: "source",
+  dedupe: "last",
+  props: {
+    pcloud,
+    db: "$.service.db",
+    timer: {
+      label: "Polling schedule",
+      description: "Pipedream polls pCloud for events on this schedule.",
+      type: "$.interface.timer",
+      default: {
+        intervalSeconds: 60 * 15, // by default, run every 15 minutes.
+      },
+    },
+    folderId: {
+      propDefinition: [
+        pcloud,
+        "folderId",
+      ],
+      description: `Select a **Folder** to watch for changes.
+        \\
+        Alternatively, you can provide a custom *Folder ID*.`,
+    },
+    event: {
+      type: "string",
+      label: "Folder Event",
+      options: [
+        "Created",
+        "Modified",
+      ],
+      description:
+        "Specify when to emit an event related to a given folder. Note that pCloud preserves files' `created` and `modified` timestamps on upload. If manually uploading via pCloud's `uploadfile` API, these timestamps can be set by specifying the `mtime` and `ctime` parameters, respectively.",
+      default: "Created",
+    },
+    showDeleted: {
+      propDefinition: [
+        pcloud,
+        "showDeleted",
+      ],
+    },
+  },
+  hooks: {
+    async deploy() {
+      const files = [];
+      const pCloudContentsData = await this.getContents();
+      const hasContents = get(pCloudContentsData, [
+        "contents",
+      ]);
+      if (hasContents) {
+        for (const folderItem of pCloudContentsData.contents) {
+          if (!folderItem.isfolder) {
+            files.push(folderItem);
+            if (files.length == 10) {
+              break;
+            }
+          }
+        }
+      } else {
+        console.log("No data available, skipping iteration");
+      }
+      files.forEach(this.emitpCloudEvent);
+      this.db.set("lastPolledTime", +Date.now());
+    },
+  },
+  methods: {
+    async getContents() {
+      return this.pcloud._withRetries(() =>
+        this.pcloud.listContents(
+          this.folderId,
+          false,
+          this.showDeleted,
+          false,
+          false,
+        ));
+    },
+    emitpCloudEvent(pCloudEvent) {
+      const metadata = this.getEventData(pCloudEvent);
+      this.$emit(pCloudEvent, metadata);
+    },
+    getEventData(pcloudEvent) {
+      const eventDate = pcloudEvent[this.event.toLowerCase()];
+      const ts = +new Date(eventDate);
+      return {
+        id: ts,
+        summary: `${this.event} file "${pcloudEvent.name}"`,
+        ts,
+      };
+    },
+  },
+  async run() {
+    const lastPolledTime = this.db.get("lastPolledTime");
+    const files = [];
+    const pCloudContentsData = await this.getContents();
+    const hasContents = get(pCloudContentsData, [
+      "contents",
+    ]);
+    if (hasContents) {
+      for (const folderItem of pCloudContentsData.contents) {
+        if (!folderItem.isfolder) {
+          let fileTime = +new Date(folderItem[this.event.toLowerCase()]);
+          if (fileTime > lastPolledTime) {
+            files.push(folderItem);
+          }
+        }
+      }
+    } else {
+      console.log("No data available, skipping iteration");
+    }
+    files.forEach(this.emitpCloudEvent);
+    this.db.set("lastPolledTime", +Date.now());
+  },
+};