@agnocon/piece-bigin-by-zoho 0.1.6

package/src/lib/common/props.ts

@@ -0,0 +1,270 @@
+import { Property } from "@agnocon/pieces-framework";
+import { biginApiService } from "./request";
+import { handleDropdownError } from "./helpers";
+import { biginAuth } from '../auth';
+
+export const usersDropdown = Property.Dropdown({
+  auth: biginAuth,
+  displayName: 'Owner',
+  description: 'Select the owner to which the record will be assigned.',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth)
+      return handleDropdownError('Please connect your account first');
+
+    const { api_domain } = auth;
+
+    try {
+      const response = await biginApiService.fetchUsers(
+        auth.access_token,
+        api_domain
+      );
+      const users = Array.isArray(response?.users) ? response.users : [];
+      if (users.length === 0) {
+        return handleDropdownError('No users found');
+      }
+
+      const options = users.map((user: any) => {
+        const fullName =
+          (typeof user.full_name === 'string' && user.full_name.trim() !== ''
+            ? user.full_name
+            : [user.first_name, user.last_name]
+                .filter((p: any) => typeof p === 'string' && p.trim() !== '')
+                .join(' ')) || user.email || user.id;
+        return {
+          label: fullName,
+          value: user.id,
+        };
+      });
+
+      return {
+        disabled: false,
+        options,
+      };
+    } catch (error) {
+      return handleDropdownError('Failed to load users');
+    }
+  },
+});
+
+export const companyDropdown = Property.Dropdown({
+  auth: biginAuth,
+  displayName: 'Company',
+  description:
+    'The ID of the company to which the record will be associated. If not provided, the record will not be associated with any company.',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchCompanies(
+      auth.access_token,
+      auth.api_domain
+    );
+    return {
+      options: resp.data.map((a: any) => ({
+        label: a.Account_Name,
+        value: a.id,
+      })),
+    };
+  },
+});
+
+export const contactsDropdown = Property.Dropdown({
+  auth: biginAuth,
+  displayName: 'Contacts',
+  description:
+    'The ID of the contact to which the record will be associated. If not provided, the record will not be associated with any contact.',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchContacts(
+      auth.access_token,
+      auth.api_domain
+    );
+    return {
+      options: resp.data.map((a: any) => ({
+        label: a.First_Name + ' ' + a.Last_Name,
+        value: a.id,
+      })),
+    };
+  },
+});
+
+export const multiContactsDropdown = Property.MultiSelectDropdown({
+  auth: biginAuth,
+  displayName: 'Secondary Contacts',
+  description:
+    'Provide a list of additional contacts associated with the record',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchContacts(
+      auth.access_token,
+      auth.api_domain
+    );
+    return {
+      options: resp.data.map((a: any) => ({
+        label: a.First_Name + ' ' + a.Last_Name,
+        value: a.id,
+      })),
+    };
+  },
+});
+
+export const pipelineRecordsDropdown = Property.Dropdown({
+  auth: biginAuth,
+  displayName: 'Pipeline Record',
+  description:
+    'Select a pipeline record',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchPipelinesRecords(
+      auth.access_token,
+      auth.api_domain
+    );
+    return {
+      options: resp.data.map((a: any) => ({
+        label: a.Deal_Name,
+        value: JSON.stringify(a),
+      })),
+    };
+  },
+});
+
+export const layoutsDropdown = (displayName: string, description: string, module_name: string) => Property.Dropdown({
+  auth: biginAuth,
+  displayName,
+  description,
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchLayouts(
+      auth.access_token,
+      auth.api_domain,
+      module_name
+    );
+
+    return {
+      options: resp.layouts.map((a: any) => ({
+        label: a.name,
+        value: JSON.stringify(a),
+      })),
+    };
+  },
+});
+
+export const productsDropdown = Property.MultiSelectDropdown({
+  auth: biginAuth,
+  displayName: 'Associated Products',
+  description:
+    'Provide a list of products associated with the record',
+  required: false,
+  refreshers: ['auth'],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    const resp = await biginApiService.fetchProducts(
+      auth.access_token,
+      auth.api_domain
+    );
+
+    if (!Array.isArray(resp.data) || resp.data.length === 0) {
+      return handleDropdownError('No products found. Please add products first.');
+    }
+
+    return {
+      options: resp.data.map((a: any) => ({
+        label: a.Product_Name,
+        value: JSON.stringify(a),
+      })),
+    };
+  },
+});
+
+export const tagsDropdown = (module: string, defaultValue?: string[]) => Property.MultiSelectDropdown({
+  auth: biginAuth,
+  displayName: 'Tags',
+  description: `Select tags to associate with this module, "${module}".`,
+  required: false,
+  refreshers: ['auth'],
+  defaultValue: defaultValue || [],
+  options: async ({ auth }: any) => {
+    if (!auth) return handleDropdownError('Please Connect your account first');
+    try {
+      const resp = await biginApiService.fetchTags(
+        auth.access_token,
+        auth.api_domain,
+        module
+      );
+
+      const tags = Array.isArray(resp?.tags) ? resp.tags : [];
+      if (tags.length === 0) {
+        return handleDropdownError('No tags found. Please add tags first.');
+      }
+
+      return {
+        options: tags.map((a: any) => ({
+          label: a.name,
+          value: a.name,
+        })),
+      };
+    } catch (e) {
+      return handleDropdownError('Failed to load tags');
+    }
+  },
+});
+
+export const SubPipelineorStageDropdown = (
+  displayName: string,
+  description: string,
+  field_label: string,
+  defaultValue?: string
+) =>
+  Property.Dropdown({
+    auth: biginAuth,
+    displayName,
+    description,
+    required: true,
+    refreshers: ['auth', 'pipeline'],
+    defaultValue,
+    options: async ({ auth, pipeline }) => {
+      if (!auth)
+        return handleDropdownError('Please connect your account first');
+      if (!pipeline)
+        return handleDropdownError('Please select a Pipeline first');
+
+      const { access_token, api_domain } = auth as any;
+
+      const response = await biginApiService.fetchLayouts(
+        access_token,
+        api_domain,
+        'Pipelines'
+      );
+
+      const layouts = response?.layouts || [];
+
+      const parsedPipeline = JSON.parse(pipeline as string);
+
+      const layout = layouts.find((l: any) => l.id === parsedPipeline.id);
+
+      const PipelineInfo = layout.sections.find(
+        (s: any) => s.api_name === 'Pipeline Information'
+      );
+
+      const stageField = PipelineInfo?.fields.find(
+        (f: any) => f.field_label === field_label
+      );
+
+      return {
+        options: stageField.pick_list_values.map((pl: any) => ({
+          label: pl.display_value,
+          value: pl.actual_value,
+        })),
+      };
+    },
+  });

package/src/lib/common/request.ts

@@ -0,0 +1,285 @@
+import { HttpMethod, httpClient } from '@agnocon/pieces-common';
+import { API_ENDPOINTS } from './constants';
+
+async function fireHttpRequest({
+  method,
+  path,
+  body,
+  access_token
+}: {
+  method: HttpMethod;
+  path: string;
+  access_token: string;
+  body?: unknown;
+}) {
+  return await httpClient
+    .sendRequest({
+      method,
+      url: path,
+      headers: {
+        Accept: 'application/json',
+        Authorization: `Zoho-oauthtoken ${access_token}`,
+        'Content-Type': 'application/json',
+      },
+      body,
+    })
+    .then((res) => res.body)
+    .catch((err) => {
+      throw new Error(
+        `Error in request to ${path}: ${err.message || JSON.stringify(err)}`
+      );
+    });
+}
+
+export const biginApiService = {
+  createWebhook: async (
+    access_token: string,
+    payload: any,
+    api_domain: string
+  ) => {
+    const res = await fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.WEBHOOKS}`,
+      body: payload,
+      access_token,
+    });
+
+    return res;
+  },
+  deleteWebhook: async (
+    access_token: string,
+    api_domain: string,
+    channel_id: string
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.DELETE,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.WEBHOOKS}?channel_ids=${channel_id}`,
+      access_token,
+    });
+  },
+  fetchUsers: async (
+    access_token: string,
+    api_domain: string,
+    params?: { type?: string; page?: number; per_page?: number }
+  ) => {
+    const qs = new URLSearchParams();
+    if (params?.type) qs.set('type', params.type);
+    if (params?.page) qs.set('page', String(params.page));
+    if (params?.per_page) qs.set('per_page', String(params.per_page));
+    const query = qs.toString();
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.USERS}${query ? `?${query}` : ''}`,
+      access_token,
+    });
+  },
+  createCompany: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.COMPANIES}`,
+      access_token,
+      body,
+    });
+  },
+  updateCompany: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.PUT,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.COMPANIES}`,
+      access_token,
+      body,
+    });
+  },
+  fetchCompanies: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.COMPANIES}?fields=Owner,Account_Name,Phone,Website,Tag,Description,Billing_Street,Billing_State,Billing_Country,Billing_Code`,
+      access_token,
+    });
+  },
+  createContact: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.CONTACTS}`,
+      access_token,
+      body,
+    });
+  },
+  updateContact: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.PUT,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.CONTACTS}`,
+      access_token,
+      body,
+    });
+  },
+  fetchTags: async (
+    access_token: string,
+    api_domain: string,
+    module: string
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.TAGS}?module=${module}`,
+      access_token,
+    });
+  },
+  fetchContacts: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.CONTACTS}?fields=First_Name,Last_Name,Title,Email,Mobile,Email_Opt_Out,Owner,Account_Name,Tag,Description,Mailing_Street,Mailing_City,Mailing_State,Mailing_Country,Mailing_Zip`,
+      access_token,
+    });
+  },
+  fetchPipelinesRecords: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.PIPELINES}?fields=Deal_Name,Stage,Owner,Description,Contact_Name,Account_Name,Amount,Closing_Date,Sub_Pipeline,Tag`,
+      access_token,
+    });
+  },
+  createPipelineRecord: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.PIPELINES}`,
+      access_token,
+      body,
+    });
+  },
+  updatePipelineRecord: async (
+    access_token: string,
+    api_domain: string,
+    body: any
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.PUT,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.PIPELINES}`,
+      access_token,
+      body,
+    });
+  },
+  fetchProducts: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.PRODUCTS}?fields=Product_Name,Owner,Product_Code,Product_Category,Unit_Price,Description,Tag,Product_Active`,
+      access_token,
+    });
+  },
+  fetchTasks: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.TASKS}?fields=Subject,Status,Owner,Due_Date,Description,Priority,Related_To,Tags,Remind_At,Recurring_Activity,$related_module`,
+      access_token,
+    });
+  },
+  createCall: async (access_token: string, api_domain: string, body: any) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.CALLS}`,
+      access_token,
+      body,
+    });
+  },
+  createEvent: async (access_token: string, api_domain: string, body: any) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.EVENTS}`,
+      access_token,
+      body,
+    });
+  },
+  fetchEvents: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.EVENTS}?fields=Owner,Event_Title,Start_DateTime,End_DateTime,Description,Recurring_Activity,Participants,Related_To,Tag,Remind_At,$related_module,All_day,Venue`,
+      access_token,
+    });
+  },
+  updateEvent: async (access_token: string, api_domain: string, body: any) => {
+    return fireHttpRequest({
+      method: HttpMethod.PUT,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.EVENTS}`,
+      access_token,
+      body,
+    });
+  },
+  createTask: async (access_token: string, api_domain: string, body: any) => {
+    return fireHttpRequest({
+      method: HttpMethod.POST,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.TASKS}`,
+      access_token,
+      body,
+    });
+  },
+  updateTask: async (access_token: string, api_domain: string, body: any) => {
+    return fireHttpRequest({
+      method: HttpMethod.PUT,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.TASKS}`,
+      access_token,
+      body,
+    });
+  },
+  fetchModules: async (access_token: string, api_domain: string) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.MODULES}`,
+      access_token,
+    });
+  },
+  fetchLayouts: async (
+    access_token: string,
+    api_domain: string,
+    module_name: string
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.LAYOUTS}?module=${module_name}`,
+      access_token,
+    });
+  },
+  fetchModuleFields: async (
+    access_token: string,
+    api_domain: string,
+    module_name: string
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2${API_ENDPOINTS.FIELDS}?module=${module_name}`,
+      access_token,
+    });
+  },
+  searchRecords: async (
+    access_token: string,
+    api_domain: string,
+    module_name: string,
+    query: {
+      key: string;
+      value: string;
+    }
+  ) => {
+    return fireHttpRequest({
+      method: HttpMethod.GET,
+      path: `${api_domain}/bigin/v2/${module_name}/search?${encodeURIComponent(query.key)}=${encodeURIComponent(query.value)}`,
+      access_token,
+    });
+  }
+};

package/src/lib/triggers/company-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_company_updated_trigger';
+
+export const companyUpdated = createTrigger({
+  auth: biginAuth,
+  name: 'companyUpdated',
+  displayName: 'Company Updated',
+  description: 'Triggers when a company record is updated',
+  aiMetadata: {
+    description: 'Fires when an existing company (account) record is edited in Bigin CRM, via an Accounts.edit webhook. Represents a change to an organization already in the CRM.',
+  },
+  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.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];
+  },
+});

package/src/lib/triggers/contact-updated.ts

@@ -0,0 +1,65 @@
+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_updated_contact_trigger';
+
+export const contactUpdated = createTrigger({
+  auth: biginAuth,
+  name: 'contactUpdated',
+  displayName: 'Contact Updated',
+  description: 'Triggers when a contact is updated',
+  aiMetadata: {
+    description: 'Fires when an existing contact (person) record is edited in Bigin CRM, via a Contacts.edit webhook. Represents a change to a person already in the CRM.',
+  },
+  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: ['Contacts.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];
+  },
+});