@slates-integrations/tableau 0.2.0-rc.8

package/src/tools/manage-projects.ts

@@ -0,0 +1,162 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageProjects = SlateTool.create(spec, {
+  name: 'Manage Projects',
+  key: 'manage_projects',
+  description: `List, create, update, or delete projects. Projects organize workbooks, data sources, and other content in Tableau.`,
+  tags: { destructive: true }
+})
+  .input(
+    z.object({
+      action: z.enum(['list', 'create', 'update', 'delete']).describe('Operation to perform'),
+      projectId: z.string().optional().describe('Project LUID (required for update, delete)'),
+      name: z
+        .string()
+        .optional()
+        .describe('Project name (required for create, optional for update)'),
+      description: z.string().optional().describe('Project description'),
+      parentProjectId: z
+        .string()
+        .optional()
+        .describe('Parent project LUID for nested projects'),
+      contentPermissions: z
+        .enum(['ManagedByOwner', 'LockedToProject', 'LockedToProjectWithoutNested'])
+        .optional()
+        .describe('Content permission model'),
+      pageSize: z.number().optional().describe('Number of items per page'),
+      pageNumber: z.number().optional().describe('Page number (1-based)'),
+      filter: z.string().optional().describe('Filter expression for list'),
+      sort: z.string().optional().describe('Sort expression for list')
+    })
+  )
+  .output(
+    z.object({
+      projects: z
+        .array(
+          z.object({
+            projectId: z.string(),
+            name: z.string().optional(),
+            description: z.string().optional(),
+            parentProjectId: z.string().optional(),
+            contentPermissions: z.string().optional(),
+            createdAt: z.string().optional(),
+            updatedAt: z.string().optional()
+          })
+        )
+        .optional(),
+      project: z
+        .object({
+          projectId: z.string(),
+          name: z.string().optional(),
+          description: z.string().optional(),
+          parentProjectId: z.string().optional(),
+          contentPermissions: z.string().optional(),
+          createdAt: z.string().optional(),
+          updatedAt: z.string().optional()
+        })
+        .optional(),
+      totalCount: z.number().optional(),
+      deleted: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.queryProjects({
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber,
+        filter: ctx.input.filter,
+        sort: ctx.input.sort
+      });
+      let pagination = result.pagination || {};
+      let projects = (result.projects?.project || []).map((p: any) => ({
+        projectId: p.id,
+        name: p.name,
+        description: p.description,
+        parentProjectId: p.parentProjectId,
+        contentPermissions: p.contentPermissions,
+        createdAt: p.createdAt,
+        updatedAt: p.updatedAt
+      }));
+      return {
+        output: { projects, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${projects.length}** projects (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    if (action === 'create') {
+      if (!ctx.input.name) throw tableauServiceError('name is required for create action.');
+
+      let p = await client.createProject(ctx.input.name, {
+        description: ctx.input.description,
+        parentProjectId: ctx.input.parentProjectId,
+        contentPermissions: ctx.input.contentPermissions
+      });
+      return {
+        output: {
+          project: {
+            projectId: p.id,
+            name: p.name,
+            description: p.description,
+            parentProjectId: p.parentProjectId,
+            contentPermissions: p.contentPermissions
+          }
+        },
+        message: `Created project **${p.name}**.`
+      };
+    }
+
+    if (action === 'update') {
+      if (!ctx.input.projectId) {
+        throw tableauServiceError('projectId is required for update action.');
+      }
+      if (
+        ctx.input.name === undefined &&
+        ctx.input.description === undefined &&
+        ctx.input.parentProjectId === undefined &&
+        ctx.input.contentPermissions === undefined
+      ) {
+        throw tableauServiceError('Provide at least one field to update a project.');
+      }
+
+      let p = await client.updateProject(ctx.input.projectId, {
+        name: ctx.input.name,
+        description: ctx.input.description,
+        parentProjectId: ctx.input.parentProjectId,
+        contentPermissions: ctx.input.contentPermissions
+      });
+      return {
+        output: {
+          project: {
+            projectId: p.id,
+            name: p.name,
+            description: p.description,
+            parentProjectId: p.parentProjectId,
+            contentPermissions: p.contentPermissions
+          }
+        },
+        message: `Updated project **${p.name}**.`
+      };
+    }
+
+    if (action === 'delete') {
+      if (!ctx.input.projectId) {
+        throw tableauServiceError('projectId is required for delete action.');
+      }
+
+      await client.deleteProject(ctx.input.projectId);
+      return {
+        output: { deleted: true },
+        message: `Deleted project \`${ctx.input.projectId}\`.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-users.ts

@@ -0,0 +1,184 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageUsers = SlateTool.create(spec, {
+  name: 'Manage Users',
+  key: 'manage_users',
+  description: `List, get, add, update, or remove users on the Tableau site. Use the **action** field to select the operation.`,
+  tags: { destructive: true }
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['list', 'get', 'add', 'update', 'remove'])
+        .describe('Operation to perform'),
+      userId: z.string().optional().describe('User LUID (required for get, update, remove)'),
+      username: z.string().optional().describe('Username (required for add)'),
+      siteRole: z
+        .string()
+        .optional()
+        .describe(
+          'Site role, e.g. "Viewer", "Explorer", "Creator", "SiteAdministratorExplorer", "SiteAdministratorCreator" (required for add)'
+        ),
+      fullName: z.string().optional().describe('Full display name (for update)'),
+      email: z.string().optional().describe('Email address (for update)'),
+      authSetting: z.string().optional().describe('Auth setting (for add/update)'),
+      pageSize: z.number().optional().describe('Number of items per page'),
+      pageNumber: z.number().optional().describe('Page number (1-based)'),
+      filter: z.string().optional().describe('Filter expression for list'),
+      sort: z.string().optional().describe('Sort expression for list')
+    })
+  )
+  .output(
+    z.object({
+      users: z
+        .array(
+          z.object({
+            userId: z.string(),
+            name: z.string().optional(),
+            fullName: z.string().optional(),
+            email: z.string().optional(),
+            siteRole: z.string().optional(),
+            authSetting: z.string().optional(),
+            lastLogin: z.string().optional()
+          })
+        )
+        .optional(),
+      user: z
+        .object({
+          userId: z.string(),
+          name: z.string().optional(),
+          fullName: z.string().optional(),
+          email: z.string().optional(),
+          siteRole: z.string().optional(),
+          authSetting: z.string().optional(),
+          lastLogin: z.string().optional()
+        })
+        .optional(),
+      totalCount: z.number().optional(),
+      removed: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.queryUsers({
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber,
+        filter: ctx.input.filter,
+        sort: ctx.input.sort
+      });
+
+      let pagination = result.pagination || {};
+      let users = (result.users?.user || []).map((u: any) => ({
+        userId: u.id,
+        name: u.name,
+        fullName: u.fullName,
+        email: u.email,
+        siteRole: u.siteRole,
+        authSetting: u.authSetting,
+        lastLogin: u.lastLogin
+      }));
+
+      return {
+        output: { users, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${users.length}** users (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    if (action === 'get') {
+      if (!ctx.input.userId) throw tableauServiceError('userId is required for get action.');
+
+      let u = await client.getUser(ctx.input.userId);
+      return {
+        output: {
+          user: {
+            userId: u.id,
+            name: u.name,
+            fullName: u.fullName,
+            email: u.email,
+            siteRole: u.siteRole,
+            authSetting: u.authSetting,
+            lastLogin: u.lastLogin
+          }
+        },
+        message: `Retrieved user **${u.name}** (${u.siteRole}).`
+      };
+    }
+
+    if (action === 'add') {
+      if (!ctx.input.username)
+        throw tableauServiceError('username is required for add action.');
+      if (!ctx.input.siteRole)
+        throw tableauServiceError('siteRole is required for add action.');
+
+      let u = await client.addUser(
+        ctx.input.username,
+        ctx.input.siteRole,
+        ctx.input.authSetting
+      );
+      return {
+        output: {
+          user: {
+            userId: u.id,
+            name: u.name,
+            siteRole: u.siteRole,
+            authSetting: u.authSetting
+          }
+        },
+        message: `Added user **${u.name}** as ${u.siteRole}.`
+      };
+    }
+
+    if (action === 'update') {
+      if (!ctx.input.userId)
+        throw tableauServiceError('userId is required for update action.');
+      if (
+        ctx.input.fullName === undefined &&
+        ctx.input.email === undefined &&
+        ctx.input.siteRole === undefined &&
+        ctx.input.authSetting === undefined
+      ) {
+        throw tableauServiceError('Provide at least one field to update a user.');
+      }
+
+      let u = await client.updateUser(ctx.input.userId, {
+        fullName: ctx.input.fullName,
+        email: ctx.input.email,
+        siteRole: ctx.input.siteRole,
+        authSetting: ctx.input.authSetting
+      });
+      return {
+        output: {
+          user: {
+            userId: u.id,
+            name: u.name,
+            fullName: u.fullName,
+            email: u.email,
+            siteRole: u.siteRole,
+            authSetting: u.authSetting
+          }
+        },
+        message: `Updated user **${u.name}**.`
+      };
+    }
+
+    if (action === 'remove') {
+      if (!ctx.input.userId)
+        throw tableauServiceError('userId is required for remove action.');
+
+      await client.removeUser(ctx.input.userId);
+      return {
+        output: { removed: true },
+        message: `Removed user \`${ctx.input.userId}\` from the site.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-workbook.ts

@@ -0,0 +1,160 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+import { normalizeBoolean } from '../lib/normalizers';
+
+export let manageWorkbook = SlateTool.create(spec, {
+  name: 'Manage Workbook',
+  key: 'manage_workbook',
+  description: `Get details, update properties, delete, refresh extracts, or manage tags for a workbook. Use the **action** field to select the operation.`,
+  tags: { destructive: true }
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['get', 'update', 'delete', 'refresh', 'addTags', 'removeTags'])
+        .describe('Operation to perform'),
+      workbookId: z.string().describe('LUID of the workbook'),
+      name: z.string().optional().describe('New name (for update)'),
+      description: z.string().optional().describe('New description (for update)'),
+      projectId: z
+        .string()
+        .optional()
+        .describe('New project LUID to move workbook to (for update)'),
+      ownerUserId: z.string().optional().describe('New owner user LUID (for update)'),
+      showTabs: z.boolean().optional().describe('Whether to show tabs (for update)'),
+      tags: z.array(z.string()).optional().describe('Tags to add or remove')
+    })
+  )
+  .output(
+    z.object({
+      workbookId: z.string().optional(),
+      name: z.string().optional(),
+      description: z.string().optional(),
+      contentUrl: z.string().optional(),
+      showTabs: z.boolean().optional(),
+      projectId: z.string().optional(),
+      projectName: z.string().optional(),
+      ownerId: z.string().optional(),
+      createdAt: z.string().optional(),
+      updatedAt: z.string().optional(),
+      jobId: z.string().optional(),
+      deleted: z.boolean().optional(),
+      connections: z.array(z.any()).optional(),
+      views: z.array(z.any()).optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, workbookId } = ctx.input;
+
+    if (action === 'get') {
+      let wb = await client.getWorkbook(workbookId);
+      let conns = await client.getWorkbookConnections(workbookId);
+      let views = await client.queryViewsForWorkbook(workbookId);
+
+      return {
+        output: {
+          workbookId: wb.id,
+          name: wb.name,
+          description: wb.description,
+          contentUrl: wb.contentUrl,
+          showTabs: normalizeBoolean(wb.showTabs),
+          projectId: wb.project?.id,
+          projectName: wb.project?.name,
+          ownerId: wb.owner?.id,
+          createdAt: wb.createdAt,
+          updatedAt: wb.updatedAt,
+          connections: conns.connections?.connection || [],
+          views: (views.views?.view || []).map((v: any) => ({
+            viewId: v.id,
+            name: v.name,
+            contentUrl: v.contentUrl
+          }))
+        },
+        message: `Retrieved workbook **${wb.name}** with ${(conns.connections?.connection || []).length} connections and ${(views.views?.view || []).length} views.`
+      };
+    }
+
+    if (action === 'update') {
+      if (
+        ctx.input.name === undefined &&
+        ctx.input.description === undefined &&
+        ctx.input.projectId === undefined &&
+        ctx.input.ownerUserId === undefined &&
+        ctx.input.showTabs === undefined
+      ) {
+        throw tableauServiceError('Provide at least one field to update a workbook.');
+      }
+
+      let wb = await client.updateWorkbook(workbookId, {
+        name: ctx.input.name,
+        description: ctx.input.description,
+        projectId: ctx.input.projectId,
+        ownerUserId: ctx.input.ownerUserId,
+        showTabs: ctx.input.showTabs
+      });
+
+      return {
+        output: {
+          workbookId: wb.id,
+          name: wb.name,
+          description: wb.description,
+          contentUrl: wb.contentUrl,
+          showTabs: normalizeBoolean(wb.showTabs),
+          projectId: wb.project?.id,
+          projectName: wb.project?.name,
+          ownerId: wb.owner?.id,
+          updatedAt: wb.updatedAt
+        },
+        message: `Updated workbook **${wb.name}**.`
+      };
+    }
+
+    if (action === 'delete') {
+      await client.deleteWorkbook(workbookId);
+      return {
+        output: { workbookId, deleted: true },
+        message: `Deleted workbook \`${workbookId}\`.`
+      };
+    }
+
+    if (action === 'refresh') {
+      let job = await client.refreshWorkbook(workbookId);
+      return {
+        output: { workbookId, jobId: job?.id },
+        message: `Triggered extract refresh for workbook \`${workbookId}\`. Job ID: \`${job?.id}\`.`
+      };
+    }
+
+    if (action === 'addTags') {
+      if (!ctx.input.tags?.length) {
+        throw tableauServiceError('tags is required for addTags action.');
+      }
+
+      await client.addTagsToWorkbook(workbookId, ctx.input.tags);
+      return {
+        output: { workbookId },
+        message: `Added tags [${ctx.input.tags.join(', ')}] to workbook \`${workbookId}\`.`
+      };
+    }
+
+    if (action === 'removeTags') {
+      if (!ctx.input.tags?.length) {
+        throw tableauServiceError('tags is required for removeTags action.');
+      }
+
+      for (let tag of ctx.input.tags) {
+        await client.deleteTagFromWorkbook(workbookId, tag);
+      }
+      return {
+        output: { workbookId },
+        message: `Removed tags [${ctx.input.tags.join(', ')}] from workbook \`${workbookId}\`.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/triggers/datasource-events.ts

@@ -0,0 +1,119 @@
+import { SlateTrigger } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+
+let eventNameMap: Record<string, string> = {
+  'webhook-source-event-datasourcecreated': 'datasource.created',
+  'webhook-source-event-datasourceupdated': 'datasource.updated',
+  'webhook-source-event-datasourcedeleted': 'datasource.deleted',
+  'webhook-source-event-datasourcerefreshstarted': 'datasource.refresh_started',
+  'webhook-source-event-datasourcerefreshsucceeded': 'datasource.refresh_succeeded',
+  'webhook-source-event-datasourcerefreshfailed': 'datasource.refresh_failed',
+  DatasourceCreated: 'datasource.created',
+  DatasourceUpdated: 'datasource.updated',
+  DatasourceDeleted: 'datasource.deleted',
+  DatasourceRefreshStarted: 'datasource.refresh_started',
+  DatasourceRefreshSucceeded: 'datasource.refresh_succeeded',
+  DatasourceRefreshFailed: 'datasource.refresh_failed'
+};
+
+let webhookEventNames = [
+  'DatasourceCreated',
+  'DatasourceUpdated',
+  'DatasourceDeleted',
+  'DatasourceRefreshStarted',
+  'DatasourceRefreshSucceeded',
+  'DatasourceRefreshFailed'
+];
+
+export let datasourceEvents = SlateTrigger.create(spec, {
+  name: 'Data Source Events',
+  key: 'datasource_events',
+  description:
+    'Triggers when a data source 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 data source'),
+      resourceName: z.string().describe('Name of the affected data source'),
+      siteId: z.string().describe('LUID of the site'),
+      timestamp: z.string().describe('Event timestamp')
+    })
+  )
+  .output(
+    z.object({
+      datasourceId: z.string().describe('LUID of the affected data source'),
+      datasourceName: z.string().describe('Name of the data source'),
+      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-datasource-${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;
+
+      let eventType = body.resource_type
+        ? `${body.resource_type}${body.event_type ? '_' + body.event_type : ''}`
+        : body.eventType || body['webhook-source-event-name'] || 'unknown';
+
+      return {
+        inputs: [
+          {
+            eventType: eventType,
+            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] || `datasource.${ctx.input.eventType}`;
+
+      return {
+        type: mappedType,
+        id: `${ctx.input.resourceId}-${ctx.input.timestamp}`,
+        output: {
+          datasourceId: ctx.input.resourceId,
+          datasourceName: ctx.input.resourceName,
+          siteId: ctx.input.siteId,
+          timestamp: ctx.input.timestamp
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/index.ts

@@ -0,0 +1,6 @@
+export * from './datasource-events';
+export * from './workbook-events';
+export * from './user-events';
+export * from './label-events';
+export * from './site-events';
+export * from './view-events';