Release/25.11.3.1

package.json

@@ -2,7 +2,7 @@
   "name": "skyflow-js",
   "preferGlobal": true,
   "analyze": false,
-  "version": "2.5.0",
+  "version": "2.5.0-dev.641a405",
   "author": "Skyflow",
   "description": "Skyflow JavaScript SDK",
   "homepage": "https://github.com/skyflowapi/skyflow-js",

src/core-utils/collect.ts

@@ -242,7 +242,7 @@ const updateRecordsInVault = (
   options,
 ) => {
   const table = skyflowIdRecord.fields.table;
-  const skyflowID = skyflowIdRecord.skyflowID;
+  const skyflowID = skyflowIdRecord?.skyflowID;
   skyflowIdRecord.fields = omit(skyflowIdRecord.fields, 'table');
   skyflowIdRecord.fields = omit(skyflowIdRecord.fields, 'skyflowID');
   return client.request({
@@ -316,6 +316,151 @@ export const updateRecordsBySkyflowID = async (
   });
 });
 
+export const updateRecordsBySkyflowIDComposable = async (
+  skyflowIdRecords,
+  client: Client,
+  options,
+  authToken: string,
+) => new Promise((rootResolve, rootReject) => {
+  let updateResponseSet: Promise<any>[];
+  // eslint-disable-next-line prefer-const
+  updateResponseSet = skyflowIdRecords?.updateRecords?.map(
+    (skyflowIdRecord: IInsertRecord) => new Promise((resolve, reject) => {
+      updateRecordsInVault(skyflowIdRecord, client, authToken, options)
+        ?.then((resolvedResult: any) => {
+          const resp = constructFinalUpdateRecordResponse(
+            resolvedResult,
+            options?.tokens,
+            skyflowIdRecord,
+          );
+          resolve(resp);
+        },
+        (rejectedResult) => {
+          let errorResponse = rejectedResult;
+          if (rejectedResult?.error) {
+            errorResponse = {
+              error: {
+                code: rejectedResult?.error?.code,
+                description: rejectedResult?.error?.description,
+              },
+            };
+          }
+          printLog(rejectedResult?.error?.description ?? '', MessageType.ERROR, LogLevel.ERROR);
+          reject(errorResponse);
+        })?.catch((error) => {
+          reject(error);
+        });
+    }),
+  );
+  Promise.allSettled(updateResponseSet)?.then((resultSet: any) => {
+    const recordsResponse: any[] = [];
+    const errorsResponse: any[] = [];
+    resultSet?.forEach((result: { status: string; value: any; reason?: any; }) => {
+      if (result?.status === 'fulfilled') {
+        recordsResponse?.push(result?.value);
+      } else {
+        errorsResponse?.push(result?.reason);
+      }
+    });
+
+    if (errorsResponse?.length === 0) {
+      rootResolve({ records: recordsResponse });
+    } else if (recordsResponse?.length === 0) {
+      rootReject({ errors: errorsResponse });
+    } else {
+      rootReject({ records: recordsResponse, errors: errorsResponse });
+    }
+  });
+});
+
+export const insertDataInCollect = async (
+  records,
+  client: Client,
+  options,
+  finalInsertRecords,
+  authToken: string,
+) => new Promise((resolve) => {
+  let insertResponse: any;
+  let insertErrorResponse: any;
+  client
+    ?.request({
+      body: JSON.stringify({
+        records,
+      }),
+      requestMethod: 'POST',
+      url: `${client.config.vaultURL}/v1/vaults/${client.config.vaultID}`,
+      headers: {
+        authorization: `Bearer ${authToken}`,
+        'content-type': 'application/json',
+      },
+    })
+    ?.then((response: any) => {
+      insertResponse = constructInsertRecordResponse(
+        response,
+        options?.tokens,
+        finalInsertRecords?.records,
+      );
+      resolve(insertResponse);
+    })
+    ?.catch((error) => {
+      insertErrorResponse = {
+        errors: [
+          {
+            error: {
+              code: error?.error?.code,
+              description: error?.error?.description,
+            },
+          },
+        ],
+      };
+      resolve(insertErrorResponse);
+    });
+});
+
+export const insertDataInMultipleFiles = async (
+  records,
+  client: Client,
+  options,
+  finalInsertRecords,
+  authToken: string,
+) => new Promise((resolve) => {
+  let insertResponse: any;
+  let insertErrorResponse: any;
+  client
+    ?.request({
+      body: JSON.stringify({
+        records,
+      }),
+      requestMethod: 'POST',
+      url: `${client.config.vaultURL}/v1/vaults/${client.config.vaultID}`,
+      headers: {
+        authorization: `Bearer ${authToken}`,
+        'content-type': 'application/json',
+      },
+    })
+    ?.then((response: any) => {
+      insertResponse = constructInsertRecordResponse(
+        response,
+        options?.tokens,
+        finalInsertRecords?.records,
+      );
+      resolve(insertResponse);
+    })
+    ?.catch((error) => {
+      insertErrorResponse = {
+        errors: [
+          {
+            error: {
+              code: error?.error?.code,
+              description: error?.error?.description,
+            },
+          },
+        ],
+      };
+      resolve(insertErrorResponse);
+    });
+});
+
 export const checkForElementMatchRule = (validations: IValidationRule[]) => {
   if (!validations) return false;
   for (let i = 0; i < validations.length; i += 1) {

src/core-utils/reveal.ts

@@ -16,6 +16,7 @@ import {
   GetResponseRecord,
   GetByIdResponse,
   GetByIdResponseRecord,
+  IRevealRecordComposable,
 } from '../utils/common';
 import { printLog } from '../utils/logs-helper';
 import { FILE_DOWNLOAD_URL_PARAM } from '../core/constants';
@@ -145,7 +146,7 @@ export const getFileURLForRender = (
 
   paramList += `${skyflowIdRecord.skyflowID}?`;
 
-  paramList += `fields=${skyflowIdRecord.column}&${FILE_DOWNLOAD_URL_PARAM}`;
+  paramList += `fields=${skyflowIdRecord.column}&${FILE_DOWNLOAD_URL_PARAM}&returnFileMetadata=true`;
 
   const vaultEndPointurl: string = `${client.config.vaultURL}/v1/vaults/${client.config.vaultID}/${skyflowIdRecord.table}/${paramList}`;
   return client.request({
@@ -182,6 +183,27 @@ export const getFileURLFromVaultBySkyflowID = (
     rootReject(err);
   }
 });
+
+export const getFileURLFromVaultBySkyflowIDComposable = (
+  skyflowIdRecord: IRevealRecord,
+  client: Client,
+  authToken: string,
+): Promise<IRenderResponseType> => new Promise((rootResolve, rootReject) => {
+  try {
+    getFileURLForRender(
+      skyflowIdRecord, client, authToken as string,
+    ).then((resolvedResult: IRenderResponseType) => {
+      rootResolve(resolvedResult);
+    }).catch((err: any) => {
+      const errorData = formatForRenderFileFailure(err, skyflowIdRecord.skyflowID as string,
+        skyflowIdRecord.column as string);
+      printLog(errorData.error?.description || '', MessageType.ERROR, LogLevel.ERROR);
+      rootReject(errorData);
+    });
+  } catch (err) {
+    rootReject(err);
+  }
+});
 export const fetchRecordsByTokenId = (
   tokenIdRecords: IRevealRecord[],
   client: Client,
@@ -235,6 +257,65 @@ export const fetchRecordsByTokenId = (
     rootReject(err);
   });
 });
+
+export const fetchRecordsByTokenIdComposable = (
+  tokenIdRecords: IRevealRecordComposable[],
+  client: Client,
+  authToken: string,
+): Promise<IRevealResponseType> => new Promise((rootResolve, rootReject) => {
+  const vaultResponseSet: Promise<any>[] = tokenIdRecords?.map(
+    (tokenRecord) => new Promise((resolve) => {
+      const apiResponse: any = [];
+      const redaction: RedactionType = tokenRecord?.redaction ?? RedactionType.PLAIN_TEXT;
+
+      getTokenRecordsFromVault(tokenRecord?.token ?? '', redaction, client, authToken)
+        ?.then(
+          (response: IApiSuccessResponse) => {
+            const fieldsData = formatForPureJsSuccess(response);
+            apiResponse?.push({
+              ...fieldsData,
+              frameId: tokenRecord?.iframeName ?? '',
+            });
+          },
+          (cause: any) => {
+            const errorData = formatForPureJsFailure(cause, tokenRecord?.token ?? '');
+            printLog(errorData?.error?.description ?? '', MessageType.ERROR, LogLevel.ERROR);
+            apiResponse?.push({
+              ...errorData,
+              frameId: tokenRecord?.iframeName ?? '',
+            });
+          },
+        )
+        ?.finally(() => {
+          resolve(apiResponse);
+        });
+    }),
+  );
+
+  Promise.allSettled(vaultResponseSet)?.then((resultSet) => {
+    const recordsResponse: Record<string, any>[] = [];
+    const errorResponse: Record<string, any>[] = [];
+    resultSet?.forEach((result) => {
+      if (result?.status === 'fulfilled') {
+        result?.value?.forEach((res: Record<string, any>) => {
+          if (Object.prototype.hasOwnProperty.call(res, 'error')) {
+            errorResponse?.push(res);
+          } else {
+            recordsResponse?.push(res);
+          }
+        });
+      }
+    });
+    if (errorResponse?.length === 0) {
+      rootResolve({ records: recordsResponse });
+    } else if (recordsResponse?.length === 0) {
+      rootReject({ errors: errorResponse });
+    } else {
+      rootReject({ records: recordsResponse, errors: errorResponse });
+    }
+  });
+});
+
 export const formatRecordsForIframe = (response: IRevealResponseType) => {
   const result: Record<string, string> = {};
   if (response.records) {
@@ -264,6 +345,7 @@ export const formatForRenderClient = (response: IRenderResponseType, column: str
     const successRecord = {
       skyflow_id: response.fields.skyflow_id,
       column,
+      fileMetadata: response.fileMetadata,
     };
     formattedResponse.success = successRecord;
   } else if (response.errors) {
@@ -295,6 +377,34 @@ export const formatRecordsForClient = (response: IRevealResponseType): RevealRes
   return revealResponse;
 };
 
+export const formatRecordsForClientComposable = (response) => {
+  let successRecords = [];
+  let errorRecords = [];
+
+  if (response?.errors && response?.errors?.length > 0) {
+    errorRecords = response?.errors?.map((errors) => ({
+      error: errors?.error ?? {},
+    }));
+  }
+
+  if (response?.records) {
+    successRecords = response?.records?.map((record) => ({
+      token: record?.[0]?.token ?? '',
+      valueType: record?.[0]?.valueType ?? '',
+    }));
+  }
+
+  if (successRecords?.length > 0 && errorRecords?.length > 0) {
+    return { success: successRecords, errors: errorRecords };
+  }
+
+  if (successRecords?.length > 0) {
+    return { success: successRecords };
+  }
+
+  return { errors: errorRecords };
+};
+
 export const fetchRecordsGET = async (
   skyflowIdRecords: IGetRecord[],
   client: Client,

src/core/constants.ts

@@ -30,11 +30,13 @@ export const SDK_IFRAME_EVENT = 'SDK IFRAME EVENT';
 export const DOMAIN = 'US2';
 export const CORALOGIX_DOMAIN = 'https://cdn.rum-ingress-coralogix.com/coralogix/browser/latest/coralogix-browser-sdk.js';
 export const FRAME_ELEMENT = 'element';
+export const COMPOSABLE_REVEAL = 'reveal-composable';
 
 export const ELEMENT_TYPES = {
   COLLECT: 'COLLECT',
   REVEAL: 'REVEAL',
   COMPOSE: 'COMPOSABLE',
+  REVEAL_COMPOSE: 'REVEAL_COMPOSE',
 };
 
 export const EVENT_TYPES = {
@@ -105,8 +107,19 @@ export const ELEMENT_EVENTS_TO_CLIENT = {
 };
 
 export const ELEMENT_EVENTS_TO_IFRAME = {
+  MULTIPLE_UPLOAD_FILES_RESPONSE: 'MULTIPLE_UPLOAD_FILES_RESPONSE',
+  RENDER_MOUNTED: 'RENDER_MOUNTED',
+  HEIGHT_CALLBACK: 'HEIGHT_CALLBACK',
+  HEIGHT_CALLBACK_COMPOSABLE: 'HEIGHT_CALLBACK_COMPOSABLE',
+  COMPOSABLE_REVEAL: 'COMPOSABLE_REVEAL',
+  MULTIPLE_UPLOAD_FILES: 'MULTIPLE_UPLOAD_FILES',
   COLLECT_CALL_REQUESTS: 'COLLECT_CALL_REQUESTS',
+  COMPOSABLE_CALL_REQUESTS: 'COMPOSABLE_CALL_REQUESTS',
+  COMPOSABLE_CALL_RESPONSE: 'COMPOSABLE_CALL_RESPONSE',
+  COMPOSABLE_FILE_CALL_RESPONSE: 'COMPOSABLE_FILE_CALL_RESPONSE',
+  COMPOSABLE_CONTAINER: 'COMPOSABLE_CONTAINER',
   REVEAL_CALL_REQUESTS: 'REVEAL_CALL_REQUESTS',
+  REVEAL_CALL_RESPONSE: 'REVEAL_CALL_RESPONSE',
   FRAME_READY: 'FRAME_READY',
   READY_FOR_CLIENT: 'READY_FOR_CLIENT',
   TOKENIZATION_REQUEST: 'TOKENIZATION_REQUEST',
@@ -163,6 +176,7 @@ export enum ElementType {
   EXPIRATION_MONTH = 'EXPIRATION_MONTH',
   EXPIRATION_YEAR = 'EXPIRATION_YEAR',
   FILE_INPUT = 'FILE_INPUT',
+  MULTI_FILE_INPUT = 'MULTI_FILE_INPUT',
 }
 
 export enum CardType {
@@ -325,6 +339,14 @@ export const ELEMENTS = {
       type: 'file',
     },
   },
+  [ElementType.MULTI_FILE_INPUT]: {
+    name: 'MULTI_FILE_INPUT',
+    sensitive: true,
+    attributes: {
+      type: 'file',
+      multiple: '',
+    },
+  },
 };
 
 export const CARDNUMBER_INPUT_FORMAT = {
@@ -638,6 +660,7 @@ export const DEFAULT_ERROR_TEXT_ELEMENT_TYPES = {
   [ElementType.EXPIRATION_MONTH]: 'Invalid expiration month',
   [ElementType.EXPIRATION_YEAR]: 'Invalid expiration year',
   [ElementType.FILE_INPUT]: logs.errorLogs.INVALID_COLLECT_VALUE,
+  [ElementType.MULTI_FILE_INPUT]: logs.errorLogs.INVALID_COLLECT_VALUE,
 };
 
 export const DEFAULT_REQUIRED_TEXT_ELEMENT_TYPES = {
@@ -650,6 +673,7 @@ export const DEFAULT_REQUIRED_TEXT_ELEMENT_TYPES = {
   [ElementType.EXPIRATION_MONTH]: 'expiration month is required',
   [ElementType.EXPIRATION_YEAR]: 'expiration year is required',
   [ElementType.FILE_INPUT]: logs.errorLogs.DEFAULT_REQUIRED_COLLECT_VALUE,
+  [ElementType.MULTI_FILE_INPUT]: logs.errorLogs.DEFAULT_REQUIRED_COLLECT_VALUE,
 };
 
 export const INPUT_KEYBOARD_EVENTS = {