@slates-integrations/tableau 0.2.0-rc.8

package/src/triggers/label-events.ts

@@ -0,0 +1,98 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+let eventNameMap: Record<string, string> = {
+  LabelCreated: 'label.created',
+  LabelUpdated: 'label.updated',
+  LabelDeleted: 'label.deleted'
+};
+
+let webhookEventNames = ['LabelCreated', 'LabelUpdated', 'LabelDeleted'];
+
+export let labelEvents = SlateTrigger.create(spec, {
+  name: 'Label Events',
+  key: 'label_events',
+  description:
+    'Triggers when data quality labels or certifications are created, updated, or deleted. Tableau Cloud only.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Tableau webhook event type'),
+      resourceId: z.string().describe('LUID of the affected label'),
+      resourceName: z.string().describe('Name of the affected label'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      labelId: z.string().describe('LUID of the affected label'),
+      labelName: z.string().describe('Name of the label'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('When the event occurred')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds: Record<string, string> = {};
+
+      for (let eventName of webhookEventNames) {
+        let webhook = await client.createWebhook(
+          `slates-label-${eventName}`,
+          eventName,
+          ctx.input.webhookBaseUrl
+        );
+        webhookIds[eventName] = webhook.id;
+      }
+
+      return { registrationDetails: { webhookIds } };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds = ctx.input.registrationDetails?.webhookIds || {};
+
+      for (let webhookId of Object.values(webhookIds) as string[]) {
+        try {
+          await client.deleteWebhook(webhookId);
+        } catch (e) {
+          // Webhook may already be deleted
+        }
+      }
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+
+      return {
+        inputs: [
+          {
+            eventType: body.eventType || body['webhook-source-event-name'] || 'unknown',
+            resourceId: body.resource_luid || body.resourceId || '',
+            resourceName: body.resource_name || body.resourceName || '',
+            siteId: body.site_luid || body.siteId || '',
+            timestamp: body.created_at || body.timestamp || new Date().toISOString()
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      let mappedType = eventNameMap[ctx.input.eventType] || `label.${ctx.input.eventType}`;
+
+      return {
+        type: mappedType,
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          labelId: ctx.input.resourceId,
+          labelName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/site-events.ts

@@ -0,0 +1,97 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+let eventNameMap: Record<string, string> = {
+  SiteCreated: 'site.created',
+  SiteUpdated: 'site.updated',
+  SiteDeleted: 'site.deleted'
+};
+
+let webhookEventNames = ['SiteCreated', 'SiteUpdated', 'SiteDeleted'];
+
+export let siteEvents = SlateTrigger.create(spec, {
+  name: 'Site Events',
+  key: 'site_events',
+  description: 'Triggers when a site is created, updated, or deleted.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Tableau webhook event type'),
+      resourceId: z.string().describe('LUID of the affected site'),
+      resourceName: z.string().describe('Name of the affected site'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      affectedSiteId: z.string().describe('LUID of the affected site'),
+      siteName: z.string().describe('Name of the site'),
+      siteId: z.string().describe('LUID of the site context'),
+      timestamp: z.string().describe('When the event occurred')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds: Record<string, string> = {};
+
+      for (let eventName of webhookEventNames) {
+        let webhook = await client.createWebhook(
+          `slates-site-${eventName}`,
+          eventName,
+          ctx.input.webhookBaseUrl
+        );
+        webhookIds[eventName] = webhook.id;
+      }
+
+      return { registrationDetails: { webhookIds } };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds = ctx.input.registrationDetails?.webhookIds || {};
+
+      for (let webhookId of Object.values(webhookIds) as string[]) {
+        try {
+          await client.deleteWebhook(webhookId);
+        } catch (e) {
+          // Webhook may already be deleted
+        }
+      }
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+
+      return {
+        inputs: [
+          {
+            eventType: body.eventType || body['webhook-source-event-name'] || 'unknown',
+            resourceId: body.resource_luid || body.resourceId || '',
+            resourceName: body.resource_name || body.resourceName || '',
+            siteId: body.site_luid || body.siteId || '',
+            timestamp: body.created_at || body.timestamp || new Date().toISOString()
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      let mappedType = eventNameMap[ctx.input.eventType] || `site.${ctx.input.eventType}`;
+
+      return {
+        type: mappedType,
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          affectedSiteId: ctx.input.resourceId,
+          siteName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/user-events.ts

@@ -0,0 +1,98 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+let eventNameMap: Record<string, string> = {
+  AdminPromoted: 'user.admin_promoted',
+  AdminDemoted: 'user.admin_demoted',
+  UserDeleted: 'user.deleted'
+};
+
+let webhookEventNames = ['AdminPromoted', 'AdminDemoted', 'UserDeleted'];
+
+export let userEvents = SlateTrigger.create(spec, {
+  name: 'User Events',
+  key: 'user_events',
+  description:
+    'Triggers when a user is promoted to or demoted from Site Administrator, or when a user is deleted.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Tableau webhook event type'),
+      resourceId: z.string().describe('LUID of the affected user'),
+      resourceName: z.string().describe('Name of the affected user'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      userId: z.string().describe('LUID of the affected user'),
+      userName: z.string().describe('Name of the user'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('When the event occurred')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds: Record<string, string> = {};
+
+      for (let eventName of webhookEventNames) {
+        let webhook = await client.createWebhook(
+          `slates-user-${eventName}`,
+          eventName,
+          ctx.input.webhookBaseUrl
+        );
+        webhookIds[eventName] = webhook.id;
+      }
+
+      return { registrationDetails: { webhookIds } };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds = ctx.input.registrationDetails?.webhookIds || {};
+
+      for (let webhookId of Object.values(webhookIds) as string[]) {
+        try {
+          await client.deleteWebhook(webhookId);
+        } catch (e) {
+          // Webhook may already be deleted
+        }
+      }
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+
+      return {
+        inputs: [
+          {
+            eventType: body.eventType || body['webhook-source-event-name'] || 'unknown',
+            resourceId: body.resource_luid || body.resourceId || '',
+            resourceName: body.resource_name || body.resourceName || '',
+            siteId: body.site_luid || body.siteId || '',
+            timestamp: body.created_at || body.timestamp || new Date().toISOString()
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      let mappedType = eventNameMap[ctx.input.eventType] || `user.${ctx.input.eventType}`;
+
+      return {
+        type: mappedType,
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          userId: ctx.input.resourceId,
+          userName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/view-events.ts

@@ -0,0 +1,83 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+export let viewEvents = SlateTrigger.create(spec, {
+  name: 'View Events',
+  key: 'view_events',
+  description: 'Triggers when a view is deleted.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Tableau webhook event type'),
+      resourceId: z.string().describe('LUID of the affected view'),
+      resourceName: z.string().describe('Name of the affected view'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      viewId: z.string().describe('LUID of the affected view'),
+      viewName: z.string().describe('Name of the view'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('When the event occurred')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+
+      let webhook = await client.createWebhook(
+        'slates-view-ViewDeleted',
+        'ViewDeleted',
+        ctx.input.webhookBaseUrl
+      );
+
+      return { registrationDetails: { webhookId: webhook.id } };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookId = ctx.input.registrationDetails?.webhookId;
+
+      if (webhookId) {
+        try {
+          await client.deleteWebhook(webhookId);
+        } catch (e) {
+          // Webhook may already be deleted
+        }
+      }
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+
+      return {
+        inputs: [
+          {
+            eventType: body.eventType || body['webhook-source-event-name'] || 'ViewDeleted',
+            resourceId: body.resource_luid || body.resourceId || '',
+            resourceName: body.resource_name || body.resourceName || '',
+            siteId: body.site_luid || body.siteId || '',
+            timestamp: body.created_at || body.timestamp || new Date().toISOString()
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: 'view.deleted',
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          viewId: ctx.input.resourceId,
+          viewName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/workbook-events.ts

@@ -0,0 +1,108 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+let eventNameMap: Record<string, string> = {
+  WorkbookCreated: 'workbook.created',
+  WorkbookUpdated: 'workbook.updated',
+  WorkbookDeleted: 'workbook.deleted',
+  WorkbookRefreshStarted: 'workbook.refresh_started',
+  WorkbookRefreshSucceeded: 'workbook.refresh_succeeded',
+  WorkbookRefreshFailed: 'workbook.refresh_failed'
+};
+
+let webhookEventNames = [
+  'WorkbookCreated',
+  'WorkbookUpdated',
+  'WorkbookDeleted',
+  'WorkbookRefreshStarted',
+  'WorkbookRefreshSucceeded',
+  'WorkbookRefreshFailed'
+];
+
+export let workbookEvents = SlateTrigger.create(spec, {
+  name: 'Workbook Events',
+  key: 'workbook_events',
+  description:
+    'Triggers when a workbook is created, updated, deleted, or when an extract refresh starts, succeeds, or fails.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Tableau webhook event type'),
+      resourceId: z.string().describe('LUID of the affected workbook'),
+      resourceName: z.string().describe('Name of the affected workbook'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      workbookId: z.string().describe('LUID of the affected workbook'),
+      workbookName: z.string().describe('Name of the workbook'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('When the event occurred')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds: Record<string, string> = {};
+
+      for (let eventName of webhookEventNames) {
+        let webhook = await client.createWebhook(
+          `slates-workbook-${eventName}`,
+          eventName,
+          ctx.input.webhookBaseUrl
+        );
+        webhookIds[eventName] = webhook.id;
+      }
+
+      return { registrationDetails: { webhookIds } };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = createClient(ctx.config, ctx.auth);
+      let webhookIds = ctx.input.registrationDetails?.webhookIds || {};
+
+      for (let webhookId of Object.values(webhookIds) as string[]) {
+        try {
+          await client.deleteWebhook(webhookId);
+        } catch (e) {
+          // Webhook may already be deleted
+        }
+      }
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+
+      return {
+        inputs: [
+          {
+            eventType: body.eventType || body['webhook-source-event-name'] || 'unknown',
+            resourceId: body.resource_luid || body.resourceId || '',
+            resourceName: body.resource_name || body.resourceName || '',
+            siteId: body.site_luid || body.siteId || '',
+            timestamp: body.created_at || body.timestamp || new Date().toISOString()
+          }
+        ]
+      };
+    },
+
+    handleEvent: async ctx => {
+      let mappedType = eventNameMap[ctx.input.eventType] || `workbook.${ctx.input.eventType}`;
+
+      return {
+        type: mappedType,
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          workbookId: ctx.input.resourceId,
+          workbookName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+    "moduleResolution": "bundler",
+
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["src"]
+}