@friggframework/api-module-zoho-crm 2.0.0-next.0 → 2.0.0-next.2

package/dist/api.js

@@ -0,0 +1,521 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const FormData = require("form-data");
+const core_1 = require("@friggframework/core");
+class Api extends core_1.OAuth2Requester {
+    constructor(params) {
+        super(params);
+        this.baseUrl = 'https://www.zohoapis.com/crm/v8';
+        this.authorizationUri = encodeURI(`https://accounts.zoho.com/oauth/v2/auth?scope=${this.scope}&client_id=${this.client_id}&redirect_uri=${this.redirect_uri}&response_type=code&access_type=offline`);
+        this.tokenUri = 'https://accounts.zoho.com/oauth/v2/token';
+        this.access_token = (0, core_1.get)(params, 'access_token', null);
+        this.refresh_token = (0, core_1.get)(params, 'refresh_token', null);
+        this.URLs = {
+            users: '/users',
+            user: (userId) => `/users/${userId}`,
+            roles: '/settings/roles',
+            role: (roleId) => `/settings/roles/${roleId}`,
+            profiles: '/settings/profiles',
+            contacts: '/Contacts',
+            contact: (contactId) => `/Contacts/${contactId}`,
+            contactSearch: '/Contacts/search',
+            leads: '/Leads',
+            lead: (leadId) => `/Leads/${leadId}`,
+            leadSearch: '/Leads/search',
+            accounts: '/Accounts',
+            account: (accountId) => `/Accounts/${accountId}`,
+            accountSearch: '/Accounts/search',
+            notificationsWatch: '/actions/watch',
+        };
+    }
+    getAuthUri() {
+        return this.authorizationUri;
+    }
+    async getTokenFromCode(code) {
+        const formData = new FormData();
+        formData.append('grant_type', 'authorization_code');
+        formData.append('client_id', this.client_id);
+        formData.append('client_secret', this.client_secret);
+        formData.append('redirect_uri', this.redirect_uri);
+        formData.append('scope', this.scope);
+        formData.append('code', code);
+        const options = {
+            body: formData,
+            headers: formData.getHeaders(),
+            url: this.tokenUri,
+        };
+        const response = await this._post(options, false);
+        await this.setTokens(response);
+        return response;
+    }
+    async _delete(options) {
+        const response = await super._delete(options);
+        return await this.parsedBody(response);
+    }
+    /**
+     * Build URL for notes endpoints with proper encoding
+     * @param module - Module API name (e.g., 'Contacts', 'Leads')
+     * @param recordId - Record ID
+     * @param noteId - Optional note ID for specific note operations
+     * @returns Encoded URL path for notes endpoint
+     */
+    buildNotesUrl(module, recordId, noteId) {
+        const segments = [module, recordId, 'Notes'];
+        if (noteId)
+            segments.push(noteId);
+        const encodedPath = segments.map(encodeURIComponent).join('/');
+        return `${this.baseUrl}/${encodedPath}`;
+    }
+    async listUsers(queryParams = {}) {
+        return this._get({
+            url: this.baseUrl + this.URLs.users,
+            query: { ...queryParams },
+        });
+    }
+    async getUser(userId) {
+        if (!userId) {
+            throw new Error('userId is required');
+        }
+        return this._get({
+            url: this.baseUrl + this.URLs.user(userId),
+        });
+    }
+    async createUser(body = {}) {
+        if (!body || Object.keys(body).length === 0) {
+            throw new Error('Request body is required');
+        }
+        return this._post({
+            url: this.baseUrl + this.URLs.users,
+            body: body
+        });
+    }
+    async updateUser(userId, body = {}) {
+        if (!userId) {
+            throw new Error('userId is required');
+        }
+        if (!body || Object.keys(body).length === 0) {
+            throw new Error('Request body is required');
+        }
+        return this._put({
+            url: this.baseUrl + this.URLs.user(userId),
+            body: body,
+        });
+    }
+    async deleteUser(userId) {
+        if (!userId) {
+            throw new Error('userId is required');
+        }
+        return this._delete({
+            url: this.baseUrl + this.URLs.user(userId),
+        });
+    }
+    async listRoles() {
+        return this._get({
+            url: this.baseUrl + this.URLs.roles
+        });
+    }
+    async getRole(roleId) {
+        if (!roleId) {
+            throw new Error('roleId is required');
+        }
+        return this._get({
+            url: this.baseUrl + this.URLs.role(roleId)
+        });
+    }
+    async createRole(body = {}) {
+        if (!body || Object.keys(body).length === 0) {
+            throw new Error('Request body is required');
+        }
+        return this._post({
+            url: this.baseUrl + this.URLs.roles,
+            body: body
+        });
+    }
+    async updateRole(roleId, body = {}) {
+        if (!roleId) {
+            throw new Error('roleId is required');
+        }
+        if (!body || Object.keys(body).length === 0) {
+            throw new Error('Request body is required');
+        }
+        return this._put({
+            url: this.baseUrl + this.URLs.role(roleId),
+            body: body,
+        });
+    }
+    async deleteRole(roleId, queryParams = {}) {
+        if (!roleId) {
+            throw new Error('roleId is required');
+        }
+        return this._delete({
+            url: this.baseUrl + this.URLs.role(roleId),
+            query: { ...queryParams },
+        });
+    }
+    async listProfiles() {
+        return this._get({
+            url: this.baseUrl + this.URLs.profiles
+        });
+    }
+    async listContacts(queryParams = {}) {
+        const params = {
+            fields: Api.CONTACTS_DEFAULT_FIELDS,
+            ...queryParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.contacts,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getContact(contactId) {
+        if (!contactId) {
+            throw new Error('contactId is required');
+        }
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.contact(contactId),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async searchContacts(searchParams = {}) {
+        if (!searchParams || Object.keys(searchParams).length === 0) {
+            throw new Error('At least one search parameter is required (email, phone, criteria, or word)');
+        }
+        const params = {
+            fields: Api.CONTACTS_DEFAULT_FIELDS,
+            ...searchParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.contactSearch,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async listLeads(queryParams = {}) {
+        const params = {
+            fields: Api.LEADS_DEFAULT_FIELDS,
+            ...queryParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.leads,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getLead(leadId) {
+        if (!leadId) {
+            throw new Error('leadId is required');
+        }
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.lead(leadId),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async searchLeads(searchParams = {}) {
+        if (!searchParams || Object.keys(searchParams).length === 0) {
+            throw new Error('At least one search parameter is required (email, phone, criteria, or word)');
+        }
+        const params = {
+            fields: Api.LEADS_DEFAULT_FIELDS,
+            ...searchParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.leadSearch,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async listAccounts(queryParams = {}) {
+        const params = {
+            fields: Api.ACCOUNTS_DEFAULT_FIELDS,
+            ...queryParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.accounts,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getAccount(accountId) {
+        if (!accountId) {
+            throw new Error('accountId is required');
+        }
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.account(accountId),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async searchAccounts(searchParams = {}) {
+        if (!searchParams || Object.keys(searchParams).length === 0) {
+            throw new Error('At least one search parameter is required (email, phone, criteria, or word)');
+        }
+        const params = {
+            fields: Api.ACCOUNTS_DEFAULT_FIELDS,
+            ...searchParams,
+        };
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.accountSearch,
+                query: params,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * List all notes for a specific record
+     * @param module - Module API name (Contacts, Leads, Accounts, etc.)
+     * @param recordId - Record ID to get notes for
+     * @param queryParams - Optional query parameters (per_page, page, etc.)
+     * @returns Promise<NoteListResponse> Notes list response
+     */
+    async listNotes(module, recordId, queryParams = {}) {
+        if (!module) {
+            throw new Error('module is required');
+        }
+        if (!recordId) {
+            throw new Error('recordId is required');
+        }
+        try {
+            return await this._get({
+                url: this.buildNotesUrl(module, recordId),
+                query: queryParams,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get a specific note by ID
+     * @param module - Module API name (Contacts, Leads, Accounts, etc.)
+     * @param recordId - Record ID the note is attached to
+     * @param noteId - Note ID to retrieve
+     * @returns Promise<NotesResponse> Note details
+     */
+    async getNote(module, recordId, noteId) {
+        if (!module) {
+            throw new Error('module is required');
+        }
+        if (!recordId) {
+            throw new Error('recordId is required');
+        }
+        if (!noteId) {
+            throw new Error('noteId is required');
+        }
+        try {
+            return await this._get({
+                url: this.buildNotesUrl(module, recordId, noteId),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Create a note for a specific record
+     * @param module - Module API name (Contacts, Leads, Accounts, etc.)
+     * @param recordId - Record ID to attach note to
+     * @param noteData - Note data with Note_Content (required) and optional Note_Title
+     * @returns Promise<NotesResponse> Created note response
+     */
+    async createNote(module, recordId, noteData) {
+        if (!module) {
+            throw new Error('module is required');
+        }
+        if (!recordId) {
+            throw new Error('recordId is required');
+        }
+        if (!noteData || !noteData.Note_Content) {
+            throw new Error('noteData.Note_Content is required');
+        }
+        const body = {
+            data: [{
+                    Note_Content: noteData.Note_Content,
+                    ...(noteData.Note_Title && { Note_Title: noteData.Note_Title }),
+                }]
+        };
+        try {
+            return await this._post({
+                url: this.buildNotesUrl(module, recordId),
+                body: body,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Update an existing note
+     * @param module - Module API name (Contacts, Leads, Accounts, etc.)
+     * @param recordId - Record ID the note is attached to
+     * @param noteId - Note ID to update
+     * @param noteData - Updated note data. At least one of Note_Content or Note_Title must be provided.
+     * @returns Promise<NotesResponse> Updated note response
+     */
+    async updateNote(module, recordId, noteId, noteData) {
+        if (!module) {
+            throw new Error('module is required');
+        }
+        if (!recordId) {
+            throw new Error('recordId is required');
+        }
+        if (!noteId) {
+            throw new Error('noteId is required');
+        }
+        if (!noteData || (!noteData.Note_Content && !noteData.Note_Title)) {
+            throw new Error('noteData must contain Note_Content or Note_Title');
+        }
+        const body = {
+            data: [{
+                    ...(noteData.Note_Content && { Note_Content: noteData.Note_Content }),
+                    ...(noteData.Note_Title && { Note_Title: noteData.Note_Title }),
+                }]
+        };
+        try {
+            return await this._put({
+                url: this.buildNotesUrl(module, recordId, noteId),
+                body: body,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Delete a note
+     * @param module - Module API name (Contacts, Leads, Accounts, etc.)
+     * @param recordId - Record ID the note is attached to
+     * @param noteId - Note ID to delete
+     * @returns Promise<NotesResponse> Deletion response
+     */
+    async deleteNote(module, recordId, noteId) {
+        if (!module) {
+            throw new Error('module is required');
+        }
+        if (!recordId) {
+            throw new Error('recordId is required');
+        }
+        if (!noteId) {
+            throw new Error('noteId is required');
+        }
+        try {
+            return await this._delete({
+                url: this.buildNotesUrl(module, recordId, noteId),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Enable notification channel to receive real-time events
+     * @param body - Notification configuration with watch items
+     * @returns Promise<NotificationResponse> Response with channel details
+     * @see https://www.zoho.com/crm/developer/docs/api/v8/notifications/enable.html
+     */
+    async enableNotification(body) {
+        if (!body || !body.watch || !Array.isArray(body.watch)) {
+            throw new Error('Body must contain watch array');
+        }
+        // Validate each watch item
+        body.watch.forEach((item, index) => {
+            if (!item.channel_id) {
+                throw new Error(`watch[${index}].channel_id is required`);
+            }
+            if (!item.events || !Array.isArray(item.events) || item.events.length === 0) {
+                throw new Error(`watch[${index}].events must be a non-empty array`);
+            }
+            if (!item.notify_url) {
+                throw new Error(`watch[${index}].notify_url is required`);
+            }
+            if (item.token && item.token.length > 50) {
+                throw new Error(`watch[${index}].token must be 50 characters or less`);
+            }
+        });
+        try {
+            return await this._post({
+                url: this.baseUrl + this.URLs.notificationsWatch,
+                body: body,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Disable notification channels
+     * @param channelIds - Array of channel IDs to disable
+     * @returns Promise<NotificationResponse> Response confirming deletion
+     * @see https://www.zoho.com/crm/developer/docs/api/v8/notifications/disable.html
+     */
+    async disableNotification(channelIds) {
+        if (!channelIds || !Array.isArray(channelIds) || channelIds.length === 0) {
+            throw new Error('channelIds must be a non-empty array');
+        }
+        try {
+            return await this._delete({
+                url: this.baseUrl + this.URLs.notificationsWatch,
+                query: {
+                    channel_ids: channelIds.join(',')
+                },
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Get details of all active notification channels
+     * @returns Promise<NotificationDetailsResponse> Details of all active channels
+     * @see https://www.zoho.com/crm/developer/docs/api/v8/notifications/get-details.html
+     */
+    async getNotificationDetails() {
+        try {
+            return await this._get({
+                url: this.baseUrl + this.URLs.notificationsWatch,
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+}
+exports.Api = Api;
+Api.CONTACTS_DEFAULT_FIELDS = 'id,First_Name,Last_Name,Email,Phone,Mobile,Account_Name,Company,Owner,Lead_Source,Created_Time,Modified_Time';
+Api.LEADS_DEFAULT_FIELDS = 'id,First_Name,Last_Name,Email,Phone,Mobile,Company,Industry,Lead_Source,Lead_Status,Owner,Created_Time,Modified_Time,Converted__s,Converted_Date_Time';
+Api.ACCOUNTS_DEFAULT_FIELDS = 'id,Account_Name,Account_Number,Account_Type,Industry,Annual_Revenue,Rating,Phone,Fax,Website,Parent_Account,Owner,Billing_City,Billing_State,Billing_Country,Shipping_City,Shipping_State,Shipping_Country,Created_Time,Modified_Time';

package/dist/defaultConfig.json

@@ -0,0 +1,13 @@
+{
+    "name": "zohoCrm",
+    "label": "Zoho CRM",
+    "productUrl": "https://www.zoho.com/crm/",
+    "apiDocs": "https://www.zoho.com/crm/developer/docs/",
+    "logoUrl": "https://friggframework.org/assets/img/zoho-icon.png",
+    "categories": [
+        "Sales",
+        "Marketing",
+        "CRM"
+    ],
+    "description": "Zoho CRM acts as a single repository to bring your sales, marketing, and customer support activities together, and streamline your process, policy, and people in one platform."
+}

package/dist/definition.d.ts

@@ -0,0 +1,22 @@
+import { Api } from './api';
+export declare const Definition: {
+    API: typeof Api;
+    getName: () => string;
+    moduleName: string;
+    requiredAuthMethods: {
+        getToken: (api: Api, params: any) => Promise<void>;
+        apiPropertiesToPersist: {
+            credential: string[];
+            entity: never[];
+        };
+        getCredentialDetails: (api: Api, userId: string) => Promise<any>;
+        getEntityDetails: (api: Api, callbackParams: any, tokenResponse: any, userId: string) => Promise<any>;
+        testAuthRequest: (api: Api) => Promise<any>;
+    };
+    env: {
+        client_id: string | undefined;
+        client_secret: string | undefined;
+        scope: string | undefined;
+        redirect_uri: string;
+    };
+};

package/dist/definition.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Definition = void 0;
+const dotenv = __importStar(require("dotenv"));
+dotenv.config();
+const api_1 = require("./api");
+const core_1 = require("@friggframework/core");
+const config = __importStar(require("./defaultConfig.json"));
+exports.Definition = {
+    API: api_1.Api,
+    getName: function () {
+        return config.name;
+    },
+    moduleName: config.name,
+    requiredAuthMethods: {
+        getToken: async function (api, params) {
+            const code = (0, core_1.get)(params, 'code');
+            await api.getTokenFromCode(code);
+        },
+        apiPropertiesToPersist: {
+            credential: ['access_token', 'refresh_token'],
+            entity: [],
+        },
+        getCredentialDetails: async function (api, userId) {
+            const response = await api.listUsers({ type: 'CurrentUser' });
+            const currentUser = response.users[0];
+            return {
+                identifiers: { externalId: currentUser.id, user: userId },
+                details: {},
+            };
+        },
+        getEntityDetails: async function (api, callbackParams, tokenResponse, userId) {
+            const response = await api.listUsers({ type: 'CurrentUser' });
+            const currentUser = response.users[0];
+            return {
+                identifiers: { externalId: currentUser.id, user: userId },
+                details: {
+                    name: currentUser.email
+                },
+            };
+        },
+        testAuthRequest: async function (api) {
+            return await api.listUsers();
+        },
+    },
+    env: {
+        client_id: process.env.ZOHO_CRM_CLIENT_ID,
+        client_secret: process.env.ZOHO_CRM_CLIENT_SECRET,
+        scope: process.env.ZOHO_CRM_SCOPE,
+        redirect_uri: `${process.env.REDIRECT_URI}/zohoCrm`,
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Api } from './api';
+import * as Config from './defaultConfig.json';
+import { Definition } from './definition';
+export { Api, Config, Definition, };

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Definition = exports.Config = exports.Api = void 0;
+const api_1 = require("./api");
+Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return api_1.Api; } });
+const Config = __importStar(require("./defaultConfig.json"));
+exports.Config = Config;
+const definition_1 = require("./definition");
+Object.defineProperty(exports, "Definition", { enumerable: true, get: function () { return definition_1.Definition; } });