@agnocon/piece-bigin-by-zoho 0.1.6

package/src/lib/triggers/new-call-created.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_new_call_created_trigger';
+
+export const newCallCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newCallCreated',
+  displayName: 'New Call Created',
+  description: 'Triggers when a new call log is created',
+  aiMetadata: {
+    description: 'Fires when a new call log entry is created in Bigin CRM, via a Calls.create webhook. Represents a newly recorded phone interaction.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Calls.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/new-company-created.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_new_company_created_trigger';
+
+export const newCompanyCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newCompanyCreated',
+  displayName: 'New Company Created',
+  description: 'Triggers when a new company record is created',
+  aiMetadata: {
+    description: 'Fires when a new company (account) record is created in Bigin CRM, via an Accounts.create webhook. Represents a newly added organization.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Accounts.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/new-contact-created.ts

@@ -0,0 +1,75 @@
+
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_created_contact_trigger';
+
+export const newContactCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newContactCreated',
+  displayName: 'New Contact Created',
+  description: 'Triggers when a new contact is created',
+  aiMetadata: {
+    description: 'Fires when a new contact (person) record is created in Bigin CRM, via a Contacts.create webhook. Represents a newly added person.',
+  },
+  props: {},
+  sampleData: {
+    server_time: 1754252081534,
+    query_params: {},
+    module: 'Contacts',
+    resource_uri: 'https://www.zohoapis.com/bigin/v1/Contacts',
+    ids: ['6913232000000583260'],
+    affected_fields: [],
+    operation: 'insert',
+    channel_id: '1722705400',
+  },
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Contacts.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(context.auth.access_token, webhookData, api_domain)
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = await context.store.get(CACHE_KEY) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/new-event-created.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_new_event_created_trigger';
+
+export const newEventCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newEventCreated',
+  displayName: 'New Event Created',
+  description: 'Triggers when a new event is created',
+  aiMetadata: {
+    description: 'Fires when a new calendar event is created in Bigin CRM, via an Events.create webhook. Represents a newly scheduled meeting or appointment.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Events.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/new-pipeline-record.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_new_pipeline_record_created_trigger';
+
+export const newPipelineRecordCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newPipelineRecordCreated',
+  displayName: 'New Pipeline Record Created',
+  description: 'Triggers when a new pipeline record is created',
+  aiMetadata: {
+    description: 'Fires when a new pipeline record (deal) is created in Bigin CRM, via a Pipelines.create webhook. Represents a newly opened sales opportunity.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Pipelines.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/new-task-created.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_new_task_created_trigger';
+
+export const newTaskCreated = createTrigger({
+  auth: biginAuth,
+  name: 'newTaskCreated',
+  displayName: 'New Task Created',
+  description: 'Triggers when a new task is created',
+  aiMetadata: {
+    description: 'Fires when a new task is created in Bigin CRM, via a Tasks.create webhook. Represents a newly added piece of follow-up work.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Tasks.create'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});

package/src/lib/triggers/pipeline-record-updated.ts

@@ -0,0 +1,69 @@
+import { createTrigger, TriggerStrategy } from '@agnocon/pieces-framework';
+import { ZOHO_WEBHOOK_TOKEN } from '../common/constants';
+import { biginAuth } from '../auth';
+import { biginApiService } from '../common/request';
+
+const CACHE_KEY = 'bigin_pipeline_record_updated_trigger';
+
+export const pipelineRecordUpdated = createTrigger({
+  auth: biginAuth,
+  name: 'pipelineRecordUpdated',
+  displayName: 'Pipeline Record Updated',
+  description: 'Triggers when a pipeline record is updated',
+  aiMetadata: {
+    description: 'Fires when an existing pipeline record (deal) is edited in Bigin CRM, via a Pipelines.edit webhook. Represents a change to a deal already in the CRM, such as a stage or amount update.',
+  },
+  props: {},
+  sampleData: {},
+  type: TriggerStrategy.WEBHOOK,
+  async onEnable(context) {
+    try {
+      const channel_id = Date.now().toString();
+      const { api_domain } = context.auth.data;
+
+      const webhookData = {
+        watch: [
+          {
+            channel_id,
+            events: ['Pipelines.edit'],
+            notify_url: context.webhookUrl,
+            token: ZOHO_WEBHOOK_TOKEN,
+          },
+        ],
+      };
+
+      await biginApiService.createWebhook(
+        context.auth.access_token,
+        webhookData,
+        api_domain
+      );
+
+      await context.store.put(CACHE_KEY, channel_id);
+    } catch (error) {
+      console.error('Failed to enable Zoho webhook');
+    }
+  },
+  async onDisable(context) {
+    const channel_id = (await context.store.get(CACHE_KEY)) as string;
+    if (!channel_id) return;
+
+    const { api_domain } = context.auth.data;
+
+    await biginApiService.deleteWebhook(
+      context.auth.access_token,
+      api_domain,
+      channel_id
+    );
+
+    await context.store.delete(CACHE_KEY);
+  },
+  async run(context) {
+    const { token } = context.payload.body as any;
+
+    if (token !== ZOHO_WEBHOOK_TOKEN) {
+      throw new Error('Invalid webhook token');
+    }
+
+    return [context.payload.body];
+  },
+});