@zauto/api-connector 0.0.1 → 0.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zauto/api-connector",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A NestJS-based API connector for managing integrations.",
   "author": "Saurabh Jain <saurabh@zautoai.com>",
   "license": "MIT",

package/src/index.ts

@@ -489,9 +489,13 @@ export async function callApiWithMapping(
  * @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>) {
+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 },
     });
@@ -501,45 +505,78 @@ export async function executeDynamicFunction(prisma: PrismaClient, orgId: string
     }
 
     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.`);
+    for (const stepKey of Object.keys(logic)) {
+      const step = logic[stepKey];
+      const {
+        apiId,
+        requestMapping,
+        responseMapping,
+        queryParamsMapping,
+        pathParamsMapping,
+        condition,
+        loopUntil,
+        onFailure,
+        maxIterations,
+      } = step;
+
+      // Evaluate the condition, if provided
+      if (condition && !evaluateCondition(condition, currentData)) {
+        console.warn(`Condition failed for step ${stepKey}.`);
+        if (onFailure === 'exit') {
+          console.warn(`Exiting execution due to failure in step ${stepKey}.`);
+          return currentData; // Return current data if exiting
+        }
+        continue; // Skip to the next step if onFailure is "continue"
       }
 
-      const suburl = substitutePathParams(endpoint.suburl, currentData, pathParamsMapping);
+      console.log(`Executing step ${stepKey}...`);
+      let iterations = 0;
+
+      // Execute the step in a loop if `loopUntil` is specified
+      do {
+        if (maxIterations && iterations >= maxIterations) {
+          console.warn(`Max iterations reached for step ${stepKey}.`);
+          break;
+        }
+        iterations++;
+        const requestData = mapData(currentData, requestMapping);
+        const endpoint = await prisma.endpointConfig.findUnique({ where: { id: apiId } });
 
-      console.log(`Substituted URL: ${suburl}`);
+        if (!endpoint) {
+          throw new Error(`Endpoint with ID ${apiId} not found.`);
+        }
 
-      const mappedQueryParams = mapData(currentData, queryParamsMapping, true);
+        const suburl = substitutePathParams(endpoint.suburl, currentData, pathParamsMapping);
+        const mappedQueryParams = mapData(currentData, queryParamsMapping, true);
 
-      console.log(`Mapped Query Params: ${JSON.stringify(mappedQueryParams)}`);
+        try {
+          const apiResponse = await callApiWithMapping(prisma, apiId, requestData, mappedQueryParams, null, suburl);
+          const newData = mapData(apiResponse, responseMapping);
+          currentData = { ...currentData, ...newData };
 
-      const apiResponse = await callApiWithMapping(prisma, apiId, requestData, mappedQueryParams, null, suburl);
-      console.log(`API Response: ${JSON.stringify(apiResponse)}`);
+          // Log the loop status
+          console.log(`Step ${stepKey} loop iteration completed.`);
 
-      const newData = mapData(apiResponse, responseMapping);
-      currentData = { ...currentData, ...newData }
+          // Break the loop if `loopUntil` evaluates to true
+          if (loopUntil && evaluateCondition(loopUntil, currentData)) {
+            console.log(`LoopUntil condition met for step ${stepKey}, exiting loop.`);
+            break;
+          }
+        } catch (error) {
+          console.error(`API call failed for step ${stepKey}:`, error);
+          if (onFailure === 'exit') {
+            console.warn(`Exiting execution due to API call failure in step ${stepKey}.`);
+            throw new Error(`Execution stopped at step ${stepKey}.`);
+          }
+          console.warn(`Continuing to next step after failure in step ${stepKey}.`);
+          break; // Exit loop on failure
+        }
+      } while (loopUntil && !evaluateCondition(loopUntil, currentData));
     }
 
-    return currentData;
+    return currentData; // Final data after executing all steps
   } catch (error) {
     console.error('Error executing dynamic function:', error);
     throw new Error(`Failed to execute function "${functionName}".`);
@@ -590,67 +627,40 @@ function mapData(data: any, mapping: Record<string, any>, isQueryParams: boolean
 
   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') {
+function evaluateExpression(template: string, data: Record<string, any>): any {
+  // Remove surrounding {} if present
+  const cleanTemplate = template.replace(/^\{|\}$/g, '');
+
+  // Check for method chaining
+  const parts = cleanTemplate.split('.');
+  let value = getNestedValue(data, parts[0]);
+
+  // Apply method chain
+  for (let i = 1; i < parts.length; i++) {
+    const methodMatch = parts[i].match(/(\w+)\(([^)]*)\)/);
+    if (methodMatch) {
+      const method = methodMatch[1];
+      const args = methodMatch[2] ? parseFunctionArgs(methodMatch[2]) : [];
+
+      switch (method) {
+        case 'split':
+          value = value.split(args[0] || ' ');
+          break;
+        case 'slice':
+          value = value.slice(args[0], args[1]);
+          break;
+        case 'join':
+          value = value.join(args[0] || '');
+          break;
+        case 'toLowerCase':
           value = value.toLowerCase();
-        }
-        break;
-      case 'touppercase':
-        if (typeof value === 'string') {
+          break;
+        case 'toUpperCase':
           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;
+          break;
+      }
     }
   }
 
@@ -679,35 +689,29 @@ function parseFunctionArgs(argString: string): any[] {
   });
 }
 
-
 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 : '';
+  if (/^\{[^}]+\}$/.test(template)) {
+    return evaluateExpression(template, data);
+  }
+  return template.replace(/\{[^}]+\}/g, (match) => {
+    try {
+      const evaluated = evaluateExpression(match, data);
+      return evaluated?.toString ? evaluated.toString() : '';
+    } catch (error) {
+      console.warn(`Error evaluating ${match}:`, error);
+      return match;
+    }
   });
 }
 
-/**
- * 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);
@@ -729,7 +733,7 @@ function mapObject(obj: Record<string, any>, mapping: Record<string, any>): Reco
         }
       });
     } 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') {
@@ -761,28 +765,22 @@ function handleArrayShortcut(
   const templateParts = entryTemplate.split(',');
   const entry: Record<string, any> = {};
 
-  templateParts.forEach(part => {
+  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);
-  }
+  // Simply push the new entry every time, no uniqueness check:
+  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:
@@ -812,13 +810,6 @@ function getAuthHeaders(apiConfig: any): Record<string, string> {
   }
 }
 
-/**
- * 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>,
@@ -846,5 +837,27 @@ function applyResponseMapping(
   }
 }
 
+/**
+ * Evaluates a condition dynamically.
+ *
+ * @param condition - A string representing the condition (e.g., "{id} !== null").
+ * @param data - The data context for evaluating the condition.
+ * @returns A boolean indicating whether the condition is met.
+ */
+function evaluateCondition(condition: string, data: Record<string, any>): boolean {
+  try {
+    const evaluatedCondition = condition.replace(/\{([^}]+)\}/g, (_, field) => {
+      const value = getNestedValue(data, field);
+      return JSON.stringify(value); // Safely inject values into the expression
+    });
+
+    return eval(evaluatedCondition); // Evaluate the resulting condition expression
+  } catch (error) {
+    console.error('Error evaluating condition:', error);
+    return false; // Default to false if condition evaluation fails
+  }
+}
+
+
 export { ApiConfigDto } from './dto/api-config.dto';
 export { AuthType } from './dto/api-config.dto';