feat(volume): add sqlite repository

Author: JSYoo5B

internal/app/volume/sqlite_repository.go

@@ -0,0 +1,277 @@
+package volume
+
+import (
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	_ "modernc.org/sqlite"
+)
+
+type SQLiteRepository struct {
+	db *sql.DB
+}
+
+func OpenSQLiteRepository(dataSourceName string) (*SQLiteRepository, error) {
+	db, err := sql.Open("sqlite", dataSourceName)
+	if err != nil {
+		return nil, err
+	}
+
+	repository := &SQLiteRepository{db: db}
+	if err := repository.Init(); err != nil {
+		_ = db.Close()
+		return nil, err
+	}
+
+	return repository, nil
+}
+
+func (r *SQLiteRepository) Init() error {
+	_, err := r.db.Exec(`
+CREATE TABLE IF NOT EXISTS volumes (
+	sequence INTEGER PRIMARY KEY AUTOINCREMENT,
+	id TEXT NOT NULL UNIQUE,
+	status TEXT NOT NULL,
+	size INTEGER NOT NULL,
+	name TEXT NOT NULL,
+	description TEXT NOT NULL,
+	volume_type TEXT NOT NULL,
+	metadata_json TEXT NOT NULL,
+	created_at TEXT NOT NULL,
+	updated_at TEXT NOT NULL,
+	bootable TEXT NOT NULL,
+	encrypted INTEGER NOT NULL,
+	multiattach INTEGER NOT NULL
+)`)
+
+	return err
+}
+
+func (r *SQLiteRepository) Close() error {
+	return r.db.Close()
+}
+
+func (r *SQLiteRepository) Create(volume Volume) Volume {
+	metadataJSON := marshalStringMap(volume.Metadata)
+	_, err := r.db.Exec(
+		`INSERT INTO volumes (
+			id,
+			status,
+			size,
+			name,
+			description,
+			volume_type,
+			metadata_json,
+			created_at,
+			updated_at,
+			bootable,
+			encrypted,
+			multiattach
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+		volume.ID,
+		volume.Status,
+		volume.Size,
+		volume.Name,
+		volume.Description,
+		volume.VolumeType,
+		metadataJSON,
+		volume.CreatedAt,
+		volume.UpdatedAt,
+		volume.Bootable,
+		boolToInt(volume.Encrypted),
+		boolToInt(volume.Multiattach),
+	)
+	if err != nil {
+		panic(fmt.Errorf("insert volume: %w", err))
+	}
+
+	return volume
+}
+
+func (r *SQLiteRepository) List() []Volume {
+	rows, err := r.db.Query(`
+SELECT
+	id,
+	status,
+	size,
+	name,
+	description,
+	volume_type,
+	metadata_json,
+	created_at,
+	updated_at,
+	bootable,
+	encrypted,
+	multiattach
+FROM volumes
+ORDER BY sequence`)
+	if err != nil {
+		panic(fmt.Errorf("list volumes: %w", err))
+	}
+	defer rows.Close()
+
+	volumes := []Volume{}
+	for rows.Next() {
+		volume, err := scanVolume(rows)
+		if err != nil {
+			panic(fmt.Errorf("scan volume: %w", err))
+		}
+		volumes = append(volumes, volume)
+	}
+	if err := rows.Err(); err != nil {
+		panic(fmt.Errorf("iterate volumes: %w", err))
+	}
+
+	return volumes
+}
+
+func (r *SQLiteRepository) Get(id string) (Volume, error) {
+	row := r.db.QueryRow(`
+SELECT
+	id,
+	status,
+	size,
+	name,
+	description,
+	volume_type,
+	metadata_json,
+	created_at,
+	updated_at,
+	bootable,
+	encrypted,
+	multiattach
+FROM volumes
+WHERE id = ?`, id)
+
+	volume, err := scanVolume(row)
+	if errors.Is(err, sql.ErrNoRows) {
+		return Volume{}, ErrVolumeNotFound
+	}
+	if err != nil {
+		return Volume{}, err
+	}
+
+	return volume, nil
+}
+
+func (r *SQLiteRepository) Update(volume Volume) (Volume, error) {
+	metadataJSON := marshalStringMap(volume.Metadata)
+	result, err := r.db.Exec(
+		`UPDATE volumes
+		SET status = ?,
+			size = ?,
+			name = ?,
+			description = ?,
+			volume_type = ?,
+			metadata_json = ?,
+			created_at = ?,
+			updated_at = ?,
+			bootable = ?,
+			encrypted = ?,
+			multiattach = ?
+		WHERE id = ?`,
+		volume.Status,
+		volume.Size,
+		volume.Name,
+		volume.Description,
+		volume.VolumeType,
+		metadataJSON,
+		volume.CreatedAt,
+		volume.UpdatedAt,
+		volume.Bootable,
+		boolToInt(volume.Encrypted),
+		boolToInt(volume.Multiattach),
+		volume.ID,
+	)
+	if err != nil {
+		return Volume{}, err
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return Volume{}, err
+	}
+	if rowsAffected == 0 {
+		return Volume{}, ErrVolumeNotFound
+	}
+
+	return volume, nil
+}
+
+func (r *SQLiteRepository) Delete(id string) error {
+	result, err := r.db.Exec(`DELETE FROM volumes WHERE id = ?`, id)
+	if err != nil {
+		return err
+	}
+
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if rowsAffected == 0 {
+		return ErrVolumeNotFound
+	}
+
+	return nil
+}
+
+func (r *SQLiteRepository) Reset() {
+	if _, err := r.db.Exec(`DELETE FROM volumes`); err != nil {
+		panic(fmt.Errorf("reset volumes: %w", err))
+	}
+}
+
+type volumeScanner interface {
+	Scan(dest ...any) error
+}
+
+func scanVolume(scanner volumeScanner) (Volume, error) {
+	var volume Volume
+	var metadataJSON string
+	var encrypted int
+	var multiattach int
+
+	if err := scanner.Scan(
+		&volume.ID,
+		&volume.Status,
+		&volume.Size,
+		&volume.Name,
+		&volume.Description,
+		&volume.VolumeType,
+		&metadataJSON,
+		&volume.CreatedAt,
+		&volume.UpdatedAt,
+		&volume.Bootable,
+		&encrypted,
+		&multiattach,
+	); err != nil {
+		return Volume{}, err
+	}
+
+	if err := json.Unmarshal([]byte(metadataJSON), &volume.Metadata); err != nil {
+		return Volume{}, err
+	}
+	volume.Encrypted = encrypted != 0
+	volume.Multiattach = multiattach != 0
+
+	return volume, nil
+}
+
+func marshalStringMap(value map[string]string) string {
+	data, err := json.Marshal(value)
+	if err != nil {
+		panic(fmt.Errorf("marshal string map: %w", err))
+	}
+
+	return string(data)
+}
+
+func boolToInt(value bool) int {
+	if value {
+		return 1
+	}
+
+	return 0
+}

internal/app/volume/sqlite_repository_test.go

@@ -0,0 +1,100 @@
+package volume_test
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/JSYoo5B/SandStack/internal/app/volume"
+	"github.com/stretchr/testify/suite"
+)
+
+type SQLiteRepositorySuite struct {
+	suite.Suite
+	repository *volume.SQLiteRepository
+}
+
+func TestSQLiteRepositorySuite(t *testing.T) {
+	suite.Run(t, new(SQLiteRepositorySuite))
+}
+
+func (s *SQLiteRepositorySuite) SetupTest() {
+	repository, err := volume.OpenSQLiteRepository(":memory:")
+	s.Require().NoError(err)
+
+	s.repository = repository
+}
+
+func (s *SQLiteRepositorySuite) TearDownTest() {
+	s.Require().NoError(s.repository.Close())
+}
+
+func (s *SQLiteRepositorySuite) TestCreateListGetAndUpdateVolume() {
+	created := s.repository.Create(volumeFixture("vol-1"))
+	created.Status = "available"
+
+	updated, err := s.repository.Update(created)
+	s.Require().NoError(err)
+	listed := s.repository.List()
+	found, err := s.repository.Get(created.ID)
+	s.Require().NoError(err)
+
+	s.Assert().Len(listed, 1)
+	s.Assert().Equal(updated, listed[0])
+	s.Assert().Equal(updated, found)
+}
+
+func (s *SQLiteRepositorySuite) TestDeleteVolume() {
+	created := s.repository.Create(volumeFixture("vol-1"))
+
+	err := s.repository.Delete(created.ID)
+	s.Require().NoError(err)
+
+	_, err = s.repository.Get(created.ID)
+	s.Require().ErrorIs(err, volume.ErrVolumeNotFound)
+	s.Assert().Empty(s.repository.List())
+}
+
+func (s *SQLiteRepositorySuite) TestResetClearsVolumes() {
+	s.repository.Create(volumeFixture("vol-1"))
+
+	s.repository.Reset()
+
+	s.Assert().Empty(s.repository.List())
+}
+
+func (s *SQLiteRepositorySuite) TestFileBackedDatabasePersistsVolumes() {
+	path := filepath.Join(s.T().TempDir(), "sandstack.db")
+	repository, err := volume.OpenSQLiteRepository(path)
+	s.Require().NoError(err)
+
+	created := repository.Create(volumeFixture("vol-1"))
+	s.Require().NoError(repository.Close())
+
+	reopened, err := volume.OpenSQLiteRepository(path)
+	s.Require().NoError(err)
+	defer reopened.Close()
+
+	found, err := reopened.Get(created.ID)
+	s.Require().NoError(err)
+
+	s.Assert().Equal(created, found)
+}
+
+func volumeFixture(id string) volume.Volume {
+	return volume.Volume{
+		ID:          id,
+		Status:      "creating",
+		Size:        1,
+		Name:        "database",
+		Description: "test volume",
+		VolumeType:  "__DEFAULT__",
+		Metadata: map[string]string{
+			"role": "database",
+		},
+		CreatedAt:   "2026-07-03T00:00:00.000000",
+		UpdatedAt:   "2026-07-03T00:00:00.000000",
+		Bootable:    "false",
+		Encrypted:   true,
+		Multiattach: true,
+	}
+}