Merge pull request #18 from xataio/feat/files-client

add delete file method

Author: omerdemirok

internal/integration-tests/files_client_test.go

@@ -0,0 +1,77 @@
+package integrationtests
+
+import (
+	"context"
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/go-retryablehttp"
+	"github.com/stretchr/testify/assert"
+	"github.com/xataio/xata-go/xata"
+)
+
+func Test_filesClient(t *testing.T) {
+	cfg, err := setupDatabase()
+	if err != nil {
+		t.Fatalf("unable to setup database: %v", err)
+	}
+
+	ctx := context.TODO()
+	err = setupTableWithColumns(ctx, cfg)
+	if err != nil {
+		t.Fatalf("unable to setup table: %v", err)
+	}
+
+	t.Cleanup(func() {
+		err = cleanup(cfg)
+		if err != nil {
+			t.Fatalf("unable to cleanup test setup: %v", err)
+		}
+	})
+
+	filesCli, err := xata.NewFilesClient(xata.WithAPIKey(cfg.apiKey),
+		xata.WithBaseURL(fmt.Sprintf(
+			"https://%s.%s.xata.sh",
+			cfg.wsID,
+			cfg.region,
+		)),
+		xata.WithHTTPClient(retryablehttp.NewClient().StandardClient()),
+	)
+	if err != nil {
+		t.Fatalf("unable to construct files cli: %v", err)
+	}
+
+	recordsCli, err := xata.NewRecordsClient(
+		xata.WithAPIKey(cfg.apiKey),
+		xata.WithBaseURL(fmt.Sprintf(
+			"https://%s.%s.xata.sh",
+			cfg.wsID,
+			cfg.region,
+		)),
+		xata.WithHTTPClient(retryablehttp.NewClient().StandardClient()),
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	insertRecordRequest := generateInsertRecordRequest(cfg.databaseName, cfg.tableName)
+
+	record, err := recordsCli.Insert(ctx, insertRecordRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.NotNil(t, record)
+
+	t.Run("delete a file", func(t *testing.T) {
+		delRes, err := filesCli.Delete(ctx, xata.DeleteFileRequest{
+			BranchRequestOptional: xata.BranchRequestOptional{
+				DatabaseName: xata.String(cfg.databaseName),
+			},
+			TableName:  cfg.tableName,
+			RecordId:   record.Id,
+			ColumnName: fileColumn,
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, testFileName, delRes.Name)
+	})
+}

xata/files_cilent.go

@@ -0,0 +1,77 @@
+package xata
+
+import (
+	"context"
+	"fmt"
+
+	xatagenworkspace "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go"
+	xatagenclient "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go/core"
+)
+
+type FilesClient interface {
+	// GetFileItem(ctx context.Context, dbBranchName DbBranchName, tableName TableName, recordId RecordId, columnName ColumnName, fileId FileItemId) error
+	// PutFileItem(ctx context.Context, dbBranchName DbBranchName, tableName TableName, recordId RecordId, columnName ColumnName, fileId FileItemId) (*FileResponse, error)
+	// DeleteFileItem(ctx context.Context, dbBranchName DbBranchName, tableName TableName, recordId RecordId, columnName ColumnName, fileId FileItemId) (*FileResponse, error)
+	// GetFile(ctx context.Context, dbBranchName DbBranchName, tableName TableName, recordId RecordId, columnName ColumnName) error
+	// PutFile(ctx context.Context, dbBranchName DbBranchName, tableName TableName, recordId RecordId, columnName ColumnName) (*FileResponse, error)
+	Delete(ctx context.Context, request DeleteFileRequest) (*xatagenworkspace.FileResponse, error)
+}
+
+type filesClient struct {
+	generated  xatagenworkspace.FilesClient
+	dbName     string
+	branchName string
+}
+
+func (f filesClient) dbBranchName(request BranchRequestOptional) (string, error) {
+	if request.DatabaseName == nil {
+		if f.dbName == "" {
+			return "", fmt.Errorf("database name cannot be empty")
+		}
+		request.DatabaseName = String(f.dbName)
+	}
+
+	if request.BranchName == nil {
+		if f.branchName == "" {
+			return "", fmt.Errorf("branch name cannot be empty")
+		}
+		request.BranchName = String(f.branchName)
+	}
+
+	return fmt.Sprintf("%s:%s", *request.DatabaseName, *request.BranchName), nil
+}
+
+type DeleteFileRequest struct {
+	BranchRequestOptional
+	TableName  string
+	RecordId   string
+	ColumnName string
+}
+
+func (f filesClient) Delete(ctx context.Context, request DeleteFileRequest) (*xatagenworkspace.FileResponse, error) {
+	dbBranchName, err := f.dbBranchName(request.BranchRequestOptional)
+	if err != nil {
+		return nil, err
+	}
+
+	return f.generated.DeleteFile(ctx, dbBranchName, request.TableName, request.RecordId, request.ColumnName)
+}
+
+func NewFilesClient(opts ...ClientOption) (FilesClient, error) {
+	cliOpts, dbCfg, err := consolidateClientOptionsForWorkspace(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return filesClient{
+			generated: xatagenworkspace.NewFilesClient(
+				func(options *xatagenclient.ClientOptions) {
+					options.HTTPClient = cliOpts.HTTPClient
+					options.BaseURL = cliOpts.BaseURL
+					options.Bearer = cliOpts.Bearer
+				}),
+			dbName:     dbCfg.dbName,
+			branchName: dbCfg.branchName,
+		},
+		nil
+}

xata/files_cilent_test.go

@@ -0,0 +1,85 @@
+package xata_test
+
+import (
+	"context"
+	"net/http"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/xataio/xata-go/xata"
+	xatagenworkspace "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go"
+
+	xatagencore "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go/core"
+)
+
+func TestNewFilesClient(t *testing.T) {
+	t.Run("should construct a new client", func(t *testing.T) {
+		got, err := xata.NewFilesClient(
+			xata.WithBaseURL("https://www.example.com"),
+			xata.WithAPIKey("my-api-token"),
+		)
+		assert.NoError(t, err)
+		assert.NotNil(t, got)
+	})
+}
+
+func Test_filesClient_Delete(t *testing.T) {
+	assert := assert.New(t)
+
+	type tc struct {
+		name       string
+		want       *xatagenworkspace.FileResponse
+		statusCode int
+		apiErr     *xatagencore.APIError
+	}
+
+	tests := []tc{
+		{
+			name: "should delete a file successfully",
+			want: &xatagenworkspace.FileResponse{
+				Name: "test-file.txt",
+			},
+			statusCode: http.StatusOK,
+		},
+	}
+
+	for _, eTC := range errTestCasesWorkspace {
+		tests = append(tests, tc{
+			name:       eTC.name,
+			statusCode: eTC.statusCode,
+			apiErr:     eTC.apiErr,
+		})
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testSrv := testService(t, http.MethodDelete, "/db", tt.statusCode, tt.apiErr != nil, tt.want)
+
+			cli, err := xata.NewFilesClient(xata.WithBaseURL(testSrv.URL), xata.WithAPIKey("test-key"))
+			assert.NoError(err)
+			assert.NotNil(cli)
+
+			got, err := cli.Delete(context.TODO(), xata.DeleteFileRequest{
+				BranchRequestOptional: xata.BranchRequestOptional{
+					DatabaseName: xata.String("my-db"),
+				},
+				TableName:  "my-table",
+				RecordId:   "my-id",
+				ColumnName: "file-column",
+			})
+
+			if tt.apiErr != nil {
+				errAPI := tt.apiErr.Unwrap()
+				if errAPI == nil {
+					t.Fatal("expected error but got nil")
+				}
+				assert.ErrorAs(err, &errAPI)
+				assert.Equal(err.Error(), tt.apiErr.Error())
+				assert.Nil(got)
+			} else {
+				assert.Equal(tt.want.Name, got.Name)
+				assert.NoError(err)
+			}
+		})
+	}
+}

xata/records_client.go

@@ -7,9 +7,8 @@ import (
 	"strings"
 	"time"
 
-	xatagenclient "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go/core"
-
 	xatagenworkspace "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go"
+	xatagenclient "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go/core"
 )
 
 type RecordRequest struct {

xata/records_client_test.go

@@ -5,10 +5,10 @@ import (
 	"net/http"
 	"testing"
 
-	xatagenworkspace "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/xataio/xata-go/xata"
+
+	xatagenworkspace "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go"
 	xatagencore "github.com/xataio/xata-go/xata/internal/fern-workspace/generated/go/core"
 )