@slates-integrations/tableau 0.2.0-rc.8

package/src/tools/manage-favorites.ts

@@ -0,0 +1,80 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageFavorites = SlateTool.create(spec, {
+  name: 'Manage Favorites',
+  key: 'manage_favorites',
+  description: `List, add, or remove favorites for a user. Supports workbooks, views, data sources, projects, and flows.`
+})
+  .input(
+    z.object({
+      action: z.enum(['list', 'add', 'remove']).describe('Operation to perform'),
+      userId: z.string().describe('User LUID'),
+      resourceType: z
+        .enum(['workbook', 'view', 'datasource', 'project', 'flow'])
+        .optional()
+        .describe('Type of resource (for add/remove)'),
+      resourceId: z.string().optional().describe('LUID of the resource (for add/remove)'),
+      label: z.string().optional().describe('Label for the favorite (for add)')
+    })
+  )
+  .output(
+    z.object({
+      favorites: z.any().optional().describe('User favorites list'),
+      added: z.boolean().optional(),
+      removed: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, userId } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.getFavorites(userId);
+      return {
+        output: { favorites: result.favorites },
+        message: `Retrieved favorites for user \`${userId}\`.`
+      };
+    }
+
+    if (action === 'add') {
+      if (!ctx.input.resourceType) {
+        throw tableauServiceError('resourceType is required for add action.');
+      }
+      if (!ctx.input.resourceId) {
+        throw tableauServiceError('resourceId is required for add action.');
+      }
+
+      await client.addFavorite(
+        userId,
+        ctx.input.resourceType,
+        ctx.input.resourceId,
+        ctx.input.label || ctx.input.resourceType
+      );
+      return {
+        output: { added: true },
+        message: `Added ${ctx.input.resourceType} \`${ctx.input.resourceId}\` to favorites.`
+      };
+    }
+
+    if (action === 'remove') {
+      if (!ctx.input.resourceType) {
+        throw tableauServiceError('resourceType is required for remove action.');
+      }
+      if (!ctx.input.resourceId) {
+        throw tableauServiceError('resourceId is required for remove action.');
+      }
+
+      await client.deleteFavorite(userId, ctx.input.resourceType + 's', ctx.input.resourceId);
+      return {
+        output: { removed: true },
+        message: `Removed ${ctx.input.resourceType} \`${ctx.input.resourceId}\` from favorites.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-flows.ts

@@ -0,0 +1,170 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageFlows = SlateTool.create(spec, {
+  name: 'Manage Flows',
+  key: 'manage_flows',
+  description: `List, get, update, delete, or run Tableau Prep flows. Use the **action** field to select the operation.`
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['list', 'get', 'update', 'delete', 'run'])
+        .describe('Operation to perform'),
+      flowId: z
+        .string()
+        .optional()
+        .describe('Flow LUID (required for get, update, delete, run)'),
+      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 (for update)'),
+      ownerUserId: z.string().optional().describe('New owner LUID (for update)'),
+      pageSize: z.number().optional().describe('Page size for list'),
+      pageNumber: z.number().optional().describe('Page number for list'),
+      filter: z.string().optional().describe('Filter expression for list'),
+      sort: z.string().optional().describe('Sort expression for list')
+    })
+  )
+  .output(
+    z.object({
+      flows: z
+        .array(
+          z.object({
+            flowId: z.string(),
+            name: z.string().optional(),
+            description: z.string().optional(),
+            projectId: z.string().optional(),
+            projectName: z.string().optional(),
+            ownerId: z.string().optional(),
+            createdAt: z.string().optional(),
+            updatedAt: z.string().optional()
+          })
+        )
+        .optional(),
+      flow: z
+        .object({
+          flowId: z.string(),
+          name: z.string().optional(),
+          description: z.string().optional(),
+          projectId: z.string().optional(),
+          projectName: z.string().optional(),
+          ownerId: z.string().optional(),
+          createdAt: z.string().optional(),
+          updatedAt: z.string().optional()
+        })
+        .optional(),
+      totalCount: z.number().optional(),
+      jobId: z.string().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.queryFlows({
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber,
+        filter: ctx.input.filter,
+        sort: ctx.input.sort
+      });
+      let pagination = result.pagination || {};
+      let flows = (result.flows?.flow || []).map((f: any) => ({
+        flowId: f.id,
+        name: f.name,
+        description: f.description,
+        projectId: f.project?.id,
+        projectName: f.project?.name,
+        ownerId: f.owner?.id,
+        createdAt: f.createdAt,
+        updatedAt: f.updatedAt
+      }));
+      return {
+        output: { flows, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${flows.length}** flows (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    if (action === 'get') {
+      if (!ctx.input.flowId) throw tableauServiceError('flowId is required for get action.');
+
+      let f = await client.getFlow(ctx.input.flowId);
+      return {
+        output: {
+          flow: {
+            flowId: f.id,
+            name: f.name,
+            description: f.description,
+            projectId: f.project?.id,
+            projectName: f.project?.name,
+            ownerId: f.owner?.id,
+            createdAt: f.createdAt,
+            updatedAt: f.updatedAt
+          }
+        },
+        message: `Retrieved flow **${f.name}**.`
+      };
+    }
+
+    if (action === 'update') {
+      if (!ctx.input.flowId)
+        throw tableauServiceError('flowId is required for update action.');
+      if (
+        ctx.input.name === undefined &&
+        ctx.input.description === undefined &&
+        ctx.input.projectId === undefined &&
+        ctx.input.ownerUserId === undefined
+      ) {
+        throw tableauServiceError('Provide at least one field to update a flow.');
+      }
+
+      let f = await client.updateFlow(ctx.input.flowId, {
+        name: ctx.input.name,
+        description: ctx.input.description,
+        projectId: ctx.input.projectId,
+        ownerUserId: ctx.input.ownerUserId
+      });
+      return {
+        output: {
+          flow: {
+            flowId: f.id,
+            name: f.name,
+            description: f.description,
+            projectId: f.project?.id,
+            projectName: f.project?.name,
+            ownerId: f.owner?.id,
+            updatedAt: f.updatedAt
+          }
+        },
+        message: `Updated flow **${f.name}**.`
+      };
+    }
+
+    if (action === 'delete') {
+      if (!ctx.input.flowId)
+        throw tableauServiceError('flowId is required for delete action.');
+
+      await client.deleteFlow(ctx.input.flowId);
+      return {
+        output: { deleted: true },
+        message: `Deleted flow \`${ctx.input.flowId}\`.`
+      };
+    }
+
+    if (action === 'run') {
+      if (!ctx.input.flowId) throw tableauServiceError('flowId is required for run action.');
+
+      let job = await client.runFlow(ctx.input.flowId);
+      return {
+        output: { jobId: job?.id },
+        message: `Started flow run for \`${ctx.input.flowId}\`. Job ID: \`${job?.id}\`.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-groups.ts

@@ -0,0 +1,178 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageGroups = SlateTool.create(spec, {
+  name: 'Manage Groups',
+  key: 'manage_groups',
+  description: `List, create, update, delete groups, and add or remove users from groups. Use the **action** field to select the operation.`,
+  tags: { destructive: true }
+})
+  .input(
+    z.object({
+      action: z
+        .enum(['list', 'create', 'update', 'delete', 'addUser', 'removeUser', 'listUsers'])
+        .describe('Operation to perform'),
+      groupId: z
+        .string()
+        .optional()
+        .describe('Group LUID (required for update, delete, addUser, removeUser, listUsers)'),
+      userId: z.string().optional().describe('User LUID (for addUser, removeUser)'),
+      name: z.string().optional().describe('Group name (for create, update)'),
+      minimumSiteRole: z
+        .string()
+        .optional()
+        .describe('Minimum site role for group members (for create, 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({
+      groups: z
+        .array(
+          z.object({
+            groupId: z.string(),
+            name: z.string().optional(),
+            minimumSiteRole: z.string().optional()
+          })
+        )
+        .optional(),
+      group: z
+        .object({
+          groupId: z.string(),
+          name: z.string().optional(),
+          minimumSiteRole: z.string().optional()
+        })
+        .optional(),
+      users: z
+        .array(
+          z.object({
+            userId: z.string(),
+            name: z.string().optional(),
+            siteRole: z.string().optional()
+          })
+        )
+        .optional(),
+      totalCount: z.number().optional(),
+      deleted: z.boolean().optional(),
+      userAdded: z.boolean().optional(),
+      userRemoved: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.queryGroups({
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber,
+        filter: ctx.input.filter,
+        sort: ctx.input.sort
+      });
+      let pagination = result.pagination || {};
+      let groups = (result.groups?.group || []).map((g: any) => ({
+        groupId: g.id,
+        name: g.name,
+        minimumSiteRole: g.minimumSiteRole
+      }));
+      return {
+        output: { groups, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${groups.length}** groups (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    if (action === 'create') {
+      if (!ctx.input.name) throw tableauServiceError('name is required for create action.');
+
+      let g = await client.createGroup(ctx.input.name, ctx.input.minimumSiteRole);
+      return {
+        output: { group: { groupId: g.id, name: g.name, minimumSiteRole: g.minimumSiteRole } },
+        message: `Created group **${g.name}**.`
+      };
+    }
+
+    if (action === 'update') {
+      if (!ctx.input.groupId)
+        throw tableauServiceError('groupId is required for update action.');
+      if (ctx.input.name === undefined && ctx.input.minimumSiteRole === undefined) {
+        throw tableauServiceError('Provide name or minimumSiteRole to update a group.');
+      }
+
+      let g = await client.updateGroup(ctx.input.groupId, {
+        name: ctx.input.name,
+        minimumSiteRole: ctx.input.minimumSiteRole
+      });
+      return {
+        output: { group: { groupId: g.id, name: g.name, minimumSiteRole: g.minimumSiteRole } },
+        message: `Updated group **${g.name}**.`
+      };
+    }
+
+    if (action === 'delete') {
+      if (!ctx.input.groupId)
+        throw tableauServiceError('groupId is required for delete action.');
+
+      await client.deleteGroup(ctx.input.groupId);
+      return {
+        output: { deleted: true },
+        message: `Deleted group \`${ctx.input.groupId}\`.`
+      };
+    }
+
+    if (action === 'addUser') {
+      if (!ctx.input.groupId)
+        throw tableauServiceError('groupId is required for addUser action.');
+      if (!ctx.input.userId)
+        throw tableauServiceError('userId is required for addUser action.');
+
+      await client.addUserToGroup(ctx.input.groupId, ctx.input.userId);
+      return {
+        output: { userAdded: true },
+        message: `Added user \`${ctx.input.userId}\` to group \`${ctx.input.groupId}\`.`
+      };
+    }
+
+    if (action === 'removeUser') {
+      if (!ctx.input.groupId) {
+        throw tableauServiceError('groupId is required for removeUser action.');
+      }
+      if (!ctx.input.userId)
+        throw tableauServiceError('userId is required for removeUser action.');
+
+      await client.removeUserFromGroup(ctx.input.groupId, ctx.input.userId);
+      return {
+        output: { userRemoved: true },
+        message: `Removed user \`${ctx.input.userId}\` from group \`${ctx.input.groupId}\`.`
+      };
+    }
+
+    if (action === 'listUsers') {
+      if (!ctx.input.groupId) {
+        throw tableauServiceError('groupId is required for listUsers action.');
+      }
+
+      let result = await client.getUsersInGroup(ctx.input.groupId, {
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber
+      });
+      let pagination = result.pagination || {};
+      let users = (result.users?.user || []).map((u: any) => ({
+        userId: u.id,
+        name: u.name,
+        siteRole: u.siteRole
+      }));
+      return {
+        output: { users, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${users.length}** users in group (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-jobs.ts

@@ -0,0 +1,120 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let manageJobs = SlateTool.create(spec, {
+  name: 'Manage Jobs',
+  key: 'manage_jobs',
+  description: `List, get details, or cancel background jobs (extract refreshes, flow runs, subscriptions). Use the **action** field to select the operation.`
+})
+  .input(
+    z.object({
+      action: z.enum(['list', 'get', 'cancel']).describe('Operation to perform'),
+      jobId: z.string().optional().describe('Job LUID (required for get, cancel)'),
+      pageSize: z.number().optional().describe('Page size for list'),
+      pageNumber: z.number().optional().describe('Page number for list'),
+      filter: z
+        .string()
+        .optional()
+        .describe('Filter expression for list (e.g., "jobType:eq:refresh_extracts")')
+    })
+  )
+  .output(
+    z.object({
+      jobs: z
+        .array(
+          z.object({
+            jobId: z.string(),
+            jobType: z.string().optional(),
+            status: z.string().optional(),
+            createdAt: z.string().optional(),
+            startedAt: z.string().optional(),
+            endedAt: z.string().optional(),
+            progress: z.number().optional(),
+            title: z.string().optional()
+          })
+        )
+        .optional(),
+      job: z
+        .object({
+          jobId: z.string(),
+          jobType: z.string().optional(),
+          status: z.string().optional(),
+          createdAt: z.string().optional(),
+          startedAt: z.string().optional(),
+          endedAt: z.string().optional(),
+          progress: z.number().optional(),
+          title: z.string().optional(),
+          finishCode: z.number().optional()
+        })
+        .optional(),
+      totalCount: z.number().optional(),
+      cancelled: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action } = ctx.input;
+
+    if (action === 'list') {
+      let result = await client.queryJobs({
+        pageSize: ctx.input.pageSize,
+        pageNumber: ctx.input.pageNumber,
+        filter: ctx.input.filter
+      });
+
+      let pagination = result.pagination || {};
+      let jobs = (result.backgroundJobs?.backgroundJob || []).map((j: any) => ({
+        jobId: j.id,
+        jobType: j.jobType,
+        status: j.status,
+        createdAt: j.createdAt,
+        startedAt: j.startedAt,
+        endedAt: j.endedAt,
+        progress: j.progress != null ? Number(j.progress) : undefined,
+        title: j.title
+      }));
+
+      return {
+        output: { jobs, totalCount: Number(pagination.totalAvailable || 0) },
+        message: `Found **${jobs.length}** jobs (${pagination.totalAvailable || 0} total).`
+      };
+    }
+
+    if (action === 'get') {
+      if (!ctx.input.jobId) throw tableauServiceError('jobId is required for get action.');
+
+      let j = await client.getJob(ctx.input.jobId);
+      return {
+        output: {
+          job: {
+            jobId: j.id,
+            jobType: j.jobType,
+            status: j.status,
+            createdAt: j.createdAt,
+            startedAt: j.startedAt,
+            endedAt: j.endedAt,
+            progress: j.progress != null ? Number(j.progress) : undefined,
+            title: j.title,
+            finishCode: j.finishCode != null ? Number(j.finishCode) : undefined
+          }
+        },
+        message: `Job \`${j.id}\` is **${j.status}** (type: ${j.jobType}).`
+      };
+    }
+
+    if (action === 'cancel') {
+      if (!ctx.input.jobId) throw tableauServiceError('jobId is required for cancel action.');
+
+      await client.cancelJob(ctx.input.jobId);
+      return {
+        output: { cancelled: true },
+        message: `Cancelled job \`${ctx.input.jobId}\`.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();

package/src/tools/manage-permissions.ts

@@ -0,0 +1,118 @@
+import { SlateTool } from 'slates';
+import { z } from 'zod';
+import { spec } from '../spec';
+import { createClient } from '../lib/helpers';
+import { tableauServiceError } from '../lib/errors';
+
+export let managePermissions = SlateTool.create(spec, {
+  name: 'Manage Permissions',
+  key: 'manage_permissions',
+  description: `Query, add, or delete permissions on Tableau resources (workbooks, datasources, projects, views, flows). Permissions are granted to users or groups with specific capability modes.`,
+  instructions: [
+    'For resourceType use the plural API path: "workbooks", "datasources", "projects", "views", "flows", or "collections".',
+    'For delete, granteeType must be "users" or "groups" (plural).'
+  ]
+})
+  .input(
+    z.object({
+      action: z.enum(['query', 'add', 'delete']).describe('Operation to perform'),
+      resourceType: z
+        .enum(['workbooks', 'datasources', 'projects', 'views', 'flows', 'collections'])
+        .describe(
+          'Resource type path: "workbooks", "datasources", "projects", "views", "flows", or "collections"'
+        ),
+      resourceId: z.string().describe('LUID of the resource'),
+      permissions: z
+        .array(
+          z.object({
+            granteeType: z
+              .enum(['user', 'group'])
+              .describe('Whether the grantee is a user or group'),
+            granteeId: z.string().describe('LUID of the user or group'),
+            capabilities: z
+              .array(
+                z.object({
+                  name: z
+                    .string()
+                    .describe('Capability name (e.g., "Read", "Write", "ExportData")'),
+                  mode: z.enum(['Allow', 'Deny']).describe('Permission mode')
+                })
+              )
+              .describe('Capabilities to grant')
+          })
+        )
+        .optional()
+        .describe('Permissions to add (for add action)'),
+      granteeType: z
+        .enum(['users', 'groups'])
+        .optional()
+        .describe('Grantee type plural (for delete)'),
+      granteeId: z.string().optional().describe('LUID of user or group (for delete)'),
+      capabilityName: z.string().optional().describe('Capability name to delete (for delete)'),
+      capabilityMode: z
+        .enum(['Allow', 'Deny'])
+        .optional()
+        .describe('Capability mode to delete (for delete)')
+    })
+  )
+  .output(
+    z.object({
+      permissions: z.any().optional(),
+      deleted: z.boolean().optional()
+    })
+  )
+  .handleInvocation(async ctx => {
+    let client = createClient(ctx.config, ctx.auth);
+    let { action, resourceType, resourceId } = ctx.input;
+
+    if (action === 'query') {
+      let perms = await client.queryPermissions(resourceType, resourceId);
+      return {
+        output: { permissions: perms },
+        message: `Retrieved permissions for ${resourceType} \`${resourceId}\`.`
+      };
+    }
+
+    if (action === 'add') {
+      if (!ctx.input.permissions?.length) {
+        throw tableauServiceError('permissions is required for add action.');
+      }
+
+      let perms = await client.addPermissions(resourceType, resourceId, ctx.input.permissions);
+      return {
+        output: { permissions: perms },
+        message: `Added permissions to ${resourceType} \`${resourceId}\`.`
+      };
+    }
+
+    if (action === 'delete') {
+      if (!ctx.input.granteeType) {
+        throw tableauServiceError('granteeType is required for delete action.');
+      }
+      if (!ctx.input.granteeId) {
+        throw tableauServiceError('granteeId is required for delete action.');
+      }
+      if (!ctx.input.capabilityName) {
+        throw tableauServiceError('capabilityName is required for delete action.');
+      }
+      if (!ctx.input.capabilityMode) {
+        throw tableauServiceError('capabilityMode is required for delete action.');
+      }
+
+      await client.deletePermission(
+        resourceType,
+        resourceId,
+        ctx.input.granteeType,
+        ctx.input.granteeId,
+        ctx.input.capabilityName,
+        ctx.input.capabilityMode
+      );
+      return {
+        output: { deleted: true },
+        message: `Deleted ${ctx.input.capabilityName} (${ctx.input.capabilityMode}) permission from ${resourceType} \`${resourceId}\`.`
+      };
+    }
+
+    throw tableauServiceError(`Unknown action: ${action}`);
+  })
+  .build();