chore(tfstated): change database state id and version id formats to uuidv7

pkg/database/locks.go

@@ -4,6 +4,9 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
+	"fmt"
+
+	"go.n16f.net/uuid"
 )
 
 // Atomically check the lock status of a state and lock it if unlocked. Returns
@@ -18,7 +21,11 @@ func (db *DB) SetLockOrGetExistingLock(path string, lock any) (bool, error) {
 				if lockData, err = json.Marshal(lock); err != nil {
 					return err
 				}
-				_, err = tx.ExecContext(db.ctx, `INSERT INTO states(path, lock) VALUES (?, json(?))`, path, lockData)
+				var stateId uuid.UUID
+				if err := stateId.Generate(uuid.V7); err != nil {
+					return fmt.Errorf("failed to generate state id: %w", err)
+				}
+				_, err = tx.ExecContext(db.ctx, `INSERT INTO states(id, path, lock) VALUES (?, ?, json(?))`, stateId, path, lockData)
 				ret = true
 				return err
 			} else {

pkg/database/sql/000_init.sql

@@ -24,7 +24,7 @@ CREATE TABLE sessions (
 ) STRICT;
 
 CREATE TABLE states (
-  id INTEGER PRIMARY KEY,
+  id TEXT PRIMARY KEY,
   path TEXT NOT NULL,
   lock TEXT,
   created INTEGER DEFAULT (unixepoch()),
@@ -33,9 +33,9 @@ CREATE TABLE states (
 CREATE UNIQUE INDEX states_path on states(path);
 
 CREATE TABLE versions (
-  id INTEGER PRIMARY KEY,
+  id TEXT PRIMARY KEY,
   account_id TEXT NOT NULL,
-  state_id INTEGER,
+  state_id TEXT,
   data BLOB,
   lock TEXT,
   created INTEGER DEFAULT (unixepoch()),

pkg/database/states.go

@@ -9,6 +9,7 @@ import (
 
 	"git.adyxax.org/adyxax/tfstated/pkg/model"
 	"github.com/mattn/go-sqlite3"
+	"go.n16f.net/uuid"
 )
 
 func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Version, error) {
@@ -16,11 +17,21 @@ func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Ve
 	if err != nil {
 		return nil, fmt.Errorf("failed to encrypt state data: %w", err)
 	}
+	var stateId uuid.UUID
+	if err := stateId.Generate(uuid.V7); err != nil {
+		return nil, fmt.Errorf("failed to generate state id: %w", err)
+	}
+	var versionId uuid.UUID
+	if err := versionId.Generate(uuid.V7); err != nil {
+		return nil, fmt.Errorf("failed to generate version id: %w", err)
+	}
 	version := &model.Version{
 		AccountId: accountId,
+		Id:        versionId,
+		StateId:   stateId,
 	}
 	return version, db.WithTransaction(func(tx *sql.Tx) error {
-		result, err := tx.ExecContext(db.ctx, `INSERT INTO states(path) VALUES (?)`, path)
+		_, err := tx.ExecContext(db.ctx, `INSERT INTO states(id, path) VALUES (?, ?)`, stateId, path)
 		if err != nil {
 			var sqliteErr sqlite3.Error
 			if errors.As(err, &sqliteErr) {
@@ -31,25 +42,16 @@ func (db *DB) CreateState(path string, accountId string, data []byte) (*model.Ve
 			}
 			return fmt.Errorf("failed to insert new state: %w", err)
 		}
-		stateId, err := result.LastInsertId()
+		_, err = tx.ExecContext(db.ctx,
-		if err != nil {
+			`INSERT INTO versions(id, account_id, data, state_id)
-			return fmt.Errorf("failed to get last insert id for new state: %w", err)
+               VALUES (:id, :accountID, :data, :stateID)`,
-		}
-		version.StateId = int(stateId)
-		result, err = tx.ExecContext(db.ctx,
-			`INSERT INTO versions(account_id, data, state_id)
-               VALUES (:accountID, :data, :stateID)`,
 			sql.Named("accountID", accountId),
 			sql.Named("data", encryptedData),
+			sql.Named("id", versionId),
 			sql.Named("stateID", stateId))
 		if err != nil {
 			return fmt.Errorf("failed to insert new state version: %w", err)
 		}
-		versionId, err := result.LastInsertId()
-		if err != nil {
-			return fmt.Errorf("failed to get last insert id for new version of the state: %w", err)
-		}
-		version.Id = int(versionId)
 		return nil
 	})
 }
@@ -89,7 +91,7 @@ func (db *DB) GetState(path string) ([]byte, error) {
 	return db.dataEncryptionKey.DecryptAES256(encryptedData)
 }
 
-func (db *DB) LoadStateById(stateId int) (*model.State, error) {
+func (db *DB) LoadStateById(stateId uuid.UUID) (*model.State, error) {
 	state := model.State{
 		Id: stateId,
 	}
@@ -104,7 +106,7 @@ func (db *DB) LoadStateById(stateId int) (*model.State, error) {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
-		return nil, fmt.Errorf("failed to load state id %d from database: %w", stateId, err)
+		return nil, fmt.Errorf("failed to load state id %s from database: %w", stateId, err)
 	}
 	state.Created = time.Unix(created, 0)
 	state.Updated = time.Unix(updated, 0)
@@ -139,8 +141,8 @@ func (db *DB) LoadStates() ([]model.State, error) {
 	return states, nil
 }
 
-// returns true in case of id mismatch
+// returns true in case of lock mismatch
-func (db *DB) SetState(path string, accountID string, data []byte, lockID string) (bool, error) {
+func (db *DB) SetState(path string, accountId string, data []byte, lock string) (bool, error) {
 	encryptedData, err := db.dataEncryptionKey.EncryptAES256(data)
 	if err != nil {
 		return false, fmt.Errorf("failed to encrypt state data: %w", err)
@@ -148,45 +150,50 @@ func (db *DB) SetState(path string, accountID string, data []byte, lockID string
 	ret := false
 	return ret, db.WithTransaction(func(tx *sql.Tx) error {
 		var (
-			stateID  int64
+			stateId  string
 			lockData []byte
 		)
-		if err = tx.QueryRowContext(db.ctx, `SELECT id, lock->>'ID' FROM states WHERE path = ?;`, path).Scan(&stateID, &lockData); err != nil {
+		if err = tx.QueryRowContext(db.ctx, `SELECT id, lock->>'ID' FROM states WHERE path = ?;`, path).Scan(&stateId, &lockData); err != nil {
 			if errors.Is(err, sql.ErrNoRows) {
-				var result sql.Result
+				var stateUUID uuid.UUID
-				result, err = tx.ExecContext(db.ctx, `INSERT INTO states(path) VALUES (?)`, path)
+				if err := stateUUID.Generate(uuid.V7); err != nil {
+					return fmt.Errorf("failed to generate state id: %w", err)
+				}
+				_, err = tx.ExecContext(db.ctx, `INSERT INTO states(id, path) VALUES (?, ?)`, stateUUID, path)
 				if err != nil {
 					return fmt.Errorf("failed to insert new state: %w", err)
 				}
-				stateID, err = result.LastInsertId()
+				stateId = stateUUID.String()
-				if err != nil {
-					return fmt.Errorf("failed to get last insert id for new state: %w", err)
-				}
 			} else {
 				return err
 			}
 		}
 
-		if lockID != "" && slices.Compare([]byte(lockID), lockData) != 0 {
+		if lock != "" && slices.Compare([]byte(lock), lockData) != 0 {
-			err = fmt.Errorf("failed to update state, lock ID does not match")
+			err = fmt.Errorf("failed to update state: lock ID mismatch")
 			ret = true
 			return err
 		}
+		var versionId uuid.UUID
+		if err := versionId.Generate(uuid.V7); err != nil {
+			return fmt.Errorf("failed to generate version id: %w", err)
+		}
 		_, err = tx.ExecContext(db.ctx,
-			`INSERT INTO versions(account_id, state_id, data, lock)
+			`INSERT INTO versions(id, account_id, state_id, data, lock)
-           SELECT :accountID, :stateID, :data, lock
+           SELECT :versionId, :accountId, :stateId, :data, lock
              FROM states
-             WHERE states.id = :stateID;`,
+             WHERE states.id = :stateId;`,
-			sql.Named("accountID", accountID),
+			sql.Named("accountId", accountId),
-			sql.Named("stateID", stateID),
+			sql.Named("data", encryptedData),
-			sql.Named("data", encryptedData))
+			sql.Named("stateId", stateId),
+			sql.Named("versionId", versionId))
 		if err != nil {
 			return fmt.Errorf("failed to insert new state version: %w", err)
 		}
 		_, err = tx.ExecContext(db.ctx,
 			`UPDATE states SET updated = ? WHERE id = ?;`,
 			time.Now().UTC().Unix(),
-			stateID)
+			stateId)
 		if err != nil {
 			return fmt.Errorf("failed to touch updated for state: %w", err)
 		}

pkg/database/versions.go

@@ -7,9 +7,10 @@ import (
 	"time"
 
 	"git.adyxax.org/adyxax/tfstated/pkg/model"
+	"go.n16f.net/uuid"
 )
 
-func (db *DB) LoadVersionById(id int) (*model.Version, error) {
+func (db *DB) LoadVersionById(id uuid.UUID) (*model.Version, error) {
 	version := model.Version{
 		Id: id,
 	}
@@ -29,12 +30,12 @@ func (db *DB) LoadVersionById(id int) (*model.Version, error) {
 		if errors.Is(err, sql.ErrNoRows) {
 			return nil, nil
 		}
-		return nil, fmt.Errorf("failed to load version id %d from database: %w", id, err)
+		return nil, fmt.Errorf("failed to load version id %s from database: %w", id, err)
 	}
 	version.Created = time.Unix(created, 0)
 	version.Data, err = db.dataEncryptionKey.DecryptAES256(encryptedData)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decrypt version %d data: %w", id, err)
+		return nil, fmt.Errorf("failed to decrypt version %s data: %w", id, err)
 	}
 	return &version, nil
 }

pkg/model/state.go

@@ -2,11 +2,13 @@ package model
 
 import (
 	"time"
+
+	"go.n16f.net/uuid"
 )
 
 type State struct {
 	Created time.Time
-	Id      int
+	Id      uuid.UUID
 	Lock    *string
 	Path    string
 	Updated time.Time

pkg/model/version.go

@@ -3,13 +3,15 @@ package model
 import (
 	"encoding/json"
 	"time"
+
+	"go.n16f.net/uuid"
 )
 
 type Version struct {
 	AccountId string
 	Created   time.Time
 	Data      json.RawMessage
-	Id        int
+	Id        uuid.UUID
 	Lock      *string
-	StateId   int
+	StateId   uuid.UUID
 }

pkg/webui/state.go

@@ -3,10 +3,10 @@ package webui
 import (
 	"html/template"
 	"net/http"
-	"strconv"
 
 	"git.adyxax.org/adyxax/tfstated/pkg/database"
 	"git.adyxax.org/adyxax/tfstated/pkg/model"
+	"go.n16f.net/uuid"
 )
 
 var stateTemplate = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/state.html"))
@@ -19,9 +19,8 @@ func handleStateGET(db *database.DB) http.Handler {
 		Versions  []model.Version
 	}
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		stateIdStr := r.PathValue("id")
+		var stateId uuid.UUID
-		stateId, err := strconv.Atoi(stateIdStr)
+		if err := stateId.Parse(r.PathValue("id")); err != nil {
-		if err != nil {
 			errorResponse(w, http.StatusBadRequest, err)
 			return
 		}

pkg/webui/states.go

@@ -7,7 +7,6 @@ import (
 	"net/http"
 	"net/url"
 	"path"
-	"strconv"
 
 	"git.adyxax.org/adyxax/tfstated/pkg/database"
 	"git.adyxax.org/adyxax/tfstated/pkg/model"
@@ -87,7 +86,7 @@ func handleStatesPOST(db *database.DB) http.Handler {
 			})
 			return
 		}
-		destination := path.Join("/version", strconv.Itoa(version.Id))
+		destination := path.Join("/version", version.Id.String())
 		http.Redirect(w, r, destination, http.StatusFound)
 	})
 }

pkg/webui/version.go

@@ -1,13 +1,13 @@
 package webui
 
 import (
-	"fmt"
 	"html/template"
 	"net/http"
-	"strconv"
+	"path"
 
 	"git.adyxax.org/adyxax/tfstated/pkg/database"
 	"git.adyxax.org/adyxax/tfstated/pkg/model"
+	"go.n16f.net/uuid"
 )
 
 var versionTemplate = template.Must(template.ParseFS(htmlFS, "html/base.html", "html/version.html"))
@@ -21,9 +21,8 @@ func handleVersionGET(db *database.DB) http.Handler {
 		VersionData string
 	}
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		versionIdStr := r.PathValue("id")
+		var versionId uuid.UUID
-		versionId, err := strconv.Atoi(versionIdStr)
+		if err := versionId.Parse(r.PathValue("id")); err != nil {
-		if err != nil {
 			errorResponse(w, http.StatusBadRequest, err)
 			return
 		}
@@ -49,7 +48,7 @@ func handleVersionGET(db *database.DB) http.Handler {
 		versionData := string(version.Data[:])
 		render(w, versionTemplate, http.StatusOK, VersionsData{
 			Page: makePage(r, &Page{
-				Precedent: fmt.Sprintf("/state/%d", state.Id),
+				Precedent: path.Join("/state/", state.Id.String()),
 				Section:   "states",
 				Title:     state.Path,
 			}),