SK-1372 fix test cases

skyflowapi · Jan 18, 2024 · 9b05e51 · 9b05e51
1 parent 7c0ef2e
commit 9b05e51
Show file tree

Hide file tree

Showing 2 changed files with 114 additions and 16 deletions.
diff --git a/src/core-utils/collect.ts b/src/core-utils/collect.ts
@@ -9,7 +9,7 @@ import SkyflowError from '../libs/skyflow-error';
 import { getAccessToken } from '../utils/bus-events';
 import {
   IInsertRecordInput, IInsertRecord, IValidationRule, ValidationRuleType,
-  MessageType, LogLevel,
+  MessageType, LogLevel, IInsertCollectResponse, IInsertOptions,
 } from '../utils/common';
 import SKYFLOW_ERROR_CODE from '../utils/constants';
 import { printLog } from '../utils/logs-helper';
@@ -33,7 +33,7 @@ export const getUpsertColumn = (tableName: string, options:Array<IUpsertOptions>
 };
 export const constructInsertRecordRequest = (
   records: IInsertRecordInput,
-  options: Record<string, any> = { tokens: true },
+  options: IInsertOptions = { tokens: true, continueOnError: true },
 ) => {
   let requestBody: any = [];
   records.records.forEach((record) => {
@@ -51,13 +51,14 @@ export const constructInsertRecordRequest = (
   return requestBody;
 };
 
-export const constructInsertRecordResponse = (
+export const constructInsertRecordResponseWithoutContinueOnError = (
   responseBody: any,
   options: Record<string, any> = { tokens: true },
   records: IInsertRecord[],
 ) => {
+  let finalResponse: IInsertCollectResponse = {};
   if (options.tokens) {
-    return {
+    finalResponse = {
       records: responseBody.responses
         .map((res, index) => {
           const skyflowId = responseBody.responses[index].records[0].skyflow_id;
@@ -67,16 +68,66 @@ export const constructInsertRecordResponse = (
               skyflow_id: skyflowId,
               ...res.records[0].tokens,
             },
+            request_index: index,
           };
         }),
     };
+  } else {
+    finalResponse = {
+      records: responseBody.responses.map((res, index) => ({
+        table: records[index].table,
+        skyflow_id: responseBody.responses[index].records[0].skyflow_id,
+        request_index: index,
+      })),
+    };
   }
-  return {
-    records: responseBody.responses.map((res, index) => ({
-      table: records[index].table,
-      skyflow_id: res.records[0].skyflow_id,
-    })),
-  };
+  return finalResponse;
+};
+
+export const constructInsertRecordResponseWithContinueOnError = (responseBody: any,
+  options: Record<string, any> = { tokens: true },
+  records: IInsertRecord[]) => {
+  const successRecord:any = [];
+  const failedRecord:any = [];
+  responseBody.responses
+    .forEach((response, index) => {
+      const body = response.Body;
+      const status = response.Status;
+      if ('records' in body) {
+        const record = body.records[0];
+        if (options.tokens) {
+          successRecord.push({
+            table: records[index].table,
+            fields: {
+              skyflow_id: record.skyflow_id,
+              ...record.tokens,
+            },
+            request_index: index,
+          });
+        } else {
+          successRecord.push({
+            table: records[index].table,
+            skyflow_id: record.skyflow_id,
+            request_index: index,
+          });
+        }
+      } else {
+        failedRecord.push({
+          code: status,
+          description: `${body.error} - requestId: ${responseBody.requestId}`,
+          request_index: index,
+        });
+      }
+    });
+  const finalResponse: IInsertCollectResponse = {};
+
+  if (successRecord.length > 0) {
+    finalResponse.records = successRecord;
+  }
+  if (failedRecord.length > 0) {
+    finalResponse.errors = failedRecord;
+  }
+  return finalResponse;
 };
 
 export const constructFinalUpdateRecordResponse = (
@@ -199,6 +250,51 @@ const updateRecordsInVault = (
   });
 };
 
+export const insertDataInCollect = async (
+  records,
+  client: Client,
+  options,
+  finalInsertRecords,
+) => new Promise((rootResolve, rootReject) => {
+  let insertResponse;
+  const clientId = client.toJSON()?.metaData?.uuid || '';
+  getAccessToken(clientId).then((authToken) => {
+    client
+      .request({
+        body: { ...records },
+        requestMethod: 'POST',
+        url: `${client.config.vaultURL}/v1/vaults/${client.config.vaultID}`,
+        headers: {
+          authorization: `Bearer ${authToken}`,
+          'content-type': 'application/json',
+        },
+      })
+      .then((response: any) => {
+        if (!options.continueOnError) {
+          insertResponse = constructInsertRecordResponseWithoutContinueOnError(
+            response,
+            options,
+            finalInsertRecords.records,
+          );
+        } else {
+          insertResponse = constructInsertRecordResponseWithContinueOnError(
+            response,
+            options,
+            finalInsertRecords.records,
+          );
+        }
+        rootResolve(insertResponse);
+      },
+      (rejectedResult) => {
+        rootReject(rejectedResult);
+      }).catch((err) => {
+        rootReject(err);
+      });
+  }).catch((err) => {
+    rootReject(err);
+  });
+});
+
 export const updateRecordsBySkyflowID = async (
   skyflowIdRecords,
   client: Client,

diff --git a/src/core/internal/iframe-form/index.ts b/src/core/internal/iframe-form/index.ts
@@ -46,6 +46,7 @@ import SKYFLOW_ERROR_CODE from '../../../utils/constants';
 import logs from '../../../utils/logs';
 import {
   Context,
+  IInsertCollectResponse,
   IValidationRule,
   LogLevel,
   MessageType,
@@ -1067,33 +1068,34 @@ export class IFrameForm {
       Promise.allSettled(insertPromiseSet).then((resultSet: any) => {
         const recordsResponse: any[] = [];
         const errorsResponse: any[] = [];
-        resultSet.forEach((result: { status: string; value: any; reason?: any; }) => {
+        resultSet.forEach((result:
+        { status: string; value: IInsertCollectResponse; reason?: IInsertCollectResponse; }) => {
           if (result.status === 'fulfilled') {
-            if (result.value.records) {
+            if (result.value.records !== undefined && Array.isArray(result.value.records)) {
               result.value.records.forEach((record) => {
                 recordsResponse.push(record);
               });
             }
-            if (result.value.errors) {
+            if (result.value.errors !== undefined && Array.isArray(result.value.errors)) {
               result.value.errors.forEach((error) => {
                 errorsResponse.push(error);
               });
             }
           } else {
-            if (result.reason.records) {
+            if (result.reason?.records !== undefined && Array.isArray(result.reason?.records)) {
               result.reason.records.forEach((record) => {
                 recordsResponse.push(record);
               });
             }
-            if (result.reason.errors) {
+            if (result.reason?.errors !== undefined && Array.isArray(result.reason?.errors)) {
               result.reason.errors.forEach((error) => {
                 errorsResponse.push(error);
               });
             }
           }
         });
         if (errorsResponse.length === 0) {
-          rootResolve(recordsResponse);
+          rootResolve({ records: recordsResponse });
         } else if (recordsResponse.length === 0) rootReject({ errors: errorsResponse });
         else rootReject({ records: recordsResponse, errors: errorsResponse });
       });