@pipedream/tableau 0.0.1 → 0.1.0

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.1",
+  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/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.1",
+  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.1.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.1",
+  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.1",
+  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,145 @@
+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,
+        }));
+      },
+    },
+  },
   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,
+      });
+    },
+    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));
     },
   },
-};
+};