SK-2071: Merge branch 'v2' into saileshwar-skyflow/SK-2071-deidentify-file

Author: saileshwar-skyflow

README.md

@@ -44,6 +44,7 @@ The Skyflow Java SDK is designed to help with integrating Skyflow into a Java ba
   - [Generate bearer tokens with context](#generate-bearer-tokens-with-context)
   - [Generate scoped bearer tokens](#generate-scoped-bearer-tokens)
   - [Generate signed data tokens](#generate-signed-data-tokens)
+  - [Bearer token expiry edge case](#bearer-token-expiry-edge-case)
 - [Logging](#logging)
 - [Reporting a Vulnerability](#reporting-a-vulnerability)
 
@@ -2147,7 +2148,7 @@ Notes:
 - If both a file path and a string are provided, the last method used takes precedence.
 - To generate multiple bearer tokens concurrently using threads, refer to the following [example](https://github.com/skyflowapi/skyflow-java/blob/main/samples/src/main/java/com/example/serviceaccount/BearerTokenGenerationUsingThreadsExample.java).
 
-## Signed Data Tokens Generation
+## Generate Signed Data Tokens
 
 Skyflow generates data tokens when sensitive data is inserted into the vault. These data tokens can be digitally signed
 with the private key of the service account credentials, which adds an additional layer of protection. Signed tokens can
@@ -2225,6 +2226,106 @@ Notes:
 - The `time-to-live` (TTL) value should be specified in seconds.
 - By default, the TTL value is set to 60 seconds.
 
+## Bearer token expiry edge case
+When you use bearer tokens for authentication and API requests in SDKs, there's the potential for a token to expire after the token is verified as valid but before the actual API call is made, causing the request to fail unexpectedly due to the token's expiration. An error from this edge case would look something like this:
+
+```txt
+message: Authentication failed. Bearer token is expired. Use a valid bearer token. See https://docs.skyflow.com/api-authentication/
+```
+
+If you encounter this kind of error, retry the request. During the retry, the SDK detects that the previous bearer token has expired and generates a new one for the current and subsequent requests.
+
+#### [Example](https://github.com/skyflowapi/skyflow-java/blob/v2/samples/src/main/java/com/example/serviceaccount/BearerTokenExpiryExample.java):
+
+```java
+package com.example.serviceaccount;
+
+import com.skyflow.Skyflow;
+import com.skyflow.config.Credentials;
+import com.skyflow.config.VaultConfig;
+import com.skyflow.enums.Env;
+import com.skyflow.enums.LogLevel;
+import com.skyflow.enums.RedactionType;
+import com.skyflow.errors.SkyflowException;
+import com.skyflow.vault.tokens.DetokenizeRequest;
+import com.skyflow.vault.tokens.DetokenizeResponse;
+import io.github.cdimascio.dotenv.Dotenv;
+import java.util.ArrayList;
+
+/**
+ * This example demonstrates how to configure and use the Skyflow SDK
+ * to detokenize sensitive data stored in a Skyflow vault.
+ * It includes setting up credentials, configuring the vault, and
+ * making a detokenization request. The code also implements a retry
+ * mechanism to handle unauthorized access errors (HTTP 401).
+ */
+public class DetokenizeExample {
+    public static void main(String[] args) {
+        try {
+            // Setting up credentials for accessing the Skyflow vault
+            Credentials vaultCredentials = new Credentials();
+            vaultCredentials.setCredentialsString("<YOUR_CREDENTIALS_STRING>");
+
+            // Configuring the Skyflow vault with necessary details
+            VaultConfig vaultConfig = new VaultConfig();
+            vaultConfig.setVaultId("<YOUR_VAULT_ID>"); // Vault ID
+            vaultConfig.setClusterId("<YOUR_CLUSTER_ID>"); // Cluster ID
+            vaultConfig.setEnv(Env.PROD); // Environment (e.g., DEV, PROD)
+            vaultConfig.setCredentials(vaultCredentials); // Setting credentials
+
+            // Creating a Skyflow client instance with the configured vault
+            Skyflow skyflowClient = Skyflow.builder()
+                    .setLogLevel(LogLevel.ERROR) // Setting log level to ERROR
+                    .addVaultConfig(vaultConfig) // Adding vault configuration
+                    .build();
+
+            // Attempting to detokenize data using the Skyflow client
+            try {
+                detokenizeData(skyflowClient);
+            } catch (SkyflowException e) {
+                // Retry detokenization if the error is due to unauthorized access (HTTP 401)
+                if (e.getHttpCode() == 401) {
+                    detokenizeData(skyflowClient);
+                } else {
+                    // Rethrow the exception for other error codes
+                    throw e;
+                }
+            }
+        } catch (SkyflowException e) {
+            // Handling any exceptions that occur during the process
+            System.out.println("An error occurred: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Method to detokenize data using the Skyflow client.
+     * It sends a detokenization request with a list of tokens and prints the response.
+     *
+     * @param skyflowClient The Skyflow client instance used for detokenization.
+     * @throws SkyflowException If an error occurs during the detokenization process.
+     */
+    public static void detokenizeData(Skyflow skyflowClient) throws SkyflowException {
+        // Creating a list of tokens to be detokenized
+        ArrayList<String> tokenList = new ArrayList<>();
+        tokenList.add("<YOUR_TOKEN_VALUE_1>"); // First token
+        tokenList.add("<YOUR_TOKEN_VALUE_2>"); // Second token
+
+        // Building a detokenization request with the token list and configuration
+        DetokenizeRequest detokenizeRequest = DetokenizeRequest.builder()
+                .tokens(tokenList) // Adding tokens to the request
+                .continueOnError(false) // Stop on error
+                .redactionType(RedactionType.PLAIN_TEXT) // Redaction type (e.g., PLAIN_TEXT)
+                .build();
+
+        // Sending the detokenization request and receiving the response
+        DetokenizeResponse detokenizeResponse = skyflowClient.vault().detokenize(detokenizeRequest);
+
+        // Printing the detokenized response
+        System.out.println(detokenizeResponse);
+    }
+}
+```
+
 # Logging
 
 The SDK provides logging with Java's built-in logging library. By default, the SDK's logging level is set to `LogLevel.ERROR`. This can be changed using the `setLogLevel(logLevel)` method, as shown below:

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.skyflow</groupId>
     <artifactId>skyflow-java</artifactId>
-    <version>2.0.0-beta.1-dev.ea71c1d</version>
+    <version>2.0.0-beta.1-dev.ec349a9</version>
     <packaging>jar</packaging>
 
     <name>${project.groupId}:${project.artifactId}</name>

samples/src/main/java/com/example/connection/InvokeConnectionExample.java

@@ -13,92 +13,89 @@
 import java.util.Map;
 
 /**
- * This example demonstrates how to use the Skyflow SDK to invoke connections for different endpoints with different configurations.
+ * This example demonstrates how to use the Skyflow SDK to invoke API connections.
  * It includes:
- * 1. Setting up connection configurations.
- * 2. Creating a Skyflow client.
- * 3. Sending POST and GET requests to connections.
+ * 1. Setting up credentials and connection configurations.
+ * 2. Creating a Skyflow client with multiple connections.
+ * 3. Sending a POST request with request body and headers.
+ * 4. Sending a GET request with path and query parameters.
  */
 public class InvokeConnectionExample {
     public static void main(String[] args) throws SkyflowException {
-        // Step 1: Set up credentials for the first connection configuration
+        // Step 1: Set up credentials for API authentication
         Credentials credentials = new Credentials();
-        credentials.setPath("<YOUR_CREDENTIALS_FILE_PATH_1>"); // Replace with the path to the credentials file
+        credentials.setApiKey("<YOUR_API_KEY>"); // Replace with the actual API key
 
-        // Step 2: Configure the first connection (Connection 1)
-        ConnectionConfig connectionConfig1 = new ConnectionConfig();
-        connectionConfig1.setConnectionId("<YOUR_CONNECTION_ID_1>"); // Replace with the ID of the first connection
-        connectionConfig1.setConnectionUrl("<YOUR_CONNECTION_URL_1>"); // Replace with the URL of the first connection
-        connectionConfig1.setCredentials(credentials); // Associate credentials for the first connection
+        // Step 2: Configure the first connection
+        ConnectionConfig primaryConnectionConfig = new ConnectionConfig();
+        primaryConnectionConfig.setConnectionId("<YOUR_CONNECTION_ID_1>"); // Replace with first connection ID
+        primaryConnectionConfig.setConnectionUrl("<YOUR_CONNECTION_URL_1>"); // Replace with first connection URL
+        primaryConnectionConfig.setCredentials(credentials); // Assign credentials
 
-        // Step 3: Configure the second connection (Connection 2)
-        ConnectionConfig connectionConfig2 = new ConnectionConfig();
-        connectionConfig2.setConnectionId("<YOUR_CONNECTION_ID_2>"); // Replace with the ID of the second connection
-        connectionConfig2.setConnectionUrl("<YOUR_CONNECTION_URL_2>"); // Replace with the URL of the second connection
+        // Step 3: Configure the second connection
+        ConnectionConfig secondaryConnectionConfig = new ConnectionConfig();
+        secondaryConnectionConfig.setConnectionId("<YOUR_CONNECTION_ID_2>"); // Replace with second connection ID
+        secondaryConnectionConfig.setConnectionUrl("<YOUR_CONNECTION_URL_2>"); // Replace with second connection URL
 
         // Step 4: Set up credentials for the Skyflow client
         Credentials skyflowCredentials = new Credentials();
-        skyflowCredentials.setPath("<YOUR_CREDENTIALS_FILE_PATH_2>"); // Replace with the path to another credentials file
+        skyflowCredentials.setCredentialsString("<YOUR_CREDENTIALS_STRING>"); // Replace with the credentials string
 
-        // Step 5: Create a Skyflow client and add connection configurations
+        // Step 5: Create a Skyflow client with connection configurations
         Skyflow skyflowClient = Skyflow.builder()
-                .setLogLevel(LogLevel.DEBUG)               // Enable debugging for detailed logs
-                .addConnectionConfig(connectionConfig1)    // Add the first connection configuration
-                .addConnectionConfig(connectionConfig2)    // Add the second connection configuration
-                .addSkyflowCredentials(skyflowCredentials)  // Add general Skyflow credentials
+                .setLogLevel(LogLevel.ERROR)               // Set log level to ERROR
+                .addConnectionConfig(primaryConnectionConfig)  // Add the first connection
+                .addConnectionConfig(secondaryConnectionConfig) // Add the second connection
+                .addSkyflowCredentials(skyflowCredentials)  // Provide Skyflow credentials
                 .build();
 
         // Example 1: Sending a POST request to the first connection
         try {
-            // Set up the request body and headers for the POST request
+            // Set up request body and headers
             Map<String, String> requestBody = new HashMap<>();
-            requestBody.put("<COLUMN_NAME_1>", "<COLUMN_VALUE_1>"); // Replace with the actual column name and value
+            requestBody.put("<COLUMN_NAME_1>", "<COLUMN_VALUE_1>"); // Replace with actual column name and value
             requestBody.put("<COLUMN_NAME_2>", "<COLUMN_VALUE_2>"); // Replace with another column name and value
 
             Map<String, String> requestHeaders = new HashMap<>();
-            requestHeaders.put("<HEADER_NAME_1>", "<HEADER_VALUE_1>"); // Replace with header name and value
+            requestHeaders.put("<HEADER_NAME_1>", "<HEADER_VALUE_1>"); // Replace with actual header name and value
             requestHeaders.put("<HEADER_NAME_2>", "<HEADER_VALUE_2>"); // Replace with another header name and value
 
-            // Build the POST request to invoke the connection
+            // Build and send the POST request
             InvokeConnectionRequest invokeConnectionRequest1 = InvokeConnectionRequest.builder()
-                    .methodName(RequestMethod.POST)       // Set the HTTP method to POST
-                    .requestBody(requestBody)             // Set the request body
-                    .requestHeaders(requestHeaders)       // Set the request headers
+                    .method(RequestMethod.POST)        // HTTP method set to POST
+                    .requestBody(requestBody)          // Include request body
+                    .requestHeaders(requestHeaders)    // Include request headers
                     .build();
 
-            // Execute the POST request to the first connection
             InvokeConnectionResponse invokeConnectionResponse1 = skyflowClient.connection().invoke(invokeConnectionRequest1);
-            System.out.println("Invoke Connection Response (POST): " + invokeConnectionResponse1); // Print the response
+            System.out.println("Invoke Connection Response (POST): " + invokeConnectionResponse1);
         } catch (SkyflowException e) {
-            System.out.println("Error while invoking connection (POST):");
-            e.printStackTrace();
+            System.out.println("Error while invoking connection (POST):" + e);
         }
 
         // Example 2: Sending a GET request to the second connection
         try {
-            // Set up path parameters and query parameters for the GET request
+            // Set up path and query parameters
             Map<String, String> pathParams = new HashMap<>();
-            pathParams.put("<YOUR_PATH_PARAM_KEY_1>", "<YOUR_PATH_PARAM_VALUE_1>"); // Replace with path parameters
+            pathParams.put("<YOUR_PATH_PARAM_KEY_1>", "<YOUR_PATH_PARAM_VALUE_1>"); // Replace with actual path parameter
             pathParams.put("<YOUR_PATH_PARAM_KEY_2>", "<YOUR_PATH_PARAM_VALUE_2>"); // Replace with another path parameter
 
             Map<String, String> queryParams = new HashMap<>();
-            queryParams.put("<YOUR_QUERY_PARAM_KEY_1>", "<YOUR_QUERY_PARAM_VALUE_1>"); // Replace with query parameters
+            queryParams.put("<YOUR_QUERY_PARAM_KEY_1>", "<YOUR_QUERY_PARAM_VALUE_1>"); // Replace with actual query parameter
             queryParams.put("<YOUR_QUERY_PARAM_KEY_2>", "<YOUR_QUERY_PARAM_VALUE_2>"); // Replace with another query parameter
 
-            // Build the GET request to invoke the connection
+            // Build and send the GET request
             InvokeConnectionRequest invokeConnectionRequest2 = InvokeConnectionRequest.builder()
-                    .methodName(RequestMethod.GET)       // Set the HTTP method to GET
-                    .pathParams(pathParams)              // Set the path parameters
-                    .queryParams(queryParams)            // Set the query parameters
+                    .method(RequestMethod.GET)      // HTTP method set to GET
+                    .pathParams(pathParams)         // Include path parameters
+                    .queryParams(queryParams)       // Include query parameters
                     .build();
 
-            // Execute the GET request to the second connection
             InvokeConnectionResponse invokeConnectionResponse2 = skyflowClient
-                    .connection("<YOUR_CONNECTION_ID_2>").invoke(invokeConnectionRequest2); // Invoke connection with ID 2
-            System.out.println("Invoke Connection Response (GET): " + invokeConnectionResponse2); // Print the response
+                    .connection("<YOUR_CONNECTION_ID_2>").invoke(invokeConnectionRequest2);
+            System.out.println("Invoke Connection Response (GET): " + invokeConnectionResponse2);
         } catch (SkyflowException e) {
-            System.out.println("Error while invoking connection (GET):");
-            e.printStackTrace();
+            System.out.println("Error while invoking connection (GET):" + e);
         }
     }
 }

samples/src/main/java/com/example/serviceaccount/BearerTokenExpiryExample.java

@@ -0,0 +1,86 @@
+package com.example.serviceaccount;
+
+import com.skyflow.Skyflow;
+import com.skyflow.config.Credentials;
+import com.skyflow.config.VaultConfig;
+import com.skyflow.enums.Env;
+import com.skyflow.enums.LogLevel;
+import com.skyflow.enums.RedactionType;
+import com.skyflow.errors.SkyflowException;
+import com.skyflow.vault.tokens.DetokenizeRequest;
+import com.skyflow.vault.tokens.DetokenizeResponse;
+import io.github.cdimascio.dotenv.Dotenv;
+import java.util.ArrayList;
+
+/**
+ * This example demonstrates how to configure and use the Skyflow SDK
+ * to detokenize sensitive data stored in a Skyflow vault.
+ * It includes setting up credentials, configuring the vault, and
+ * making a detokenization request. The code also implements a retry
+ * mechanism to handle unauthorized access errors (HTTP 401).
+ */
+public class BearerTokenExpiryExample {
+    public static void main(String[] args) {
+        try {
+            // Setting up credentials for accessing the Skyflow vault
+            Credentials vaultCredentials = new Credentials();
+            vaultCredentials.setCredentialsString("<YOUR_CREDENTIALS_STRING>");
+
+            // Configuring the Skyflow vault with necessary details
+            VaultConfig vaultConfig = new VaultConfig();
+            vaultConfig.setVaultId("<YOUR_VAULT_ID>"); // Vault ID
+            vaultConfig.setClusterId("<YOUR_CLUSTER_ID>"); // Cluster ID
+            vaultConfig.setEnv(Env.PROD); // Environment (e.g., DEV, PROD)
+            vaultConfig.setCredentials(vaultCredentials); // Setting credentials
+
+            // Creating a Skyflow client instance with the configured vault
+            Skyflow skyflowClient = Skyflow.builder()
+                    .setLogLevel(LogLevel.ERROR) // Setting log level to ERROR
+                    .addVaultConfig(vaultConfig) // Adding vault configuration
+                    .build();
+
+            // Attempting to detokenize data using the Skyflow client
+            try {
+                detokenizeData(skyflowClient);
+            } catch (SkyflowException e) {
+                // Retry detokenization if the error is due to unauthorized access (HTTP 401)
+                if (e.getHttpCode() == 401) {
+                    detokenizeData(skyflowClient);
+                } else {
+                    // Rethrow the exception for other error codes
+                    throw e;
+                }
+            }
+        } catch (SkyflowException e) {
+            // Handling any exceptions that occur during the process
+            System.out.println("An error occurred: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Method to detokenize data using the Skyflow client.
+     * It sends a detokenization request with a list of tokens and prints the response.
+     *
+     * @param skyflowClient The Skyflow client instance used for detokenization.
+     * @throws SkyflowException If an error occurs during the detokenization process.
+     */
+    public static void detokenizeData(Skyflow skyflowClient) throws SkyflowException {
+        // Creating a list of tokens to be detokenized
+        ArrayList<String> tokenList = new ArrayList<>();
+        tokenList.add("<YOUR_TOKEN_VALUE_1>"); // First token
+        tokenList.add("<YOUR_TOKEN_VALUE_2>"); // Second token
+
+        // Building a detokenization request with the token list and configuration
+        DetokenizeRequest detokenizeRequest = DetokenizeRequest.builder()
+                .tokens(tokenList) // Adding tokens to the request
+                .continueOnError(false) // Stop on error
+                .redactionType(RedactionType.PLAIN_TEXT) // Redaction type (e.g., PLAIN_TEXT)
+                .build();
+
+        // Sending the detokenization request and receiving the response
+        DetokenizeResponse detokenizeResponse = skyflowClient.vault().detokenize(detokenizeRequest);
+
+        // Printing the detokenized response
+        System.out.println(detokenizeResponse);
+    }
+}