@dereekb/zoho 12.6.21 → 13.0.0

package/nestjs/index.cjs.js

@@ -0,0 +1,598 @@
+'use strict';
+
+var common = require('@nestjs/common');
+var zoho = require('@dereekb/zoho');
+var util = require('@dereekb/util');
+var path = require('path');
+var fs = require('fs');
+var config = require('@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.
+ */
+exports.ZohoAccountsAccessTokenCacheService = class ZohoAccountsAccessTokenCacheService {};
+exports.ZohoAccountsAccessTokenCacheService = __decorate([common.Injectable()], exports.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 = util.tryWithPromiseFactoriesFunction({
+        promiseFactories: accessCachesForServices.map(x => () => x.loadCachedToken().catch(() => null).then(x => {
+          let result = undefined;
+          if (x && !util.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 = util.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 => {
+      fs.mkdirSync(path.dirname(filename), {
+        recursive: true
+      }); // make the directory first
+      fs.readFile(filename, {}, (x, data) => {
+        let result = undefined;
+        if (!x) {
+          try {
+            result = JSON.parse(data.toString());
+            util.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) => {
+      fs.writeFile(filename, JSON.stringify(tokens), {}, x => {
+        if (!x) {
+          resolve();
+        } else {
+          reject(x);
+        }
+      });
+    });
+  }
+  async function deleteTokenFile() {
+    return new Promise((resolve, reject) => {
+      fs.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
+  };
+}
+
+exports.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 = zoho.zohoAccountsFactory(config.factoryConfig ?? {})({
+      accessTokenCache,
+      ...config.zohoAccounts
+    });
+  }
+  // MARK: Accessors
+  get accessToken() {
+    return zoho.zohoAccountsAccessToken(this.accountsContext);
+  }
+};
+exports.ZohoAccountsApi = __decorate([common.Injectable(), __param(0, common.Inject(ZohoAccountsServiceConfig)), __param(1, common.Inject(exports.ZohoAccountsAccessTokenCacheService)), __metadata("design:paramtypes", [ZohoAccountsServiceConfig, exports.ZohoAccountsAccessTokenCacheService])], exports.ZohoAccountsApi);
+
+/**
+ * Configuration for ZohoRecruitService
+ */
+class ZohoRecruitServiceConfig {
+  zohoRecruit;
+  factoryConfig;
+  static assertValidConfig(config) {
+    assertValidZohoConfig(config.zohoRecruit);
+  }
+}
+
+exports.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 = zoho.zohoRecruitFactory({
+      ...config.factoryConfig,
+      accountsContext: zohoAccountsApi.accountsContext
+    })(config.zohoRecruit);
+  }
+  // MARK: Accessors
+  get insertRecord() {
+    return zoho.zohoRecruitInsertRecord(this.recruitContext);
+  }
+  get upsertRecord() {
+    return zoho.zohoRecruitUpsertRecord(this.recruitContext);
+  }
+  get updateRecord() {
+    return zoho.zohoRecruitUpdateRecord(this.recruitContext);
+  }
+  get deleteRecord() {
+    return zoho.zohoRecruitDeleteRecord(this.recruitContext);
+  }
+  get getRecordById() {
+    return zoho.zohoRecruitGetRecordById(this.recruitContext);
+  }
+  get getRecords() {
+    return zoho.zohoRecruitGetRecords(this.recruitContext);
+  }
+  get searchRecords() {
+    return zoho.zohoRecruitSearchRecords(this.recruitContext);
+  }
+  get searchRecordsPageFactory() {
+    return zoho.zohoRecruitSearchRecordsPageFactory(this.recruitContext);
+  }
+  get getRelatedRecordsFunctionFactory() {
+    return zoho.zohoRecruitGetRelatedRecordsFunctionFactory(this.recruitContext);
+  }
+  get getEmailsForRecord() {
+    return zoho.zohoRecruitGetEmailsForRecord(this.recruitContext);
+  }
+  get getEmailsForRecordPageFactory() {
+    return zoho.zohoRecruitGetEmailsForRecordPageFactory(this.recruitContext);
+  }
+  get getAttachmentsForRecord() {
+    return zoho.zohoRecruitGetAttachmentsForRecord(this.recruitContext);
+  }
+  get getAttachmentsForRecordPageFactory() {
+    return zoho.zohoRecruitGetAttachmentsForRecordPageFactory(this.recruitContext);
+  }
+  get uploadAttachmentForRecord() {
+    return zoho.zohoRecruitUploadAttachmentForRecord(this.recruitContext);
+  }
+  get downloadAttachmentForRecord() {
+    return zoho.zohoRecruitDownloadAttachmentForRecord(this.recruitContext);
+  }
+  get deleteAttachmentFromRecord() {
+    return zoho.zohoRecruitDeleteAttachmentFromRecord(this.recruitContext);
+  }
+  get createNotes() {
+    return zoho.zohoRecruitCreateNotes(this.recruitContext);
+  }
+  get deleteNotes() {
+    return zoho.zohoRecruitDeleteNotes(this.recruitContext);
+  }
+  get createNotesForRecord() {
+    return zoho.zohoRecruitCreateNotesForRecord(this.recruitContext);
+  }
+  get getNotesForRecord() {
+    return zoho.zohoRecruitGetNotesForRecord(this.recruitContext);
+  }
+  get getNotesForRecordPageFactory() {
+    return zoho.zohoRecruitGetNotesForRecordPageFactory(this.recruitContext);
+  }
+  get executeRestApiFunction() {
+    return zoho.zohoRecruitExecuteRestApiFunction(this.recruitContext);
+  }
+  get associateCandidateRecordsWithJobOpenings() {
+    return zoho.zohoRecruitAssociateCandidateRecordsWithJobOpenings(this.recruitContext);
+  }
+  get searchCandidateAssociatedJobOpeningRecords() {
+    return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecords(this.recruitContext);
+  }
+  get searchCandidateAssociatedJobOpeningRecordsPageFactory() {
+    return zoho.zohoRecruitSearchCandidateAssociatedJobOpeningRecordsPageFactory(this.recruitContext);
+  }
+  get searchJobOpeningAssociatedCandidateRecords() {
+    return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecords(this.recruitContext);
+  }
+  get searchJobOpeningAssociatedCandidateRecordsPageFactory() {
+    return zoho.zohoRecruitSearchJobOpeningAssociatedCandidateRecordsPageFactory(this.recruitContext);
+  }
+  get createTagsForModule() {
+    return zoho.zohoRecruitCreateTagsForModule(this.recruitContext);
+  }
+  get getTagsForModule() {
+    return zoho.zohoRecruitGetTagsForModule(this.recruitContext);
+  }
+  get addTagsToRecords() {
+    return zoho.zohoRecruitAddTagsToRecords(this.recruitContext);
+  }
+  get removeTagsFromRecords() {
+    return zoho.zohoRecruitRemoveTagsFromRecords(this.recruitContext);
+  }
+};
+exports.ZohoRecruitApi = __decorate([common.Injectable(), __param(0, common.Inject(ZohoRecruitServiceConfig)), __param(1, common.Inject(exports.ZohoAccountsApi)), __metadata("design:paramtypes", [ZohoRecruitServiceConfig, exports.ZohoAccountsApi])], exports.ZohoRecruitApi);
+
+// MARK: Provider Factories
+function zohoRecruitServiceConfigFactory(configService) {
+  const getFromConfigService = zohoConfigServiceReaderFunction(zoho.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.ZOHO_RECRUIT_SERVICE_NAME
+  });
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's ZohoRecruitModule.
+ *
+ * @param provide
+ * @param useFactory
+ * @returns
+ */
+function appZohoRecruitModuleMetadata(config$1) {
+  const {
+    dependencyModule,
+    imports,
+    exports: exports$1,
+    providers
+  } = config$1;
+  const dependencyModuleImport = dependencyModule ? [dependencyModule] : [];
+  return {
+    imports: [config.ConfigModule, ...dependencyModuleImport, ...(imports ?? [])],
+    exports: [exports.ZohoRecruitApi, ...(exports$1 ?? [])],
+    providers: [{
+      provide: ZohoRecruitServiceConfig,
+      inject: [config.ConfigService],
+      useFactory: zohoRecruitServiceConfigFactory
+    }, exports.ZohoRecruitApi,
+    // Accounts
+    {
+      provide: ZohoAccountsServiceConfig,
+      inject: [config.ConfigService],
+      useFactory: zohoRecruitAccountServiceConfigFactory
+    }, exports.ZohoAccountsApi, ...(providers ?? [])]
+  };
+}
+
+exports.DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH = DEFAULT_FILE_ZOHO_ACCOUNTS_ACCESS_TOKEN_CACHE_SERVICE_PATH;
+exports.ZOHO_API_URL_CONFIG_KEY = ZOHO_API_URL_CONFIG_KEY;
+exports.ZohoAccountsServiceConfig = ZohoAccountsServiceConfig;
+exports.ZohoRecruitServiceConfig = ZohoRecruitServiceConfig;
+exports.appZohoRecruitModuleMetadata = appZohoRecruitModuleMetadata;
+exports.assertValidZohoConfig = assertValidZohoConfig;
+exports.fileZohoAccountsAccessTokenCacheService = fileZohoAccountsAccessTokenCacheService;
+exports.logMergeZohoAccountsAccessTokenCacheServiceErrorFunction = logMergeZohoAccountsAccessTokenCacheServiceErrorFunction;
+exports.memoryZohoAccountsAccessTokenCacheService = memoryZohoAccountsAccessTokenCacheService;
+exports.mergeZohoAccountsAccessTokenCacheServices = mergeZohoAccountsAccessTokenCacheServices;
+exports.readZohoConfigFromConfigService = readZohoConfigFromConfigService;
+exports.zohoAccountsServiceConfigFromConfigService = zohoAccountsServiceConfigFromConfigService;
+exports.zohoConfigServiceReaderFunction = zohoConfigServiceReaderFunction;
+exports.zohoRecruitAccountServiceConfigFactory = zohoRecruitAccountServiceConfigFactory;
+exports.zohoRecruitServiceConfigFactory = zohoRecruitServiceConfigFactory;