update

Author: clun

astra-db-java/src/main/java/com/datastax/astra/client/DataAPIClient.java

@@ -70,6 +70,8 @@
  */
 public class DataAPIClient {
 
+
+
     /**
      * The authentication token used as credentials in HTTP requests, specifically as the Authorization bearer token.
      * This token is crucial for accessing and interacting with Astra environments, where it plays a role in determining
@@ -234,56 +236,30 @@ public DataAPIClient(DataAPIClientOptions options) {
      * @throws SecurityException if the current token does not have the necessary administrative privileges.
      */
     public AstraDBAdmin getAdmin() {
-        return getAdmin(token, new AdminOptions(options));
+        return getAdmin(new AdminOptions(token, options));
     }
 
-    /**
-     * Retrieves an administration client capable of performing CRUD operations on databases, requiring a token with
-     * advanced privileges. This method is designed for scenarios where administrative access is necessary beyond the
-     * default token capabilities associated with the {@code DataAPIClient}.
-     * <p>
-     * The provided {@code superUserToken} should be granted sufficient privileges to perform administrative operations,
-     * such as creating, updating, and deleting databases. This typically involves tokens associated with roles like
-     * Database Administrator or Organization Administrator within the Astra environment.
-     * </p>
-     * <p>
-     * Utilizing this method allows for direct access to the Astra database's administrative functionalities, enabling
-     * comprehensive management capabilities through the returned {@link AstraDBAdmin} client. This includes but is not
-     * limited to database creation, modification, and deletion.
-     * </p>
-     *
-     * <p>Example usage:</p>
-     * <pre>
-     * {@code
-     * String superUserToken = "AstraCS:super_user_token_here";
-     * DataAPIClient apiClient = new DataAPIClient(superUserToken);
-     * AstraDBAdmin adminClient = apiClient.getAdmin(superUserToken);
-     * // Now you can use adminClient for administrative operations like creating a database
-     * }
-     * </pre>
-     *
-     * @param superUserToken A token with elevated privileges, enabling administrative actions within the Astra
-     *        environment. This token must be authorized to perform operations such as creating and managing databases.
-     * @return An instance of {@link AstraDBAdmin}, configured for administrative tasks with the provided  user token.
-     * @throws SecurityException if the provided {@code superUserToken} lacks the necessary privileges for administrative operations.
-     */
-    public AstraDBAdmin getAdmin(String superUserToken, AdminOptions adminOptions) {
+    public AstraDBAdmin getAdmin(String superToken) {
+        return getAdmin(new AdminOptions(superToken, options));
+    }
+
+    public AstraDBAdmin getAdmin(AdminOptions adminOptions) {
         if (!options.isAstra()) {
             throwErrorRestrictedAstra("getAdmin()", options.getDestination());
         }
-        return new AstraDBAdmin(adminOptions.adminToken(superUserToken));
+        return new AstraDBAdmin(adminOptions);
     }
 
     // --------------------------------------------------
     // ---       Access Database                      ---
     // --------------------------------------------------
 
     public Database getDatabase(String apiEndpoint) {
-        return getDatabase(apiEndpoint, new DatabaseOptions(options).token(token));
+        return getDatabase(apiEndpoint, new DatabaseOptions(token, options));
     }
 
     public Database getDatabase(UUID databaseId) {
-        return getDatabase(lookupEndpoint(databaseId, null), new DatabaseOptions(options).token(token));
+        return getDatabase(lookupEndpoint(databaseId, null), new DatabaseOptions(token, options));
     }
 
     /**

astra-db-java/src/main/java/com/datastax/astra/client/DataAPIClients.java

@@ -24,10 +24,9 @@
 import com.datastax.astra.client.core.auth.UsernamePasswordTokenProvider;
 import com.datastax.astra.client.core.options.DataAPIClientOptions;
 import com.datastax.astra.client.databases.Database;
-import com.datastax.astra.client.databases.DatabaseOptions;
 import com.datastax.astra.internal.command.LoggingCommandObserver;
 
-import static com.datastax.astra.client.admin.AstraDBAdmin.DEFAULT_KEYSPACE;
+import static com.datastax.astra.client.core.options.DataAPIClientOptions.DEFAULT_KEYSPACE;
 
 /**
  * Provides utility methods for initializing and configuring clients to interact with the Data API. This class
@@ -86,6 +85,31 @@ public static DataAPIClient local() {
                         .addObserver(new LoggingCommandObserver(DataAPIClient.class)));
     }
 
+    /**
+     * Creates a {@link DataAPIClient} configured for interacting with Astra in a development environment. This
+     * method simplifies the setup of a client specifically tailored for development purposes, where you might
+     * need different configurations or less stringent security measures compared to a production environment.
+     * The client is configured to target Astra's development environment, ensuring that operations do not
+     * affect production data.
+     *
+     * @param token The authentication token required for accessing Astra's development environment. This token
+     *              should have the necessary permissions for development activities and be protected accordingly.
+     * @return A {@link DataAPIClient} instance ready for development activities with Astra, configured with the
+     *         provided authentication token and targeting Astra's development environment.
+     *
+     * <p>Example usage:</p>
+     * <pre>
+     * {@code
+     * DataAPIClient devClient = DataAPIClients.astraDev("your_astra_dev_token");
+     * // Utilize devClient for development database operations
+     * }
+     * </pre>
+     */
+    public static DataAPIClient astra(String token) {
+        return new DataAPIClient(token, new DataAPIClientOptions()
+                .destination(DataAPIDestination.ASTRA)
+                .addObserver(new LoggingCommandObserver(DataAPIClient.class)));
+    }
 
     /**
      * Creates a {@link DataAPIClient} configured for interacting with Astra in a development environment. This
@@ -154,7 +178,7 @@ public static DataAPIClient astraTest(String token) {
     public static Database defaultLocalDatabase() {
         Database db = local().getDatabase(DEFAULT_ENDPOINT_LOCAL);
         DataAPIDatabaseAdmin dbAdmin = (DataAPIDatabaseAdmin) db.getDatabaseAdmin();
-        dbAdmin.createKeyspace(DatabaseOptions.DEFAULT_KEYSPACE);
+        dbAdmin.createKeyspace(DEFAULT_KEYSPACE);
         return db;
     }
 

astra-db-java/src/main/java/com/datastax/astra/client/admin/AdminOptions.java

@@ -20,43 +20,24 @@
  * #L%
  */
 
+import com.datastax.astra.client.core.commands.BaseOptions;
+import com.datastax.astra.client.core.commands.CommandType;
 import com.datastax.astra.client.core.options.DataAPIClientOptions;
+import com.datastax.astra.internal.serdes.DatabaseSerializer;
 import com.datastax.astra.internal.utils.Assert;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
 @Setter
 @Accessors(fluent = true, chain = true)
-public class AdminOptions {
+public class AdminOptions extends BaseOptions<AdminOptions> {
 
-    private String adminToken;
-
-    private DataAPIClientOptions dataAPIClientOptions;
-
-    public AdminOptions() {
-        this(new DataAPIClientOptions());
-    }
-
-    public AdminOptions(DataAPIClientOptions options) {
+    public AdminOptions(String token, DataAPIClientOptions options) {
         Assert.notNull(options, "options");
+        this.token = token;
+        this.commandType = CommandType.DATABASE_ADMIN;
         this.dataAPIClientOptions = options.clone();
+        this.serializer = new DatabaseSerializer();
     }
 
-    /**
-     * Gets token
-     *
-     * @return value of token
-     */
-    public String getAdminToken() {
-        return adminToken;
-    }
-
-    /**
-     * Gets dataAPIClientOptions
-     *
-     * @return value of dataAPIClientOptions
-     */
-    public DataAPIClientOptions getDataAPIClientOptions() {
-        return dataAPIClientOptions;
-    }
 }

astra-db-java/src/main/java/com/datastax/astra/client/admin/AstraDBAdmin.java

@@ -22,6 +22,7 @@
 
 import com.datastax.astra.client.core.options.DataAPIClientOptions;
 import com.datastax.astra.client.databases.DatabaseInfo;
+import com.datastax.astra.client.databases.DatabaseOptions;
 import com.datastax.astra.internal.api.AstraApiEndpoint;
 import com.datastax.astra.internal.command.LoggingCommandObserver;
 import com.datastax.astra.internal.utils.Assert;
@@ -47,6 +48,7 @@
 import java.util.UUID;
 import java.util.stream.Collectors;
 
+import static com.datastax.astra.client.core.options.DataAPIClientOptions.DEFAULT_KEYSPACE;
 import static com.datastax.astra.client.exception.InvalidEnvironmentException.throwErrorRestrictedAstra;
 import static com.datastax.astra.internal.utils.AnsiUtils.green;
 import static com.dtsx.astra.sdk.utils.Utils.readEnvVariable;
@@ -104,9 +106,11 @@ public AstraDBAdmin(AdminOptions options) {
             if (dataAPIClientOptions.getObservers().containsKey(LoggingCommandObserver.class.getSimpleName())) {
                 devopsObservers.put("logging", new LoggingRequestObserver(AstraDBAdmin.class));
             }
-            this.devopsDbClient = new AstraDBOpsClient(options.getAdminToken(), dataAPIClientOptions.getAstraEnvironment(), devopsObservers);
+            this.devopsDbClient = new AstraDBOpsClient(options.getToken(),
+                    dataAPIClientOptions.getAstraEnvironment(), devopsObservers);
         } else {
-            this.devopsDbClient = new AstraDBOpsClient(options.getAdminToken(), dataAPIClientOptions.getAstraEnvironment());
+            this.devopsDbClient = new AstraDBOpsClient(options.getToken(),
+                    dataAPIClientOptions.getAstraEnvironment());
         }
 
         // Local Agent for Resume
@@ -323,17 +327,23 @@ public DatabaseInfo getDatabaseInfo(@NonNull UUID id) {
     public com.datastax.astra.client.databases.Database getDatabase(UUID databaseId, String keyspace) {
         Assert.notNull(databaseId, "databaseId");
         Assert.hasLength(keyspace, "keyspace");
-        if (!dataAPIClientOptions.isAstra()) {
-            throwErrorRestrictedAstra("getDatabase(id, keyspace)", dataAPIClientOptions.getDestination());
+        if (!adminOptions.getDataAPIClientOptions().isAstra()) {
+            throwErrorRestrictedAstra("getDatabase(id, keyspace)", adminOptions.getDataAPIClientOptions().getDestination());
         }
+
         String databaseRegion = devopsDbClient
                 .findById(databaseId.toString())
                 .map(db -> db.getInfo().getRegion())
                 .orElseThrow(() -> new DatabaseNotFoundException(databaseId.toString()));
-        return new com.datastax.astra.client.databases.Database(
-            new AstraApiEndpoint(databaseId, databaseRegion, dataAPIClientOptions.getAstraEnvironment()).getApiEndPoint(),
-            token, keyspace, dataAPIClientOptions) {
-        };
+
+        AstraApiEndpoint astraApiEndpoint = new AstraApiEndpoint(databaseId,
+                databaseRegion, adminOptions.getDataAPIClientOptions().getAstraEnvironment());
+
+        // Accessing DB with the right keyspace
+        DatabaseOptions dbOptions = new DatabaseOptions(this.adminOptions.getToken(), this.adminOptions.getDataAPIClientOptions())
+                .keyspace(keyspace);
+
+        return new com.datastax.astra.client.databases.Database(astraApiEndpoint.getApiEndPoint(), dbOptions);
     }
 
     /**
@@ -358,7 +368,9 @@ public com.datastax.astra.client.databases.Database getDatabase(UUID databaseId)
      */
     public AstraDBDatabaseAdmin getDatabaseAdmin(UUID databaseId) {
         Assert.notNull(databaseId, "databaseId");
-        return new AstraDBDatabaseAdmin(token, databaseId, dataAPIClientOptions);
+        return new AstraDBDatabaseAdmin(
+                adminOptions.getToken(), databaseId,
+                adminOptions.getDataAPIClientOptions());
     }
 
     /**

astra-db-java/src/main/java/com/datastax/astra/client/admin/AstraDBDatabaseAdmin.java

@@ -21,9 +21,10 @@
  */
 
 import com.datastax.astra.client.DataAPIDestination;
-import com.datastax.astra.client.core.commands.CommandOptions;
+import com.datastax.astra.client.core.commands.BaseOptions;
 import com.datastax.astra.client.core.options.DataAPIClientOptions;
 import com.datastax.astra.client.core.results.FindEmbeddingProvidersResult;
+import com.datastax.astra.client.databases.DatabaseOptions;
 import com.datastax.astra.internal.api.AstraApiEndpoint;
 import com.dtsx.astra.sdk.db.AstraDBOpsClient;
 import com.dtsx.astra.sdk.db.domain.Database;
@@ -34,8 +35,6 @@
 import java.util.Set;
 import java.util.UUID;
 
-import static com.datastax.astra.client.admin.AstraDBAdmin.DEFAULT_KEYSPACE;
-
 
 /**
  * Implementation of the DatabaseAdmin interface for Astra. To create the namespace the devops APi is leverage. To use this class a higher token permission is required.
@@ -87,7 +86,8 @@ public AstraDBDatabaseAdmin(String token, UUID databaseId, DataAPIClientOptions
         this.databaseId     = databaseId;
         this.dataAPIClientOptions = options;
         this.devopsDbClient = new AstraDBOpsClient(token, options.getAstraEnvironment());
-        this.db = new com.datastax.astra.client.databases.Database(getApiEndpoint(), token, DEFAULT_KEYSPACE, options);
+        this.db = new com.datastax.astra.client.databases.Database(getApiEndpoint(),
+                new DatabaseOptions(token, options));
     }
 
     /**
@@ -162,7 +162,7 @@ public com.datastax.astra.client.databases.Database getDatabase(String keyspace)
      *      client to interact with database DML.
      */
     public com.datastax.astra.client.databases.Database getDatabase(String keyspace, String tokenUser) {
-        return new com.datastax.astra.client.databases.Database(getApiEndpoint(), tokenUser, keyspace, db.getDatabaseOptions());
+        return new com.datastax.astra.client.databases.Database(getApiEndpoint(), db.getDatabaseOptions());
     }
 
     @Override
@@ -178,7 +178,8 @@ public Set<String> listKeyspaceNames() {
     public FindEmbeddingProvidersResult findEmbeddingProviders() {
         log.debug("findEmbeddingProviders");
         DataAPIDatabaseAdmin admin =
-                new DataAPIDatabaseAdmin(getApiEndpoint() + "/" + db.getDatabaseOptions().getApiVersion(), token, db.getDatabaseOptions());
+                new DataAPIDatabaseAdmin(getApiEndpoint() + "/" + db.getDatabaseOptions()
+                        .getDataAPIClientOptions().getApiVersion(), db.getDatabaseOptions());
         return new FindEmbeddingProvidersResult(admin.findEmbeddingProviders().getEmbeddingProviders());
     }
 
@@ -199,7 +200,7 @@ public void dropKeyspace(String keyspace) {
     }
 
     @Override
-    public void dropKeyspace(String namespace, CommandOptions<?> options) {
+    public void dropKeyspace(String namespace, BaseOptions<?> options) {
         log.warn("CommandOptions are not supported for dropKeyspace in Astra MODE");
         dropKeyspace(namespace);
     }

astra-db-java/src/main/java/com/datastax/astra/client/admin/DataAPIDatabaseAdmin.java

@@ -21,7 +21,7 @@
  */
 
 import com.datastax.astra.client.core.commands.Command;
-import com.datastax.astra.client.core.commands.CommandOptions;
+import com.datastax.astra.client.core.commands.BaseOptions;
 import com.datastax.astra.client.core.commands.CommandType;
 import com.datastax.astra.client.core.results.FindEmbeddingProvidersResult;
 import com.datastax.astra.client.core.vectorize.EmbeddingProvider;
@@ -80,7 +80,7 @@ public DataAPIDatabaseAdmin(String apiEndpoint, DatabaseOptions options) {
      */
     public DataAPIDatabaseAdmin(Database db) {
         this.db             = db;
-        this.commandOptions = new CommandOptions<>(
+        this.baseOptions = new BaseOptions<>(
                 db.getDatabaseOptions().getToken(),
                 CommandType.KEYSPACE_ADMIN,
                 db.getDatabaseOptions().getDataAPIClientOptions());
@@ -161,7 +161,7 @@ public void createKeyspace(String keyspace, KeyspaceOptions options) {
     }
 
     @Override
-    public void dropKeyspace(String keyspace, CommandOptions<?> options) {
+    public void dropKeyspace(String keyspace, BaseOptions<?> options) {
         hasLength(keyspace, ARG_KEYSPACE);
         Command dropNamespace = Command
                 .create("dropKeyspace")
@@ -183,15 +183,15 @@ protected DataAPISerializer getSerializer() {
     }
 
     /**
-     * Register a listener to execute commands on the collection. Please now use {@link CommandOptions}.
+     * Register a listener to execute commands on the collection. Please now use {@link BaseOptions}.
      *
      * @param logger
      *      name for the logger
      * @param commandObserver
      *      class for the logger
      */
     public void registerListener(String logger, CommandObserver commandObserver) {
-        this.commandOptions.registerObserver(logger, commandObserver);
+        this.baseOptions.registerObserver(logger, commandObserver);
     }
 
 }

astra-db-java/src/main/java/com/datastax/astra/client/admin/DatabaseAdmin.java

@@ -20,7 +20,7 @@
  * #L%
  */
 
-import com.datastax.astra.client.core.commands.CommandOptions;
+import com.datastax.astra.client.core.commands.BaseOptions;
 import com.datastax.astra.client.databases.Database;
 import com.datastax.astra.client.core.commands.CommandRunner;
 import com.datastax.astra.client.core.vectorize.EmbeddingProvider;
@@ -207,7 +207,7 @@ default void dropKeyspace(String namespace) {
         dropKeyspace(namespace, null);
     }
 
-    void dropKeyspace(String namespace, CommandOptions<?> options);
+    void dropKeyspace(String namespace, BaseOptions<?> options);
 
     /**
      * Asynchronously drops (deletes) the specified keyspace from the database. This operation is idempotent, meaning