@pipedream/tableau 0.0.1 → 0.2.0

package/README.md

@@ -0,0 +1,17 @@
+# Overview
+
+The Tableau API allows you to tap into the robust data visualization and business intelligence capabilities of Tableau. Within Pipedream, you can leverage this API to automate reporting, manage users, update data sources, and extract insights. This enables you to integrate Tableau's analytics with other services, streamlining your data workflows and ensuring your dashboards remain up-to-date with minimal manual effort.
+
+# Example Use Cases
+
+- **Automated Snapshot Sharing**: Generate snapshots of your key Tableau dashboards and share them via email or Slack at regular intervals. This keeps your team informed with the latest business insights without manual exports.
+
+  _Example Workflow_: Trigger a Pipedream workflow on a schedule; use Tableau API to capture a view of the dashboard; send the image via Gmail or post to a Slack channel using their respective Pipedream app integrations.
+
+- **Dynamic Data Updates**: Automatically update Tableau data sources when new data comes into your backend systems, ensuring that Tableau dashboards reflect the most current data.
+
+  _Example Workflow_: Trigger a Pipedream workflow with a webhook when new data is added to a database; process and format the data within the workflow; use Tableau API to refresh the corresponding data source on Tableau Server or Tableau Online.
+
+- **User Management Automation**: Streamline user provisioning by automating the addition and removal of users to and from Tableau sites based on HR software triggers or internal databases.
+
+  _Example Workflow_: Trigger a Pipedream workflow from a user management event in an app like BambooHR; use conditions within the workflow to determine if the user should be added or removed; utilize Tableau API to update the user list on the relevant Tableau site.

package/actions/create-project/create-project.mjs

@@ -0,0 +1,72 @@
+import app from "../../tableau.app.mjs";
+
+export default {
+  key: "tableau-create-project",
+  name: "Create Project",
+  description: "Creates a project on the specified site. You can also create project hierarchies by creating a project under the specified parent project on the site. [See the documentation](https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_projects.htm#create_project)",
+  version: "0.0.2",
+  type: "action",
+  props: {
+    app,
+    siteId: {
+      propDefinition: [
+        app,
+        "siteId",
+      ],
+    },
+    name: {
+      type: "string",
+      label: "Project Name",
+      description: "The name of the new project to create",
+    },
+    description: {
+      type: "string",
+      label: "Project Description",
+      description: "The description of the new project to create",
+      optional: true,
+    },
+    parentProjectId: {
+      propDefinition: [
+        app,
+        "parentProjectId",
+        ({ siteId }) => ({
+          siteId,
+        }),
+      ],
+    },
+  },
+  methods: {
+    createProject({
+      siteId, ...args
+    } = {}) {
+      return this.app.post({
+        path: `/sites/${siteId}/projects`,
+        ...args,
+      });
+    },
+  },
+  async run({ $ }) {
+    const {
+      createProject,
+      siteId,
+      name,
+      description,
+      parentProjectId,
+    } = this;
+
+    const response = await createProject({
+      $,
+      siteId,
+      data: {
+        project: {
+          name,
+          description,
+          parentProjectId,
+        },
+      },
+    });
+
+    $.export("$summary", `Successfully created project with ID \`${response.project?.id}\``);
+    return response;
+  },
+};

package/actions/download-pdf/download-pdf.mjs

@@ -0,0 +1,130 @@
+import app from "../../tableau.app.mjs";
+import fs from "fs";
+import path from "path";
+
+export default {
+  key: "tableau-download-pdf",
+  name: "Download PDF",
+  description: "Downloads images of the sheets of a workbook as a PDF file. [See the documentation](https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_workbooks_and_views.htm#download_workbook_pdf)",
+  version: "0.0.1",
+  type: "action",
+  props: {
+    app,
+    siteId: {
+      propDefinition: [
+        app,
+        "siteId",
+      ],
+    },
+    workbookId: {
+      propDefinition: [
+        app,
+        "workbookId",
+        ({ siteId }) => ({
+          siteId,
+        }),
+      ],
+    },
+    maxAge: {
+      type: "integer",
+      label: "Max Age",
+      description: "The maximum number of minutes a workbook PDF will be cached before being refreshed. Minimum interval is one minute",
+      optional: true,
+      min: 1,
+    },
+    orientation: {
+      type: "string",
+      label: "Page Orientation",
+      description: "The orientation of the pages in the PDF file produced",
+      options: [
+        "Portrait",
+        "Landscape",
+      ],
+      default: "Portrait",
+      optional: true,
+    },
+    pageType: {
+      type: "string",
+      label: "Page Type",
+      description: "The type of page, which determines the page dimensions of the PDF file returned",
+      options: [
+        "A3",
+        "A4",
+        "A5",
+        "B5",
+        "Executive",
+        "Folio",
+        "Ledger",
+        "Legal",
+        "Letter",
+        "Note",
+        "Quarto",
+        "Tabloid",
+      ],
+      default: "Legal",
+      optional: true,
+    },
+    vizHeight: {
+      type: "integer",
+      label: "Viz Height",
+      description: "The height of the rendered PDF image in pixels that, along with `Viz Width`, determines its resolution and aspect ratio",
+      optional: true,
+    },
+    vizWidth: {
+      type: "integer",
+      label: "Viz Width",
+      description: "The width of the rendered PDF image in pixels that, along with `Viz Height`, determines its resolution and aspect ratio",
+      optional: true,
+    },
+    outputFilename: {
+      type: "string",
+      label: "Output Filename",
+      description: "The filename for the downloaded PDF file, which will be saved to the `/tmp` folder",
+      default: "workbook.pdf",
+      optional: true,
+    },
+    syncDir: {
+      type: "dir",
+      accessMode: "write",
+      sync: true,
+    },
+  },
+  async run({ $ }) {
+    const {
+      siteId,
+      workbookId,
+      maxAge,
+      orientation,
+      pageType,
+      vizHeight,
+      vizWidth,
+      outputFilename,
+    } = this;
+
+    const response = await this.app.downloadWorkbookPdf({
+      $,
+      siteId,
+      workbookId,
+      params: {
+        "max-age-minutes": maxAge,
+        orientation,
+        "page-type": pageType,
+        "viz-height": vizHeight,
+        "viz-width": vizWidth,
+      },
+      responseType: "arraybuffer",
+    });
+
+    // Write the PDF to the /tmp folder
+    const filename = outputFilename || "workbook.pdf";
+    const filePath = path.join("/tmp", filename);
+
+    await fs.promises.writeFile(filePath, Buffer.from(response));
+
+    $.export("$summary", `Successfully downloaded workbook PDF to \`${filePath}\``);
+    return {
+      filePath,
+      fileContent: response,
+    };
+  },
+};

package/actions/query-projects/query-projects.mjs

@@ -0,0 +1,40 @@
+import app from "../../tableau.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  key: "tableau-query-projects",
+  name: "Query Projects",
+  description: "Returns a list of projects on the specified site. [See the documentation](https://help.tableau.com/current/api/rest_api/en-us/REST/rest_api_ref_projects.htm)",
+  version: "0.0.2",
+  type: "action",
+  props: {
+    app,
+    siteId: {
+      propDefinition: [
+        app,
+        "siteId",
+      ],
+    },
+  },
+  async run({ $ }) {
+    const {
+      app,
+      siteId,
+    } = this;
+
+    const projects = await app.paginate({
+      resourcesFn: app.listProjects,
+      resourcesFnArgs: {
+        $,
+        siteId,
+        params: {
+          pageSize: constants.DEFAULT_LIMIT,
+        },
+      },
+      resourceName: "projects.project",
+    });
+
+    $.export("$summary", `Successfully retrieved \`${projects.length}\` project(s)`);
+    return projects;
+  },
+};

package/common/constants.mjs

@@ -0,0 +1,11 @@
+const VERSION_PATH = "/api/3.21";
+const DEFAULT_MAX = 600;
+const DEFAULT_LIMIT = 100;
+const WEBHOOK_ID = "webhookId";
+
+export default {
+  VERSION_PATH,
+  DEFAULT_MAX,
+  DEFAULT_LIMIT,
+  WEBHOOK_ID,
+};

package/common/utils.mjs

@@ -0,0 +1,17 @@
+async function iterate(iterations) {
+  const items = [];
+  for await (const item of iterations) {
+    items.push(item);
+  }
+  return items;
+}
+
+function getNestedProperty(obj, propertyString) {
+  const properties = propertyString.split(".");
+  return properties.reduce((prev, curr) => prev && prev[curr], obj);
+}
+
+export default {
+  iterate,
+  getNestedProperty,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/tableau",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Pipedream Tableau Components",
   "main": "tableau.app.mjs",
   "keywords": [
@@ -11,5 +11,8 @@
   "author": "Pipedream <support@pipedream.com> (https://pipedream.com/)",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@pipedream/platform": "^1.6.0"
   }
 }

package/sources/common/events.mjs

@@ -0,0 +1,24 @@
+export default {
+  ADMIN_PROMOTED: "AdminPromoted",
+  ADMIN_DEMOTED: "AdminDemoted",
+  DATASOURCE_UPDATED: "DatasourceUpdated",
+  DATASOURCE_CREATED: "DatasourceCreated",
+  DATASOURCE_DELETED: "DatasourceDeleted",
+  DATASOURCE_REFRESH_STARTED: "DatasourceRefreshStarted",
+  DATASOURCE_REFRESH_SUCCEEDED: "DatasourceRefreshSucceeded",
+  DATASOURCE_REFRESH_FAILED: "DatasourceRefreshFailed",
+  LABEL_CREATED: "LabelCreated",
+  LABEL_UPDATED: "LabelUpdated",
+  LABEL_DELETED: "LabelDeleted",
+  SITE_CREATED: "SiteCreated",
+  SITE_UPDATED: "SiteUpdated",
+  SITE_DELETED: "SiteDeleted",
+  USER_DELETED: "UserDeleted",
+  VIEW_DELETED: "ViewDeleted",
+  WORKBOOK_UPDATED: "WorkbookUpdated",
+  WORKBOOK_CREATED: "WorkbookCreated",
+  WORKBOOK_DELETED: "WorkbookDeleted",
+  WORKBOOK_REFRESH_STARTED: "WorkbookRefreshStarted",
+  WORKBOOK_REFRESH_SUCCEEDED: "WorkbookRefreshSucceeded",
+  WORKBOOK_REFRESH_FAILED: "WorkbookRefreshFailed",
+};

package/sources/common/webhook.mjs

@@ -0,0 +1,105 @@
+import { ConfigurationError } from "@pipedream/platform";
+import app from "../../tableau.app.mjs";
+import constants from "../../common/constants.mjs";
+
+export default {
+  props: {
+    app,
+    db: "$.service.db",
+    http: "$.interface.http",
+    siteId: {
+      propDefinition: [
+        app,
+        "siteId",
+      ],
+    },
+  },
+  hooks: {
+    async activate() {
+      const {
+        createWebhook,
+        siteId,
+        getWebhookName,
+        getEventName,
+        http,
+        setWebhookId,
+      } = this;
+
+      const { webhook: { id: webhookId } } =
+        await createWebhook({
+          siteId,
+          data: {
+            webhook: {
+              "name": getWebhookName(),
+              "event": getEventName(),
+              "isEnabled": true,
+              "webhook-destination": {
+                "webhook-destination-http": {
+                  "method": "POST",
+                  "url": http.endpoint,
+                },
+              },
+            },
+          },
+        });
+
+      setWebhookId(webhookId);
+    },
+    async deactivate() {
+      const {
+        getWebhookId,
+        siteId,
+        deleteWebhook,
+      } = this;
+
+      const webhookId = getWebhookId();
+      if (webhookId) {
+        await deleteWebhook({
+          siteId,
+          webhookId,
+        });
+      }
+    },
+  },
+  methods: {
+    setWebhookId(value) {
+      this.db.set(constants.WEBHOOK_ID, value);
+    },
+    getWebhookId() {
+      return this.db.get(constants.WEBHOOK_ID);
+    },
+    generateMeta() {
+      throw new ConfigurationError("generateMeta is not implemented");
+    },
+    getWebhookName() {
+      throw new ConfigurationError("getWebhookName is not implemented");
+    },
+    getEventName() {
+      throw new ConfigurationError("getEventName is not implemented");
+    },
+    processResource(resource) {
+      this.$emit(resource, this.generateMeta(resource));
+    },
+    createWebhook({
+      siteId, ...args
+    } = {}) {
+      return this.app.post({
+        debug: true,
+        path: `/sites/${siteId}/webhooks`,
+        ...args,
+      });
+    },
+    deleteWebhook({
+      siteId, webhookId, ...args
+    } = {}) {
+      return this.app.delete({
+        debug: true,
+        path: `/sites/${siteId}/webhooks/${webhookId}`,
+        ...args,
+      });
+    },
+  },
+  run({ body }) {
+    this.processResource(body);
+  },
+};

package/sources/label-created-instant/label-created-instant.mjs

@@ -0,0 +1,28 @@
+import common from "../common/webhook.mjs";
+import events from "../common/events.mjs";
+
+export default {
+  ...common,
+  key: "tableau-label-created-instant",
+  name: "New Label Created (Instant)",
+  description: "Emit new event when a label is created in Tableau. [See the documentation](https://help.tableau.com/current/developer/webhooks/en-us/docs/webhooks-events-payload.html)",
+  version: "0.0.2",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getWebhookName() {
+      return "label-creation";
+    },
+    getEventName() {
+      return events.LABEL_CREATED;
+    },
+    generateMeta(resource) {
+      return {
+        id: resource.resource_luid,
+        summary: `New Label: ${resource.resource_luid}`,
+        ts: Date.parse(resource.created_at),
+      };
+    },
+  },
+};

package/sources/workbook-created-instant/workbook-created-instant.mjs

@@ -0,0 +1,28 @@
+import common from "../common/webhook.mjs";
+import events from "../common/events.mjs";
+
+export default {
+  ...common,
+  key: "tableau-workbook-created-instant",
+  name: "New Workbook Created (Instant)",
+  description: "Emit new event each time a new workbook is created in Tableau. [See the documentation](https://help.tableau.com/current/developer/webhooks/en-us/docs/webhooks-events-payload.html)",
+  version: "0.0.2",
+  type: "source",
+  dedupe: "unique",
+  methods: {
+    ...common.methods,
+    getWebhookName() {
+      return "workbook-creation";
+    },
+    getEventName() {
+      return events.WORKBOOK_CREATED;
+    },
+    generateMeta(resource) {
+      return {
+        id: resource.resource_luid,
+        summary: `New Workbook: ${resource.resource_luid}`,
+        ts: Date.parse(resource.created_at),
+      };
+    },
+  },
+};

package/tableau.app.mjs

@@ -1,11 +1,187 @@
+import { axios } from "@pipedream/platform";
+import utils from "./common/utils.mjs";
+import constants from "./common/constants.mjs";
+
 export default {
   type: "app",
   app: "tableau",
-  propDefinitions: {},
+  propDefinitions: {
+    siteId: {
+      type: "string",
+      label: "Site ID",
+      description: "The ID of the site where the project or event is located",
+      async options() {
+        const { session: { site } } = await this.getCurrentSession();
+        return [
+          {
+            label: site.name,
+            value: site.id,
+          },
+        ];
+      },
+    },
+    parentProjectId: {
+      type: "string",
+      label: "Parent Project ID",
+      description: "The ID of the parent project under which the new project will be created",
+      optional: true,
+      async options({
+        siteId, page,
+      }) {
+        if (!siteId) {
+          return [];
+        }
+        const { projects: { project: data } } =
+          await this.listProjects({
+            siteId,
+            params: {
+              pageSize: constants.DEFAULT_LIMIT,
+              pageNumber: page + 1,
+            },
+          });
+        return data.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        }));
+      },
+    },
+    workbookId: {
+      type: "string",
+      label: "Workbook ID",
+      description: "The ID of the workbook to download as PDF",
+      async options({
+        siteId, page,
+      }) {
+        if (!siteId) {
+          return [];
+        }
+        const { workbooks: { workbook: data } } =
+          await this.listWorkbooks({
+            siteId,
+            params: {
+              pageSize: constants.DEFAULT_LIMIT,
+              pageNumber: page + 1,
+            },
+          });
+        return data?.map(({
+          id: value, name: label,
+        }) => ({
+          label,
+          value,
+        })) || [];
+      },
+    },
+  },
   methods: {
-    // this.$auth contains connected account data
-    authKeys() {
-      console.log(Object.keys(this.$auth));
+    getUrl(path) {
+      return `https://${this.$auth.domain}${constants.VERSION_PATH}${path}`;
+    },
+    getHeaders(headers) {
+      return {
+        ...headers,
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "X-Tableau-Auth": this.$auth.oauth_access_token,
+      };
+    },
+    _makeRequest({
+      $ = this, path, headers, ...args
+    } = {}) {
+      return axios($, {
+        ...args,
+        url: this.getUrl(path),
+        headers: this.getHeaders(headers),
+      });
+    },
+    post(args = {}) {
+      return this._makeRequest({
+        method: "POST",
+        ...args,
+      });
+    },
+    delete(args = {}) {
+      return this._makeRequest({
+        method: "DELETE",
+        ...args,
+      });
+    },
+    getCurrentSession(args = {}) {
+      return this._makeRequest({
+        path: "/sessions/current",
+        ...args,
+      });
+    },
+    listProjects({
+      siteId, ...args
+    }) {
+      return this._makeRequest({
+        path: `/sites/${siteId}/projects`,
+        ...args,
+      });
+    },
+    listWorkbooks({
+      siteId, ...args
+    }) {
+      return this._makeRequest({
+        path: `/sites/${siteId}/workbooks`,
+        ...args,
+      });
+    },
+    downloadWorkbookPdf({
+      siteId, workbookId, ...args
+    }) {
+      return this._makeRequest({
+        path: `/sites/${siteId}/workbooks/${workbookId}/pdf`,
+        ...args,
+      });
+    },
+    async *getIterations({
+      resourcesFn, resourcesFnArgs, resourceName,
+      max = constants.DEFAULT_MAX,
+    }) {
+      let pageNumber = 1;
+      let resourcesCount = 0;
+
+      while (true) {
+        const response =
+          await resourcesFn({
+            ...resourcesFnArgs,
+            params: {
+              ...resourcesFnArgs?.params,
+              pageNumber,
+            },
+          });
+
+        const nextResources = utils.getNestedProperty(response, resourceName);
+
+        if (!nextResources?.length) {
+          console.log("No more resources found");
+          return;
+        }
+
+        for (const resource of nextResources) {
+          yield resource;
+          resourcesCount += 1;
+
+          if (resourcesCount >= max) {
+            return;
+          }
+        }
+
+        const totalAvailable = response.pagination?.totalAvailable;
+
+        if (resourcesCount >= totalAvailable) {
+          console.log("There are no more resources to fetch");
+          return;
+        }
+
+        pageNumber += 1;
+      }
+    },
+    paginate(args = {}) {
+      return utils.iterate(this.getIterations(args));
     },
   },
-};
+};