@zauto/api-connector 0.0.1

package/src/index.ts

@@ -0,0 +1,850 @@
+import { PrismaClient } from '@prisma/client';
+import { ApiConfigDto, AuthType } from './dto/api-config.dto';
+import { EndpointConfigDto } from './dto/endpoint-config.dto';
+import { FieldMappingDto } from './dto/field-mapping.dto';
+import axios, { AxiosRequestConfig } from 'axios';
+
+/**
+ * Saves or updates API configuration in the database.
+ * 
+ * @param prisma - PrismaClient instance
+ * @param apiConfig - API configuration object of type ApiConfigDto
+ * @param additionalParams - Additional fields to include in the database (e.g., orgId)
+ * @param searchCriteria - Optional search criteria for finding an existing record
+ * @returns A promise that resolves to the stored or updated configuration
+ */
+export async function saveApiConfig(
+  prisma: PrismaClient,
+  apiConfig: ApiConfigDto,
+  additionalParams: Record<string, any> = {},
+  searchCriteria: Record<string, any> = {},
+) {
+  try {
+
+    const existingConfig = await prisma.apiConfig.findFirst({
+      where: searchCriteria,
+    });
+
+    if (existingConfig) {
+
+      const updatedConfig = await prisma.apiConfig.update({
+        where: { id: existingConfig.id },
+        data: {
+          baseUrl: apiConfig.baseUrl,
+          authType: apiConfig.authType,
+          infoForAuthType: apiConfig.infoForAuthType
+            ? JSON.stringify(apiConfig.infoForAuthType)
+            : '{}',
+          timeout: apiConfig.timeout || null,
+          retryPolicy: apiConfig.retryPolicy
+            ? JSON.stringify(apiConfig.retryPolicy)
+            : '{}',
+          ...additionalParams,
+        },
+      });
+
+      return {
+        operation: 'updated',
+        config: updatedConfig,
+      };
+    } else {
+
+      const createdConfig = await prisma.apiConfig.create({
+        data: {
+          baseUrl: apiConfig.baseUrl,
+          authType: apiConfig.authType,
+          infoForAuthType: typeof apiConfig.infoForAuthType === 'string'
+            ? apiConfig.infoForAuthType
+            : JSON.stringify(apiConfig.infoForAuthType || '{}'),
+          timeout: apiConfig.timeout || null,
+          retryPolicy: apiConfig.retryPolicy
+            ? JSON.stringify(apiConfig.retryPolicy)
+            : '{}',
+          ...additionalParams,
+        },
+      });
+
+      return {
+        operation: 'created',
+        config: createdConfig,
+      };
+    }
+  } catch (error) {
+    console.error('Error saving or updating API configuration:', error);
+    throw new Error('Failed to save or update API configuration');
+  }
+}
+
+/**
+ * Updates an existing API configuration in the database.
+ * 
+ * @param prisma - PrismaClient instance
+ * @param updateData - Data to update (fields in ApiConfigDto or additional fields)
+ * @param searchCriteria - Criteria to find the record to update
+ * @returns A promise that resolves to the updated configuration, or throws an error if not found
+ */
+export async function updateApiConfig(
+  prisma: PrismaClient,
+  updateData: Partial<ApiConfigDto> & Record<string, any>,
+  searchCriteria: Record<string, any>,
+) {
+  try {
+
+    const existingConfig = await prisma.apiConfig.findFirst({
+      where: searchCriteria,
+    });
+
+    if (!existingConfig) {
+      throw new Error('API configuration not found for the given criteria.');
+    }
+
+    const updatedConfig = await prisma.apiConfig.update({
+      where: { id: existingConfig.id },
+      data: {
+        ...updateData,
+        infoForAuthType: typeof updateData.infoForAuthType === 'string' ? updateData.infoForAuthType : updateData.infoForAuthType
+          ? JSON.stringify(updateData.infoForAuthType)
+          : undefined,
+        retryPolicy: updateData.retryPolicy
+          ? JSON.stringify(updateData.retryPolicy)
+          : undefined,
+      },
+    });
+
+    return updatedConfig;
+  } catch (error) {
+    console.error('Error updating API configuration:', error);
+    throw new Error('Failed to update API configuration');
+  }
+}
+
+/**
+ * Saves an endpoint configuration linked to a specific API configuration.
+ * 
+ * @param prisma - PrismaClient instance
+ * @param endpointConfig - Endpoint configuration object
+ * @returns A promise that resolves to the stored configuration
+ */
+export async function saveEndpointConfig(
+  prisma: PrismaClient,
+  endpointConfig: EndpointConfigDto,
+) {
+  try {
+
+    const apiConfig = await prisma.apiConfig.findFirst({
+      where: { id: endpointConfig.apiConfigId },
+    });
+
+    if (!apiConfig) {
+      throw new Error(`API Configuration with ID ${endpointConfig.apiConfigId} not found.`);
+    }
+
+    const existingConfig = await prisma.endpointConfig.findFirst({
+      where: { name: endpointConfig.name, apiConfigId: apiConfig.id },
+    });
+
+    if (existingConfig) {
+
+      return {
+        message: "An endpoint with the same name already exists for this API configuration",
+        config: existingConfig
+      };
+    } else {
+
+      const createdConfig = await prisma.endpointConfig.create({
+        data: {
+          name: endpointConfig.name,
+          method: endpointConfig.method,
+          suburl: endpointConfig.suburl,
+          headers: endpointConfig.headers || {},
+          apiConfigId: endpointConfig.apiConfigId,
+        },
+      });
+      return {
+        operation: 'created',
+        config: createdConfig,
+      };
+    }
+  } catch (error) {
+    console.error('Error saving endpoint configuration:', error);
+    throw new Error('Failed to save endpoint configuration');
+  }
+}
+
+/**
+ * Updates an existing endpoint configuration.
+ *
+ * @param prisma - PrismaClient instance
+ * @param endpointId - ID of the endpoint configuration to update
+ * @param updateData - Partial data to update (fields in EndpointConfigDto)
+ * @returns A promise that resolves to the updated endpoint configuration
+ */
+export async function updateEndpointConfig(
+  prisma: PrismaClient,
+  endpointId: string,
+  updateData: Partial<EndpointConfigDto>,
+) {
+  try {
+
+    const existingEndpoint = await prisma.endpointConfig.findUnique({
+      where: { id: endpointId },
+    });
+
+    if (!existingEndpoint) {
+      throw new Error('Endpoint configuration not found for the given ID.');
+    }
+
+    if (updateData.name && updateData.name !== existingEndpoint.name) {
+      const conflict = await prisma.endpointConfig.findFirst({
+        where: {
+          name: updateData.name,
+          apiConfigId: existingEndpoint.apiConfigId,
+        },
+      });
+      if (conflict) {
+        throw new Error(
+          `Endpoint with the name "${updateData.name}" already exists for this API configuration.`,
+        );
+      }
+    }
+
+    const updatedEndpoint = await prisma.endpointConfig.update({
+      where: { id: endpointId },
+      data: {
+        name: updateData.name ?? existingEndpoint.name,
+        method: updateData.method ?? existingEndpoint.method,
+        suburl: updateData.suburl ?? existingEndpoint.suburl,
+        headers: updateData.headers ?? existingEndpoint.headers,
+      },
+    });
+
+    return {
+      operation: 'updated',
+      config: updatedEndpoint,
+    };
+  } catch (error) {
+    console.error('Error updating endpoint configuration:', error);
+    throw new Error('Failed to update endpoint configuration');
+  }
+}
+
+/**
+ * Saves a field mapping configuration associated with an endpoint.
+ * 
+ * @param prisma - PrismaClient instance
+ * @param fieldMapping - Field mapping configuration object
+ * @returns A promise that resolves to the stored configuration
+ */
+export async function saveFieldMapping(
+  prisma: PrismaClient,
+  fieldMapping: FieldMappingDto,
+) {
+  try {
+
+    const endpoint = await prisma.endpointConfig.findFirst({
+      where: { id: fieldMapping.endpointId },
+    });
+
+    if (!endpoint) {
+      throw new Error(`Endpoint with ID ${fieldMapping.endpointId} not found.`);
+    }
+
+    const existingMapping = await prisma.fieldMapping.findFirst({
+      where: {
+        resourceType: fieldMapping.resourceType,
+        endpointId: fieldMapping.endpointId,
+      },
+    });
+
+    if (existingMapping) {
+
+      return {
+        message: "Field mapping already exists for this resource and endpoint"
+      };
+    } else {
+
+      const createdMapping = await prisma.fieldMapping.create({
+        data: {
+          resourceType: fieldMapping.resourceType,
+          requestMapping: fieldMapping.requestMapping,
+          responseMapping: fieldMapping.responseMapping,
+          endpointId: fieldMapping.endpointId,
+        },
+      });
+      return {
+        operation: 'created',
+        mapping: createdMapping,
+      };
+    }
+  } catch (error) {
+    console.error('Error saving field mapping:', error);
+    throw new Error('Failed to save field mapping');
+  }
+}
+
+/**
+ * Updates an existing field mapping configuration associated with an endpoint.
+ *
+ * @param prisma - PrismaClient instance
+ * @param fieldMappingId - ID of the field mapping configuration to update
+ * @param updateData - Partial data to update (fields in FieldMappingDto)
+ * @returns A promise that resolves to the updated mapping configuration
+ */
+export async function updateFieldMapping(
+  prisma: PrismaClient,
+  fieldMappingId: string,
+  updateData: Partial<FieldMappingDto>,
+) {
+  try {
+
+    const existingMapping = await prisma.fieldMapping.findUnique({
+      where: { id: fieldMappingId },
+    });
+
+    if (!existingMapping) {
+      throw new Error(`Field mapping not found for the given ID: ${fieldMappingId}`);
+    }
+
+    if (updateData.endpointId && updateData.endpointId !== existingMapping.endpointId) {
+      const endpoint = await prisma.endpointConfig.findUnique({
+        where: { id: updateData.endpointId },
+      });
+      if (!endpoint) {
+        throw new Error(`Endpoint with ID ${updateData.endpointId} not found.`);
+      }
+    }
+
+    if (
+      updateData.resourceType &&
+      updateData.resourceType !== existingMapping.resourceType &&
+      (updateData.endpointId ?? existingMapping.endpointId)
+    ) {
+      const conflict = await prisma.fieldMapping.findFirst({
+        where: {
+          resourceType: updateData.resourceType,
+          endpointId: updateData.endpointId ?? existingMapping.endpointId,
+        },
+      });
+      if (conflict) {
+        throw new Error(
+          `Field mapping already exists for resource "${updateData.resourceType}" on endpoint ID ${updateData.endpointId ?? existingMapping.endpointId
+          }.`,
+        );
+      }
+    }
+
+    const updatedMapping = await prisma.fieldMapping.update({
+      where: { id: fieldMappingId },
+      data: {
+        resourceType: updateData.resourceType ?? existingMapping.resourceType,
+        requestMapping: updateData.requestMapping ?? existingMapping.requestMapping,
+        responseMapping: updateData.responseMapping ?? existingMapping.responseMapping,
+        endpointId: updateData.endpointId ?? existingMapping.endpointId,
+      },
+    });
+
+    return {
+      operation: 'updated',
+      mapping: updatedMapping,
+    };
+  } catch (error) {
+    console.error('Error updating field mapping:', error);
+    throw new Error('Failed to update field mapping');
+  }
+}
+
+/**
+ * Calls an API by endpoint ID, applying field mappings dynamically for request body, query params, response, and authentication.
+ * 
+ * @param prisma - PrismaClient instance
+ * @param endpointId - The ID of the endpoint to call
+ * @param data - Data to send in the API request (local fields)
+ * @returns The API response with fields mapped back to local format
+ */
+export async function callApiWithMapping(
+  prisma: PrismaClient,
+  endpointId: string,
+  data?: Record<string, any>,
+  queryParams?: Record<string, any>,
+  pathParams?: string,
+  subUrl?: string
+) {
+  try {
+
+    const endpoint = await prisma.endpointConfig.findFirst({
+      where: { id: endpointId },
+      include: { apiConfig: true },
+    });
+
+    if (!endpoint) {
+      throw new Error(`Endpoint with ID ${endpointId} not found.`);
+    }
+
+    const { apiConfig } = endpoint;
+    if (!apiConfig) {
+      throw new Error(`Top-level API configuration not found for endpoint ID ${endpointId}.`);
+    }
+
+    const fieldMapping = await prisma.fieldMapping.findFirst({
+      where: { endpointId },
+    });
+
+    const mappedRequestData = fieldMapping?.requestMapping
+      ? Object.entries(fieldMapping.requestMapping as Record<string, string>).reduce(
+        (acc, [localField, apiField]) => {
+          if (data[localField] !== undefined) {
+            acc[apiField] = data[localField];
+          }
+          return acc;
+        },
+        {} as Record<string, any>,
+      )
+      : data;
+
+    const mappedQueryParams = fieldMapping?.requestMapping
+      ? Object.entries(fieldMapping.requestMapping as Record<string, string>).reduce(
+        (acc, [localField, apiField]) => {
+          if (queryParams[localField] !== undefined) {
+            acc[apiField] = queryParams[localField];
+          }
+          return acc;
+        },
+        {} as Record<string, any>,
+      )
+      : queryParams;
+
+    const authHeaders = getAuthHeaders(apiConfig);
+
+    let url = apiConfig.baseUrl
+    if (subUrl) {
+      url = url + subUrl
+    } else {
+      url = url + endpoint.suburl
+    }
+
+    let config: AxiosRequestConfig = {
+      method: endpoint.method as AxiosRequestConfig['method'],
+      url,
+      headers: {
+        ...endpoint.headers,
+        ...authHeaders,
+      },
+      params: mappedQueryParams,
+      data: mappedRequestData,
+    };
+
+    if (pathParams) {
+      config.url = config.url + "/" + pathParams;
+    }
+
+    if (apiConfig.timeout) {
+      config.timeout = apiConfig.timeout;
+    }
+    const maxRetries = apiConfig.retryPolicy?.maxRetries || 0;
+    const retryDelayMs = apiConfig.retryPolicy?.retryDelayMs || 1000;
+
+    let attempt = 0;
+    console.log(config);
+
+    while (attempt <= maxRetries) {
+      try {
+
+        const response = await axios(config);
+
+        const mappedResponseData = fieldMapping?.responseMapping
+          ? applyResponseMapping(response.data, fieldMapping.responseMapping)
+          : response.data;
+
+        return mappedResponseData;
+      } catch (error: any) {
+        attempt++;
+
+        const retryOnStatusCodes = apiConfig.retryPolicy?.retryOnStatusCodes || [];
+        const shouldRetry =
+          retryOnStatusCodes.length === 0 ||
+          retryOnStatusCodes.includes(String(error.response?.status)) ||
+          !error.response;
+
+        if (attempt <= maxRetries && shouldRetry) {
+          console.warn(
+            `Retrying request... Attempt ${attempt} of ${maxRetries}. Waiting ${retryDelayMs}ms.`,
+          );
+          await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+        } else {
+          console.error('Error calling API:', error);
+          throw new Error('Failed to call API with mapping');
+        }
+      }
+    }
+  } catch (error) {
+    console.error('Error calling API:', error);
+    throw new Error('Failed to call API with mapping');
+  }
+}
+
+/**
+ * Executes a dynamic function based on its configuration.
+ * 
+ * @param functionName - Name of the function to execute
+ * @param input - Input data for the function
+ * @returns The final output of the function
+ */
+export async function executeDynamicFunction(prisma: PrismaClient, orgId: string, functionName: string, input: Record<string, any>) {
+  try {
+
+    const functionConfig = await prisma.functionConfig.findFirst({
+      where: { name: functionName, orgId },
+    });
+
+    if (!functionConfig) {
+      throw new Error(`Function with name "${functionName}" not found.`);
+    }
+
+    const { logic } = functionConfig;
+
+    let currentData = input;
+
+    for (const step of Object.values(logic) as any[]) {
+      const { apiId, requestMapping, responseMapping, queryParamsMapping, pathParamsMapping } = step;
+
+      console.log(`currentData: ${JSON.stringify(currentData)}`);
+      console.log(`Request Mapping: ${JSON.stringify(requestMapping)}`);
+      console.log(`Response Mapping: ${JSON.stringify(responseMapping)}`);
+      console.log(`Query Params Mapping: ${JSON.stringify(queryParamsMapping)}`);
+      console.log(`Path Params Mapping: ${JSON.stringify(pathParamsMapping)}`);
+
+      const requestData = mapData(currentData, requestMapping);
+      console.log(`Request Data: ${JSON.stringify(requestData)}`);
+
+      const endpoint = await prisma.endpointConfig.findUnique({
+        where: { id: apiId },
+      });
+
+      if (!endpoint) {
+        throw new Error(`Endpoint with ID ${apiId} not found.`);
+      }
+
+      const suburl = substitutePathParams(endpoint.suburl, currentData, pathParamsMapping);
+
+      console.log(`Substituted URL: ${suburl}`);
+
+      const mappedQueryParams = mapData(currentData, queryParamsMapping, true);
+
+      console.log(`Mapped Query Params: ${JSON.stringify(mappedQueryParams)}`);
+
+      const apiResponse = await callApiWithMapping(prisma, apiId, requestData, mappedQueryParams, null, suburl);
+      console.log(`API Response: ${JSON.stringify(apiResponse)}`);
+
+      const newData = mapData(apiResponse, responseMapping);
+      currentData = { ...currentData, ...newData }
+    }
+
+    return currentData;
+  } catch (error) {
+    console.error('Error executing dynamic function:', error);
+    throw new Error(`Failed to execute function "${functionName}".`);
+  }
+}
+
+/**
+ * Substitutes path parameters in the URL using the provided mapping and data.
+ * 
+ * @param url - The URL with placeholders
+ * @param data - The data to use for substitution
+ * @param pathParamsMapping - Mapping of placeholders to data fields
+ * @returns The URL with substituted path parameters
+ */
+function substitutePathParams(
+  url: string,
+  data: Record<string, any>,
+  pathParamsMapping: Record<string, string>,
+): string {
+  if (!pathParamsMapping) return url
+  return Object.entries(pathParamsMapping).reduce((updatedUrl, [placeholder, field]) => {
+    const value = data[field];
+    if (!value) {
+      throw new Error(`Missing value for path parameter "${placeholder}"`);
+    }
+    return updatedUrl.replace(`:${placeholder}`, value);
+  }, url);
+}
+
+/**
+ * Maps data based on a given mapping configuration.
+ * 
+ * @param data - The input data
+ * @param mapping - The mapping configuration
+ * @returns The mapped data
+ */
+function mapData(data: any, mapping: Record<string, any>, isQueryParams: boolean = false): any {
+  if (!mapping || typeof data !== 'object' || data === null) {
+    if (isQueryParams) {
+      return {};
+    }
+    return data;
+  }
+
+  if (Array.isArray(data)) {
+    return data.map((item) => mapObject(item, mapping));
+  }
+
+  return mapObject(data, mapping);
+}
+function evaluateExpression(template: string, data: Record<string, any>): any {
+  const expressionRegex = /\{([^}]+)\}((?:\.[a-zA-Z]+\([^)]*\))*)/;
+  const match = template.match(expressionRegex);
+
+  if (!match) {
+    return template.replace(/\{([^}]+)\}/g, (_, path) => {
+      // Handle nested paths (e.g., "address.line1")
+      return getNestedValue(data, path) ?? '';
+    });
+  }
+
+  const fieldPath = match[1];
+  const functionChain = match[2];
+  let value = getNestedValue(data, fieldPath);
+
+  if (!functionChain) return value;
+
+  const functionCallRegex = /\.([a-zA-Z]+)\(([^)]*)\)/g;
+  let fnMatch;
+
+  while ((fnMatch = functionCallRegex.exec(functionChain)) !== null) {
+    const fnName = fnMatch[1];
+    const fnArgs = fnMatch[2];
+
+    const args = parseFunctionArgs(fnArgs);
+
+    switch (fnName.toLowerCase()) {
+      case 'tolowercase':
+        if (typeof value === 'string') {
+          value = value.toLowerCase();
+        }
+        break;
+      case 'touppercase':
+        if (typeof value === 'string') {
+          value = value.toUpperCase();
+        }
+        break;
+      case 'split':
+        if (typeof value === 'string') {
+
+          const delimiter = args[0] ?? '';
+          value = value.split(delimiter);
+        }
+        break;
+      case 'slice':
+        if (typeof value === 'string' || Array.isArray(value)) {
+          const start = args[0] !== undefined ? args[0] : 0;
+          const end = args[1] !== undefined ? args[1] : undefined;
+          value = value.slice(start, end);
+        }
+        break;
+      case 'join':
+        if (Array.isArray(value)) {
+          const delimiter = args[0] || '';
+          value = value.join(delimiter);
+        }
+        break;
+      default:
+
+        console.warn(`Unrecognized function: ${fnName}`);
+        break;
+    }
+  }
+
+  return value;
+}
+
+function parseFunctionArgs(argString: string): any[] {
+  if (!argString.trim()) return [];
+
+  return argString.split(',').map((arg) => {
+    arg = arg.trim();
+
+    if (
+      (arg.startsWith("'") && arg.endsWith("'")) ||
+      (arg.startsWith('"') && arg.endsWith('"'))
+    ) {
+      return arg.slice(1, -1);
+    }
+
+    const num = Number(arg);
+    if (!isNaN(num)) {
+      return num;
+    }
+
+    return arg;
+  });
+}
+
+
+function replaceValue(template: string, data: any): any {
+  if (!template.includes('{')) {
+    return template;
+  }
+
+  return template.replace(/\{([^}]+)\}/g, (match, field) => {
+    const value = data[field];
+    return value !== undefined ? value : '';
+  });
+}
+
+/**
+ * Maps an object's fields based on a mapping configuration.
+ * 
+ * @param obj - The input object
+ * @param mapping - The mapping configuration
+ * @returns The mapped object
+ */
+function mapObject(obj: Record<string, any>, mapping: Record<string, any>): Record<string, any> {
+  const result: Record<string, any> = {};
+
+  if (mapping.resourceType) {
+    result.resourceType = mapping.resourceType;
+  }
+
+  for (const [mappingKey, mappingValue] of Object.entries(mapping)) {
+    if (mappingKey === 'resourceType') continue;
+
+    if (typeof mappingValue === 'string') {
+      if (mappingValue.includes('[?]')) {
+        handleArrayShortcut(result, obj, mappingValue, mappingKey);
+      } else {
+        result[mappingKey] = replaceValue(mappingValue, obj);
+      }
+    } else if (Array.isArray(mappingValue)) {
+      result[mappingKey] = mappingValue.map((element) => {
+        if (typeof element === 'string') {
+          return replaceValue(element, obj);
+        } else if (Array.isArray(element)) {
+          return element.map((sub) =>
+            typeof sub === 'string' ? replaceValue(sub, obj) : sub
+          );
+        } else if (typeof element === 'object' && element !== null) {
+          return mapObject(obj, element);
+        } else {
+          return element;
+        }
+      });
+    } else if (typeof mappingValue === 'object' && mappingValue !== null) {
+      // For nested objects, process each field with the original data
+      const nestedResult: Record<string, any> = {};
+      for (const [nestedKey, nestedValue] of Object.entries(mappingValue)) {
+        if (typeof nestedValue === 'string') {
+          nestedResult[nestedKey] = replaceValue(nestedValue, obj);
+        } else {
+          nestedResult[nestedKey] = mapObject(obj, nestedValue);
+        }
+      }
+      result[mappingKey] = nestedResult;
+    } else {
+      result[mappingKey] = obj[mappingKey];
+    }
+  }
+
+  return result;
+}
+
+function handleArrayShortcut(
+  resultObj: Record<string, any>,
+  sourceObj: Record<string, any>,
+  mappingValue: string,
+  mappingKey: string,
+): void {
+  const [arrayField, entryTemplate] = mappingValue.split('[?].');
+  if (!resultObj[arrayField]) {
+    resultObj[arrayField] = [];
+  }
+
+  const templateParts = entryTemplate.split(',');
+  const entry: Record<string, any> = {};
+
+  templateParts.forEach(part => {
+    const [field, valueTemplate] = part.split('=');
+    const fieldValue = replaceValue(valueTemplate, sourceObj);
+    entry[field] = fieldValue;
+  });
+
+  const existingIndex = resultObj[arrayField].findIndex((e: any) => e.system === entry.system);
+  if (existingIndex === -1) {
+    resultObj[arrayField].push(entry);
+  }
+}
+function getNestedValue(obj: Record<string, any>, path: string): any {
+  return path.split('.').reduce((current, part) => {
+    return current?.[part];
+  }, obj);
+}
+/**
+ * Prepares authentication headers based on the top-level API configuration.
+ * 
+ * @param apiConfig - The top-level API configuration
+ * @returns A Record of authentication headers
+ */
+function getAuthHeaders(apiConfig: any): Record<string, string> {
+  switch (apiConfig.authType) {
+    case AuthType.BASIC:
+      if (!apiConfig.infoForAuthType?.username || !apiConfig.infoForAuthType?.password) {
+        throw new Error('Missing credentials for BASIC auth.');
+      }
+      const credentials = Buffer.from(
+        `${apiConfig.infoForAuthType.username}:${apiConfig.infoForAuthType.password}`,
+      ).toString('base64');
+      return { Authorization: `Basic ${credentials}` };
+
+    case AuthType.BEARER:
+      if (!apiConfig.infoForAuthType?.token) {
+        throw new Error('Missing token for BEARER auth.');
+      }
+      return { Authorization: `Bearer ${apiConfig.infoForAuthType.token}` };
+
+    case AuthType.API_KEY:
+      if (!apiConfig.infoForAuthType?.apiKeyHeader || !apiConfig.infoForAuthType?.apiKey) {
+        throw new Error('Missing API key information.');
+      }
+      return { [apiConfig.infoForAuthType.apiKeyHeader]: apiConfig.infoForAuthType.apiKey };
+
+    case AuthType.NONE:
+    default:
+      return {};
+  }
+}
+
+/**
+ * Recursively applies the response mapping to handle nested structures.
+ * 
+ * @param response - The API response data
+ * @param responseMapping - The field mapping configuration
+ * @returns The mapped response
+ */
+function applyResponseMapping(
+  response: any,
+  responseMapping: Record<string, any>,
+): any {
+  if (Array.isArray(response)) {
+
+    return response.map((item) => applyResponseMapping(item, responseMapping));
+  } else if (typeof response === 'object' && response !== null) {
+
+    return Object.entries(responseMapping).reduce((mappedObject, [apiField, localField]) => {
+      if (response[apiField] !== undefined) {
+        if (typeof localField === 'string') {
+
+          mappedObject[localField] = response[apiField];
+        } else if (typeof localField === 'object') {
+
+          mappedObject[localField] = applyResponseMapping(response[apiField], localField);
+        }
+      }
+      return mappedObject;
+    }, {} as Record<string, any>);
+  } else {
+
+    return response;
+  }
+}
+
+export { ApiConfigDto } from './dto/api-config.dto';
+export { AuthType } from './dto/api-config.dto';