@dereekb/zoho 12.6.21 → 13.0.0

package/nestjs/index.esm.js

@@ -0,0 +1,582 @@
+import { Injectable, Inject } from '@nestjs/common';
+import { zohoAccountsFactory, zohoAccountsAccessToken, zohoRecruitFactory, zohoRecruitInsertRecord, zohoRecruitUpsertRecord, zohoRecruitUpdateRecord, zohoRecruitDeleteRecord, zohoRecruitGetRecordById, zohoRecruitGetRecords, zohoRecruitSearchRecords, zohoRecruitSearchRecordsPageFactory, zohoRecruitGetRelatedRecordsFunctionFactory, zohoRecruitGetEmailsForRecord, zohoRecruitGetEmailsForRecordPageFactory, zohoRecruitGetAttachmentsForRecord, zohoRecruitGetAttachmentsForRecordPageFactory, zohoRecruitUploadAttachmentForRecord, zohoRecruitDownloadAttachmentForRecord, zohoRecruitDeleteAttachmentFromRecord, zohoRecruitCreateNotes, zohoRecruitDeleteNotes, zohoRecruitCreateNotesForRecord, zohoRecruitGetNotesForRecord, zohoRecruitGetNotesForRecordPageFactory, zohoRecruitExecuteRestApiFunction, zohoRecruitAssociateCandidateRecordsWithJobOpenings, zohoRecruitSearchCandidateAssociatedJobOpeningRecords, zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory, zohoRecruitSearchJobOpeningAssociatedCandidateRecords, zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory, zohoRecruitCreateTagsForModule, zohoRecruitGetTagsForModule, zohoRecruitAddTagsToRecords, zohoRecruitRemoveTagsFromRecords, ZOHO_RECRUIT_SERVICE_NAME } from '@dereekb/zoho';
+import { forEachKeyValue, tryWithPromiseFactoriesFunction, isPast, filterMaybeArrayValues } from '@dereekb/util';
+import { dirname } from 'path';
+import { rm, writeFile, mkdirSync, readFile } from 'fs';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const ZOHO_API_URL_CONFIG_KEY = 'API_URL';
+function zohoConfigServiceReaderFunction(inputOrKey, inputConfigService) {
+  let configService;
+  let serviceAccessTokenKey;
+  if (typeof inputOrKey === 'string') {
+    serviceAccessTokenKey = inputOrKey;
+    configService = inputConfigService;
+  } else {
+    configService = inputOrKey.configService;
+    serviceAccessTokenKey = inputOrKey.serviceAccessTokenKey;
+  }
+  const baseServicePrefix = 'ZOHO_';
+  const servicePrefix = serviceAccessTokenKey.toUpperCase(); // "RECRUIT"
+  const servicePrefixString = `${baseServicePrefix}${servicePrefix}_`; // "ZOHO_RECRUIT_"
+  return key => {
+    const baseConfigKey = `${baseServicePrefix}${key}`; // "ZOHO_ACCOUNTS_URL"
+    const serviceSpecificConfigKey = `${servicePrefixString}${key}`; // "ZOHO_RECRUIT_ACCOUNTS_URL"
+    return configService.get(serviceSpecificConfigKey) ?? configService.get(baseConfigKey);
+  };
+}
+/**
+ * Reads the ZohoConfig config from the ConfigService.
+ *
+ * @param configService
+ * @param prefix
+ */
+function readZohoConfigFromConfigService(configService, servicePrefix, assertValid = true) {
+  const servicePrefixString = servicePrefix ? `${servicePrefix}_` : '';
+  const apiUrlConfigKey = `${servicePrefixString}${ZOHO_API_URL_CONFIG_KEY}`;
+  const config = {
+    apiUrl: configService.get(apiUrlConfigKey) ?? configService.get(ZOHO_API_URL_CONFIG_KEY)
+  };
+  if (assertValid) {
+    if (!config.apiUrl) {
+      throw new Error(`No Zoho API url or type specified for key "${apiUrlConfigKey}".`);
+    }
+  }
+  return config;
+}
+function assertValidZohoConfig(config) {
+  if (!config.apiUrl) {
+    throw new Error(`No Zoho API url or type specified.`);
+  }
+}
+
+/**
+ * Configuration for ZohoService
+ */
+class ZohoAccountsServiceConfig {
+  zohoAccounts;
+  factoryConfig;
+  static assertValidConfig(config) {
+    const {
+      zohoAccounts
+    } = config;
+    if (!zohoAccounts) {
+      throw new Error('ZohoAccountsServiceConfig.zohoAccounts is required');
+    } else {
+      if (!zohoAccounts.serviceAccessTokenKey) {
+        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.serviceAccessTokenKey is required');
+      } else if (!zohoAccounts.refreshToken) {
+        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.refreshToken is required');
+      } else if (!zohoAccounts.apiUrl) {
+        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.apiUrl is required');
+      } else if (!zohoAccounts.clientId) {
+        throw new Error('ZohoAccountsServiceConfig.zohoAccounts.clientId is required');
+      }
+    }
+  }
+}
+/**
+ * Builds a {@link ZohoAccountsServiceConfig} by reading Zoho Accounts OAuth credentials
+ * from a NestJS `ConfigService` (typically backed by environment variables).
+ *
+ * ## Environment Variable Resolution
+ *
+ * For each credential, the function first looks for a **service-specific** environment variable
+ * (e.g. `ZOHO_CRM_ACCOUNTS_URL`), then falls back to the **shared** variable
+ * (e.g. `ZOHO_ACCOUNTS_URL`). The service prefix is derived from `serviceAccessTokenKey`
+ * uppercased (e.g. `'crm'` → `ZOHO_CRM_`, `'recruit'` → `ZOHO_RECRUIT_`).
+ *
+ * | Credential       | Shared env var                | Service-specific env var (example: CRM)      |
+ * |------------------|-------------------------------|----------------------------------------------|
+ * | Accounts API URL | `ZOHO_ACCOUNTS_URL`           | `ZOHO_CRM_ACCOUNTS_URL`                      |
+ * | Refresh Token    | `ZOHO_ACCOUNTS_REFRESH_TOKEN` | `ZOHO_CRM_ACCOUNTS_REFRESH_TOKEN`            |
+ * | Client ID        | `ZOHO_ACCOUNTS_CLIENT_ID`     | `ZOHO_CRM_ACCOUNTS_CLIENT_ID`                |
+ * | Client Secret    | `ZOHO_ACCOUNTS_CLIENT_SECRET` | `ZOHO_CRM_ACCOUNTS_CLIENT_SECRET`            |
+ *
+ * When using Zoho Recruit, replace `CRM` with `RECRUIT` in the service-specific variable names.
+ *
+ * @param input - The {@link ZohoAccountsServiceConfigFromConfigServiceInput} containing the
+ *   `ConfigService` and the `serviceAccessTokenKey` for the target Zoho service.
+ * @returns A validated {@link ZohoAccountsServiceConfig} ready for use with `ZohoAccountsApi`.
+ * @throws If any required credential (apiUrl, refreshToken, clientId) is missing.
+ */
+function zohoAccountsServiceConfigFromConfigService(input) {
+  const {
+    serviceAccessTokenKey
+  } = input;
+  const getFromConfigService = zohoConfigServiceReaderFunction(input);
+  const zohoAccounts = {
+    serviceAccessTokenKey,
+    apiUrl: getFromConfigService('ACCOUNTS_URL'),
+    // ZOHO_<SERVICE>_ACCOUNTS_URL, ZOHO_ACCOUNTS_URL
+    refreshToken: getFromConfigService('ACCOUNTS_REFRESH_TOKEN'),
+    // ZOHO_<SERVICE>_ACCOUNTS_REFRESH_TOKEN, ZOHO_ACCOUNTS_REFRESH_TOKEN
+    clientId: getFromConfigService('ACCOUNTS_CLIENT_ID'),
+    // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_ID, ZOHO_ACCOUNTS_CLIENT_ID
+    clientSecret: getFromConfigService('ACCOUNTS_CLIENT_SECRET') // ZOHO_<SERVICE>_ACCOUNTS_CLIENT_SECRET, ZOHO_ACCOUNTS_CLIENT_SECRET
+  };
+  const config = {
+    zohoAccounts
+  };
+  ZohoAccountsServiceConfig.assertValidConfig(config);
+  return config;
+}
+
+/**
+ * Service used for retrieving ZohoAccessTokenCache for Zoho services.
+ */
+let ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {};
+ZohoAccountsAccessTokenCacheService = __decorate([Injectable()], ZohoAccountsAccessTokenCacheService);
+function logMergeZohoAccountsAccessTokenCacheServiceErrorFunction(failedUpdates) {
+  console.warn(`mergeZohoAccountsAccessTokenCacheServices(): failed updating ${failedUpdates.length} caches.`);
+  failedUpdates.forEach(([x, e], i) => {
+    console.warn(`Cache update failure ${i + 1}: - ${e}`);
+  });
+}
+/**
+ * Merges the input services in order to use some as a backup source.
+ *
+ * If once source fails retrieval, the next will be tried.
+ *
+ * When updating a cached token, it will update the token across all services.
+ *
+ * @param servicesToMerge Must include atleast one service. Empty arrays will throw an error.
+ */
+function mergeZohoAccountsAccessTokenCacheServices(inputServicesToMerge, logError) {
+  const services = [...inputServicesToMerge];
+  const logErrorFunction = typeof logError === 'function' ? logError : logError !== false ? logMergeZohoAccountsAccessTokenCacheServiceErrorFunction : undefined;
+  if (services.length === 0) {
+    throw new Error('mergeZohoAccountsAccessTokenCacheServices() input cannot be empty.');
+  }
+  const service = {
+    loadZohoAccessTokenCache: function (service) {
+      const accessCachesForServices = services.map(x => x.loadZohoAccessTokenCache(service));
+      const loadCachedTokenFromFirstService = tryWithPromiseFactoriesFunction({
+        promiseFactories: accessCachesForServices.map(x => () => x.loadCachedToken().catch(() => null).then(x => {
+          let result = undefined;
+          if (x && !isPast(x.expiresAt)) {
+            result = x; // only return from cache if it is not expired
+          }
+          return result;
+        })),
+        successOnMaybe: false,
+        throwErrors: false
+      });
+      const cacheForService = {
+        loadCachedToken: function () {
+          return loadCachedTokenFromFirstService();
+        },
+        updateCachedToken: async function (accessToken) {
+          return Promise.allSettled(accessCachesForServices.map(x => x.updateCachedToken(accessToken).then(() => null).catch(e => {
+            return [x, e];
+          }))).then(x => {
+            // only find the failures if we're logging
+            if (logErrorFunction != null) {
+              const failedUpdates = filterMaybeArrayValues(x.map(y => y.value));
+              if (failedUpdates.length) {
+                logErrorFunction(failedUpdates);
+              }
+            }
+          });
+        },
+        clearCachedToken: async function () {
+          await Promise.allSettled(accessCachesForServices.map(x => x.clearCachedToken()));
+        }
+      };
+      return cacheForService;
+    }
+  };
+  return service;
+}
+// MARK: Memory Access Token Cache
+/**
+ * Creates a ZohoAccountsAccessTokenCacheService that uses in-memory storage.
+ *
+ * @returns
+ */
+function memoryZohoAccountsAccessTokenCacheService(existingCache, logAccessToConsole) {
+  const tokens = existingCache ?? {};
+  function loadZohoAccessTokenCache(service) {
+    const accessTokenCache = {
+      loadCachedToken: async function () {
+        const token = tokens[service];
+        if (logAccessToConsole) {
+          console.log('retrieving access token from memory: ', {
+            token,
+            service
+          });
+        }
+        return token;
+      },
+      updateCachedToken: async function (accessToken) {
+        tokens[service] = accessToken;
+        if (logAccessToConsole) {
+          console.log('updating access token in memory: ', {
+            accessToken,
+            service
+          });
+        }
+      },
+      clearCachedToken: async function () {
+        delete tokens[service];
+        if (logAccessToConsole) {
+          console.log('clearing access token in memory: ', {
+            service
+          });
+        }
+      }
+    };
+    return accessTokenCache;
+  }
+  return {
+    loadZohoAccessTokenCache
+  };
+}
+// MARK: File System Access Token Cache
+const DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = '.tmp/zoho-access-tokens.json';
+/**
+ * Creates a ZohoAccountsAccessTokenCacheService that reads and writes the access token to the file system.
+ *
+ * Useful for testing.
+ *
+ * @returns
+ */
+function fileZohoAccountsAccessTokenCacheService(filename = DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, useMemoryCache = true) {
+  let loadedTokens = null;
+  async function loadTokens() {
+    if (!loadedTokens) {
+      return (await readTokenFile()) ?? {};
+    } else {
+      return loadedTokens;
+    }
+  }
+  function readTokenFile() {
+    return new Promise(resolve => {
+      mkdirSync(dirname(filename), {
+        recursive: true
+      }); // make the directory first
+      readFile(filename, {}, (x, data) => {
+        let result = undefined;
+        if (!x) {
+          try {
+            result = JSON.parse(data.toString());
+            forEachKeyValue(result, {
+              forEach: x => {
+                if (x[1]) {
+                  x[1].expiresAt = new Date(x[1].expiresAt);
+                }
+              }
+            });
+          } catch (e) {
+            console.error('Failed reading token file: ', e);
+          }
+        }
+        resolve(result);
+      });
+    }).then(x => {
+      // update loaded tokens
+      if (useMemoryCache) {
+        loadedTokens = {
+          ...loadedTokens,
+          ...x
+        };
+      }
+      return x;
+    });
+  }
+  async function writeTokenFile(tokens) {
+    return new Promise((resolve, reject) => {
+      writeFile(filename, JSON.stringify(tokens), {}, x => {
+        if (!x) {
+          resolve();
+        } else {
+          reject(x);
+        }
+      });
+    });
+  }
+  async function deleteTokenFile() {
+    return new Promise((resolve, reject) => {
+      rm(filename, x => {
+        if (!x) {
+          resolve();
+        } else {
+          reject(x);
+        }
+      });
+    });
+  }
+  function loadZohoAccessTokenCache(service) {
+    const accessTokenCache = {
+      loadCachedToken: async function () {
+        const tokens = await loadTokens();
+        const token = tokens[service];
+        // console.log('retrieving access token from file: ', { token, service });
+        return token;
+      },
+      updateCachedToken: async function (accessToken) {
+        const tokens = await loadTokens();
+        if (tokens) {
+          tokens[service] = accessToken;
+        }
+        // console.log('updating access token in file: ', { accessToken, service });
+        try {
+          await writeTokenFile(tokens);
+        } catch (e) {
+          console.error('Failed updating access token in file: ', e);
+        }
+      },
+      clearCachedToken: async function () {
+        try {
+          await writeTokenFile({});
+        } catch (e) {
+          console.error('Failed clearing access token in file: ', e);
+        }
+      }
+    };
+    return accessTokenCache;
+  }
+  return {
+    loadZohoAccessTokenCache,
+    readTokenFile,
+    writeTokenFile,
+    deleteTokenFile
+  };
+}
+
+let ZohoAccountsApi = class ZohoAccountsApi {
+  config;
+  cacheService;
+  zohoAccounts;
+  get accountsContext() {
+    return this.zohoAccounts.accountsContext;
+  }
+  constructor(config, cacheService) {
+    this.config = config;
+    this.cacheService = cacheService;
+    const accessTokenCache = config.zohoAccounts.accessTokenCache ? config.zohoAccounts.accessTokenCache : cacheService.loadZohoAccessTokenCache(config.zohoAccounts.serviceAccessTokenKey);
+    this.zohoAccounts = zohoAccountsFactory(config.factoryConfig ?? {})({
+      accessTokenCache,
+      ...config.zohoAccounts
+    });
+  }
+  // MARK: Accessors
+  get accessToken() {
+    return zohoAccountsAccessToken(this.accountsContext);
+  }
+};
+ZohoAccountsApi = __decorate([Injectable(), __param(0, Inject(ZohoAccountsServiceConfig)), __param(1, Inject(ZohoAccountsAccessTokenCacheService)), __metadata("design:paramtypes", [ZohoAccountsServiceConfig, ZohoAccountsAccessTokenCacheService])], ZohoAccountsApi);
+
+/**
+ * Configuration for ZohoRecruitService
+ */
+class ZohoRecruitServiceConfig {
+  zohoRecruit;
+  factoryConfig;
+  static assertValidConfig(config) {
+    assertValidZohoConfig(config.zohoRecruit);
+  }
+}
+
+let ZohoRecruitApi = class ZohoRecruitApi {
+  config;
+  zohoAccountsApi;
+  zohoRecruit;
+  get recruitContext() {
+    return this.zohoRecruit.recruitContext;
+  }
+  get zohoRateLimiter() {
+    return this.zohoRecruit.recruitContext.zohoRateLimiter;
+  }
+  constructor(config, zohoAccountsApi) {
+    this.config = config;
+    this.zohoAccountsApi = zohoAccountsApi;
+    this.zohoRecruit = zohoRecruitFactory({
+      ...config.factoryConfig,
+      accountsContext: zohoAccountsApi.accountsContext
+    })(config.zohoRecruit);
+  }
+  // MARK: Accessors
+  get insertRecord() {
+    return zohoRecruitInsertRecord(this.recruitContext);
+  }
+  get upsertRecord() {
+    return zohoRecruitUpsertRecord(this.recruitContext);
+  }
+  get updateRecord() {
+    return zohoRecruitUpdateRecord(this.recruitContext);
+  }
+  get deleteRecord() {
+    return zohoRecruitDeleteRecord(this.recruitContext);
+  }
+  get getRecordById() {
+    return zohoRecruitGetRecordById(this.recruitContext);
+  }
+  get getRecords() {
+    return zohoRecruitGetRecords(this.recruitContext);
+  }
+  get searchRecords() {
+    return zohoRecruitSearchRecords(this.recruitContext);
+  }
+  get searchRecordsPageFactory() {
+    return zohoRecruitSearchRecordsPageFactory(this.recruitContext);
+  }
+  get getRelatedRecordsFunctionFactory() {
+    return zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
+  }
+  get getEmailsForRecord() {
+    return zohoRecruitGetEmailsForRecord(this.recruitContext);
+  }
+  get getEmailsForRecordPageFactory() {
+    return zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
+  }
+  get getAttachmentsForRecord() {
+    return zohoRecruitGetAttachmentsForRecord(this.recruitContext);
+  }
+  get getAttachmentsForRecordPageFactory() {
+    return zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
+  }
+  get uploadAttachmentForRecord() {
+    return zohoRecruitUploadAttachmentForRecord(this.recruitContext);
+  }
+  get downloadAttachmentForRecord() {
+    return zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
+  }
+  get deleteAttachmentFromRecord() {
+    return zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
+  }
+  get createNotes() {
+    return zohoRecruitCreateNotes(this.recruitContext);
+  }
+  get deleteNotes() {
+    return zohoRecruitDeleteNotes(this.recruitContext);
+  }
+  get createNotesForRecord() {
+    return zohoRecruitCreateNotesForRecord(this.recruitContext);
+  }
+  get getNotesForRecord() {
+    return zohoRecruitGetNotesForRecord(this.recruitContext);
+  }
+  get getNotesForRecordPageFactory() {
+    return zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
+  }
+  get executeRestApiFunction() {
+    return zohoRecruitExecuteRestApiFunction(this.recruitContext);
+  }
+  get associateCandidateRecordsWithJobOpenings() {
+    return zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
+  }
+  get searchCandidateAssociatedJobOpeningRecords() {
+    return zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
+  }
+  get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
+    return zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
+  }
+  get searchJobOpeningAssociatedCandidateRecords() {
+    return zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
+  }
+  get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
+    return zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
+  }
+  get createTagsForModule() {
+    return zohoRecruitCreateTagsForModule(this.recruitContext);
+  }
+  get getTagsForModule() {
+    return zohoRecruitGetTagsForModule(this.recruitContext);
+  }
+  get addTagsToRecords() {
+    return zohoRecruitAddTagsToRecords(this.recruitContext);
+  }
+  get removeTagsFromRecords() {
+    return zohoRecruitRemoveTagsFromRecords(this.recruitContext);
+  }
+};
+ZohoRecruitApi = __decorate([Injectable(), __param(0, Inject(ZohoRecruitServiceConfig)), __param(1, Inject(ZohoAccountsApi)), __metadata("design:paramtypes", [ZohoRecruitServiceConfig, ZohoAccountsApi])], ZohoRecruitApi);
+
+// MARK: Provider Factories
+function zohoRecruitServiceConfigFactory(configService) {
+  const getFromConfigService = zohoConfigServiceReaderFunction(ZOHO_RECRUIT_SERVICE_NAME, configService);
+  const config = {
+    zohoRecruit: {
+      apiUrl: getFromConfigService(ZOHO_API_URL_CONFIG_KEY)
+    }
+  };
+  ZohoRecruitServiceConfig.assertValidConfig(config);
+  return config;
+}
+function zohoRecruitAccountServiceConfigFactory(configService) {
+  return zohoAccountsServiceConfigFromConfigService({
+    configService,
+    serviceAccessTokenKey: ZOHO_RECRUIT_SERVICE_NAME
+  });
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's ZohoRecruitModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function appZohoRecruitModuleMetadata(config) {
+  const {
+    dependencyModule,
+    imports,
+    exports: exports$1,
+    providers
+  } = config;
+  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+  return {
+    imports: [ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+    exports: [ZohoRecruitApi, ...(exports$1 ?? [])],
+    providers: [{
+      provide: ZohoRecruitServiceConfig,
+      inject: [ConfigService],
+      useFactory: zohoRecruitServiceConfigFactory
+    }, ZohoRecruitApi,
+    // Accounts
+    {
+      provide: ZohoAccountsServiceConfig,
+      inject: [ConfigService],
+      useFactory: zohoRecruitAccountServiceConfigFactory
+    }, ZohoAccountsApi, ...(providers ?? [])]
+  };
+}
+
+export { DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH, ZOHO_API_URL_CONFIG_KEY, ZohoAccountsAccessTokenCacheService, ZohoAccountsApi, ZohoAccountsServiceConfig, ZohoRecruitApi, ZohoRecruitServiceConfig, appZohoRecruitModuleMetadata, assertValidZohoConfig, fileZohoAccountsAccessTokenCacheService, logMergeZohoAccountsAccessTokenCacheServiceErrorFunction, memoryZohoAccountsAccessTokenCacheService, mergeZohoAccountsAccessTokenCacheServices, readZohoConfigFromConfigService, zohoAccountsServiceConfigFromConfigService, zohoConfigServiceReaderFunction, zohoRecruitAccountServiceConfigFactory, zohoRecruitServiceConfigFactory };

package/nestjs/package.json

@@ -1,7 +1,23 @@
 {
   "name": "@dereekb/zoho/nestjs",
-  "version": "12.6.21",
-  "type": "commonjs",
+  "version": "13.0.0",
   "types": "./src/index.d.ts",
-  "main": "./src/index.js"
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "node": {
+        "require": "./index.cjs.js"
+      },
+      "browser": {
+        "require": "./index.cjs.js",
+        "import": "./index.esm.js"
+      },
+      "default": "./index.cjs.js"
+    }
+  },
+  "peerDependencies": {
+    "core-js": "^3.0.0"
+  }
 }

package/nestjs/src/lib/accounts/accounts.config.d.ts

@@ -11,5 +11,37 @@ export declare abstract class ZohoAccountsServiceConfig {
     readonly factoryConfig?: ZohoAccountsFactoryConfig;
     static assertValidConfig(config: ZohoAccountsServiceConfig): void;
 }
+/**
+ * Input configuration for {@link zohoAccountsServiceConfigFromConfigService}.
+ *
+ * Requires a NestJS `ConfigService` instance (typically populated from environment variables)
+ * and a `serviceAccessTokenKey` that identifies which Zoho service (e.g. `'crm'` or `'recruit'`)
+ * is being configured. The key is used to derive service-specific environment variable names.
+ */
 export type ZohoAccountsServiceConfigFromConfigServiceInput = ZohoConfigServiceReaderConfig;
+/**
+ * Builds a {@link ZohoAccountsServiceConfig} by reading Zoho Accounts OAuth credentials
+ * from a NestJS `ConfigService` (typically backed by environment variables).
+ *
+ * ## Environment Variable Resolution
+ *
+ * For each credential, the function first looks for a **service-specific** environment variable
+ * (e.g. `ZOHO_CRM_ACCOUNTS_URL`), then falls back to the **shared** variable
+ * (e.g. `ZOHO_ACCOUNTS_URL`). The service prefix is derived from `serviceAccessTokenKey`
+ * uppercased (e.g. `'crm'` → `ZOHO_CRM_`, `'recruit'` → `ZOHO_RECRUIT_`).
+ *
+ * | Credential       | Shared env var                | Service-specific env var (example: CRM)      |
+ * |------------------|-------------------------------|----------------------------------------------|
+ * | Accounts API URL | `ZOHO_ACCOUNTS_URL`           | `ZOHO_CRM_ACCOUNTS_URL`                      |
+ * | Refresh Token    | `ZOHO_ACCOUNTS_REFRESH_TOKEN` | `ZOHO_CRM_ACCOUNTS_REFRESH_TOKEN`            |
+ * | Client ID        | `ZOHO_ACCOUNTS_CLIENT_ID`     | `ZOHO_CRM_ACCOUNTS_CLIENT_ID`                |
+ * | Client Secret    | `ZOHO_ACCOUNTS_CLIENT_SECRET` | `ZOHO_CRM_ACCOUNTS_CLIENT_SECRET`            |
+ *
+ * When using Zoho Recruit, replace `CRM` with `RECRUIT` in the service-specific variable names.
+ *
+ * @param input - The {@link ZohoAccountsServiceConfigFromConfigServiceInput} containing the
+ *   `ConfigService` and the `serviceAccessTokenKey` for the target Zoho service.
+ * @returns A validated {@link ZohoAccountsServiceConfig} ready for use with `ZohoAccountsApi`.
+ * @throws If any required credential (apiUrl, refreshToken, clientId) is missing.
+ */
 export declare function zohoAccountsServiceConfigFromConfigService(input: ZohoAccountsServiceConfigFromConfigServiceInput): ZohoAccountsServiceConfig;