Merged in feature/textextract (pull request #108)

Start adding Textract + UUID changes

* base

* startclient

* ts

* short

* tests

internal/query/create.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"fmt"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	contextfull "queryorchestration/internal/query/types/contextFull"
 	jsonextractor "queryorchestration/internal/query/types/jsonExtractor"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 )
 
 func (s *Service) Create(ctx context.Context, entity *resultprocessor.Create) (uuid.UUID, error) {
@@ -58,20 +56,20 @@ func (s *Service) submitCreate(ctx context.Context, entity *resultprocessor.Crea
 		return uuid.Nil, err
 	}
 
-	var dbID pgtype.UUID
+	var id uuid.UUID
 	err = s.cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, qtx *repository.Queries) error {
-		dbID, err = qtx.CreateQuery(ctx, query.Type)
+		id, err = qtx.CreateQuery(ctx, query.Type)
 		if err != nil {
 			return err
 		}
 
-		version, err := qtx.AddLatestQueryVersion(ctx, dbID)
+		version, err := qtx.AddLatestQueryVersion(ctx, id)
 		if err != nil {
 			return err
 		}
 
 		err = qtx.AddActiveQueryVersion(ctx, &repository.AddActiveQueryVersionParams{
-			Queryid:   dbID,
+			Queryid:   id,
 			Versionid: version,
 		})
 		if err != nil {
@@ -81,7 +79,7 @@ func (s *Service) submitCreate(ctx context.Context, entity *resultprocessor.Crea
 		if query.RequiredQueryIDs != nil {
 			for _, reqQuery := range *query.RequiredQueryIDs {
 				err = qtx.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
-					Queryid:         dbID,
+					Queryid:         id,
 					Requiredqueryid: reqQuery,
 					Addedversion:    version,
 				})
@@ -93,7 +91,7 @@ func (s *Service) submitCreate(ctx context.Context, entity *resultprocessor.Crea
 
 		if query.Config != nil {
 			err = qtx.SetQueryConfig(ctx, &repository.SetQueryConfigParams{
-				Queryid:      dbID,
+				Queryid:      id,
 				Config:       *query.Config,
 				Addedversion: version,
 			})
@@ -108,11 +106,6 @@ func (s *Service) submitCreate(ctx context.Context, entity *resultprocessor.Crea
 		return uuid.Nil, err
 	}
 
-	id, err := database.ToUUID(dbID)
-	if err != nil {
-		return uuid.Nil, err
-	}
-
 	return id, nil
 
 }
@@ -130,7 +123,7 @@ func (s *Service) getCreator(qType resultprocessor.Type) (resultprocessor.Creato
 
 type createQuery struct {
 	Type             repository.Querytype
-	RequiredQueryIDs *[]pgtype.UUID
+	RequiredQueryIDs *[]uuid.UUID
 	Config           *[]byte
 }
 
@@ -140,9 +133,9 @@ func parseCreateQuery(q *resultprocessor.Create) (*createQuery, error) {
 		return nil, err
 	}
 
-	var reqIDs *[]pgtype.UUID
+	var reqIDs *[]uuid.UUID
 	if q.RequiredQueryIDs != nil {
-		tIDs := database.MustToDBUUIDArray(*q.RequiredQueryIDs)
+		tIDs := *q.RequiredQueryIDs
 		reqIDs = &tIDs
 	}
 

internal/query/create_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -47,26 +46,26 @@ func TestCreate(t *testing.T) {
 	dbType, err := resultprocessor.ToDBQueryType(create.Type)
 	require.NoError(t, err)
 
-	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(database.MustToDBUUIDArray(*create.RequiredQueryIDs)).WillReturnRows(
+	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(*create.RequiredQueryIDs).WillReturnRows(
 		pgxmock.NewRows([]string{"all_exist"}).AddRow(true),
 	)
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
 		pgxmock.NewRows([]string{"id"}).
-			AddRow(database.MustToDBUUID(q.ID)),
+			AddRow(q.ID),
 	)
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(q.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(q.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(1)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), int32(1)).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	for _, req := range *create.RequiredQueryIDs {
-		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(database.MustToDBUUID(q.ID), database.MustToDBUUID(req), int32(1)).
+		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(q.ID, req, int32(1)).
 			WillReturnResult(pgxmock.NewResult("", 1))
 	}
-	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(database.MustToDBUUID(q.ID), []byte(*create.Config), int32(1)).
+	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(q.ID, []byte(*create.Config), int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 
@@ -99,13 +98,13 @@ func TestCreateMinimal(t *testing.T) {
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
 		pgxmock.NewRows([]string{"id"}).
-			AddRow(database.MustToDBUUID(q.ID)),
+			AddRow(q.ID),
 	)
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(q.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(q.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(1)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), int32(1)).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 

internal/query/createprivate_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	"queryorchestration/internal/serviceconfig"
@@ -51,7 +50,7 @@ func TestParseCreateQuery(t *testing.T) {
 
 	resultQuery, err := parseCreateQuery(cQuery)
 	require.NoError(t, err)
-	rQIDs := database.MustToDBUUIDArray(*cQuery.RequiredQueryIDs)
+	rQIDs := *cQuery.RequiredQueryIDs
 	qcfg := []byte(*cQuery.Config)
 	assert.EqualExportedValues(t, createQuery{
 		Type:             repository.QuerytypeContextFull,
@@ -105,19 +104,19 @@ func TestSubmitCreate(t *testing.T) {
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
 		pgxmock.NewRows([]string{"id"}).
-			AddRow(database.MustToDBUUID(q.ID)),
+			AddRow(q.ID),
 	)
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(q.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(q.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(1)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), int32(1)).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	for _, req := range *create.RequiredQueryIDs {
-		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(database.MustToDBUUID(q.ID), database.MustToDBUUID(req), int32(1)).
+		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(q.ID, req, int32(1)).
 			WillReturnResult(pgxmock.NewResult("", 1))
 	}
-	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(database.MustToDBUUID(q.ID), []byte(*create.Config), int32(1)).
+	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(q.ID, []byte(*create.Config), int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 
@@ -150,13 +149,13 @@ func TestSubmitCreateNoReqsOrConfig(t *testing.T) {
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows(
 		pgxmock.NewRows([]string{"id"}).
-			AddRow(database.MustToDBUUID(q.ID)),
+			AddRow(q.ID),
 	)
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(q.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(q.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(1)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), int32(1)).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, int32(1)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 
@@ -181,7 +180,7 @@ func TestNormalizeCreate(t *testing.T) {
 		RequiredQueryIDs: &[]uuid.UUID{},
 	}
 
-	dbids := database.MustToDBUUIDArray(*create.RequiredQueryIDs)
+	dbids := *create.RequiredQueryIDs
 
 	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 		pgxmock.NewRows([]string{"all_exist"}).

internal/query/get.go

@@ -3,7 +3,6 @@ package query
 import (
 	"context"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 
@@ -21,7 +20,7 @@ type Query struct {
 
 func (s *Service) GetWithVersion(ctx context.Context, id uuid.UUID, version int32) (*Query, error) {
 	query, err := s.cfg.GetDBQueries().GetQueryWithVersion(ctx, &repository.GetQueryWithVersionParams{
-		ID:      database.MustToDBUUID(id),
+		ID:      &id,
 		Version: &version,
 	})
 	if err != nil {
@@ -32,7 +31,7 @@ func (s *Service) GetWithVersion(ctx context.Context, id uuid.UUID, version int3
 }
 
 func (s *Service) Get(ctx context.Context, id uuid.UUID) (*Query, error) {
-	query, err := s.cfg.GetDBQueries().GetQuery(ctx, database.MustToDBUUID(id))
+	query, err := s.cfg.GetDBQueries().GetQuery(ctx, id)
 	if err != nil {
 		return nil, err
 	}

internal/query/get_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -38,11 +37,11 @@ func TestGet(t *testing.T) {
 		Config: &config,
 	}
 
-	dbReqIDs := database.MustToDBUUIDArray(*query.RequiredQueryIDs)
+	dbReqIDs := *query.RequiredQueryIDs
 
-	pool.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows(
+	pool.ExpectQuery("name: GetQuery :one").WithArgs(query.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.ActiveVersion, query.LatestVersion, []byte(config), dbReqIDs),
+			AddRow(query.ID, repository.QuerytypeJsonExtractor, query.ActiveVersion, query.LatestVersion, []byte(config), dbReqIDs),
 	)
 
 	returnQuery, err := svc.Get(ctx, query.ID)
@@ -75,11 +74,11 @@ func TestGetWithVersion(t *testing.T) {
 
 	version := int32(2)
 
-	dbReqIDs := database.MustToDBUUIDArray(*query.RequiredQueryIDs)
+	dbReqIDs := *query.RequiredQueryIDs
 
-	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(database.MustToDBUUID(query.ID), &version).WillReturnRows(
+	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(&query.ID, &version).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.ActiveVersion, query.LatestVersion, []byte(config), dbReqIDs),
+			AddRow(query.ID, repository.QuerytypeJsonExtractor, query.ActiveVersion, query.LatestVersion, []byte(config), dbReqIDs),
 	)
 
 	returnQuery, err := svc.GetWithVersion(ctx, query.ID, version)

internal/query/list.go

@@ -3,8 +3,6 @@ package query
 import (
 	"context"
 
-	"queryorchestration/internal/database"
-
 	"github.com/google/uuid"
 )
 
@@ -23,7 +21,7 @@ func (s *Service) List(ctx context.Context) ([]*Query, error) {
 }
 
 func (s *Service) ListById(ctx context.Context, ids []uuid.UUID) ([]*Query, error) {
-	dbQueries, err := s.cfg.GetDBQueries().ListQueriesById(ctx, database.MustToDBUUIDArray(ids))
+	dbQueries, err := s.cfg.GetDBQueries().ListQueriesById(ctx, ids)
 	if err != nil {
 		return nil, err
 	}

internal/query/list_test.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	"queryorchestration/internal/serviceconfig"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/require"
 
@@ -40,11 +38,11 @@ func TestList(t *testing.T) {
 		Config: &config,
 	}
 
-	dbReqIDs := database.MustToDBUUIDArray(*q.RequiredQueryIDs)
+	dbReqIDs := *q.RequiredQueryIDs
 
 	pool.ExpectQuery("name: ListQueries :many").WithArgs().WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(q.ID), repository.QuerytypeJsonExtractor, q.ActiveVersion, q.LatestVersion, []byte(config), dbReqIDs),
+			AddRow(q.ID, repository.QuerytypeJsonExtractor, q.ActiveVersion, q.LatestVersion, []byte(config), dbReqIDs),
 	)
 
 	resList, err := svc.List(ctx)
@@ -75,11 +73,11 @@ func TestListById(t *testing.T) {
 		Config: &config,
 	}
 
-	dbReqIDs := database.MustToDBUUIDArray(*q.RequiredQueryIDs)
+	dbReqIDs := *q.RequiredQueryIDs
 
-	pool.ExpectQuery("name: ListQueriesById :many").WithArgs([]pgtype.UUID{database.MustToDBUUID(q.ID)}).WillReturnRows(
+	pool.ExpectQuery("name: ListQueriesById :many").WithArgs([]uuid.UUID{q.ID}).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(q.ID), repository.QuerytypeJsonExtractor, q.ActiveVersion, q.LatestVersion, []byte(config), dbReqIDs),
+			AddRow(q.ID, repository.QuerytypeJsonExtractor, q.ActiveVersion, q.LatestVersion, []byte(config), dbReqIDs),
 	)
 
 	resList, err := svc.ListById(ctx, []uuid.UUID{q.ID})

internal/query/normalize.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"strings"
 
-	"queryorchestration/internal/database"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	"queryorchestration/internal/validation"
 
@@ -72,7 +71,7 @@ func (s *Service) NormalizeQueryIDs(ctx context.Context, ids RequiredQueryIDs) e
 	dedup := validation.DeduplicateArray(*ide)
 	ids.SetRequiredQueryIDs(&dedup)
 
-	dbids := database.MustToDBUUIDArray(dedup)
+	dbids := dedup
 
 	exist, err := s.cfg.GetDBQueries().AllQueriesExist(ctx, dbids)
 	if err != nil {

internal/query/normalize_test.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	"queryorchestration/internal/serviceconfig"
@@ -97,7 +96,7 @@ func TestNormalizeQueryIDs(t *testing.T) {
 
 	ids := []uuid.UUID{uuid.New()}
 	entity.RequiredQueryIDs = &ids
-	dbids := database.MustToDBUUIDArray(*entity.RequiredQueryIDs)
+	dbids := *entity.RequiredQueryIDs
 
 	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 		pgxmock.NewRows([]string{"all_exist"}).
@@ -127,7 +126,7 @@ func TestNormalizeQueryIDs(t *testing.T) {
 	singleid := uuid.New()
 	entity.RequiredQueryIDs = &[]uuid.UUID{singleid, singleid}
 	outids := []uuid.UUID{singleid}
-	dbids = database.MustToDBUUIDArray(outids)
+	dbids = outids
 
 	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 		pgxmock.NewRows([]string{"all_exist"}).

internal/query/parse.go

@@ -1,7 +1,6 @@
 package query
 
 import (
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 
@@ -30,15 +29,6 @@ func ParseQuery(q *Query) *resultprocessor.Query {
 }
 
 func ParseFullActiveQuery(q *repository.Fullactivequery) (*Query, error) {
-	var reqQueryIDs *[]uuid.UUID
-	if len(q.Requiredids) > 0 {
-		rQ, err := database.ToUUIDArray(q.Requiredids)
-		if err != nil {
-			return nil, err
-		}
-		reqQueryIDs = &rQ
-	}
-
 	qType, err := resultprocessor.ParseDBType(q.Type)
 	if err != nil {
 		return nil, err
@@ -50,12 +40,17 @@ func ParseFullActiveQuery(q *repository.Fullactivequery) (*Query, error) {
 		scfg = &s
 	}
 
+	var reqIds *[]uuid.UUID
+	if len(q.Requiredids) > 0 {
+		reqIds = &q.Requiredids
+	}
+
 	return &Query{
-		ID:               database.MustToUUID(q.ID),
+		ID:               q.ID,
 		ActiveVersion:    q.Activeversion,
 		LatestVersion:    q.Latestversion,
 		Type:             qType,
-		RequiredQueryIDs: reqQueryIDs,
+		RequiredQueryIDs: reqIds,
 		Config:           scfg,
 	}, nil
 }

internal/query/parse_test.go

@@ -3,13 +3,11 @@ package query_test
 import (
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -39,12 +37,12 @@ func TestParseQuery(t *testing.T) {
 
 func TestParseFullActiveQuery(t *testing.T) {
 	q := &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: int32(1),
 		Latestversion: int32(2),
-		Requiredids: []pgtype.UUID{
-			database.MustToDBUUID(uuid.New()),
+		Requiredids: []uuid.UUID{
+			uuid.New(),
 		},
 		Config: []byte("example"),
 	}
@@ -53,12 +51,12 @@ func TestParseFullActiveQuery(t *testing.T) {
 	require.NoError(t, err)
 	bcfg := string(q.Config)
 	assert.EqualExportedValues(t, query.Query{
-		ID:            database.MustToUUID(q.ID),
+		ID:            q.ID,
 		Type:          resultprocessor.TypeContextFull,
 		ActiveVersion: q.Activeversion,
 		LatestVersion: q.Latestversion,
 		RequiredQueryIDs: &[]uuid.UUID{
-			database.MustToUUID(q.Requiredids[0]),
+			q.Requiredids[0],
 		},
 		Config: &bcfg,
 	}, *out)
@@ -66,7 +64,7 @@ func TestParseFullActiveQuery(t *testing.T) {
 
 func TestFullActiveQueryEmpty(t *testing.T) {
 	dbQuery := &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: int32(1),
 		Latestversion: int32(2),
@@ -75,7 +73,7 @@ func TestFullActiveQueryEmpty(t *testing.T) {
 	out, err := query.ParseFullActiveQuery(dbQuery)
 	require.NoError(t, err)
 	assert.EqualExportedValues(t, query.Query{
-		ID:            database.MustToUUID(dbQuery.ID),
+		ID:            dbQuery.ID,
 		Type:          resultprocessor.TypeContextFull,
 		ActiveVersion: int32(1),
 		LatestVersion: int32(2),
@@ -84,7 +82,7 @@ func TestFullActiveQueryEmpty(t *testing.T) {
 
 func TestFullActiveQueryWithNullUUID(t *testing.T) {
 	dbQuery := &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: int32(1),
 		Latestversion: int32(2),
@@ -93,7 +91,7 @@ func TestFullActiveQueryWithNullUUID(t *testing.T) {
 	out, err := query.ParseFullActiveQuery(dbQuery)
 	require.NoError(t, err)
 	assert.EqualExportedValues(t, query.Query{
-		ID:            database.MustToUUID(dbQuery.ID),
+		ID:            dbQuery.ID,
 		Type:          resultprocessor.TypeContextFull,
 		ActiveVersion: int32(1),
 		LatestVersion: int32(2),
@@ -103,7 +101,7 @@ func TestFullActiveQueryWithNullUUID(t *testing.T) {
 func TestFullActiveQueryArray(t *testing.T) {
 	dbQueries := []*repository.Fullactivequery{
 		{
-			ID:            database.MustToDBUUID(uuid.New()),
+			ID:            uuid.New(),
 			Type:          repository.QuerytypeContextFull,
 			Activeversion: int32(1),
 			Latestversion: int32(2),
@@ -114,7 +112,7 @@ func TestFullActiveQueryArray(t *testing.T) {
 	require.NoError(t, err)
 	assert.EqualExportedValues(t, []*query.Query{
 		{
-			ID:            database.MustToUUID(dbQueries[0].ID),
+			ID:            dbQueries[0].ID,
 			Type:          resultprocessor.TypeContextFull,
 			ActiveVersion: int32(1),
 			LatestVersion: int32(2),

internal/query/result/get.go

@@ -5,7 +5,6 @@ import (
 	"errors"
 	"fmt"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	contextfull "queryorchestration/internal/query/types/contextFull"
@@ -23,9 +22,9 @@ type GetValueWithVersionParams struct {
 
 func (s *Service) GetValueWithVersion(ctx context.Context, params *GetValueWithVersionParams) (resultprocessor.Value, error) {
 	res, err := s.cfg.GetDBQueries().GetResultValueWithVersion(ctx, &repository.GetResultValueWithVersionParams{
-		Queryid:      database.MustToDBUUID(params.QueryID),
+		Queryid:      &params.QueryID,
 		Queryversion: &params.QueryVersion,
-		Documentid:   database.MustToDBUUID(params.DocumentID),
+		Documentid:   &params.DocumentID,
 	})
 	if err != nil {
 		return nil, err

internal/query/result/get_test.go

@@ -4,14 +4,12 @@ import (
 	"context"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	jsonextractor "queryorchestration/internal/query/types/jsonExtractor"
 	"queryorchestration/internal/serviceconfig"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -49,10 +47,10 @@ func TestGetValueWithVersion(t *testing.T) {
 	}
 
 	value := "exaple_value"
-	pool.ExpectQuery("name: GetResultValueWithVersion :one").WithArgs(database.MustToDBUUID(params.QueryID), &params.QueryVersion, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: GetResultValueWithVersion :one").WithArgs(&params.QueryID, &params.QueryVersion, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "value"}).
-				AddRow(pgtype.UUID{}, &value),
+				AddRow(&uuid.UUID{}, &value),
 		)
 
 	val, err := svc.GetValueWithVersion(ctx, params)

internal/query/result/process.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"log/slog"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	contextfull "queryorchestration/internal/query/types/contextFull"
@@ -70,8 +69,8 @@ func (s *Service) listRequiredValues(ctx context.Context, p *Process, query *res
 	}
 
 	qResults, err := s.cfg.GetDBQueries().ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
-		Queryid:    database.MustToDBUUID(p.QueryID),
-		Documentid: database.MustToDBUUID(p.DocumentID),
+		Queryid:    &p.QueryID,
+		Documentid: &p.DocumentID,
 		Version:    &p.QueryVersion,
 	})
 	if err != nil && !errors.Is(err, sql.ErrNoRows) {

internal/query/result/process_test.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -46,17 +45,17 @@ func TestProcess(t *testing.T) {
 		QueryVersion: query.Version,
 	}
 
-	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(database.MustToDBUUID(query.ID), &query.Version).WillReturnRows(
+	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(&query.ID, &query.Version).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), database.MustToDBUUIDArray(*query.RequiredQueryIDs)),
+			AddRow(query.ID, repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), *query.RequiredQueryIDs),
 	)
 	strVal := `{"examplekey":"example_value"}`
-	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(database.MustToDBUUID(query.ID), &query.Version, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&query.ID, &query.Version, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
-				AddRow(database.MustToDBUUID(uuid.New()), database.MustToDBUUID(query.ID), repository.QuerytypeContextFull, &strVal),
+				AddRow(&uuid.UUID{}, query.ID, repository.QuerytypeContextFull, &strVal),
 		)
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows(
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"config"}).
 			AddRow([]byte(qcfg)),
 	)
@@ -109,10 +108,10 @@ func TestListRequiredValue(t *testing.T) {
 
 	strVal := "axe_value"
 
-	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(database.MustToDBUUID(query.ID), &query.Version, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&query.ID, &query.Version, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
-				AddRow(database.MustToDBUUID(uuid.New()), database.MustToDBUUID((*query.RequiredQueryIDs)[0]), repository.QuerytypeJsonExtractor, &strVal),
+				AddRow(&uuid.UUID{}, (*query.RequiredQueryIDs)[0], repository.QuerytypeJsonExtractor, &strVal),
 		)
 
 	pr, err = svc.listRequiredValues(ctx, &params, query)
@@ -141,7 +140,7 @@ func TestParseQueryRequirementValueArray(t *testing.T) {
 	exval := "exampleval"
 	in := []*repository.ListQueryRequirementValuesRow{
 		{
-			Queryid: database.MustToDBUUID(uuid.New()),
+			Queryid: uuid.New(),
 			Value:   &exval,
 			Type:    repository.QuerytypeJsonExtractor,
 		},

internal/query/result/processor/parse.go

@@ -3,7 +3,6 @@ package resultprocessor
 import (
 	"fmt"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 
 	"github.com/google/uuid"
@@ -67,22 +66,21 @@ func ToDBNullQueryType(t Type) (repository.NullQuerytype, error) {
 }
 
 func ParseDBCollectorQuery(q *repository.Collectorquerydependencytree) (*Query, error) {
-	var reqQueryIDs *[]uuid.UUID
-	if len(q.Requiredids) > 0 {
-		ids := database.MustToUUIDArray(q.Requiredids)
-		reqQueryIDs = &ids
-	}
-
 	qType, err := ParseDBType(q.Type)
 	if err != nil {
 		return nil, err
 	}
 
+	var reqIds *[]uuid.UUID
+	if len(q.Requiredids) > 0 {
+		reqIds = &q.Requiredids
+	}
+
 	return &Query{
-		ID:               database.MustToUUID(q.Queryid),
+		ID:               *q.Queryid,
 		Version:          q.Queryversion,
 		Type:             qType,
-		RequiredQueryIDs: reqQueryIDs,
+		RequiredQueryIDs: reqIds,
 	}, nil
 }
 
@@ -96,23 +94,22 @@ func ParseFullQuery(qs *repository.Fullactivequery) (*Query, error) {
 		return nil, err
 	}
 
-	var rids *[]uuid.UUID
-	if len(qs.Requiredids) > 0 {
-		r := database.MustToUUIDArray(qs.Requiredids)
-		rids = &r
-	}
-
 	var cfg *string
 	if qs.Config != nil {
 		c := string(qs.Config)
 		cfg = &c
 	}
 
+	var reqIds *[]uuid.UUID
+	if len(qs.Requiredids) > 0 {
+		reqIds = &qs.Requiredids
+	}
+
 	return &Query{
-		ID:               database.MustToUUID(qs.ID),
+		ID:               qs.ID,
 		Type:             qt,
 		Version:          qs.Activeversion,
-		RequiredQueryIDs: rids,
+		RequiredQueryIDs: reqIds,
 		Config:           cfg,
 	}, nil
 }

internal/query/result/processor/parse_test.go

@@ -3,21 +3,19 @@ package resultprocessor_test
 import (
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
 func TestParseDBCollectorQuery(t *testing.T) {
 	dbResult := repository.Collectorquerydependencytree{
-		Clientid:     pgtype.UUID{},
-		Queryid:      pgtype.UUID{},
-		Requiredids:  []pgtype.UUID{},
+		Clientid:     uuid.UUID{},
+		Queryid:      &uuid.UUID{},
+		Requiredids:  []uuid.UUID{},
 		Type:         repository.QuerytypeJsonExtractor,
 		Queryversion: 1,
 	}
@@ -118,7 +116,7 @@ func TestParseFullQuery(t *testing.T) {
 	assert.Nil(t, out)
 
 	q = &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: 1,
 		Latestversion: 2,
@@ -126,36 +124,36 @@ func TestParseFullQuery(t *testing.T) {
 
 	out, err = resultprocessor.ParseFullQuery(q)
 	require.NoError(t, err)
-	assert.EqualExportedValues(t, &resultprocessor.Query{
-		ID:      database.MustToUUID(q.ID),
+	assert.EqualExportedValues(t, resultprocessor.Query{
+		ID:      q.ID,
 		Type:    resultprocessor.TypeContextFull,
 		Version: 1,
-	}, out)
+	}, *out)
 
 	q = &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: 1,
 		Latestversion: 2,
-		Requiredids:   []pgtype.UUID{},
+		Requiredids:   []uuid.UUID{},
 	}
 
 	out, err = resultprocessor.ParseFullQuery(q)
 	require.NoError(t, err)
 	assert.EqualExportedValues(t, &resultprocessor.Query{
-		ID:      database.MustToUUID(q.ID),
+		ID:      q.ID,
 		Type:    resultprocessor.TypeContextFull,
 		Version: 1,
 	}, out)
 
 	q = &repository.Fullactivequery{
-		ID:            database.MustToDBUUID(uuid.New()),
+		ID:            uuid.New(),
 		Type:          repository.QuerytypeContextFull,
 		Activeversion: 1,
 		Latestversion: 2,
 		Config:        []byte("hello"),
-		Requiredids: []pgtype.UUID{
-			database.MustToDBUUID(uuid.New()),
+		Requiredids: []uuid.UUID{
+			uuid.New(),
 		},
 	}
 
@@ -163,11 +161,11 @@ func TestParseFullQuery(t *testing.T) {
 	require.NoError(t, err)
 	cfg := "hello"
 	assert.EqualExportedValues(t, &resultprocessor.Query{
-		ID:               database.MustToUUID(q.ID),
+		ID:               q.ID,
 		Type:             resultprocessor.TypeContextFull,
 		Version:          1,
 		Config:           &cfg,
-		RequiredQueryIDs: &[]uuid.UUID{database.MustToUUID(q.Requiredids[0])},
+		RequiredQueryIDs: &[]uuid.UUID{q.Requiredids[0]},
 	}, out)
 }
 
@@ -179,7 +177,7 @@ func TestParseFullQueryArray(t *testing.T) {
 
 	q = []*repository.Fullactivequery{
 		{
-			ID:            database.MustToDBUUID(uuid.New()),
+			ID:            uuid.New(),
 			Type:          repository.QuerytypeContextFull,
 			Activeversion: 1,
 			Latestversion: 2,
@@ -190,7 +188,7 @@ func TestParseFullQueryArray(t *testing.T) {
 	require.NoError(t, err)
 	assert.EqualExportedValues(t, []*resultprocessor.Query{
 		{
-			ID:      database.MustToUUID(q[0].ID),
+			ID:      q[0].ID,
 			Type:    resultprocessor.TypeContextFull,
 			Version: 1,
 		},

internal/query/result/set/set.go

@@ -6,9 +6,9 @@ import (
 	"errors"
 	"log/slog"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query/result"
+	resultprocessor "queryorchestration/internal/query/result/processor"
 
 	"github.com/google/uuid"
 )
@@ -19,7 +19,7 @@ type Set struct {
 }
 
 func (s *Service) Set(ctx context.Context, params *Set) error {
-	dbid := database.MustToDBUUID(params.DocumentID)
+	dbid := params.DocumentID
 	textVersion, err := s.cfg.GetDBQueries().GetTextEntryByDocId(ctx, dbid)
 	if err != nil {
 		return err
@@ -39,38 +39,7 @@ func (s *Service) Set(ctx context.Context, params *Set) error {
 		return err
 	}
 
-	err = s.cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, q *repository.Queries) error {
-		id, err := q.AddResult(ctx, &repository.AddResultParams{
-			Queryid:      database.MustToDBUUID(params.QueryID),
-			Value:        value.GetStoreValue(),
-			Queryversion: query.ActiveVersion,
-			Textentryid:  textVersion.ID,
-		})
-		if err != nil {
-			return err
-		}
-
-		qResults, err := q.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
-			Queryid:    database.MustToDBUUID(params.QueryID),
-			Documentid: database.MustToDBUUID(params.DocumentID),
-			Version:    &query.ActiveVersion,
-		})
-		if err != nil && !errors.Is(err, sql.ErrNoRows) {
-			return err
-		}
-
-		for _, result := range qResults {
-			err = q.AddResultDependency(ctx, &repository.AddResultDependencyParams{
-				Resultid:         id,
-				Requiredresultid: result.ID,
-			})
-			if err != nil {
-				return err
-			}
-		}
-
-		return nil
-	})
+	err = s.storeResult(ctx, textVersion, params, query.ActiveVersion, value)
 	if err != nil {
 		return err
 	}
@@ -80,14 +49,49 @@ func (s *Service) Set(ctx context.Context, params *Set) error {
 	return s.informQueryDependents(ctx, params)
 }
 
+func (s *Service) storeResult(ctx context.Context, textVersion *repository.Currenttextentry, params *Set, activeVersion int32, value resultprocessor.Value) error {
+	return s.cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, q *repository.Queries) error {
+		id, err := q.AddResult(ctx, &repository.AddResultParams{
+			Queryid:      params.QueryID,
+			Value:        value.GetStoreValue(),
+			Queryversion: activeVersion,
+			Textentryid:  textVersion.ID,
+		})
+		if err != nil {
+			return err
+		}
+
+		qResults, err := q.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{
+			Queryid:    &params.QueryID,
+			Documentid: &params.DocumentID,
+			Version:    &activeVersion,
+		})
+		if err != nil && !errors.Is(err, sql.ErrNoRows) {
+			return err
+		}
+
+		for _, result := range qResults {
+			err = q.AddResultDependency(ctx, &repository.AddResultDependencyParams{
+				Resultid:         id,
+				Requiredresultid: *result.ID,
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
 func (s *Service) informQueryDependents(ctx context.Context, params *Set) error {
 	ids, err := s.cfg.GetDBQueries().ListQueryDirectDependentsByDocumentID(ctx, &repository.ListQueryDirectDependentsByDocumentIDParams{
-		Documentid: database.MustToDBUUID(params.DocumentID),
-		Queryid:    database.MustToDBUUID(params.QueryID),
+		Documentid: params.DocumentID,
+		Queryid:    params.QueryID,
 	})
 	if err != nil {
 		return err
 	}
 
-	return s.svc.Sync.TriggerMultiSync(ctx, params.DocumentID, database.MustToUUIDArray(ids))
+	return s.svc.Sync.TriggerMultiSync(ctx, params.DocumentID, ids)
 }

internal/query/result/set/set_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	"queryorchestration/internal/query/result"
@@ -53,10 +52,11 @@ func TestSet(t *testing.T) {
 	}
 
 	qcfg := "{\"path\":\"examplekey\"}"
+	requiredQuery := uuid.New()
 	query := &resultprocessor.Query{
 		ID:               uuid.New(),
 		Version:          2,
-		RequiredQueryIDs: &[]uuid.UUID{uuid.New()},
+		RequiredQueryIDs: &[]uuid.UUID{requiredQuery},
 		Config:           &qcfg,
 	}
 	params := Set{
@@ -65,56 +65,56 @@ func TestSet(t *testing.T) {
 	}
 
 	textEntryId := uuid.New()
-	pool.ExpectQuery("name: GetTextEntryByDocId :one").WithArgs(database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: GetTextEntryByDocId :one").WithArgs(params.DocumentID).
 		WillReturnRows(
-			pgxmock.NewRows([]string{"id", "documentId", "bucket", "key", "version", "cleanEntryId"}).
-				AddRow(database.MustToDBUUID(textEntryId), database.MustToDBUUID(params.DocumentID), "buket", "/i/am/here", int32(1), database.MustToDBUUID(uuid.New())),
+			pgxmock.NewRows([]string{"id", "documentId", "bucket", "key", "version", "hash", "cleanEntryId"}).
+				AddRow(textEntryId, params.DocumentID, "buket", "/i/am/here", int32(1), "example", uuid.New()),
 		)
-	pool.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows(
+	pool.ExpectQuery("name: GetQuery :one").WithArgs(query.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), database.MustToDBUUIDArray(*query.RequiredQueryIDs)),
+			AddRow(query.ID, repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), *query.RequiredQueryIDs),
 	)
-	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(database.MustToDBUUID(query.ID), &query.Version).WillReturnRows(
+	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(&query.ID, &query.Version).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), database.MustToDBUUIDArray(*query.RequiredQueryIDs)),
+			AddRow(query.ID, repository.QuerytypeJsonExtractor, query.Version, query.Version, []byte(*query.Config), *query.RequiredQueryIDs),
 	)
 	requiredResultId := uuid.New()
 	strVal := "{\"examplekey\":\"example_value\"}"
-	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(database.MustToDBUUID(query.ID), &query.Version, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&query.ID, &query.Version, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
-				AddRow(database.MustToDBUUID(requiredResultId), database.MustToDBUUID((*query.RequiredQueryIDs)[0]), repository.QuerytypeContextFull, &strVal),
+				AddRow(&requiredResultId, (*query.RequiredQueryIDs)[0], repository.QuerytypeContextFull, &strVal),
 		)
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows(
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"config"}).
 			AddRow([]byte(qcfg)),
 	)
 	pool.ExpectBegin()
 	resultId := uuid.New()
-	pool.ExpectQuery("name: AddResult :one").WithArgs(database.MustToDBUUID(query.ID), pgxmock.AnyArg(), database.MustToDBUUID(textEntryId), query.Version).
+	pool.ExpectQuery("name: AddResult :one").WithArgs(query.ID, pgxmock.AnyArg(), textEntryId, query.Version).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id"}).
-				AddRow(database.MustToDBUUID(resultId)),
+				AddRow(resultId),
 		)
-	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(database.MustToDBUUID(query.ID), &query.Version, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&query.ID, &query.Version, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
-				AddRow(database.MustToDBUUID(requiredResultId), database.MustToDBUUID((*query.RequiredQueryIDs)[0]), repository.QuerytypeContextFull, &strVal),
+				AddRow(&requiredResultId, (*query.RequiredQueryIDs)[0], repository.QuerytypeContextFull, &strVal),
 		)
-	pool.ExpectExec("name: AddResultDependency :exec").WithArgs(database.MustToDBUUID(resultId), database.MustToDBUUID(requiredResultId)).
+	pool.ExpectExec("name: AddResultDependency :exec").WithArgs(resultId, requiredResultId).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
-	pool.ExpectQuery("name: ListQueryDirectDependentsByDocumentID :many").WithArgs(database.MustToDBUUID(params.QueryID), database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryDirectDependentsByDocumentID :many").WithArgs(params.QueryID, params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"queryId"}).
-				AddRow(database.MustToDBUUID((*query.RequiredQueryIDs)[0])),
+				AddRow(&requiredQuery),
 		)
 
 	mockSQS.EXPECT().
 		SendMessage(
 			mock.Anything,
 			mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", params.DocumentID.String(), (*query.RequiredQueryIDs)[0].String())
+				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", params.DocumentID.String(), requiredQuery.String())
 			}),
 			mock.Anything,
 		).
@@ -148,20 +148,22 @@ func TestInformQueryDependents(t *testing.T) {
 		},
 	}
 
+	reqOne := uuid.New()
+	reqTwo := uuid.New()
 	qIds := []uuid.UUID{
-		uuid.New(),
-		uuid.New(),
+		reqOne,
+		reqTwo,
 	}
 	params := &Set{
 		DocumentID: uuid.New(),
 		QueryID:    uuid.New(),
 	}
 
-	pool.ExpectQuery("name: ListQueryDirectDependentsByDocumentID :many").WithArgs(database.MustToDBUUID(params.QueryID), database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryDirectDependentsByDocumentID :many").WithArgs(params.QueryID, params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"queryId"}).
-				AddRow(database.MustToDBUUID(qIds[0])).
-				AddRow(database.MustToDBUUID(qIds[1])),
+				AddRow(&reqOne).
+				AddRow(&reqTwo),
 		)
 
 	mockSQS.EXPECT().

internal/query/result/sync/trigger.go

@@ -13,11 +13,11 @@ type Body struct {
 	QueryID    uuid.UUID `json:"query_id" validate:"required,uuid"`
 }
 
-func (s *Service) TriggerMultiSync(ctx context.Context, documentID uuid.UUID, queryIDs []uuid.UUID) error {
+func (s *Service) TriggerMultiSync(ctx context.Context, documentID uuid.UUID, queryIDs []*uuid.UUID) error {
 	for _, id := range queryIDs {
 		err := s.TriggerSync(ctx, &Body{
 			DocumentID: documentID,
-			QueryID:    id,
+			QueryID:    *id,
 		})
 
 		if err != nil {

internal/query/result/sync/trigger_test.go

@@ -75,16 +75,14 @@ func TestTriggerMultiSync(t *testing.T) {
 	}
 
 	docId := uuid.New()
-	qIds := []uuid.UUID{
-		uuid.New(),
-		uuid.New(),
-	}
+	queryIDOne := uuid.New()
+	queryIDTwo := uuid.New()
 
 	mockSQS.EXPECT().
 		SendMessage(
 			mock.Anything,
 			mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", docId.String(), qIds[0].String())
+				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", docId.String(), queryIDOne.String())
 			}),
 			mock.Anything,
 		).
@@ -94,12 +92,12 @@ func TestTriggerMultiSync(t *testing.T) {
 		SendMessage(
 			mock.Anything,
 			mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", docId.String(), qIds[1].String())
+				return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", docId.String(), queryIDTwo.String())
 			}),
 			mock.Anything,
 		).
 		Return(&sqs.SendMessageOutput{}, nil)
 
-	err = svc.TriggerMultiSync(ctx, docId, qIds)
+	err = svc.TriggerMultiSync(ctx, docId, []*uuid.UUID{&queryIDOne, &queryIDTwo})
 	require.NoError(t, err)
 }

internal/query/sync/sync.go

@@ -4,15 +4,11 @@ import (
 	"context"
 	"log/slog"
 
-	"queryorchestration/internal/database"
-
 	"github.com/google/uuid"
 )
 
 func (s *Service) Sync(ctx context.Context, id uuid.UUID) error {
-	dbid := database.MustToDBUUID(id)
-
-	isextracted, err := s.cfg.GetDBQueries().IsDocumentTextExtracted(ctx, dbid)
+	isextracted, err := s.cfg.GetDBQueries().IsDocumentTextExtracted(ctx, id)
 	if err != nil {
 		return err
 	} else if !isextracted {
@@ -20,17 +16,12 @@ func (s *Service) Sync(ctx context.Context, id uuid.UUID) error {
 		return nil
 	}
 
-	unsyncedQueries, err := s.cfg.GetDBQueries().ListUnsyncedNoDepsQueriesByDocId(ctx, dbid)
+	unsyncedQueries, err := s.cfg.GetDBQueries().ListUnsyncedNoDepsQueriesByDocId(ctx, &id)
 	if err != nil {
 		return err
 	}
 
 	slog.Debug("unsynced queries", "document_id", id.String(), "queries", unsyncedQueries)
 
-	ids := make([]uuid.UUID, len(unsyncedQueries))
-	for i, dbId := range unsyncedQueries {
-		ids[i] = database.MustToUUID(dbId)
-	}
-
-	return s.svc.ResultSync.TriggerMultiSync(ctx, id, ids)
+	return s.svc.ResultSync.TriggerMultiSync(ctx, id, unsyncedQueries)
 }

internal/query/sync/sync_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultsync "queryorchestration/internal/query/result/sync"
 	"queryorchestration/internal/serviceconfig"
@@ -44,28 +43,26 @@ func TestSync(t *testing.T) {
 
 	t.Run("valid", func(t *testing.T) {
 		id := uuid.New()
-		qs := []uuid.UUID{
-			uuid.New(),
-			uuid.New(),
-		}
+		reqOne := uuid.New()
+		reqTwo := uuid.New()
 
-		pool.ExpectQuery("name: IsDocumentTextExtracted :one").WithArgs(database.MustToDBUUID(id)).
+		pool.ExpectQuery("name: IsDocumentTextExtracted :one").WithArgs(id).
 			WillReturnRows(
 				pgxmock.NewRows([]string{"isextracted"}).
 					AddRow(true),
 			)
-		pool.ExpectQuery("name: ListUnsyncedNoDepsQueriesByDocId :many").WithArgs(database.MustToDBUUID(id)).
+		pool.ExpectQuery("name: ListUnsyncedNoDepsQueriesByDocId :many").WithArgs(&id).
 			WillReturnRows(
 				pgxmock.NewRows([]string{"id"}).
-					AddRow(database.MustToDBUUID(qs[0])).
-					AddRow(database.MustToDBUUID(qs[1])),
+					AddRow(&reqOne).
+					AddRow(&reqTwo),
 			)
 
 		mockSQS.EXPECT().
 			SendMessage(
 				mock.Anything,
 				mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-					return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", id.String(), qs[0].String())
+					return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", id.String(), reqOne.String())
 				}),
 				mock.Anything,
 			).
@@ -75,7 +72,7 @@ func TestSync(t *testing.T) {
 			SendMessage(
 				mock.Anything,
 				mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-					return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", id.String(), qs[1].String())
+					return *in.QueueUrl == cfg.QueryURL && *in.MessageBody == fmt.Sprintf("{\"document_id\":\"%s\",\"query_id\":\"%s\"}", id.String(), reqTwo.String())
 				}),
 				mock.Anything,
 			).
@@ -86,7 +83,7 @@ func TestSync(t *testing.T) {
 	t.Run("not extracted", func(t *testing.T) {
 		id := uuid.New()
 
-		pool.ExpectQuery("name: IsDocumentTextExtracted :one").WithArgs(database.MustToDBUUID(id)).
+		pool.ExpectQuery("name: IsDocumentTextExtracted :one").WithArgs(id).
 			WillReturnRows(
 				pgxmock.NewRows([]string{"isextracted"}).
 					AddRow(false),

internal/query/test/test_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"queryorchestration/internal/collector"
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/document"
 	"queryorchestration/internal/query"
@@ -16,7 +15,6 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/assert"
 )
@@ -48,18 +46,18 @@ func TestTest(t *testing.T) {
 		QueryVersion: int32(1),
 	}
 
-	reqID := database.MustToDBUUID(uuid.New())
-	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(database.MustToDBUUID(params.QueryID), &params.QueryVersion).WillReturnRows(
+	reqID := uuid.New()
+	pool.ExpectQuery("name: GetQueryWithVersion :one").WithArgs(&params.QueryID, &params.QueryVersion).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(params.QueryID), repository.QuerytypeJsonExtractor, int32(1), params.QueryVersion+1, []byte("{\"path\":\"oldkey\"}"), []pgtype.UUID{reqID}),
+			AddRow(params.QueryID, repository.QuerytypeJsonExtractor, int32(1), params.QueryVersion+1, []byte("{\"path\":\"oldkey\"}"), []uuid.UUID{reqID}),
 	)
 	strVal := "{\"mykey\":\"example_value\",\"oldkey\":\"old_value\"}"
-	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(database.MustToDBUUID(params.QueryID), &params.QueryVersion, database.MustToDBUUID(params.DocumentID)).
+	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&params.QueryID, &params.QueryVersion, &params.DocumentID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
-				AddRow(database.MustToDBUUID(uuid.New()), reqID, repository.QuerytypeContextFull, &strVal),
+				AddRow(&uuid.UUID{}, reqID, repository.QuerytypeContextFull, &strVal),
 		)
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(params.QueryID)).WillReturnRows(
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(params.QueryID).WillReturnRows(
 		pgxmock.NewRows([]string{"config"}).
 			AddRow([]byte("{\"path\":\"oldkey\"}")),
 	)

internal/query/types/jsonExtractor/process_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	contextfull "queryorchestration/internal/query/types/contextFull"
@@ -44,7 +43,7 @@ func TestJSONProcess(t *testing.T) {
 
 	config := "{\"path\":\"key\"}"
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -59,7 +58,7 @@ func TestJSONProcess(t *testing.T) {
 	values = []resultprocessor.Value{
 		contextfull.NewResult(jsonString),
 	}
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -74,7 +73,7 @@ func TestJSONProcess(t *testing.T) {
 	values = []resultprocessor.Value{
 		contextfull.NewResult(jsonString),
 	}
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -110,7 +109,7 @@ func TestJSONProcessJSON(t *testing.T) {
 
 	config := "{\"path\":\"invalid_key\"}"
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -122,7 +121,7 @@ func TestJSONProcessJSON(t *testing.T) {
 
 	config = ""
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -134,7 +133,7 @@ func TestJSONProcessJSON(t *testing.T) {
 
 	config = "{\"path\":\"\"}"
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -146,7 +145,7 @@ func TestJSONProcessJSON(t *testing.T) {
 
 	config = "{\"path\":}"
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}).
 				AddRow([]byte(config)),
@@ -156,7 +155,7 @@ func TestJSONProcessJSON(t *testing.T) {
 	assert.EqualError(t, err, "invalid character '}' looking for beginning of value")
 	assert.Empty(t, value)
 
-	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID)).
+	pool.ExpectQuery("name: GetActiveQueryConfig :one").WithArgs(query.ID).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"config"}),
 		)

internal/query/types/jsonExtractor/service.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"queryorchestration/internal/database"
 	resultprocessor "queryorchestration/internal/query/result/processor"
 	"queryorchestration/internal/serviceconfig"
 
@@ -34,7 +33,7 @@ func (e *Extractor) Process(ctx context.Context, query *resultprocessor.Query, v
 		return "", err
 	}
 
-	byteConfig, err := e.cfg.GetDBQueries().GetActiveQueryConfig(ctx, database.MustToDBUUID(query.ID))
+	byteConfig, err := e.cfg.GetDBQueries().GetActiveQueryConfig(ctx, query.ID)
 	if err != nil {
 		return "", err
 	}

internal/query/update/update.go

@@ -7,7 +7,6 @@ import (
 	"log/slog"
 
 	queryversionsyncrunner "queryorchestration/api/queryVersionSyncRunner"
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -67,8 +66,8 @@ func (s *Service) normalizeUpdateRequiredQueryIDs(ctx context.Context, current *
 	}
 
 	createsloop, err := s.cfg.GetDBQueries().IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{
-		Queryid:          database.MustToDBUUID(current.ID),
-		Requiredqueryids: database.MustToDBUUIDArray(*entity.GetRequiredQueryIDs()),
+		Queryid:          &current.ID,
+		Requiredqueryids: *entity.GetRequiredQueryIDs(),
 	})
 	if err != nil {
 		return err
@@ -127,7 +126,7 @@ func (s *Service) normalizeUpdate(ctx context.Context, current *query.Query, ent
 
 func (s *Service) submitUpdate(ctx context.Context, current *query.Query, entity *resultprocessor.Update) error {
 	err := s.cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, q *repository.Queries) error {
-		id := database.MustToDBUUID(entity.ID)
+		id := entity.ID
 
 		activeName, err := validation.GetFieldName(entity, entity.ActiveVersion)
 		if err != nil {
@@ -158,7 +157,7 @@ func (s *Service) submitUpdate(ctx context.Context, current *query.Query, entity
 			for _, qID := range addIDs {
 				err := q.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{
 					Queryid:         id,
-					Requiredqueryid: database.MustToDBUUID(qID),
+					Requiredqueryid: qID,
 					Addedversion:    latestVersion,
 				})
 				if err != nil {
@@ -170,7 +169,7 @@ func (s *Service) submitUpdate(ctx context.Context, current *query.Query, entity
 			for _, qID := range removeIDs {
 				err := q.RemoveRequiredQuery(ctx, &repository.RemoveRequiredQueryParams{
 					Queryid:         id,
-					Requiredqueryid: database.MustToDBUUID(qID),
+					Requiredqueryid: qID,
 					Removedversion:  &latestVersion,
 				})
 				if err != nil {

internal/query/update/update_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -19,7 +18,6 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/mock"
 )
@@ -58,18 +56,18 @@ func TestUpdate(t *testing.T) {
 		Config:        &jcfg,
 	}
 
-	pool.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(update.ID)).WillReturnRows(
+	pool.ExpectQuery("name: GetQuery :one").WithArgs(update.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
-			AddRow(database.MustToDBUUID(existing.ID), repository.QuerytypeJsonExtractor, existing.ActiveVersion, existing.LatestVersion, []byte(config), []pgtype.UUID{}),
+			AddRow(existing.ID, repository.QuerytypeJsonExtractor, existing.ActiveVersion, existing.LatestVersion, []byte(config), []uuid.UUID{}),
 	)
 	pool.ExpectBeginTx(pgx.TxOptions{})
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(update.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(update.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(2)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(update.ID), av).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(update.ID, av).
 		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(database.MustToDBUUID(update.ID), []byte(*update.Config), int32(2)).
+	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(update.ID, []byte(*update.Config), int32(2)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 

internal/query/update/updateprivate_test.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/query"
 	resultprocessor "queryorchestration/internal/query/result/processor"
@@ -87,17 +86,17 @@ func TestSubmitUpdate(t *testing.T) {
 	}
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
-	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(q.ID)).WillReturnRows(
+	pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(q.ID).WillReturnRows(
 		pgxmock.NewRows([]string{"version"}).
 			AddRow(int32(3)),
 	)
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), aV).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, aV).
 		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(database.MustToDBUUID(update.ID), database.MustToDBUUID((*update.RequiredQueryIDs)[0]), pgxmock.AnyArg()).
+	pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(update.ID, (*update.RequiredQueryIDs)[0], pgxmock.AnyArg()).
 		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), database.MustToDBUUID((*q.RequiredQueryIDs)[0]), database.MustToDBUUID(update.ID)).
+	pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), (*q.RequiredQueryIDs)[0], update.ID).
 		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(database.MustToDBUUID(update.ID), []byte(*update.Config), int32(3)).
+	pool.ExpectExec("name: SetQueryConfig :exec").WithArgs(update.ID, []byte(*update.Config), int32(3)).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 
@@ -130,7 +129,7 @@ func TestSubmitUpdateRollback(t *testing.T) {
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
 	msg := "database failure"
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), aV).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, aV).
 		WillReturnError(errors.New(msg))
 	pool.ExpectCommit()
 
@@ -174,17 +173,17 @@ func TestSubmitUpdateRequiredQueries(t *testing.T) {
 		}
 
 		pool.ExpectBeginTx(pgx.TxOptions{})
-		pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(database.MustToDBUUID(update.ID)).WillReturnRows(
+		pool.ExpectQuery("name: AddLatestQueryVersion :one").WithArgs(update.ID).WillReturnRows(
 			pgxmock.NewRows([]string{"version"}).
 				AddRow(int32(1)),
 		)
-		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(database.MustToDBUUID(update.ID), database.MustToDBUUID((*update.RequiredQueryIDs)[0]), pgxmock.AnyArg()).
+		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(update.ID, (*update.RequiredQueryIDs)[0], pgxmock.AnyArg()).
 			WillReturnResult(pgxmock.NewResult("", 1))
-		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(database.MustToDBUUID(update.ID), database.MustToDBUUID((*update.RequiredQueryIDs)[1]), pgxmock.AnyArg()).
+		pool.ExpectExec("name: AddRequiredQuery :exec").WithArgs(update.ID, (*update.RequiredQueryIDs)[1], pgxmock.AnyArg()).
 			WillReturnResult(pgxmock.NewResult("", 1))
-		pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), database.MustToDBUUID((*q.RequiredQueryIDs)[1]), database.MustToDBUUID(update.ID)).
+		pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), (*q.RequiredQueryIDs)[1], update.ID).
 			WillReturnResult(pgxmock.NewResult("", 1))
-		pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), database.MustToDBUUID((*q.RequiredQueryIDs)[2]), database.MustToDBUUID(update.ID)).
+		pool.ExpectExec("name: RemoveRequiredQuery :exec").WithArgs(pgxmock.AnyArg(), (*q.RequiredQueryIDs)[2], update.ID).
 			WillReturnResult(pgxmock.NewResult("", 1))
 		pool.ExpectCommit()
 
@@ -223,7 +222,7 @@ func TestSubmitUpdateRequiredQueries(t *testing.T) {
 		}
 
 		pool.ExpectBeginTx(pgx.TxOptions{})
-		pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), av).
+		pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, av).
 			WillReturnResult(pgxmock.NewResult("", 1))
 		pool.ExpectCommit()
 
@@ -256,7 +255,7 @@ func TestSubmitUpdateActiveVersion(t *testing.T) {
 	}
 
 	pool.ExpectBeginTx(pgx.TxOptions{})
-	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(database.MustToDBUUID(q.ID), aV).
+	pool.ExpectExec("name: AddActiveQueryVersion :exec").WithArgs(q.ID, aV).
 		WillReturnResult(pgxmock.NewResult("", 1))
 	pool.ExpectCommit()
 
@@ -444,7 +443,7 @@ func TestNormalizeUpdateRequiredQueryIDs(t *testing.T) {
 			ID:               current.ID,
 			RequiredQueryIDs: &[]uuid.UUID{uuid.New()},
 		}
-		dbids := database.MustToDBUUIDArray(*update.RequiredQueryIDs)
+		dbids := *update.RequiredQueryIDs
 
 		pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 			pgxmock.NewRows([]string{"all_exist"}).
@@ -475,12 +474,12 @@ func TestNormalizeUpdateRequiredQueryIDs(t *testing.T) {
 			RequiredQueryIDs: &[]uuid.UUID{uuid.New()},
 		}
 
-		dbids := database.MustToDBUUIDArray(*update.RequiredQueryIDs)
+		dbids := *update.RequiredQueryIDs
 		pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 			pgxmock.NewRows([]string{"all_exist"}).
 				AddRow(true),
 		)
-		pool.ExpectQuery("name: IsQueryInDependencyTree :one").WithArgs(dbids, database.MustToDBUUID(current.ID)).WillReturnRows(
+		pool.ExpectQuery("name: IsQueryInDependencyTree :one").WithArgs(dbids, current.ID).WillReturnRows(
 			pgxmock.NewRows([]string{"all_exist"}).
 				AddRow(true),
 		)
@@ -510,12 +509,12 @@ func TestNormalizeUpdateRequiredQueryIDs(t *testing.T) {
 		update.RequiredQueryIDs = &ids
 		current.RequiredQueryIDs = &ids
 
-		dbids := database.MustToDBUUIDArray(*update.RequiredQueryIDs)
+		dbids := *update.RequiredQueryIDs
 		pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
 			pgxmock.NewRows([]string{"all_exist"}).
 				AddRow(true),
 		)
-		pool.ExpectQuery("name: IsQueryInDependencyTree :one").WithArgs(dbids, database.MustToDBUUID(current.ID)).WillReturnRows(
+		pool.ExpectQuery("name: IsQueryInDependencyTree :one").WithArgs(dbids, &current.ID).WillReturnRows(
 			pgxmock.NewRows([]string{"all_exist"}).
 				AddRow(false),
 		)

internal/query/versionsync/sync.go

@@ -6,14 +6,13 @@ import (
 	"errors"
 
 	clientsyncrunner "queryorchestration/api/clientSyncRunner"
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/serviceconfig/queue"
 
 	"github.com/google/uuid"
 )
 
 func (s *Service) Sync(ctx context.Context, id uuid.UUID) error {
-	clientIds, err := s.cfg.GetDBQueries().ListQueryClientIDs(ctx, database.MustToDBUUID(id))
+	clientIds, err := s.cfg.GetDBQueries().ListQueryClientIDs(ctx, &id)
 	if err != nil && errors.Is(err, sql.ErrNoRows) {
 		return nil
 	} else if err != nil {
@@ -24,7 +23,7 @@ func (s *Service) Sync(ctx context.Context, id uuid.UUID) error {
 		err := s.cfg.SendToQueue(ctx, &queue.SendParams{
 			QueueURL: s.cfg.GetClientSyncURL(),
 			Body: clientsyncrunner.Body{
-				ID: database.MustToUUID(id),
+				ID: id,
 			},
 		})
 		if err != nil {

internal/query/versionsync/sync_test.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 	"testing"
 
-	"queryorchestration/internal/database"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/serviceconfig"
 	"queryorchestration/internal/serviceconfig/queue/clientsync"
@@ -44,11 +43,11 @@ func TestSync(t *testing.T) {
 		uuid.New(),
 	}
 
-	pool.ExpectQuery("name: ListQueryClientIDs :many").WithArgs(database.MustToDBUUID(queryId)).
+	pool.ExpectQuery("name: ListQueryClientIDs :many").WithArgs(&queryId).
 		WillReturnRows(
 			pgxmock.NewRows([]string{"clientId"}).
-				AddRow(database.MustToDBUUID(clientIds[0])).
-				AddRow(database.MustToDBUUID(clientIds[1])),
+				AddRow(clientIds[0]).
+				AddRow(clientIds[1]),
 		)
 
 	mockSQS.EXPECT().