use db-api v3 for certain operations (#1032)

Use regional db-api endpoints if `--v3-api` flag is set for db-related
operations (create/show/list/etc)

Author: sivukhin

internal/cmd/auth.go

@@ -18,7 +18,6 @@ import (
 	"github.com/tursodatabase/turso-cli/internal"
 	"github.com/tursodatabase/turso-cli/internal/flags"
 	"github.com/tursodatabase/turso-cli/internal/settings"
-	"github.com/tursodatabase/turso-cli/internal/turso"
 )
 
 //go:embed login.html
@@ -277,8 +276,8 @@ func signupHint(config *settings.Settings) {
 		return
 	}
 
-	r, err := client.Databases.List(turso.DatabaseListOptions{})
-	if err != nil || len(r.Databases) != 0 {
+	databases, err := listDatabases(client)
+	if err != nil || len(databases) != 0 {
 		return
 	}
 

internal/cmd/db.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/tursodatabase/turso-cli/internal"
+	"github.com/tursodatabase/turso-cli/internal/flags"
 	"github.com/tursodatabase/turso-cli/internal/settings"
 	"github.com/tursodatabase/turso-cli/internal/turso"
 )
@@ -38,6 +39,21 @@ func extractDatabaseNames(databases []turso.Database) []string {
 	return names
 }
 
+func getDatabaseConfig(client *turso.Client, name string) (turso.DatabaseConfig, error) {
+	if !flags.V3Api() {
+		return client.Databases.GetConfig(name)
+	}
+	orgID, err := tryResolveOrgID(client)
+	if err != nil {
+		return turso.DatabaseConfig{}, err
+	}
+	dbID, err := tryResolveDbID(client, name)
+	if err != nil {
+		return turso.DatabaseConfig{}, err
+	}
+	return client.DatabasesV3.GetConfig(orgID, dbID)
+}
+
 func getDatabase(client *turso.Client, name string, fresh ...bool) (turso.Database, error) {
 	databases, err := getDatabases(client, fresh...)
 	if err != nil {
@@ -53,17 +69,40 @@ func getDatabase(client *turso.Client, name string, fresh ...bool) (turso.Databa
 	return turso.Database{}, fmt.Errorf("database %s not found. List known databases using %s", internal.Emph(name), internal.Emph("turso db list"))
 }
 
+func listDatabases(client *turso.Client) ([]turso.Database, error) {
+	if !flags.V3Api() {
+		return listDatabasesV2(client)
+	}
+	orgID, err := tryResolveOrgID(client)
+	if err != nil {
+		return nil, err
+	}
+	if orgID == "" {
+		return listDatabasesV2(client)
+	}
+	databases, _, err := client.DatabasesV3.List(orgID, turso.DatabaseV3ListOptions{})
+	return databases, err
+}
+
+func listDatabasesV2(client *turso.Client) ([]turso.Database, error) {
+	response, err := client.Databases.List(turso.DatabaseListOptions{})
+	if err != nil {
+		return nil, err
+	}
+	return response.Databases, err
+}
+
 func getDatabases(client *turso.Client, fresh ...bool) ([]turso.Database, error) {
 	skipCache := len(fresh) > 0 && fresh[0]
 	if cachedNames := getDatabasesCache(); !skipCache && cachedNames != nil {
 		return cachedNames, nil
 	}
-	r, err := client.Databases.List(turso.DatabaseListOptions{})
+	databases, err := listDatabases(client)
 	if err != nil {
 		return nil, err
 	}
-	setDatabasesCache(r.Databases)
-	return r.Databases, nil
+	setDatabasesCache(databases)
+	return databases, nil
 }
 
 func getDatabasesMap(client *turso.Client, fresh bool) (map[string]turso.Database, error) {

internal/cmd/db_create.go

@@ -92,7 +92,7 @@ func CreateDatabase(name string) error {
 		return err
 	}
 
-	groups, err := client.Groups.List()
+	groups, err := listGroups(client)
 	if err != nil {
 		return err
 	}
@@ -127,7 +127,7 @@ func CreateDatabase(name string) error {
 	spinner := prompt.Spinner(fmt.Sprintf("Creating database %s in group %s...", internal.Emph(name), internal.Emph(groupName)))
 	defer spinner.Stop()
 
-	if _, err = client.Databases.Create(name, location, "", "", groupName, schemaFlag, typeFlag == "schema", seed, sizeLimitFlag, remoteEncryptionCipherFlag, remoteEncryptionKeyFlag(), tursoDBFlag, spinner); err != nil {
+	if err := createDatabase(client, name, location, groupName, seed, spinner); err != nil {
 		return fmt.Errorf("could not create database %s: %w", name, err)
 	}
 
@@ -145,6 +145,78 @@ func CreateDatabase(name string) error {
 	return nil
 }
 
+func createDatabase(client *turso.Client, name, location, groupName string, seed *turso.DBSeed, spinner *prompt.SpinnerT) error {
+	if !flags.V3Api() {
+		return createDatabaseV2(client, name, location, groupName, seed, spinner)
+	}
+	if schemaFlag != "" || typeFlag == "schema" {
+		return createDatabaseV2(client, name, location, groupName, seed, spinner)
+	}
+	if sizeLimitFlag != "" {
+		return createDatabaseV2(client, name, location, groupName, seed, spinner)
+	}
+	if seed != nil && seed.Type != "database" && seed.Type != "upload" {
+		return createDatabaseV2(client, name, location, groupName, seed, spinner)
+	}
+	orgID, err := tryResolveOrgID(client)
+	if err != nil {
+		return err
+	}
+	if orgID == "" {
+		return createDatabaseV2(client, name, location, groupName, seed, spinner)
+	}
+	body := CreateDatabaseV3BodyFromFlags(name, seed)
+	if seed == nil || seed.Type != "database" {
+		groupID, err := tryResolveGroupID(client, groupName)
+		if err != nil {
+			return err
+		}
+		if groupID == "" {
+			return createDatabaseV2(client, name, location, groupName, seed, spinner)
+		}
+		body.GroupID = groupID
+	} else if seed.Type == "database" {
+		_, err := client.DatabasesV3.Create(orgID, body)
+		return err
+	}
+	_, err = client.DatabasesV3.Create(orgID, body)
+	return err
+}
+
+func createDatabaseV2(client *turso.Client, name, location, groupName string, seed *turso.DBSeed, spinner *prompt.SpinnerT) error {
+	_, err := client.Databases.Create(name, location, "", "", groupName, schemaFlag, typeFlag == "schema", seed, sizeLimitFlag, remoteEncryptionCipherFlag, remoteEncryptionKeyFlag(), tursoDBFlag, spinner)
+	return err
+}
+
+func CreateDatabaseV3BodyFromFlags(name string, seed *turso.DBSeed) turso.CreateDatabaseV3Body {
+	body := turso.CreateDatabaseV3Body{
+		Name:         name,
+		CreationMode: "empty",
+	}
+	if tursoDBFlag {
+		body.DatabaseType = "tursodb"
+	} else {
+		body.DatabaseType = "libsql"
+	}
+	if seed != nil && seed.Type == "database" {
+		body.CreationMode = "fork"
+		body.ParentDBName = seed.Name
+		if seed.Timestamp != nil {
+			body.Timestamp = seed.Timestamp
+		}
+	}
+	if seed != nil && seed.Type == "upload" {
+		body.CreationMode = "upload"
+	}
+	if remoteEncryptionKeyFlag() != "" {
+		body.RemoteEncryption = &turso.RemoteEncryption{
+			EncryptionKey:    remoteEncryptionKeyFlag(),
+			EncryptionCipher: remoteEncryptionCipherFlag,
+		}
+	}
+	return body
+}
+
 func ensureGroup(client *turso.Client, group string, groups []turso.Group, location, version string) error {
 	if !shouldAutoCreateGroup(group, groups) {
 		return nil

internal/cmd/db_generatetoken.go

@@ -62,7 +62,7 @@ var dbGenerateTokenCmd = &cobra.Command{
 		}
 		token, err := getToken(client, database, expiration, flags.ReadOnly(), groupTokenFlag, claim, permissions)
 		if err != nil {
-			return errors.New("your database does not support token generation")
+			return fmt.Errorf("failed to generate database token: %v", err)
 		}
 		fmt.Println(token)
 		return nil
@@ -77,11 +77,36 @@ func getToken(
 	claim *turso.PermissionsClaim,
 	fineGrainedPermissions []flags.FineGrainedPermissions,
 ) (string, error) {
-	if !group {
-		return client.Databases.Token(database.Name, expiration, readOnly, claim, fineGrainedPermissions)
+	if group {
+		if database.Group == "" {
+			return "", errors.New("--group flag can only be set with group databases")
+		}
+		return client.Groups.Token(database.Group, expiration, readOnly, claim, fineGrainedPermissions)
+	}
+	if !flags.V3Api() {
+		return getTokenV2(client, database, expiration, readOnly, claim, fineGrainedPermissions)
+	}
+	if claim != nil {
+		return getTokenV2(client, database, expiration, readOnly, claim, fineGrainedPermissions)
 	}
-	if group && database.Group == "" {
-		return "", errors.New("--group flag can only be set with group databases")
+	orgID, err := tryResolveOrgID(client)
+	if err != nil {
+		return "", err
 	}
-	return client.Groups.Token(database.Group, expiration, readOnly, claim, fineGrainedPermissions)
+	dbID := database.ID
+	if orgID == "" || dbID == "" {
+		return getTokenV2(client, database, expiration, readOnly, claim, fineGrainedPermissions)
+	}
+	return client.DatabasesV3.Token(orgID, dbID, expiration, readOnly, fineGrainedPermissions)
+}
+
+func getTokenV2(
+	client *turso.Client,
+	database turso.Database,
+	expiration string,
+	readOnly bool,
+	claim *turso.PermissionsClaim,
+	fineGrainedPermissions []flags.FineGrainedPermissions,
+) (string, error) {
+	return client.Databases.Token(database.Name, expiration, readOnly, claim, fineGrainedPermissions)
 }

internal/cmd/db_inspect.go

@@ -7,7 +7,6 @@ import (
 	"github.com/dustin/go-humanize"
 	"github.com/rodaine/table"
 	"github.com/spf13/cobra"
-	"github.com/tursodatabase/turso-cli/internal"
 	"github.com/tursodatabase/turso-cli/internal/turso"
 )
 
@@ -57,11 +56,6 @@ var dbInspectCmd = &cobra.Command{
 			fmt.Printf("Embedded syncs: %s\n", humanize.Bytes(dbUsage.Usage.BytesSynced))
 		}
 
-		if len(instances) == 0 {
-			fmt.Printf("\n🛠 Run %s to finish your database creation!\n", internal.Emph("turso db replicate "+db.Name))
-			return nil
-		}
-
 		if !verboseFlag {
 			return nil
 		}

internal/cmd/db_list.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"github.com/spf13/cobra"
+	"github.com/tursodatabase/turso-cli/internal/flags"
 	"github.com/tursodatabase/turso-cli/internal/turso"
 )
 
@@ -15,10 +16,68 @@ func init() {
 }
 
 type DatabaseFetcher struct {
-	client *turso.Client
+	client       *turso.Client
+	SchemaFilter string
+	GroupFilter  string
+	ParentDbId   string
+	LoadFullInfo bool
 }
 
 func (df *DatabaseFetcher) FetchPage(pageSize int, cursor *string) (turso.ListResponse, error) {
+	if !flags.V3Api() {
+		return df.fetchPageV2(pageSize, cursor)
+	}
+	if df.SchemaFilter != "" {
+		return df.fetchPageV2(pageSize, cursor)
+	}
+	orgID, err := tryResolveOrgID(df.client)
+	if err != nil {
+		return turso.ListResponse{}, err
+	}
+	if orgID == "" {
+		return df.fetchPageV2(pageSize, cursor)
+	}
+	groupID := ""
+	if df.GroupFilter != "" {
+		id, err := tryResolveGroupID(df.client, df.GroupFilter)
+		if err != nil {
+			return turso.ListResponse{}, err
+		}
+		if id == "" {
+			return df.fetchPageV2(pageSize, cursor)
+		}
+		groupID = id
+	}
+	cursorStr := ""
+	if cursor != nil {
+		cursorStr = *cursor
+	}
+	options := turso.DatabaseV3ListOptions{
+		GroupId:    groupID,
+		Limit:      pageSize,
+		Cursor:     cursorStr,
+		ParentDbId: df.ParentDbId,
+	}
+	dbs, next, err := df.client.DatabasesV3.List(orgID, options)
+	if err != nil {
+		return turso.ListResponse{}, err
+	}
+	response := turso.ListResponse{Databases: dbs}
+	if next != "" {
+		response.Pagination = &turso.Pagination{Next: &next}
+	}
+	if df.LoadFullInfo {
+		for i := range response.Databases {
+			response.Databases[i], err = df.client.DatabasesV3.Get(orgID, response.Databases[i].ID)
+			if err != nil {
+				return turso.ListResponse{}, err
+			}
+		}
+	}
+	return response, nil
+}
+
+func (df *DatabaseFetcher) fetchPageV2(pageSize int, cursor *string) (turso.ListResponse, error) {
 	cursorStr := ""
 	if cursor != nil {
 		cursorStr = *cursor
@@ -29,9 +88,22 @@ func (df *DatabaseFetcher) FetchPage(pageSize int, cursor *string) (turso.ListRe
 		Schema: schemaFilter,
 		Limit:  pageSize,
 		Cursor: cursorStr,
+		Parent: df.ParentDbId,
 	}
 
-	return df.client.Databases.List(options)
+	response, err := df.client.Databases.List(options)
+	if err != nil {
+		return turso.ListResponse{}, err
+	}
+	if df.LoadFullInfo {
+		for i := range response.Databases {
+			response.Databases[i], err = df.client.Databases.Get(response.Databases[i].Name)
+			if err != nil {
+				return turso.ListResponse{}, err
+			}
+		}
+	}
+	return response, nil
 }
 
 var listCmd = &cobra.Command{
@@ -47,7 +119,9 @@ var listCmd = &cobra.Command{
 		}
 
 		fetcher := &DatabaseFetcher{
-			client: client,
+			client:       client,
+			SchemaFilter: schemaFilter,
+			GroupFilter:  groupFilter,
 		}
 		return printDatabaseList(fetcher)
 	},