@slates-integrations/attio 0.2.0-rc.5

package/src/triggers/list-entry-events.ts

@@ -0,0 +1,106 @@
+import { SlateTrigger } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let LIST_ENTRY_EVENT_TYPES = [
+  'list-entry.created',
+  'list-entry.updated',
+  'list-entry.deleted'
+] as const;
+
+export let listEntryEventsTrigger = SlateTrigger.create(spec, {
+  name: 'List Entry Events',
+  key: 'list_entry_events',
+  description:
+    'Triggers when records are added to, updated within, or removed from lists (e.g. sales pipelines, recruitment pipelines).'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Type of list entry event'),
+      eventId: z.string().describe('Unique event identifier'),
+      listId: z.string().describe('The list ID'),
+      entryId: z.string().describe('The entry ID'),
+      parentObjectId: z.string().optional().describe('Parent object ID'),
+      parentRecordId: z.string().optional().describe('Parent record ID'),
+      attributeId: z
+        .string()
+        .optional()
+        .describe('Attribute ID that changed (for update events)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .output(
+    z.object({
+      listId: z.string().describe('The list ID'),
+      entryId: z.string().describe('The entry ID'),
+      parentObjectId: z.string().optional().describe('Parent object ID'),
+      parentRecordId: z.string().optional().describe('Parent record ID'),
+      attributeId: z
+        .string()
+        .optional()
+        .describe('Attribute ID that changed (for update events)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+
+      let webhook = await client.createWebhook(
+        ctx.input.webhookBaseUrl,
+        LIST_ENTRY_EVENT_TYPES.map(eventType => ({ eventType }))
+      );
+
+      return {
+        registrationDetails: {
+          webhookId: webhook.id?.webhook_id ?? webhook.webhook_id
+        }
+      };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+      await client.deleteWebhook(ctx.input.registrationDetails.webhookId);
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+      let events = body.events ?? [];
+
+      let inputs = events
+        .filter((e: any) => LIST_ENTRY_EVENT_TYPES.includes(e.event_type))
+        .map((e: any) => ({
+          eventType: e.event_type,
+          eventId: e.id?.event_id ?? `${e.event_type}-${e.id?.entry_id}-${Date.now()}`,
+          listId: e.id?.list_id ?? '',
+          entryId: e.id?.entry_id ?? '',
+          parentObjectId: e.id?.parent_object_id,
+          parentRecordId: e.id?.parent_record_id,
+          attributeId: e.id?.attribute_id,
+          actorType: e.actor?.type,
+          actorId: e.actor?.id
+        }));
+
+      return { inputs };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: ctx.input.eventType,
+        id: ctx.input.eventId,
+        output: {
+          listId: ctx.input.listId,
+          entryId: ctx.input.entryId,
+          parentObjectId: ctx.input.parentObjectId,
+          parentRecordId: ctx.input.parentRecordId,
+          attributeId: ctx.input.attributeId,
+          actorType: ctx.input.actorType,
+          actorId: ctx.input.actorId
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/note-events.ts

@@ -0,0 +1,93 @@
+import { SlateTrigger } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let NOTE_EVENT_TYPES = [
+  'note.created',
+  'note.updated',
+  'note.deleted',
+  'note-content.updated'
+] as const;
+
+export let noteEventsTrigger = SlateTrigger.create(spec, {
+  name: 'Note Events',
+  key: 'note_events',
+  description:
+    'Triggers when notes are created, updated (title changes), deleted, or when note content changes.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Type of note event'),
+      eventId: z.string().describe('Unique event identifier'),
+      noteId: z.string().describe('The note ID'),
+      parentObjectId: z.string().optional().describe('Parent object ID'),
+      parentRecordId: z.string().optional().describe('Parent record ID'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .output(
+    z.object({
+      noteId: z.string().describe('The note ID'),
+      parentObjectId: z.string().optional().describe('Parent object ID'),
+      parentRecordId: z.string().optional().describe('Parent record ID'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+
+      let webhook = await client.createWebhook(
+        ctx.input.webhookBaseUrl,
+        NOTE_EVENT_TYPES.map(eventType => ({ eventType }))
+      );
+
+      return {
+        registrationDetails: {
+          webhookId: webhook.id?.webhook_id ?? webhook.webhook_id
+        }
+      };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+      await client.deleteWebhook(ctx.input.registrationDetails.webhookId);
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+      let events = body.events ?? [];
+
+      let inputs = events
+        .filter((e: any) => NOTE_EVENT_TYPES.includes(e.event_type))
+        .map((e: any) => ({
+          eventType: e.event_type,
+          eventId: e.id?.event_id ?? `${e.event_type}-${e.id?.note_id}-${Date.now()}`,
+          noteId: e.id?.note_id ?? '',
+          parentObjectId: e.id?.parent_object_id,
+          parentRecordId: e.id?.parent_record_id,
+          actorType: e.actor?.type,
+          actorId: e.actor?.id
+        }));
+
+      return { inputs };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: ctx.input.eventType,
+        id: ctx.input.eventId,
+        output: {
+          noteId: ctx.input.noteId,
+          parentObjectId: ctx.input.parentObjectId,
+          parentRecordId: ctx.input.parentRecordId,
+          actorType: ctx.input.actorType,
+          actorId: ctx.input.actorId
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/record-events.ts

@@ -0,0 +1,109 @@
+import { SlateTrigger } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let RECORD_EVENT_TYPES = [
+  'record.created',
+  'record.updated',
+  'record.deleted',
+  'record.merged'
+] as const;
+
+export let recordEventsTrigger = SlateTrigger.create(spec, {
+  name: 'Record Events',
+  key: 'record_events',
+  description:
+    'Triggers when records are created, updated, deleted, or merged in Attio. Covers all object types (People, Companies, Deals, custom objects).'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Type of record event'),
+      eventId: z.string().describe('Unique event identifier'),
+      objectId: z.string().describe('Object ID the record belongs to'),
+      recordId: z.string().describe('The affected record ID'),
+      attributeId: z
+        .string()
+        .optional()
+        .describe('Attribute ID that changed (for update events)'),
+      duplicateRecordId: z
+        .string()
+        .optional()
+        .describe('Duplicate record ID (for merge events)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .output(
+    z.object({
+      objectId: z.string().describe('Object ID the record belongs to'),
+      recordId: z.string().describe('The affected record ID'),
+      attributeId: z
+        .string()
+        .optional()
+        .describe('Attribute ID that changed (for update events)'),
+      duplicateRecordId: z
+        .string()
+        .optional()
+        .describe('Duplicate record ID (for merge events)'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+
+      let webhook = await client.createWebhook(
+        ctx.input.webhookBaseUrl,
+        RECORD_EVENT_TYPES.map(eventType => ({ eventType }))
+      );
+
+      return {
+        registrationDetails: {
+          webhookId: webhook.id?.webhook_id ?? webhook.webhook_id
+        }
+      };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+      await client.deleteWebhook(ctx.input.registrationDetails.webhookId);
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+      let events = body.events ?? [];
+
+      let inputs = events
+        .filter((e: any) => RECORD_EVENT_TYPES.includes(e.event_type))
+        .map((e: any) => ({
+          eventType: e.event_type,
+          eventId: e.id?.event_id ?? `${e.event_type}-${e.id?.record_id}-${Date.now()}`,
+          objectId: e.id?.object_id ?? '',
+          recordId: e.id?.record_id ?? '',
+          attributeId: e.id?.attribute_id,
+          duplicateRecordId: e.id?.duplicate_record_id,
+          actorType: e.actor?.type,
+          actorId: e.actor?.id
+        }));
+
+      return { inputs };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: ctx.input.eventType,
+        id: ctx.input.eventId,
+        output: {
+          objectId: ctx.input.objectId,
+          recordId: ctx.input.recordId,
+          attributeId: ctx.input.attributeId,
+          duplicateRecordId: ctx.input.duplicateRecordId,
+          actorType: ctx.input.actorType,
+          actorId: ctx.input.actorId
+        }
+      };
+    }
+  })
+  .build();

package/src/triggers/task-events.ts

@@ -0,0 +1,79 @@
+import { SlateTrigger } from 'slates';
+import { AttioClient } from '../lib/client';
+import { spec } from '../spec';
+import { z } from 'zod';
+
+let TASK_EVENT_TYPES = ['task.created', 'task.updated', 'task.deleted'] as const;
+
+export let taskEventsTrigger = SlateTrigger.create(spec, {
+  name: 'Task Events',
+  key: 'task_events',
+  description: 'Triggers when tasks are created, updated, or deleted in the workspace.'
+})
+  .input(
+    z.object({
+      eventType: z.string().describe('Type of task event'),
+      eventId: z.string().describe('Unique event identifier'),
+      taskId: z.string().describe('The task ID'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .output(
+    z.object({
+      taskId: z.string().describe('The task ID'),
+      actorType: z.string().optional().describe('Type of actor that triggered the event'),
+      actorId: z.string().optional().describe('ID of the actor that triggered the event')
+    })
+  )
+  .webhook({
+    autoRegisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+
+      let webhook = await client.createWebhook(
+        ctx.input.webhookBaseUrl,
+        TASK_EVENT_TYPES.map(eventType => ({ eventType }))
+      );
+
+      return {
+        registrationDetails: {
+          webhookId: webhook.id?.webhook_id ?? webhook.webhook_id
+        }
+      };
+    },
+
+    autoUnregisterWebhook: async ctx => {
+      let client = new AttioClient({ token: ctx.auth.token });
+      await client.deleteWebhook(ctx.input.registrationDetails.webhookId);
+    },
+
+    handleRequest: async ctx => {
+      let body = (await ctx.request.json()) as any;
+      let events = body.events ?? [];
+
+      let inputs = events
+        .filter((e: any) => TASK_EVENT_TYPES.includes(e.event_type))
+        .map((e: any) => ({
+          eventType: e.event_type,
+          eventId: e.id?.event_id ?? `${e.event_type}-${e.id?.task_id}-${Date.now()}`,
+          taskId: e.id?.task_id ?? '',
+          actorType: e.actor?.type,
+          actorId: e.actor?.id
+        }));
+
+      return { inputs };
+    },
+
+    handleEvent: async ctx => {
+      return {
+        type: ctx.input.eventType,
+        id: ctx.input.eventId,
+        output: {
+          taskId: ctx.input.taskId,
+          actorType: ctx.input.actorType,
+          actorId: ctx.input.actorId
+        }
+      };
+    }
+  })
+  .build();

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "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"]
+}