Refactor: Attempt II at removing pgtype.UUID everywhere + convert string UUIDs into uuid.UUID (#2894)

* fix: add type override in sqlc.yaml

* chore: gen sqlc

* chore: big find and replace

* chore: more

* fix: clean up bunch of outdated `.Valid` refs

* refactor: remove `sqlchelpers.uuidFromStr()` in favor of `uuid.MustParse()`

* refactor: remove uuidToStr

* fix: lint

* fix: use pointers for null uuids

* chore: clean up more null pointers

* chore: clean up a bunch more

* fix: couple more

* fix: some types on the api

* fix: incorrectly non-null param

* fix: more nullable params

* fix: more refs

* refactor: start replacing tenant id strings with uuids

* refactor: more tenant id uuid casting

* refactor: fix a bunch more

* refactor: more

* refactor: more

* refactor: is that all of them?!

* fix: panic

* fix: rm scans

* fix: unwind some broken things

* chore: tests

* fix: rebase issues

* fix: more tests

* fix: nil checks

* Refactor: Make all UUIDs into `uuid.UUID` (#2897)

* refactor: remove a bunch more string uuids

* refactor: pointers and lists

* refactor: fix all the refs

* refactor: fix a few more

* fix: config loader

* fix: revert some changes

* fix: tests

* fix: test

* chore: proto

* fix: durable listener

* fix: some more string types

* fix: python health worker sleep

* fix: remove a bunch of `MustParse`s from the various gRPC servers

* fix: rm more uuid.MustParse calls

* fix: rm mustparse from api

* fix: test

* fix: merge issues

* fix: handle a bunch more uses of `MustParse` everywhere

* fix: nil id for worker label

* fix: more casting in the oss

* fix: more id parsing

* fix: stringify jwt opt

* fix: couple more bugs in untyped calls

* fix: more types

* fix: broken test

* refactor: implement `GetKeyUuid`

* chore: regen sqlc

* chore: replace pgtype.UUID again

* fix: bunch more type errors

* fix: panic

api/v1/server/authn/middleware.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"strings"
 
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 	"github.com/labstack/echo/v4"
 	"github.com/rs/zerolog"
@@ -13,7 +14,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/middleware"
 	"github.com/hatchet-dev/hatchet/api/v1/server/middleware/redirect"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -169,7 +169,14 @@ func (a *AuthN) handleCookieAuth(c echo.Context) error {
 		return forbidden
 	}
 
-	user, err := a.config.V1.User().GetUserByID(c.Request().Context(), userID)
+	userIdUUID, err := uuid.Parse(userID)
+	if err != nil {
+		a.l.Debug().Err(err).Msg("error parsing user id from session")
+
+		return forbidden
+	}
+
+	user, err := a.config.V1.User().GetUserByID(c.Request().Context(), userIdUUID)
 	if err != nil {
 		a.l.Debug().Err(err).Msg("error getting user by id")
 
@@ -219,7 +226,7 @@ func (a *AuthN) handleBearerAuth(c echo.Context) error {
 
 	// Verify that the tenant id which exists in the context is the same as the tenant id
 	// in the token.
-	if sqlchelpers.UUIDToStr(queriedTenant.ID) != tenantId {
+	if queriedTenant.ID != tenantId {
 		a.l.Debug().Msgf("tenant id in token does not match tenant id in context")
 
 		return forbidden

api/v1/server/authn/session_helpers.go

@@ -3,12 +3,12 @@ package authn
 import (
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/gorilla/sessions"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
 	"github.com/hatchet-dev/hatchet/pkg/random"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -30,7 +30,7 @@ func (s *SessionHelpers) SaveAuthenticated(c echo.Context, user *sqlcv1.User) er
 	}
 
 	session.Values["authenticated"] = true
-	session.Values["user_id"] = sqlchelpers.UUIDToStr(user.ID)
+	session.Values["user_id"] = user.ID.String()
 
 	return session.Save(c.Request(), c.Response())
 }
@@ -94,6 +94,25 @@ func (s *SessionHelpers) GetKey(
 	return vStr, nil
 }
 
+func (s *SessionHelpers) GetKeyUuid(
+	c echo.Context,
+	k string,
+) (*uuid.UUID, error) {
+	vStr, err := s.GetKey(c, k)
+
+	if err != nil {
+		return nil, err
+	}
+
+	vUuid, err := uuid.Parse(vStr)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &vUuid, nil
+}
+
 func (s *SessionHelpers) RemoveKey(
 	c echo.Context,
 	k string,

api/v1/server/authz/middleware.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/middleware"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -78,7 +77,7 @@ func (a *AuthZ) handleCookieAuth(c echo.Context, r *middleware.RouteInfo) error
 		}
 
 		// check if the user is a member of the tenant
-		tenantMember, err := a.config.V1.Tenant().GetTenantMemberByUserID(c.Request().Context(), sqlchelpers.UUIDToStr(tenant.ID), sqlchelpers.UUIDToStr(user.ID))
+		tenantMember, err := a.config.V1.Tenant().GetTenantMemberByUserID(c.Request().Context(), tenant.ID, user.ID)
 
 		if err != nil {
 			a.l.Debug().Err(err).Msgf("error getting tenant member")

api/v1/server/handlers/api-tokens/create.go

@@ -8,7 +8,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -16,7 +15,7 @@ func (a *APITokenService) ApiTokenCreate(ctx echo.Context, request gen.ApiTokenC
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
 	user := ctx.Get("user").(*sqlcv1.User)
 
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// validate the request
 	if apiErrors, err := a.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -50,13 +49,13 @@ func (a *APITokenService) ApiTokenCreate(ctx echo.Context, request gen.ApiTokenC
 
 	a.config.Analytics.Enqueue(
 		"api-token:create",
-		sqlchelpers.UUIDToStr(user.ID),
+		user.ID.String(),
 		&tenantId,
 		nil,
 		map[string]interface{}{
 			"name":       request.Body.Name,
 			"expires_at": expiresAt,
-			"token_id":   token.TokenId,
+			"token_id":   token.TokenId.String(),
 		},
 	)
 

api/v1/server/handlers/api-tokens/list.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (a *APITokenService) ApiTokenList(ctx echo.Context, request gen.ApiTokenListRequestObject) (gen.ApiTokenListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	tokens, err := a.config.V1.APIToken().ListAPITokensByTenant(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/api-tokens/revoke.go

@@ -6,7 +6,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -20,7 +19,7 @@ func (a *APITokenService) ApiTokenUpdateRevoke(ctx echo.Context, request gen.Api
 		), nil
 	}
 
-	err := a.config.V1.APIToken().RevokeAPIToken(ctx.Request().Context(), sqlchelpers.UUIDToStr(apiToken.ID))
+	err := a.config.V1.APIToken().RevokeAPIToken(ctx.Request().Context(), apiToken.ID)
 
 	if err != nil {
 		return nil, err
@@ -29,15 +28,13 @@ func (a *APITokenService) ApiTokenUpdateRevoke(ctx echo.Context, request gen.Api
 	ctx.Set(constants.ResourceIdKey.String(), apiToken.ID.String())
 	ctx.Set(constants.ResourceTypeKey.String(), constants.ResourceTypeApiToken.String())
 
-	tenantId := sqlchelpers.UUIDToStr(apiToken.TenantId)
-
 	a.config.Analytics.Enqueue(
 		"api-token:revoke",
-		sqlchelpers.UUIDToStr(user.ID),
-		&tenantId,
+		user.ID.String(),
+		apiToken.TenantId,
 		nil,
 		map[string]interface{}{
-			"token_id": apiToken.ID,
+			"token_id": apiToken.ID.String(),
 		},
 	)
 	return gen.ApiTokenUpdateRevoke204Response{}, nil

api/v1/server/handlers/ingestors/sns.go

@@ -31,7 +31,7 @@ func (i *IngestorsService) SnsUpdate(ctx echo.Context, req gen.SnsUpdateRequestO
 		return nil, err
 	}
 
-	tenantId := req.Tenant.String()
+	tenantId := req.Tenant
 
 	// verify that the tenant and the topic ARN are set in the database
 	snsInt, err := i.config.V1.SNS().GetSNSIntegration(ctx.Request().Context(), tenantId, payload.TopicArn)

api/v1/server/handlers/ingestors/sns_create.go

@@ -7,13 +7,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (i *IngestorsService) SnsCreate(ctx echo.Context, req gen.SnsCreateRequestObject) (gen.SnsCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// validate the request
 	if apiErrors, err := i.config.Validator.ValidateAPI(req.Body); err != nil {

api/v1/server/handlers/ingestors/sns_delete.go

@@ -5,17 +5,16 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (i *IngestorsService) SnsDelete(ctx echo.Context, req gen.SnsDeleteRequestObject) (gen.SnsDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	sns := ctx.Get("sns").(*sqlcv1.SNSIntegration)
 
 	// create the SNS integration
-	err := i.config.V1.SNS().DeleteSNSIntegration(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(sns.ID))
+	err := i.config.V1.SNS().DeleteSNSIntegration(ctx.Request().Context(), tenantId, sns.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/ingestors/sns_list.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (i *IngestorsService) SnsList(ctx echo.Context, req gen.SnsListRequestObject) (gen.SnsListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// create the SNS integration
 	snsIntegrations, err := i.config.V1.SNS().ListSNSIntegrations(ctx.Request().Context(), tenantId)

api/v1/server/handlers/rate-limits/list.go

@@ -11,13 +11,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *RateLimitService) RateLimitList(ctx echo.Context, request gen.RateLimitListRequestObject) (gen.RateLimitListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limit := 50
 	offset := 0

api/v1/server/handlers/slack-app/oauth_callback.go

@@ -22,7 +22,7 @@ func (g *SlackAppService) UserUpdateSlackOauthCallback(ctx echo.Context, _ gen.U
 
 	sh := authn.NewSessionHelpers(g.config)
 
-	tenantId, err := sh.GetKey(ctx, "tenant")
+	tenantId, err := sh.GetKeyUuid(ctx, "tenant")
 
 	if err != nil {
 		return nil, redirect.GetRedirectWithError(ctx, g.config.Logger, err, "Could not link Slack account. Please try again and make sure cookies are enabled.")
@@ -63,7 +63,7 @@ func (g *SlackAppService) UserUpdateSlackOauthCallback(ctx echo.Context, _ gen.U
 
 	_, err = g.config.V1.Slack().UpsertSlackWebhook(
 		ctx.Request().Context(),
-		tenantId,
+		*tenantId,
 		&v1.UpsertSlackWebhookOpts{
 			TeamId:      resp.Team.ID,
 			TeamName:    resp.Team.Name,

api/v1/server/handlers/slack-app/oauth_start.go

@@ -7,14 +7,13 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/authn"
 	"github.com/hatchet-dev/hatchet/api/v1/server/middleware/redirect"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 // Note: we want all errors to redirect, otherwise the user will be greeted with raw JSON in the middle of the login flow.
 func (g *SlackAppService) UserUpdateSlackOauthStart(ctx echo.Context, _ gen.UserUpdateSlackOauthStartRequestObject) (gen.UserUpdateSlackOauthStartResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	oauth, ok := g.config.AdditionalOAuthConfigs["slack"]
 
@@ -24,7 +23,7 @@ func (g *SlackAppService) UserUpdateSlackOauthStart(ctx echo.Context, _ gen.User
 
 	sh := authn.NewSessionHelpers(g.config)
 
-	if err := sh.SaveKV(ctx, "tenant", tenantId); err != nil {
+	if err := sh.SaveKV(ctx, "tenant", tenantId.String()); err != nil {
 		return nil, redirect.GetRedirectWithError(ctx, g.config.Logger, err, "Could not get cookie. Please make sure cookies are enabled.")
 	}
 

api/v1/server/handlers/slack-app/slack_delete.go

@@ -5,16 +5,15 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (i *SlackAppService) SlackWebhookDelete(ctx echo.Context, req gen.SlackWebhookDeleteRequestObject) (gen.SlackWebhookDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	slack := ctx.Get("slack").(*sqlcv1.SlackAppWebhook)
 
-	err := i.config.V1.Slack().DeleteSlackWebhook(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(slack.ID))
+	err := i.config.V1.Slack().DeleteSlackWebhook(ctx.Request().Context(), tenantId, slack.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/slack-app/slack_list.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (s *SlackAppService) SlackWebhookList(ctx echo.Context, req gen.SlackWebhookListRequestObject) (gen.SlackWebhookListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	webhooks, err := s.config.V1.Slack().ListSlackWebhooks(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/tenants/create.go

@@ -11,7 +11,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -79,7 +78,7 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
 		return nil, err
 	}
 
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	err = t.config.V1.TenantLimit().SelectOrInsertTenantLimits(context.Background(), tenantId, nil)
 
@@ -89,7 +88,7 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
 
 	// add the user as an owner of the tenant
 	_, err = t.config.V1.Tenant().CreateTenantMember(ctx.Request().Context(), tenantId, &v1.CreateTenantMemberOpts{
-		UserId: sqlchelpers.UUIDToStr(user.ID),
+		UserId: user.ID,
 		Role:   "OWNER",
 	})
 

api/v1/server/handlers/tenants/create_email_group.go

@@ -6,13 +6,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) AlertEmailGroupCreate(ctx echo.Context, request gen.AlertEmailGroupCreateRequestObject) (gen.AlertEmailGroupCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// validate the request
 	if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {

api/v1/server/handlers/tenants/create_invite.go

@@ -11,14 +11,13 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	"github.com/hatchet-dev/hatchet/pkg/integrations/email"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantInviteCreateRequestObject) (gen.TenantInviteCreateResponseObject, error) {
 	user := ctx.Get("user").(*sqlcv1.User)
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
 	if !t.config.Runtime.AllowInvites {
 		t.config.Logger.Warn().Msg("tenant invites are disabled")
@@ -92,11 +91,11 @@ func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantI
 	}()
 
 	t.config.Analytics.Enqueue("user-invite:create",
-		sqlchelpers.UUIDToStr(user.ID),
+		user.ID.String(),
 		&tenantId,
 		nil,
 		map[string]interface{}{
-			"invite_id": invite.ID,
+			"invite_id": invite.ID.String(),
 			"role":      request.Body.Role,
 		},
 	)

api/v1/server/handlers/tenants/delete_email_group.go

@@ -4,17 +4,16 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) AlertEmailGroupDelete(ctx echo.Context, request gen.AlertEmailGroupDeleteRequestObject) (gen.AlertEmailGroupDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	emailGroup := ctx.Get("alert-email-group").(*sqlcv1.TenantAlertEmailGroup)
 
 	// delete the invite
-	err := t.config.V1.TenantAlertingSettings().DeleteTenantAlertGroup(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(emailGroup.ID))
+	err := t.config.V1.TenantAlertingSettings().DeleteTenantAlertGroup(ctx.Request().Context(), tenantId, emailGroup.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/tenants/delete_invite.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -13,7 +12,7 @@ func (t *TenantService) TenantInviteDelete(ctx echo.Context, request gen.TenantI
 	invite := ctx.Get("tenant-invite").(*sqlcv1.TenantInviteLink)
 
 	// delete the invite
-	err := t.config.V1.TenantInvite().DeleteTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID))
+	err := t.config.V1.TenantInvite().DeleteTenantInvite(ctx.Request().Context(), invite.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/tenants/delete_member.go

@@ -6,13 +6,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantMemberDelete(ctx echo.Context, request gen.TenantMemberDeleteRequestObject) (gen.TenantMemberDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
 	memberToDelete := ctx.Get("member").(*sqlcv1.PopulateTenantMembersRow)
 
@@ -22,19 +21,19 @@ func (t *TenantService) TenantMemberDelete(ctx echo.Context, request gen.TenantM
 		), nil
 	}
 
-	if sqlchelpers.UUIDToStr(tenantMember.UserId) == sqlchelpers.UUIDToStr(memberToDelete.UserId) {
+	if tenantMember.UserId == memberToDelete.UserId {
 		return gen.TenantMemberDelete403JSONResponse(
 			apierrors.NewAPIErrors("You cannot delete yourself"),
 		), nil
 	}
 
-	if sqlchelpers.UUIDToStr(memberToDelete.TenantId) != tenantId {
+	if memberToDelete.TenantId != tenantId {
 		return gen.TenantMemberDelete404JSONResponse(
 			apierrors.NewAPIErrors("Member not found"),
 		), nil
 	}
 
-	err := t.config.V1.Tenant().DeleteTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToDelete.ID))
+	err := t.config.V1.Tenant().DeleteTenantMember(ctx.Request().Context(), memberToDelete.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/tenants/get_alerting_settings.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantAlertingSettingsGet(ctx echo.Context, request gen.TenantAlertingSettingsGetRequestObject) (gen.TenantAlertingSettingsGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	tenantAlerting, err := t.config.V1.TenantAlertingSettings().GetTenantAlertingSettings(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/tenants/get_prometheus_metrics.go

@@ -9,13 +9,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantGetPrometheusMetrics(ctx echo.Context, request gen.TenantGetPrometheusMetricsRequestObject) (gen.TenantGetPrometheusMetricsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	var response string
 

api/v1/server/handlers/tenants/get_resource_policy.go

@@ -7,13 +7,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantResourcePolicyGet(ctx echo.Context, request gen.TenantResourcePolicyGetRequestObject) (gen.TenantResourcePolicyGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limits, err := t.config.V1.TenantLimit().GetLimits(context.Background(), tenantId)
 

api/v1/server/handlers/tenants/get_step_run_queue_metrics.go

@@ -4,13 +4,12 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantGetStepRunQueueMetrics(ctx echo.Context, request gen.TenantGetStepRunQueueMetricsRequestObject) (gen.TenantGetStepRunQueueMetricsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	stepRunQueueCounts, err := t.config.V1.Tasks().GetQueueCounts(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/tenants/get_task_stats.go

@@ -11,7 +11,7 @@ import (
 func (t *TenantService) TenantGetTaskStats(ctx echo.Context, request gen.TenantGetTaskStatsRequestObject) (gen.TenantGetTaskStatsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
 
-	stats, err := t.config.V1.Tasks().GetTaskStats(ctx.Request().Context(), tenant.ID.String())
+	stats, err := t.config.V1.Tasks().GetTaskStats(ctx.Request().Context(), tenant.ID)
 	if err != nil {
 		return nil, err
 	}

api/v1/server/handlers/tenants/list_email_groups.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) AlertEmailGroupList(ctx echo.Context, request gen.AlertEmailGroupListRequestObject) (gen.AlertEmailGroupListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	emailGroups, err := t.config.V1.TenantAlertingSettings().ListTenantAlertGroups(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/tenants/list_invites.go

@@ -6,13 +6,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantInviteList(ctx echo.Context, request gen.TenantInviteListRequestObject) (gen.TenantInviteListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	tenantInvites, err := t.config.V1.TenantInvite().ListTenantInvitesByTenantId(ctx.Request().Context(), tenantId, &v1.ListTenantInvitesOpts{
 		Expired: v1.BoolPtr(false),

api/v1/server/handlers/tenants/list_members.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantMemberList(ctx echo.Context, request gen.TenantMemberListRequestObject) (gen.TenantMemberListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	members, err := t.config.V1.Tenant().ListTenantMembers(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/tenants/update.go

@@ -6,13 +6,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TenantService) TenantUpdate(ctx echo.Context, request gen.TenantUpdateRequestObject) (gen.TenantUpdateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// validate the request
 	if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {

api/v1/server/handlers/tenants/update_email_group.go

@@ -6,7 +6,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -25,7 +24,7 @@ func (t *TenantService) AlertEmailGroupUpdate(ctx echo.Context, request gen.Aler
 		Emails: request.Body.Emails,
 	}
 
-	emailGroup, err := t.config.V1.TenantAlertingSettings().UpdateTenantAlertGroup(ctx.Request().Context(), sqlchelpers.UUIDToStr(emailGroup.ID), updateOpts)
+	emailGroup, err := t.config.V1.TenantAlertingSettings().UpdateTenantAlertGroup(ctx.Request().Context(), emailGroup.ID, updateOpts)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/tenants/update_invite.go

@@ -7,7 +7,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -35,7 +34,7 @@ func (t *TenantService) TenantInviteUpdate(ctx echo.Context, request gen.TenantI
 	}
 
 	// update the invite
-	invite, err := t.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
+	invite, err := t.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), invite.ID, updateOpts)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/tenants/update_member.go

@@ -7,7 +7,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -45,7 +44,7 @@ func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantM
 	}
 
 	// Users cannot change their own role
-	if sqlchelpers.UUIDToStr(tenantMember.UserId) == sqlchelpers.UUIDToStr(memberToUpdate.UserId) {
+	if tenantMember.UserId == memberToUpdate.UserId {
 		return gen.TenantMemberUpdate400JSONResponse(
 			apierrors.NewAPIErrors("you cannot change your own role"),
 		), nil
@@ -55,7 +54,7 @@ func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantM
 		Role: v1.StringPtr(string(request.Body.Role)),
 	}
 
-	updatedMember, err := t.config.V1.Tenant().UpdateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToUpdate.ID), updateOpts)
+	updatedMember, err := t.config.V1.Tenant().UpdateTenantMember(ctx.Request().Context(), memberToUpdate.ID, updateOpts)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/users/accept_invite.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 	"github.com/labstack/echo/v4"
 
@@ -11,13 +12,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInviteAcceptRequestObject) (gen.TenantInviteAcceptResponseObject, error) {
 	user := ctx.Get("user").(*sqlcv1.User)
-	userId := sqlchelpers.UUIDToStr(user.ID)
+	userId := user.ID
 
 	// validate the request
 	if apiErrors, err := u.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -26,9 +26,15 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
 		return gen.TenantInviteAccept400JSONResponse(*apiErrors), nil
 	}
 
-	inviteId := request.Body.Invite
+	inviteIdStr := request.Body.Invite
 
-	if inviteId == "" {
+	if inviteIdStr == "" {
+		return nil, errors.New("invalid invite id")
+	}
+
+	inviteId, err := uuid.Parse(inviteIdStr)
+
+	if err != nil {
 		return nil, errors.New("invalid invite id")
 	}
 
@@ -55,7 +61,7 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
 	}
 
 	// ensure the user is not already a member of the tenant
-	_, err = u.config.V1.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), user.Email)
+	_, err = u.config.V1.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), invite.TenantId, user.Email)
 
 	if err != nil && !errors.Is(err, pgx.ErrNoRows) {
 		return nil, err
@@ -69,14 +75,14 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
 	}
 
 	// update the invite
-	invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
+	invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), invite.ID, updateOpts)
 
 	if err != nil {
 		return nil, err
 	}
 
 	// add the user to the tenant
-	member, err := u.config.V1.Tenant().CreateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), &v1.CreateTenantMemberOpts{
+	member, err := u.config.V1.Tenant().CreateTenantMember(ctx.Request().Context(), invite.TenantId, &v1.CreateTenantMemberOpts{
 		UserId: userId,
 		Role:   string(invite.Role),
 	})
@@ -85,23 +91,21 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
 		return nil, err
 	}
 
-	tenantId := sqlchelpers.UUIDToStr(invite.TenantId)
-
 	u.config.Analytics.Enqueue(
 		"user-invite:accept",
-		userId,
-		&tenantId,
+		userId.String(),
+		&invite.TenantId,
 		nil,
 		map[string]interface{}{
-			"user_id":   userId,
-			"invite_id": inviteId,
+			"user_id":   userId.String(),
+			"invite_id": inviteId.String(),
 			"role":      invite.Role,
 		},
 	)
 
 	ctx.Set("tenant-member", member)
 
-	tenant, err := u.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
+	tenant, err := u.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), invite.TenantId)
 	if err != nil {
 		return nil, err
 	}

api/v1/server/handlers/users/get_current.go

@@ -11,13 +11,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (u *UserService) UserGetCurrent(ctx echo.Context, request gen.UserGetCurrentRequestObject) (gen.UserGetCurrentResponseObject, error) {
 	user := ctx.Get("user").(*sqlcv1.User)
-	userId := sqlchelpers.UUIDToStr(user.ID)
+	userId := user.ID
 
 	var hasPass bool
 
@@ -45,7 +44,7 @@ func (u *UserService) UserGetCurrent(ctx echo.Context, request gen.UserGetCurren
 
 	u.config.Analytics.Enqueue(
 		"user:current",
-		userId,
+		userId.String(),
 		nil,
 		map[string]interface{}{
 			"email": user.Email,

api/v1/server/handlers/users/github_oauth_callback.go

@@ -15,7 +15,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -106,7 +105,7 @@ func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *ser
 
 	switch err {
 	case nil:
-		user, err = u.config.V1.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &v1.UpdateUserOpts{
+		user, err = u.config.V1.User().UpdateUser(ctx, user.ID, &v1.UpdateUserOpts{
 			EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
 			Name:          v1.StringPtr(gInfo.Name),
 			OAuth:         oauthOpts,

api/v1/server/handlers/users/google_oauth_callback.go

@@ -17,7 +17,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -99,7 +98,7 @@ func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *ser
 
 	switch err {
 	case nil:
-		user, err = u.config.V1.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &v1.UpdateUserOpts{
+		user, err = u.config.V1.User().UpdateUser(ctx, user.ID, &v1.UpdateUserOpts{
 			EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
 			Name:          v1.StringPtr(gInfo.Name),
 			OAuth:         oauthOpts,

api/v1/server/handlers/users/list_memberships.go

@@ -5,13 +5,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *UserService) TenantMembershipsList(ctx echo.Context, request gen.TenantMembershipsListRequestObject) (gen.TenantMembershipsListResponseObject, error) {
 	user := ctx.Get("user").(*sqlcv1.User)
-	userId := sqlchelpers.UUIDToStr(user.ID)
+	userId := user.ID
 
 	memberships, err := t.config.V1.User().ListTenantMemberships(ctx.Request().Context(), userId)
 

api/v1/server/handlers/users/reject_invite.go

@@ -4,18 +4,18 @@ import (
 	"errors"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInviteRejectRequestObject) (gen.TenantInviteRejectResponseObject, error) {
 	user := ctx.Get("user").(*sqlcv1.User)
-	userId := sqlchelpers.UUIDToStr(user.ID)
+	userId := user.ID.String()
 
 	// validate the request
 	if apiErrors, err := u.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -24,9 +24,15 @@ func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInv
 		return gen.TenantInviteReject400JSONResponse(*apiErrors), nil
 	}
 
-	inviteId := request.Body.Invite
+	inviteIdStr := request.Body.Invite
 
-	if inviteId == "" {
+	if inviteIdStr == "" {
+		return nil, errors.New("invalid invite id")
+	}
+
+	inviteId, err := uuid.Parse(inviteIdStr)
+
+	if err != nil {
 		return nil, errors.New("invalid invite id")
 	}
 
@@ -58,22 +64,20 @@ func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInv
 	}
 
 	// update the invite
-	invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
+	invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), invite.ID, updateOpts)
 
 	if err != nil {
 		return nil, err
 	}
 
-	tenantId := sqlchelpers.UUIDToStr(invite.TenantId)
-
 	u.config.Analytics.Enqueue(
 		"user-invite:reject",
 		userId,
-		&tenantId,
+		&invite.TenantId,
 		nil,
 		map[string]interface{}{
 			"user_id":   userId,
-			"invite_id": inviteId,
+			"invite_id": inviteId.String(),
 			"role":      invite.Role,
 		},
 	)

api/v1/server/handlers/users/update_login.go

@@ -11,7 +11,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 )
 
 func (u *UserService) UserUpdateLogin(ctx echo.Context, request gen.UserUpdateLoginRequestObject) (gen.UserUpdateLoginResponseObject, error) {
@@ -47,7 +46,7 @@ func (u *UserService) UserUpdateLogin(ctx echo.Context, request gen.UserUpdateLo
 		return gen.UserUpdateLogin400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
 	}
 
-	userPass, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), sqlchelpers.UUIDToStr(existingUser.ID))
+	userPass, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), existingUser.ID)
 
 	if err != nil {
 		u.config.Logger.Err(err).Msg("failed to get user password")

api/v1/server/handlers/users/update_password.go

@@ -7,7 +7,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -35,7 +34,7 @@ func (u *UserService) UserUpdatePassword(ctx echo.Context, request gen.UserUpdat
 		return gen.UserUpdatePassword400JSONResponse(*apiErrors), nil
 	}
 
-	userId := sqlchelpers.UUIDToStr(existingUser.ID)
+	userId := existingUser.ID
 
 	userPass, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), userId)
 

api/v1/server/handlers/v1/events/list.go

@@ -11,13 +11,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *V1EventsService) V1EventList(ctx echo.Context, request gen.V1EventListRequestObject) (gen.V1EventListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limit := int64(50)
 	offset := int64(0)
@@ -36,7 +35,7 @@ func (t *V1EventsService) V1EventList(ctx echo.Context, request gen.V1EventListR
 	}
 
 	opts := sqlcv1.ListEventsParams{
-		Tenantid: sqlchelpers.UUIDFromStr(tenantId),
+		Tenantid: tenantId,
 		Limit: pgtype.Int8{
 			Int64: limit,
 			Valid: true,
@@ -63,13 +62,7 @@ func (t *V1EventsService) V1EventList(ctx echo.Context, request gen.V1EventListR
 	}
 
 	if request.Params.WorkflowIds != nil {
-		workflowIds := make([]pgtype.UUID, len(*request.Params.WorkflowIds))
-
-		for i, workflowId := range *request.Params.WorkflowIds {
-			workflowIds[i] = sqlchelpers.UUIDFromStr(workflowId.String())
-		}
-
-		opts.WorkflowIds = workflowIds
+		opts.WorkflowIds = *request.Params.WorkflowIds
 	}
 
 	if request.Params.WorkflowRunStatuses != nil {
@@ -81,11 +74,7 @@ func (t *V1EventsService) V1EventList(ctx echo.Context, request gen.V1EventListR
 	}
 
 	if request.Params.EventIds != nil {
-		eventIds := make([]pgtype.UUID, len(*request.Params.EventIds))
-		for i, eventId := range *request.Params.EventIds {
-			eventIds[i] = sqlchelpers.UUIDFromStr(eventId.String())
-		}
-		opts.EventIds = eventIds
+		opts.EventIds = *request.Params.EventIds
 	}
 
 	if request.Params.Scopes != nil {

api/v1/server/handlers/v1/events/list_keys.go

@@ -4,13 +4,12 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *V1EventsService) V1EventKeyList(ctx echo.Context, request gen.V1EventKeyListRequestObject) (gen.V1EventKeyListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	eventKeys, err := t.config.V1.OLAP().ListEventKeys(ctx.Request().Context(), tenantId)
 

api/v1/server/handlers/v1/filters/create.go

@@ -4,11 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 	"github.com/labstack/echo/v4"
 )
@@ -26,8 +26,14 @@ func (t *V1FiltersService) V1FilterCreate(ctx echo.Context, request gen.V1Filter
 		payload = marshalledPayload
 	}
 
+	workflowId, err := uuid.Parse(request.Body.WorkflowId.String())
+
+	if err != nil {
+		return gen.V1FilterCreate400JSONResponse(apierrors.NewAPIErrors("workflow id is not a valid uuid")), nil
+	}
+
 	params := v1.CreateFilterOpts{
-		Workflowid:    sqlchelpers.UUIDFromStr(request.Body.WorkflowId.String()),
+		Workflowid:    workflowId,
 		Scope:         request.Body.Scope,
 		Expression:    request.Body.Expression,
 		Payload:       payload,
@@ -36,7 +42,7 @@ func (t *V1FiltersService) V1FilterCreate(ctx echo.Context, request gen.V1Filter
 
 	filter, err := t.config.V1.Filters().CreateFilter(
 		ctx.Request().Context(),
-		tenant.ID.String(),
+		tenant.ID,
 		params,
 	)
 

api/v1/server/handlers/v1/filters/delete.go

@@ -13,8 +13,8 @@ func (t *V1FiltersService) V1FilterDelete(ctx echo.Context, request gen.V1Filter
 
 	filter, err := t.config.V1.Filters().DeleteFilter(
 		ctx.Request().Context(),
-		filter.TenantID.String(),
-		filter.ID.String(),
+		filter.TenantID,
+		filter.ID,
 	)
 
 	if err != nil {

api/v1/server/handlers/v1/filters/list.go

@@ -1,13 +1,12 @@
 package filtersv1
 
 import (
+	"github.com/google/uuid"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v4"
 )
 
@@ -17,12 +16,12 @@ func (t *V1FiltersService) V1FilterList(ctx echo.Context, request gen.V1FilterLi
 	scopes := request.Params.Scopes
 	workflowIds := request.Params.WorkflowIds
 
-	var workflowIdParams []pgtype.UUID
+	var workflowIdParams []uuid.UUID
 	var scopeParams []string
 
 	if workflowIds != nil {
 		for _, id := range *workflowIds {
-			workflowIdParams = append(workflowIdParams, sqlchelpers.UUIDFromStr(id.String()))
+			workflowIdParams = append(workflowIdParams, id)
 		}
 	}
 
@@ -43,7 +42,7 @@ func (t *V1FiltersService) V1FilterList(ctx echo.Context, request gen.V1FilterLi
 
 	filters, count, err := t.config.V1.Filters().ListFilters(
 		ctx.Request().Context(),
-		tenant.ID.String(),
+		tenant.ID,
 		v1.ListFiltersOpts{
 			WorkflowIds: workflowIdParams,
 			Scopes:      scopeParams,

api/v1/server/handlers/v1/filters/update.go

@@ -28,8 +28,8 @@ func (t *V1FiltersService) V1FilterUpdate(ctx echo.Context, request gen.V1Filter
 
 	filter, err := t.config.V1.Filters().UpdateFilter(
 		ctx.Request().Context(),
-		tenant.ID.String(),
-		filter.ID.String(),
+		tenant.ID,
+		filter.ID,
 		v1.UpdateFilterOpts{
 			Scope:      request.Body.Scope,
 			Expression: request.Body.Expression,

api/v1/server/handlers/v1/proxy/proxy.go

@@ -6,7 +6,6 @@ import (
 
 	client "github.com/hatchet-dev/hatchet/pkg/client/v1"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -23,7 +22,7 @@ func NewProxy[in, out any](config *server.ServerConfig, method func(ctx context.
 }
 
 func (p *Proxy[in, out]) Do(ctx context.Context, tenant *sqlcv1.Tenant, input *in) (*out, error) {
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	expiresAt := time.Now().Add(5 * time.Minute).UTC()
 

api/v1/server/handlers/v1/tasks/get.go

@@ -53,7 +53,7 @@ func (t *TasksService) V1TaskGet(ctx echo.Context, request gen.V1TaskGetRequestO
 		return nil, err
 	}
 
-	workflowVersion, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), task.TenantID.String(), taskWithData.WorkflowVersionID.String())
+	workflowVersion, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), task.TenantID, taskWithData.WorkflowVersionID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/v1/tasks/get_metrics.go

@@ -4,11 +4,9 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 
 	"github.com/labstack/echo/v4"
@@ -18,7 +16,7 @@ import (
 
 func (t *TasksService) V1TaskListStatusMetrics(ctx echo.Context, request gen.V1TaskListStatusMetricsRequestObject) (gen.V1TaskListStatusMetricsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	var workflowIds []uuid.UUID
 
@@ -26,18 +24,15 @@ func (t *TasksService) V1TaskListStatusMetrics(ctx echo.Context, request gen.V1T
 		workflowIds = *request.Params.WorkflowIds
 	}
 
-	var parentTaskExternalId *pgtype.UUID
+	var parentTaskExternalId *uuid.UUID
 
 	if request.Params.ParentTaskExternalId != nil {
-		uuidPtr := *request.Params.ParentTaskExternalId
-		uuidVal := sqlchelpers.UUIDFromStr(uuidPtr.String())
-		parentTaskExternalId = &uuidVal
+		parentTaskExternalId = request.Params.ParentTaskExternalId
 	}
 
-	var triggeringEventExternalId *pgtype.UUID
+	var triggeringEventExternalId *uuid.UUID
 	if request.Params.TriggeringEventExternalId != nil {
-		uuidVal := sqlchelpers.UUIDFromStr(request.Params.TriggeringEventExternalId.String())
-		triggeringEventExternalId = &uuidVal
+		triggeringEventExternalId = request.Params.TriggeringEventExternalId
 	}
 
 	additionalMetadataFilters := make(map[string]interface{})

api/v1/server/handlers/v1/tasks/get_point_metrics.go

@@ -9,13 +9,12 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *TasksService) V1TaskGetPointMetrics(ctx echo.Context, request gen.V1TaskGetPointMetricsRequestObject) (gen.V1TaskGetPointMetricsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// 24 hours ago, rounded to the nearest minute
 	lowerBound := time.Now().UTC().Add(-24 * time.Hour).Truncate(30 * time.Minute)

api/v1/server/handlers/v1/tasks/list_by_dag_id.go

@@ -1,28 +1,21 @@
 package tasks
 
 import (
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 )
 
 func (t *TasksService) V1DagListTasks(ctx echo.Context, request gen.V1DagListTasksRequestObject) (gen.V1DagListTasksResponseObject, error) {
-	tenantId := request.Params.Tenant.String()
+	tenantId := request.Params.Tenant
 	dagIds := request.Params.DagIds
 
-	pguuids := make([]pgtype.UUID, 0)
-	for _, dagId := range dagIds {
-		pguuids = append(pguuids, sqlchelpers.UUIDFromStr(dagId.String()))
-	}
-
 	tasks, taskIdToDagExternalId, err := t.config.V1.OLAP().ListTasksByDAGId(
 		ctx.Request().Context(),
 		tenantId,
-		pguuids,
+		dagIds,
 		false,
 	)
 

api/v1/server/handlers/v1/tasks/list_events.go

@@ -4,7 +4,6 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
@@ -12,7 +11,7 @@ import (
 
 func (t *TasksService) V1TaskEventList(ctx echo.Context, request gen.V1TaskEventListRequestObject) (gen.V1TaskEventListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	task := ctx.Get("task").(*sqlcv1.V1TasksOlap)
 
 	taskRunEvents, err := t.config.V1.OLAP().ListTaskRunEvents(ctx.Request().Context(), tenantId, task.ID, task.InsertedAt, *request.Params.Limit, *request.Params.Offset)
@@ -21,7 +20,7 @@ func (t *TasksService) V1TaskEventList(ctx echo.Context, request gen.V1TaskEvent
 		return nil, err
 	}
 
-	result := transformers.ToTaskRunEventMany(taskRunEvents, sqlchelpers.UUIDToStr(task.ExternalID))
+	result := transformers.ToTaskRunEventMany(taskRunEvents, task.ExternalID)
 
 	return gen.V1TaskEventList200JSONResponse(
 		result,

api/v1/server/handlers/v1/tasks/list_logs.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 	"github.com/hatchet-dev/hatchet/pkg/telemetry"
 
@@ -16,7 +15,7 @@ import (
 
 func (t *TasksService) V1LogLineList(ctx echo.Context, request gen.V1LogLineListRequestObject) (gen.V1LogLineListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	task := ctx.Get("task").(*sqlcv1.V1TasksOlap)
 
 	reqCtx, span := telemetry.NewSpan(ctx.Request().Context(), "GET /api/v1/stable/tasks/{task}/logs")
@@ -81,7 +80,7 @@ func (t *TasksService) V1LogLineList(ctx echo.Context, request gen.V1LogLineList
 		Attempt:          attempt,
 	}
 
-	logLines, err := t.config.V1.Logs().ListLogLines(reqCtx, tenantId, task.ExternalID.String(), opts)
+	logLines, err := t.config.V1.Logs().ListLogLines(reqCtx, tenantId, task.ExternalID, opts)
 
 	if err != nil {
 		span.RecordError(err)

api/v1/server/handlers/v1/webhooks/create.go

@@ -4,19 +4,19 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (w *V1WebhooksService) V1WebhookCreate(ctx echo.Context, request gen.V1WebhookCreateRequestObject) (gen.V1WebhookCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
 
-	canCreate, _, err := w.config.V1.TenantLimit().CanCreate(ctx.Request().Context(), sqlcv1.LimitResourceINCOMINGWEBHOOK, tenant.ID.String(), 1)
+	canCreate, _, err := w.config.V1.TenantLimit().CanCreate(ctx.Request().Context(), sqlcv1.LimitResourceINCOMINGWEBHOOK, tenant.ID, 1)
 
 	if err != nil {
 		return nil, fmt.Errorf("failed to check if webhook can be created: %w", err)
@@ -32,7 +32,7 @@ func (w *V1WebhooksService) V1WebhookCreate(ctx echo.Context, request gen.V1Webh
 		}, nil
 	}
 
-	params, err := w.constructCreateOpts(tenant.ID.String(), *request.Body)
+	params, err := w.constructCreateOpts(tenant.ID, *request.Body)
 	if err != nil {
 		return gen.V1WebhookCreate400JSONResponse{
 			Errors: []gen.APIError{
@@ -45,7 +45,7 @@ func (w *V1WebhooksService) V1WebhookCreate(ctx echo.Context, request gen.V1Webh
 
 	webhook, err := w.config.V1.Webhooks().CreateWebhook(
 		ctx.Request().Context(),
-		tenant.ID.String(),
+		tenant.ID,
 		params,
 	)
 
@@ -85,9 +85,9 @@ func extractAuthType(request gen.V1CreateWebhookRequest) (sqlcv1.V1IncomingWebho
 	return authType, nil
 }
 
-func (w *V1WebhooksService) constructCreateOpts(tenantId string, request gen.V1CreateWebhookRequest) (v1.CreateWebhookOpts, error) {
+func (w *V1WebhooksService) constructCreateOpts(tenantId uuid.UUID, request gen.V1CreateWebhookRequest) (v1.CreateWebhookOpts, error) {
 	params := v1.CreateWebhookOpts{
-		Tenantid: sqlchelpers.UUIDFromStr(tenantId),
+		Tenantid: tenantId,
 	}
 
 	discriminator, err := extractAuthType(request)

api/v1/server/handlers/v1/webhooks/delete.go

@@ -14,7 +14,7 @@ func (w *V1WebhooksService) V1WebhookDelete(ctx echo.Context, request gen.V1Webh
 
 	webhook, err := w.config.V1.Webhooks().DeleteWebhook(
 		ctx.Request().Context(),
-		webhook.TenantID.String(),
+		webhook.TenantID,
 		webhook.Name,
 	)
 

api/v1/server/handlers/v1/webhooks/list.go

@@ -28,7 +28,7 @@ func (w *V1WebhooksService) V1WebhookList(ctx echo.Context, request gen.V1Webhoo
 
 	webhooks, err := w.config.V1.Webhooks().ListWebhooks(
 		ctx.Request().Context(),
-		tenant.ID.String(),
+		tenant.ID,
 		v1.ListWebhooksOpts{
 			WebhookNames:       webhookNames,
 			WebhookSourceNames: sourceNames,

api/v1/server/handlers/v1/webhooks/receive.go

@@ -27,10 +27,10 @@ import (
 )
 
 func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1WebhookReceiveRequestObject) (gen.V1WebhookReceiveResponseObject, error) {
-	tenantId := request.Tenant.String()
+	tenantId := request.Tenant
 	webhookName := request.V1Webhook
 
-	w.config.Logger.Debug().Str("webhook", webhookName).Str("tenant", tenantId).Str("method", ctx.Request().Method).Str("content_type", ctx.Request().Header.Get("Content-Type")).Msg("received webhook request")
+	w.config.Logger.Debug().Str("webhook", webhookName).Str("tenant", tenantId.String()).Str("method", ctx.Request().Method).Str("content_type", ctx.Request().Header.Get("Content-Type")).Msg("received webhook request")
 
 	tenant, err := w.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
 
@@ -56,7 +56,7 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
 		}, nil
 	}
 
-	if webhook.TenantID.String() != tenantId {
+	if webhook.TenantID != tenantId {
 		return gen.V1WebhookReceive403JSONResponse{
 			Errors: []gen.APIError{
 				{
@@ -108,7 +108,7 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
 			formData, err := url.ParseQuery(string(rawBody))
 			if err != nil {
 				errorMsg := "Failed to parse form data"
-				w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId).Msg(errorMsg)
+				w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId.String()).Msg(errorMsg)
 				return gen.V1WebhookReceive400JSONResponse{
 					Errors: []gen.APIError{
 						{
@@ -137,7 +137,7 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
 							payloadPreview = payloadPreview[:200] + "..."
 						}
 						errorMsg := "Failed to unmarshal payload parameter as JSON"
-						w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId).Int("payload_length", len(payloadValue)).Str("payload_preview", payloadPreview).Msg(errorMsg)
+						w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId.String()).Int("payload_length", len(payloadValue)).Str("payload_preview", payloadPreview).Msg(errorMsg)
 						return gen.V1WebhookReceive400JSONResponse{
 							Errors: []gen.APIError{
 								{
@@ -179,7 +179,7 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
 					bodyPreview = bodyPreview[:200] + "..."
 				}
 				errorMsg := "Failed to unmarshal request body as JSON"
-				w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId).Str("content_type", contentType).Int("body_length", len(rawBody)).Str("body_preview", bodyPreview).Msg(errorMsg)
+				w.config.Logger.Info().Err(err).Str("webhook", webhookName).Str("tenant", tenantId.String()).Str("content_type", contentType).Int("body_length", len(rawBody)).Str("body_preview", bodyPreview).Msg(errorMsg)
 				return gen.V1WebhookReceive400JSONResponse{
 					Errors: []gen.APIError{
 						{
@@ -221,11 +221,11 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
 			errorMsg = "Failed to evaluate event key expression"
 		}
 
-		w.config.Logger.Warn().Err(err).Str("webhook", webhookName).Str("tenant", tenantId).Str("event_key_expression", webhook.EventKeyExpression).Msg(errorMsg)
+		w.config.Logger.Warn().Err(err).Str("webhook", webhookName).Str("tenant", tenantId.String()).Str("event_key_expression", webhook.EventKeyExpression).Msg(errorMsg)
 
 		ingestionErr := w.config.Ingestor.IngestCELEvaluationFailure(
 			ctx.Request().Context(),
-			tenant.ID.String(),
+			tenant.ID,
 			err.Error(),
 			sqlcv1.V1CelEvaluationFailureSourceWEBHOOK,
 		)

api/v1/server/handlers/v1/webhooks/update.go

@@ -14,7 +14,7 @@ func (w *V1WebhooksService) V1WebhookUpdate(ctx echo.Context, request gen.V1Webh
 
 	webhook, err := w.config.V1.Webhooks().UpdateWebhook(
 		ctx.Request().Context(),
-		webhook.TenantID.String(),
+		webhook.TenantID,
 		webhook.Name,
 		request.Body.EventKeyExpression,
 	)

api/v1/server/handlers/v1/workflow-runs/get-timings.go

@@ -8,7 +8,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
@@ -18,7 +17,7 @@ import (
 
 func (t *V1WorkflowRunsService) V1WorkflowRunGetTimings(ctx echo.Context, request gen.V1WorkflowRunGetTimingsRequestObject) (gen.V1WorkflowRunGetTimingsResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
 
 	workflowRun := rawWorkflowRun.WorkflowRun

api/v1/server/handlers/v1/workflow-runs/get.go

@@ -4,12 +4,10 @@ import (
 	"context"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
@@ -17,7 +15,7 @@ import (
 
 func (t *V1WorkflowRunsService) V1WorkflowRunGet(ctx echo.Context, request gen.V1WorkflowRunGetRequestObject) (gen.V1WorkflowRunGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
 
 	requestContext := ctx.Request().Context()
@@ -40,7 +38,7 @@ func (t *V1WorkflowRunsService) V1WorkflowRunGet(ctx echo.Context, request gen.V
 
 func (t *V1WorkflowRunsService) getWorkflowRunDetails(
 	ctx context.Context,
-	tenantId string,
+	tenantId uuid.UUID,
 	rawWorkflowRun *v1.V1WorkflowRunPopulator,
 ) (*gen.V1WorkflowRunDetails, error) {
 	workflowRun := rawWorkflowRun.WorkflowRun
@@ -68,23 +66,21 @@ func (t *V1WorkflowRunsService) getWorkflowRunDetails(
 		return nil, err
 	}
 
-	stepIdToTaskExternalId := make(map[pgtype.UUID]pgtype.UUID)
+	stepIdToTaskExternalId := make(map[uuid.UUID]uuid.UUID)
 
 	for _, task := range tasks {
 		stepIdToTaskExternalId[task.StepID] = task.ExternalID
 	}
 
-	workflowVersionId := uuid.MustParse(sqlchelpers.UUIDToStr(workflowRun.WorkflowVersionId))
-
 	shape, err := t.config.V1.Workflows().GetWorkflowShape(
-		ctx, workflowVersionId,
+		ctx, workflowRun.WorkflowVersionId,
 	)
 
 	if err != nil {
 		return nil, err
 	}
 
-	workflowVersion, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx, tenantId, workflowRun.WorkflowVersionId.String())
+	workflowVersion, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx, tenantId, workflowRun.WorkflowVersionId)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/v1/workflow-runs/list-task-events.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
@@ -13,7 +12,7 @@ import (
 
 func (t *V1WorkflowRunsService) V1WorkflowRunTaskEventsList(ctx echo.Context, request gen.V1WorkflowRunTaskEventsListRequestObject) (gen.V1WorkflowRunTaskEventsListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
 
 	workflowRun := rawWorkflowRun.WorkflowRun

api/v1/server/handlers/v1/workflow-runs/list.go

@@ -5,19 +5,17 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 	"github.com/hatchet-dev/hatchet/pkg/telemetry"
 
 	transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 )
 
-func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1WorkflowRunListRequestObject, tenantId string) (gen.V1WorkflowRunListResponseObject, error) {
+func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1WorkflowRunListRequestObject, tenantId uuid.UUID) (gen.V1WorkflowRunListResponseObject, error) {
 	ctx, span := telemetry.NewSpan(ctx, "v1-workflow-runs-list-with-dags-tasks")
 	defer span.End()
 
@@ -29,10 +27,9 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 			sqlcv1.V1ReadableStatusOlapCOMPLETED,
 			sqlcv1.V1ReadableStatusOlapCANCELLED,
 		}
-		since             = request.Params.Since
-		workflowIds       = []uuid.UUID{}
-		limit       int64 = 50
-		offset      int64
+		since        = request.Params.Since
+		limit  int64 = 50
+		offset int64
 	)
 
 	if request.Params.Statuses != nil {
@@ -52,6 +49,7 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 		offset = *request.Params.Offset
 	}
 
+	workflowIds := make([]uuid.UUID, 0)
 	if request.Params.WorkflowIds != nil {
 		workflowIds = *request.Params.WorkflowIds
 	}
@@ -88,14 +86,11 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 	}
 
 	if request.Params.ParentTaskExternalId != nil {
-		parentTaskExternalId := request.Params.ParentTaskExternalId.String()
-		id := sqlchelpers.UUIDFromStr(parentTaskExternalId)
-		opts.ParentTaskExternalId = &id
+		opts.ParentTaskExternalId = request.Params.ParentTaskExternalId
 	}
 
 	if request.Params.TriggeringEventExternalId != nil {
-		id := sqlchelpers.UUIDFromStr(request.Params.TriggeringEventExternalId.String())
-		opts.TriggeringEventExternalId = &id
+		opts.TriggeringEventExternalId = request.Params.TriggeringEventExternalId
 	}
 
 	dags, total, err := t.config.V1.OLAP().ListWorkflowRuns(
@@ -108,7 +103,7 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 		return nil, err
 	}
 
-	dagExternalIds := make([]pgtype.UUID, 0)
+	dagExternalIds := make([]uuid.UUID, 0)
 
 	for _, dag := range dags {
 		if dag.Kind == sqlcv1.V1RunKindDAG {
@@ -127,7 +122,7 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 		return nil, err
 	}
 
-	pgWorkflowIds := make([]pgtype.UUID, 0)
+	pgWorkflowIds := make([]uuid.UUID, 0)
 
 	for _, wf := range dags {
 		pgWorkflowIds = append(pgWorkflowIds, wf.WorkflowID)
@@ -176,7 +171,7 @@ func (t *V1WorkflowRunsService) WithDags(ctx context.Context, request gen.V1Work
 	), nil
 }
 
-func (t *V1WorkflowRunsService) OnlyTasks(ctx context.Context, request gen.V1WorkflowRunListRequestObject, tenantId string) (gen.V1WorkflowRunListResponseObject, error) {
+func (t *V1WorkflowRunsService) OnlyTasks(ctx context.Context, request gen.V1WorkflowRunListRequestObject, tenantId uuid.UUID) (gen.V1WorkflowRunListResponseObject, error) {
 	ctx, span := telemetry.NewSpan(ctx, "v1-workflow-runs-list-only-tasks")
 	defer span.End()
 
@@ -261,7 +256,7 @@ func (t *V1WorkflowRunsService) OnlyTasks(ctx context.Context, request gen.V1Wor
 		return nil, err
 	}
 
-	workflowIdsForNames := make([]pgtype.UUID, 0)
+	workflowIdsForNames := make([]uuid.UUID, 0)
 	for _, task := range tasks {
 		workflowIdsForNames = append(workflowIdsForNames, task.WorkflowID)
 	}
@@ -294,7 +289,7 @@ func (t *V1WorkflowRunsService) OnlyTasks(ctx context.Context, request gen.V1Wor
 
 func (t *V1WorkflowRunsService) V1WorkflowRunList(ctx echo.Context, request gen.V1WorkflowRunListRequestObject) (gen.V1WorkflowRunListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	spanContext, span := telemetry.NewSpan(ctx.Request().Context(), "v1-workflow-runs-list")
 	defer span.End()
@@ -309,11 +304,7 @@ func (t *V1WorkflowRunsService) V1WorkflowRunList(ctx echo.Context, request gen.
 func (t *V1WorkflowRunsService) V1WorkflowRunDisplayNamesList(ctx echo.Context, request gen.V1WorkflowRunDisplayNamesListRequestObject) (gen.V1WorkflowRunDisplayNamesListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
 
-	externalIds := make([]pgtype.UUID, len(request.Params.ExternalIds))
-
-	for i, id := range request.Params.ExternalIds {
-		externalIds[i] = sqlchelpers.UUIDFromStr(id.String())
-	}
+	externalIds := request.Params.ExternalIds
 
 	displayNames, err := t.config.V1.OLAP().ListWorkflowRunDisplayNames(
 		ctx.Request().Context(),
@@ -334,7 +325,7 @@ func (t *V1WorkflowRunsService) V1WorkflowRunDisplayNamesList(ctx echo.Context,
 
 func (t *V1WorkflowRunsService) V1WorkflowRunExternalIdsList(ctx echo.Context, request gen.V1WorkflowRunExternalIdsListRequestObject) (gen.V1WorkflowRunExternalIdsListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := tenant.ID.String()
+	tenantId := tenant.ID
 	spanCtx, span := telemetry.NewSpan(ctx.Request().Context(), "v1-workflow-runs-list-external-ids")
 	defer span.End()
 
@@ -396,9 +387,7 @@ func (t *V1WorkflowRunsService) V1WorkflowRunExternalIdsList(ctx echo.Context, r
 		return nil, err
 	}
 
-	result := transformers.ToWorkflowRunExternalIds(externalIds)
-
 	return gen.V1WorkflowRunExternalIdsList200JSONResponse(
-		result,
+		externalIds,
 	), nil
 }

api/v1/server/handlers/v1/workflow-runs/trigger.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 	"github.com/labstack/echo/v4"
 	"google.golang.org/grpc/codes"
@@ -16,13 +17,12 @@ import (
 	contracts "github.com/hatchet-dev/hatchet/internal/services/shared/proto/v1"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *V1WorkflowRunsService) V1WorkflowRunCreate(ctx echo.Context, request gen.V1WorkflowRunCreateRequestObject) (gen.V1WorkflowRunCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	// make sure input can be marshalled and unmarshalled to input type
 	inputBytes, err := json.Marshal(request.Body.Input)
@@ -92,10 +92,16 @@ func (t *V1WorkflowRunsService) V1WorkflowRunCreate(ctx echo.Context, request ge
 	var rawWorkflowRun *v1.V1WorkflowRunPopulator
 	retries := 0
 
+	externalId, err := uuid.Parse(resp.ExternalId)
+
+	if err != nil {
+		return nil, fmt.Errorf("invalid external id returned from trigger workflow run: %w", err)
+	}
+
 	for retries < 10 {
 		rawWorkflowRun, err = t.config.V1.OLAP().ReadWorkflowRun(
 			ctx.Request().Context(),
-			sqlchelpers.UUIDFromStr(resp.ExternalId),
+			externalId,
 		)
 
 		if err != nil && !errors.Is(err, pgx.ErrNoRows) {
@@ -115,7 +121,7 @@ func (t *V1WorkflowRunsService) V1WorkflowRunCreate(ctx echo.Context, request ge
 		return nil, fmt.Errorf("rawWorkflowRun not populated, we are likely seeing high latency in creating tasks")
 	}
 
-	if sqlchelpers.UUIDToStr(rawWorkflowRun.WorkflowRun.TenantID) != tenantId {
+	if rawWorkflowRun.WorkflowRun.TenantID != tenantId {
 		return nil, fmt.Errorf("tenantId mismatch in the triggered workflow run")
 	}
 

api/v1/server/handlers/workers/get.go

@@ -3,12 +3,12 @@ package workers
 import (
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	transformersv1 "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -21,15 +21,15 @@ func (t *WorkerService) WorkerGet(ctx echo.Context, request gen.WorkerGetRequest
 func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *sqlcv1.Tenant, request gen.WorkerGetRequestObject) (gen.WorkerGetResponseObject, error) {
 	workerV0 := ctx.Get("worker").(*sqlcv1.GetWorkerByIdRow)
 
-	worker, err := t.config.V1.Workers().GetWorkerById(sqlchelpers.UUIDToStr(workerV0.Worker.ID))
+	worker, err := t.config.V1.Workers().GetWorkerById(workerV0.Worker.ID)
 
 	if err != nil {
 		return nil, err
 	}
 
 	slotState, err := t.config.V1.Workers().ListWorkerState(
-		sqlchelpers.UUIDToStr(worker.Worker.TenantId),
-		sqlchelpers.UUIDToStr(worker.Worker.ID),
+		worker.Worker.TenantId,
+		worker.Worker.ID,
 		int(worker.Worker.MaxRuns),
 	)
 
@@ -38,23 +38,23 @@ func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *sqlcv1.Tenant, req
 	}
 
 	workerIdToActions, err := t.config.V1.Workers().GetWorkerActionsByWorkerId(
-		sqlchelpers.UUIDToStr(worker.Worker.TenantId),
-		[]string{sqlchelpers.UUIDToStr(worker.Worker.ID)},
+		worker.Worker.TenantId,
+		[]uuid.UUID{worker.Worker.ID},
 	)
 
 	if err != nil {
 		return nil, err
 	}
 
-	workerWorkflows, err := t.config.V1.Workers().GetWorkerWorkflowsByWorkerId(tenant.ID.String(), worker.Worker.ID.String())
+	workerWorkflows, err := t.config.V1.Workers().GetWorkerWorkflowsByWorkerId(tenant.ID, worker.Worker.ID)
 
 	if err != nil {
 		return nil, err
 	}
 
-	actions, ok := workerIdToActions[sqlchelpers.UUIDToStr(worker.Worker.ID)]
+	actions, ok := workerIdToActions[worker.Worker.ID.String()]
 	if !ok {
-		return nil, fmt.Errorf("worker %s has no actions", sqlchelpers.UUIDToStr(worker.Worker.ID))
+		return nil, fmt.Errorf("worker %s has no actions", worker.Worker.ID.String())
 	}
 
 	respStepRuns := make([]gen.RecentStepRuns, 0)
@@ -67,8 +67,8 @@ func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *sqlcv1.Tenant, req
 	workerResp.Slots = transformersv1.ToSlotState(slotState, slots)
 
 	affinity, err := t.config.V1.Workers().ListWorkerLabels(
-		sqlchelpers.UUIDToStr(worker.Worker.TenantId),
-		sqlchelpers.UUIDToStr(worker.Worker.ID),
+		worker.Worker.TenantId,
+		worker.Worker.ID,
 	)
 
 	if err != nil {

api/v1/server/handlers/workers/list.go

@@ -4,13 +4,13 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	transformersv1 "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 	"github.com/hatchet-dev/hatchet/pkg/telemetry"
 )
@@ -31,7 +31,7 @@ func (t *WorkerService) WorkerList(ctx echo.Context, request gen.WorkerListReque
 
 func (t *WorkerService) workerListV0(ctx echo.Context, tenant *sqlcv1.Tenant, request gen.WorkerListRequestObject) (gen.WorkerListResponseObject, error) {
 	reqCtx := ctx.Request().Context()
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	sixSecAgo := time.Now().Add(-24 * time.Hour)
 
@@ -75,7 +75,7 @@ func (t *WorkerService) workerListV0(ctx echo.Context, tenant *sqlcv1.Tenant, re
 
 func (t *WorkerService) workerListV1(ctx echo.Context, tenant *sqlcv1.Tenant, request gen.WorkerListRequestObject) (gen.WorkerListResponseObject, error) {
 	reqCtx := ctx.Request().Context()
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	sixSecAgo := time.Now().Add(-24 * time.Hour)
 
@@ -101,13 +101,13 @@ func (t *WorkerService) workerListV1(ctx echo.Context, tenant *sqlcv1.Tenant, re
 		telemetry.AttributeKV{Key: "workers.count", Value: len(workers)},
 	)
 
-	workerIdSet := make(map[string]struct{})
+	workerIdSet := make(map[uuid.UUID]struct{})
 
 	for _, worker := range workers {
-		workerIdSet[sqlchelpers.UUIDToStr(worker.Worker.ID)] = struct{}{}
+		workerIdSet[worker.Worker.ID] = struct{}{}
 	}
 
-	workerIds := make([]string, 0, len(workerIdSet))
+	workerIds := make([]uuid.UUID, 0, len(workerIdSet))
 	for workerId := range workerIdSet {
 		workerIds = append(workerIds, workerId)
 	}
@@ -120,7 +120,7 @@ func (t *WorkerService) workerListV1(ctx echo.Context, tenant *sqlcv1.Tenant, re
 	)
 
 	workerIdToActionIds, err := t.config.V1.Workers().GetWorkerActionsByWorkerId(
-		sqlchelpers.UUIDToStr(tenant.ID),
+		tenant.ID,
 		workerIds,
 	)
 
@@ -138,7 +138,7 @@ func (t *WorkerService) workerListV1(ctx echo.Context, tenant *sqlcv1.Tenant, re
 	for i, worker := range workers {
 		workerCp := worker
 		slots := int(worker.RemainingSlots)
-		actions := workerIdToActionIds[sqlchelpers.UUIDToStr(workerCp.Worker.ID)]
+		actions := workerIdToActionIds[workerCp.Worker.ID.String()]
 
 		rows[i] = *transformersv1.ToWorkerSqlc(&workerCp.Worker, &slots, &workerCp.WebhookUrl.String, actions, nil)
 	}

api/v1/server/handlers/workers/update.go

@@ -6,7 +6,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -28,8 +27,8 @@ func (t *WorkerService) WorkerUpdate(ctx echo.Context, request gen.WorkerUpdateR
 
 	updatedWorker, err := t.config.V1.Workers().UpdateWorker(
 		ctx.Request().Context(),
-		sqlchelpers.UUIDToStr(worker.Worker.TenantId),
-		sqlchelpers.UUIDToStr(worker.Worker.ID),
+		worker.Worker.TenantId,
+		worker.Worker.ID,
 		update,
 	)
 

api/v1/server/handlers/workflows/bulk_delete_scheduled.go

@@ -12,13 +12,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request gen.WorkflowScheduledBulkDeleteRequestObject) (gen.WorkflowScheduledBulkDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	if request.Body == nil {
 		return gen.WorkflowScheduledBulkDelete400JSONResponse(gen.APIErrors{
@@ -51,24 +50,15 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
 		orderDirection := "DESC"
 
 		opts := &v1.ListScheduledWorkflowsOpts{
-			Limit:          &limit,
-			Offset:         &offset,
-			OrderBy:        &orderBy,
-			OrderDirection: &orderDirection,
+			Limit:               &limit,
+			Offset:              &offset,
+			OrderBy:             &orderBy,
+			OrderDirection:      &orderDirection,
+			WorkflowId:          filter.WorkflowId,
+			ParentWorkflowRunId: filter.ParentWorkflowRunId,
+			ParentStepRunId:     filter.ParentStepRunId,
 		}
 
-		if filter.WorkflowId != nil {
-			wid := filter.WorkflowId.String()
-			opts.WorkflowId = &wid
-		}
-		if filter.ParentWorkflowRunId != nil {
-			pid := filter.ParentWorkflowRunId.String()
-			opts.ParentWorkflowRunId = &pid
-		}
-		if filter.ParentStepRunId != nil {
-			psid := filter.ParentStepRunId.String()
-			opts.ParentStepRunId = &psid
-		}
 		if filter.AdditionalMetadata != nil {
 			additionalMetadata := make(map[string]interface{}, len(*filter.AdditionalMetadata))
 			for _, v := range *filter.AdditionalMetadata {
@@ -101,7 +91,7 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
 		// Convert list results into ids + pre-fill errors for non-API items.
 		ids = make([]uuid.UUID, 0, len(all))
 		for _, row := range all {
-			idStr := sqlchelpers.UUIDToStr(row.ID)
+			idStr := row.ID.String()
 			idUUID, err := uuid.Parse(idStr)
 			if err != nil {
 				// fall back to skip with generic error (should never happen)
@@ -134,12 +124,11 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
 		}
 		chunk := ids[i:end]
 
-		chunkStr := make([]string, 0, len(chunk))
-		chunkUUIDByStr := make(map[string]uuid.UUID, len(chunk))
+		chunkStr := make([]uuid.UUID, 0, len(chunk))
+		chunkUUIDByStr := make(map[uuid.UUID]uuid.UUID, len(chunk))
 		for _, id := range chunk {
-			idStr := id.String()
-			chunkStr = append(chunkStr, idStr)
-			chunkUUIDByStr[idStr] = id
+			chunkStr = append(chunkStr, id)
+			chunkUUIDByStr[id] = id
 		}
 
 		deletedIds, err := t.config.V1.WorkflowSchedules().BulkDeleteScheduledWorkflows(dbCtx, tenantId, chunkStr)
@@ -147,13 +136,13 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
 			return nil, err
 		}
 
-		deletedSet := make(map[string]struct{}, len(deletedIds))
+		deletedSet := make(map[uuid.UUID]struct{}, len(deletedIds))
 		for _, idStr := range deletedIds {
 			deletedSet[idStr] = struct{}{}
 		}
 
 		for _, id := range chunk {
-			if _, ok := deletedSet[id.String()]; ok {
+			if _, ok := deletedSet[id]; ok {
 				deleted = append(deleted, id)
 			}
 		}

api/v1/server/handlers/workflows/bulk_update_scheduled.go

@@ -4,18 +4,18 @@ import (
 	"context"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 	openapi_types "github.com/oapi-codegen/runtime/types"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request gen.WorkflowScheduledBulkUpdateRequestObject) (gen.WorkflowScheduledBulkUpdateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	if request.Body == nil {
 		return gen.WorkflowScheduledBulkUpdate400JSONResponse(gen.APIErrors{
@@ -37,12 +37,11 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
 		}
 		chunk := request.Body.Updates[i:end]
 
-		chunkIds := make([]string, 0, len(chunk))
-		chunkUUIDByStr := make(map[string]openapi_types.UUID, len(chunk))
+		chunkIds := make([]uuid.UUID, 0, len(chunk))
+		chunkUUIDByStr := make(map[uuid.UUID]openapi_types.UUID, len(chunk))
 		for _, u := range chunk {
-			idStr := u.Id.String()
-			chunkIds = append(chunkIds, idStr)
-			chunkUUIDByStr[idStr] = u.Id
+			chunkIds = append(chunkIds, u.Id)
+			chunkUUIDByStr[u.Id] = u.Id
 		}
 
 		metaById, err := t.config.V1.WorkflowSchedules().ScheduledWorkflowMetaByIds(dbCtx, tenantId, chunkIds)
@@ -53,9 +52,8 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
 		toUpdate := make([]v1.ScheduledWorkflowUpdate, 0, len(chunk))
 		for _, u := range chunk {
 			id := u.Id
-			idStr := id.String()
 
-			meta, ok := metaById[idStr]
+			meta, ok := metaById[id]
 			if !ok {
 				idCp := id
 				errors = append(errors, gen.ScheduledWorkflowsBulkError{Id: &idCp, Error: "Scheduled workflow not found."})
@@ -69,7 +67,7 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
 			}
 
 			toUpdate = append(toUpdate, v1.ScheduledWorkflowUpdate{
-				Id:        idStr,
+				Id:        id,
 				TriggerAt: u.TriggerAt,
 			})
 		}
@@ -79,13 +77,13 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
 			return nil, err
 		}
 
-		updatedSet := make(map[string]struct{}, len(updatedIds))
+		updatedSet := make(map[uuid.UUID]struct{}, len(updatedIds))
 		for _, idStr := range updatedIds {
 			updatedSet[idStr] = struct{}{}
 		}
 
 		for _, u := range chunk {
-			if _, ok := updatedSet[u.Id.String()]; ok {
+			if _, ok := updatedSet[u.Id]; ok {
 				updated = append(updated, u.Id)
 			}
 		}

api/v1/server/handlers/workflows/create_cron.go

@@ -10,13 +10,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) CronWorkflowTriggerCreate(ctx echo.Context, request gen.CronWorkflowTriggerCreateRequestObject) (gen.CronWorkflowTriggerCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	if request.Body.CronName == "" {
 		return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors("cron name is required")), nil
@@ -60,7 +59,7 @@ func (t *WorkflowService) CronWorkflowTriggerCreate(ctx echo.Context, request ge
 			Cron:               request.Body.CronExpression,
 			Input:              request.Body.Input,
 			AdditionalMetadata: request.Body.AdditionalMetadata,
-			WorkflowId:         sqlchelpers.UUIDToStr(workflow.ID),
+			WorkflowId:         workflow.ID,
 			Priority:           &priority,
 		},
 	)

api/v1/server/handlers/workflows/create_scheduled.go

@@ -10,13 +10,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	"github.com/hatchet-dev/hatchet/pkg/constants"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) ScheduledWorkflowRunCreate(ctx echo.Context, request gen.ScheduledWorkflowRunCreateRequestObject) (gen.ScheduledWorkflowRunCreateResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	workflow, err := t.config.V1.Workflows().GetWorkflowByName(ctx.Request().Context(), tenantId, request.Workflow)
 
@@ -56,7 +55,7 @@ func (t *WorkflowService) ScheduledWorkflowRunCreate(ctx echo.Context, request g
 		ScheduledTrigger:   request.Body.TriggerAt,
 		Input:              input,
 		AdditionalMetadata: additionalMetadata,
-		WorkflowId:         sqlchelpers.UUIDToStr(workflow.ID),
+		WorkflowId:         workflow.ID,
 		Priority:           &priority,
 	})
 

api/v1/server/handlers/workflows/delete.go

@@ -4,16 +4,15 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowDelete(ctx echo.Context, request gen.WorkflowDeleteRequestObject) (gen.WorkflowDeleteResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
 
-	_, err := t.config.V1.Workflows().DeleteWorkflow(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.Workflow.ID))
+	_, err := t.config.V1.Workflows().DeleteWorkflow(ctx.Request().Context(), tenantId, workflow.Workflow.ID)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/workflows/delete_cron.go

@@ -7,7 +7,6 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -19,8 +18,8 @@ func (t *WorkflowService) WorkflowCronDelete(ctx echo.Context, request gen.Workf
 	defer cancel()
 
 	err := t.config.V1.WorkflowSchedules().DeleteCronWorkflow(dbCtx,
-		sqlchelpers.UUIDToStr(cron.TenantId),
-		sqlchelpers.UUIDToStr(cron.CronId),
+		cron.TenantId,
+		cron.CronId,
 	)
 
 	if err != nil {

api/v1/server/handlers/workflows/delete_scheduled.go

@@ -7,7 +7,6 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -24,7 +23,7 @@ func (t *WorkflowService) WorkflowScheduledDelete(ctx echo.Context, request gen.
 	dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
 	defer cancel()
 
-	err := t.config.V1.WorkflowSchedules().DeleteScheduledWorkflow(dbCtx, sqlchelpers.UUIDToStr(scheduled.TenantId), request.ScheduledWorkflowRun.String())
+	err := t.config.V1.WorkflowSchedules().DeleteScheduledWorkflow(dbCtx, scheduled.TenantId, request.ScheduledWorkflowRun)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/workflows/get.go

@@ -1,24 +1,24 @@
 package workflows
 
 import (
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowGet(ctx echo.Context, request gen.WorkflowGetRequestObject) (gen.WorkflowGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
 
-	if workflow == nil || !workflow.WorkflowVersionId.Valid {
+	if workflow == nil || workflow.WorkflowVersionId == nil || *workflow.WorkflowVersionId == uuid.Nil {
 		return gen.WorkflowGet404JSONResponse(gen.APIErrors{}), nil
 	}
 
-	version, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.WorkflowVersionId))
+	version, _, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), tenantId, *workflow.WorkflowVersionId)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/workflows/get_cron.go

@@ -9,18 +9,16 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowCronGet(ctx echo.Context, request gen.WorkflowCronGetRequestObject) (gen.WorkflowCronGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
 
 	dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
 	defer cancel()
 
-	scheduled, err := t.config.V1.WorkflowSchedules().GetCronWorkflow(dbCtx, tenantId, request.CronWorkflow.String())
+	scheduled, err := t.config.V1.WorkflowSchedules().GetCronWorkflow(dbCtx, tenant.ID, request.CronWorkflow)
 
 	if err != nil {
 		return nil, err

api/v1/server/handlers/workflows/get_version.go

@@ -4,29 +4,29 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowVersionGet(ctx echo.Context, request gen.WorkflowVersionGetRequestObject) (gen.WorkflowVersionGetResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 	workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
 
-	var workflowVersionId string
+	var workflowVersionId uuid.UUID
 
 	if request.Params.Version != nil {
-		workflowVersionId = request.Params.Version.String()
+		workflowVersionId = *request.Params.Version
 	} else {
 		row, err := t.config.V1.Workflows().GetWorkflowById(
 			ctx.Request().Context(),
-			sqlchelpers.UUIDToStr(workflow.Workflow.ID),
+			workflow.Workflow.ID,
 		)
 
 		if err != nil {
@@ -40,7 +40,7 @@ func (t *WorkflowService) WorkflowVersionGet(ctx echo.Context, request gen.Workf
 
 		}
 
-		workflowVersionId = sqlchelpers.UUIDToStr(row.WorkflowVersionId)
+		workflowVersionId = *row.WorkflowVersionId
 	}
 
 	row, crons, events, scheduleT, stepConcurrency, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), tenantId, workflowVersionId)

api/v1/server/handlers/workflows/list.go

@@ -8,13 +8,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowList(ctx echo.Context, request gen.WorkflowListRequestObject) (gen.WorkflowListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limit := 50
 	offset := 0

api/v1/server/handlers/workflows/list_crons.go

@@ -13,13 +13,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWorkflowListRequestObject) (gen.CronWorkflowListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limit := 50
 	offset := 0
@@ -31,6 +30,7 @@ func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWor
 		Offset:         &offset,
 		OrderBy:        &orderBy,
 		OrderDirection: &orderDirection,
+		WorkflowId:     request.Params.WorkflowId,
 	}
 
 	if request.Params.OrderByField != nil {
@@ -53,11 +53,6 @@ func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWor
 		listOpts.Offset = &offset
 	}
 
-	if request.Params.WorkflowId != nil {
-		workflowIdStr := request.Params.WorkflowId.String()
-		listOpts.WorkflowId = &workflowIdStr
-	}
-
 	if request.Params.CronName != nil {
 		listOpts.CronName = request.Params.CronName
 	}

api/v1/server/handlers/workflows/list_scheduled.go

@@ -13,13 +13,12 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.WorkflowScheduledListRequestObject) (gen.WorkflowScheduledListResponseObject, error) {
 	tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
-	tenantId := sqlchelpers.UUIDToStr(tenant.ID)
+	tenantId := tenant.ID
 
 	limit := 50
 	offset := 0
@@ -27,10 +26,13 @@ func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.Wo
 	orderBy := "triggerAt"
 
 	listOpts := &v1.ListScheduledWorkflowsOpts{
-		Limit:          &limit,
-		Offset:         &offset,
-		OrderBy:        &orderBy,
-		OrderDirection: &orderDirection,
+		Limit:               &limit,
+		Offset:              &offset,
+		OrderBy:             &orderBy,
+		OrderDirection:      &orderDirection,
+		WorkflowId:          request.Params.WorkflowId,
+		ParentWorkflowRunId: request.Params.ParentWorkflowRunId,
+		ParentStepRunId:     request.Params.ParentStepRunId,
 	}
 
 	if request.Params.OrderByField != nil {
@@ -53,11 +55,6 @@ func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.Wo
 		listOpts.Offset = &offset
 	}
 
-	if request.Params.WorkflowId != nil {
-		workflowIdStr := request.Params.WorkflowId.String()
-		listOpts.WorkflowId = &workflowIdStr
-	}
-
 	if request.Params.Statuses != nil {
 		statuses := make([]sqlcv1.WorkflowRunStatus, len(*request.Params.Statuses))
 

api/v1/server/handlers/workflows/update_cron.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -21,8 +20,8 @@ func (t *WorkflowService) WorkflowCronUpdate(ctx echo.Context, request gen.Workf
 
 	err := t.config.V1.WorkflowSchedules().UpdateCronWorkflow(
 		dbCtx,
-		sqlchelpers.UUIDToStr(cron.TenantId),
-		sqlchelpers.UUIDToStr(cron.CronId),
+		cron.TenantId,
+		cron.CronId,
 		&v1.UpdateCronOpts{
 			Enabled: request.Body.Enabled,
 		},

api/v1/server/handlers/workflows/update_scheduled.go

@@ -4,12 +4,12 @@ import (
 	"context"
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/labstack/echo/v4"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/apierrors"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -26,7 +26,7 @@ func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.
 	}
 
 	// If a scheduled run has already been triggered, it can no longer be rescheduled.
-	if scheduled.WorkflowRunId.Valid {
+	if scheduled.WorkflowRunId == nil || *scheduled.WorkflowRunId != uuid.Nil {
 		return gen.WorkflowScheduledUpdate400JSONResponse(apierrors.NewAPIErrors("Scheduled run has already been triggered and cannot be rescheduled.")), nil
 	}
 
@@ -35,8 +35,8 @@ func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.
 
 	err := t.config.V1.WorkflowSchedules().UpdateScheduledWorkflow(
 		dbCtx,
-		sqlchelpers.UUIDToStr(scheduled.TenantId),
-		request.ScheduledWorkflowRun.String(),
+		scheduled.TenantId,
+		request.ScheduledWorkflowRun,
 		request.Body.TriggerAt,
 	)
 	if err != nil {
@@ -45,8 +45,8 @@ func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.
 
 	updated, err := t.config.V1.WorkflowSchedules().GetScheduledWorkflow(
 		dbCtx,
-		sqlchelpers.UUIDToStr(scheduled.TenantId),
-		request.ScheduledWorkflowRun.String(),
+		scheduled.TenantId,
+		request.ScheduledWorkflowRun,
 	)
 	if err != nil {
 		return nil, err

api/v1/server/oas/transformers/api_token.go

@@ -2,13 +2,12 @@ package transformers
 
 import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func ToAPIToken(token *sqlcv1.APIToken) *gen.APIToken {
 	res := &gen.APIToken{
-		Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(token.ID), token.CreatedAt.Time, token.UpdatedAt.Time),
+		Metadata: *toAPIMetadata(token.ID, token.CreatedAt.Time, token.UpdatedAt.Time),
 	}
 
 	if token.ExpiresAt.Valid {

api/v1/server/oas/transformers/event.go

@@ -2,14 +2,10 @@ package transformers
 
 import (
 	"encoding/json"
-	"fmt"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
-
-	"github.com/jackc/pgx/v5/pgtype"
 )
 
 func ToEventList(events []*sqlcv1.Event) []gen.Event {
@@ -24,9 +20,9 @@ func ToEventList(events []*sqlcv1.Event) []gen.Event {
 
 func ToEvent(event *sqlcv1.Event) gen.Event {
 	return gen.Event{
-		Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(event.ID), event.CreatedAt.Time, event.UpdatedAt.Time),
+		Metadata: *toAPIMetadata(event.ID, event.CreatedAt.Time, event.UpdatedAt.Time),
 		Key:      event.Key,
-		TenantId: pgUUIDToStr(event.TenantId),
+		TenantId: event.TenantId.String(),
 	}
 }
 
@@ -41,9 +37,9 @@ func ToEventFromSQLCV1(event *v1.EventWithPayload) (*gen.Event, error) {
 	}
 
 	res := &gen.Event{
-		Metadata:           *toAPIMetadata(pgUUIDToStr(event.EventExternalID), event.EventSeenAt.Time, event.EventSeenAt.Time),
+		Metadata:           *toAPIMetadata(event.EventExternalID, event.EventSeenAt.Time, event.EventSeenAt.Time),
 		Key:                event.EventKey,
-		TenantId:           pgUUIDToStr(event.TenantID),
+		TenantId:           event.TenantID.String(),
 		AdditionalMetadata: &metadata,
 	}
 
@@ -58,7 +54,3 @@ func ToEventFromSQLCV1(event *v1.EventWithPayload) (*gen.Event, error) {
 
 	return res, nil
 }
-
-func pgUUIDToStr(uuid pgtype.UUID) string {
-	return fmt.Sprintf("%x-%x-%x-%x-%x", uuid.Bytes[0:4], uuid.Bytes[4:6], uuid.Bytes[6:8], uuid.Bytes[8:10], uuid.Bytes[10:16])
-}

api/v1/server/oas/transformers/metadata.go

@@ -3,12 +3,13 @@ package transformers
 import (
 	"time"
 
+	"github.com/google/uuid"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 )
 
-func toAPIMetadata(id string, createdAt, updatedAt time.Time) *gen.APIResourceMeta {
+func toAPIMetadata(id uuid.UUID, createdAt, updatedAt time.Time) *gen.APIResourceMeta {
 	return &gen.APIResourceMeta{
-		Id:        id,
+		Id:        id.String(),
 		CreatedAt: createdAt,
 		UpdatedAt: updatedAt,
 	}

api/v1/server/oas/transformers/rate_limits.go

@@ -8,7 +8,7 @@ import (
 func ToRateLimitFromSQLC(rl *sqlcv1.ListRateLimitsForTenantNoMutateRow) (*gen.RateLimit, error) {
 	res := &gen.RateLimit{
 		Key:        rl.Key,
-		TenantId:   pgUUIDToStr(rl.TenantId),
+		TenantId:   rl.TenantId.String(),
 		LastRefill: rl.LastRefill.Time,
 		LimitValue: int(rl.LimitValue),
 		Value:      int(rl.Value),

api/v1/server/oas/transformers/slack.go

@@ -1,17 +1,14 @@
 package transformers
 
 import (
-	"github.com/google/uuid"
-
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func ToSlackWebhook(slack *sqlcv1.SlackAppWebhook) *gen.SlackWebhook {
 	return &gen.SlackWebhook{
-		Metadata:    *toAPIMetadata(sqlchelpers.UUIDToStr(slack.ID), slack.CreatedAt.Time, slack.UpdatedAt.Time),
-		TenantId:    uuid.MustParse(sqlchelpers.UUIDToStr(slack.TenantId)),
+		Metadata:    *toAPIMetadata(slack.ID, slack.CreatedAt.Time, slack.UpdatedAt.Time),
+		TenantId:    slack.TenantId,
 		ChannelId:   slack.ChannelId,
 		ChannelName: slack.ChannelName,
 		TeamId:      slack.TeamId,

api/v1/server/oas/transformers/sns.go

@@ -3,20 +3,17 @@ package transformers
 import (
 	"fmt"
 
-	"github.com/google/uuid"
-
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func ToSNSIntegration(sns *sqlcv1.SNSIntegration, serverUrl string) *gen.SNSIntegration {
-	ingestUrl := fmt.Sprintf("%s/api/v1/sns/%s/sns-event", serverUrl, sqlchelpers.UUIDToStr(sns.TenantId))
+	ingestUrl := fmt.Sprintf("%s/api/v1/sns/%s/sns-event", serverUrl, sns.TenantId.String())
 
 	return &gen.SNSIntegration{
-		Metadata:  *toAPIMetadata(sqlchelpers.UUIDToStr(sns.ID), sns.CreatedAt.Time, sns.UpdatedAt.Time),
+		Metadata:  *toAPIMetadata(sns.ID, sns.CreatedAt.Time, sns.UpdatedAt.Time),
 		TopicArn:  sns.TopicArn,
-		TenantId:  uuid.MustParse(sqlchelpers.UUIDToStr(sns.TenantId)),
+		TenantId:  sns.TenantId,
 		IngestUrl: &ingestUrl,
 	}
 }

api/v1/server/oas/transformers/tenant.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -17,7 +16,7 @@ func ToTenant(tenant *sqlcv1.Tenant) *gen.Tenant {
 	}
 
 	return &gen.Tenant{
-		Metadata:          *toAPIMetadata(sqlchelpers.UUIDToStr(tenant.ID), tenant.CreatedAt.Time, tenant.UpdatedAt.Time),
+		Metadata:          *toAPIMetadata(tenant.ID, tenant.CreatedAt.Time, tenant.UpdatedAt.Time),
 		Name:              tenant.Name,
 		Slug:              tenant.Slug,
 		AnalyticsOptOut:   &tenant.AnalyticsOptOut,
@@ -29,7 +28,7 @@ func ToTenant(tenant *sqlcv1.Tenant) *gen.Tenant {
 
 func ToTenantAlertingSettings(alerting *sqlcv1.TenantAlertingSettings) *gen.TenantAlertingSettings {
 	res := &gen.TenantAlertingSettings{
-		Metadata:                        *toAPIMetadata(sqlchelpers.UUIDToStr(alerting.ID), alerting.CreatedAt.Time, alerting.UpdatedAt.Time),
+		Metadata:                        *toAPIMetadata(alerting.ID, alerting.CreatedAt.Time, alerting.UpdatedAt.Time),
 		MaxAlertingFrequency:            alerting.MaxFrequency,
 		EnableExpiringTokenAlerts:       &alerting.EnableExpiringTokenAlerts,
 		EnableWorkflowRunFailureAlerts:  &alerting.EnableWorkflowRunFailureAlerts,
@@ -47,7 +46,7 @@ func ToTenantAlertEmailGroup(group *sqlcv1.TenantAlertEmailGroup) *gen.TenantAle
 	emails := strings.Split(group.Emails, ",")
 
 	return &gen.TenantAlertEmailGroup{
-		Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(group.ID), group.CreatedAt.Time, group.UpdatedAt.Time),
+		Metadata: *toAPIMetadata(group.ID, group.CreatedAt.Time, group.UpdatedAt.Time),
 		Emails:   emails,
 	}
 }
@@ -69,7 +68,7 @@ func ToTenantResourcePolicy(_limits []*sqlcv1.TenantResourceLimit) *gen.TenantRe
 		}
 
 		limits[i] = gen.TenantResourceLimit{
-			Metadata:   *toAPIMetadata(sqlchelpers.UUIDToStr(limit.ID), limit.CreatedAt.Time, limit.UpdatedAt.Time),
+			Metadata:   *toAPIMetadata(limit.ID, limit.CreatedAt.Time, limit.UpdatedAt.Time),
 			Resource:   gen.TenantResource(limit.Resource),
 			LimitValue: int(limit.LimitValue),
 			AlarmValue: &alarmValue,

api/v1/server/oas/transformers/tenant_invite.go

@@ -2,17 +2,16 @@ package transformers
 
 import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
 func ToTenantInviteLink(invite *sqlcv1.TenantInviteLink) *gen.TenantInvite {
 	res := &gen.TenantInvite{
-		Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(invite.ID), invite.CreatedAt.Time, invite.UpdatedAt.Time),
+		Metadata: *toAPIMetadata(invite.ID, invite.CreatedAt.Time, invite.UpdatedAt.Time),
 		Email:    invite.InviteeEmail,
 		Expires:  invite.Expires.Time,
 		Role:     gen.TenantMemberRole(invite.Role),
-		TenantId: sqlchelpers.UUIDToStr(invite.TenantId),
+		TenantId: invite.TenantId.String(),
 	}
 
 	return res
@@ -20,11 +19,11 @@ func ToTenantInviteLink(invite *sqlcv1.TenantInviteLink) *gen.TenantInvite {
 
 func ToUserTenantInviteLink(invite *sqlcv1.ListTenantInvitesByEmailRow) *gen.TenantInvite {
 	res := &gen.TenantInvite{
-		Metadata:   *toAPIMetadata(sqlchelpers.UUIDToStr(invite.ID), invite.CreatedAt.Time, invite.UpdatedAt.Time),
+		Metadata:   *toAPIMetadata(invite.ID, invite.CreatedAt.Time, invite.UpdatedAt.Time),
 		Email:      invite.InviteeEmail,
 		Expires:    invite.Expires.Time,
 		Role:       gen.TenantMemberRole(invite.Role),
-		TenantId:   sqlchelpers.UUIDToStr(invite.TenantId),
+		TenantId:   invite.TenantId.String(),
 		TenantName: &invite.TenantName,
 	}
 

api/v1/server/oas/transformers/user.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -17,7 +16,7 @@ func ToUser(user *sqlcv1.User, hasPassword bool, hashedEmail *string) *gen.User
 	}
 
 	return &gen.User{
-		Metadata:      *toAPIMetadata(sqlchelpers.UUIDToStr(user.ID), user.CreatedAt.Time, user.UpdatedAt.Time),
+		Metadata:      *toAPIMetadata(user.ID, user.CreatedAt.Time, user.UpdatedAt.Time),
 		Email:         types.Email(user.Email),
 		EmailHash:     hashedEmail,
 		EmailVerified: user.EmailVerified,
@@ -34,13 +33,13 @@ func ToTenantMember(tenantMember *sqlcv1.PopulateTenantMembersRow) *gen.TenantMe
 	}
 
 	res := &gen.TenantMember{
-		Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(tenantMember.ID), tenantMember.CreatedAt.Time, tenantMember.UpdatedAt.Time),
+		Metadata: *toAPIMetadata(tenantMember.ID, tenantMember.CreatedAt.Time, tenantMember.UpdatedAt.Time),
 		User: gen.UserTenantPublic{
 			Email: types.Email(tenantMember.Email),
 			Name:  v1.StringPtr(tenantMember.Name.String),
 		},
 		Tenant: &gen.Tenant{
-			Metadata:          *toAPIMetadata(sqlchelpers.UUIDToStr(tenantMember.TenantId), tenantMember.TenantCreatedAt.Time, tenantMember.TenantUpdatedAt.Time),
+			Metadata:          *toAPIMetadata(tenantMember.TenantId, tenantMember.TenantCreatedAt.Time, tenantMember.TenantUpdatedAt.Time),
 			Name:              tenantMember.TenantName,
 			Slug:              tenantMember.TenantSlug,
 			AnalyticsOptOut:   &tenantMember.AnalyticsOptOut,

api/v1/server/oas/transformers/v1/filters.go

@@ -3,7 +3,6 @@ package transformers
 import (
 	"math"
 
-	"github.com/google/uuid"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
@@ -25,7 +24,7 @@ func ToV1Filter(filter *sqlcv1.V1Filter) gen.V1Filter {
 		Payload:       payload,
 		Scope:         filter.Scope,
 		TenantId:      filter.TenantID.String(),
-		WorkflowId:    uuid.MustParse(filter.WorkflowID.String()),
+		WorkflowId:    filter.WorkflowID,
 		IsDeclarative: &filter.IsDeclarative,
 	}
 }

api/v1/server/oas/transformers/v1/tasks.go

@@ -6,12 +6,10 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/oapi-codegen/runtime/types"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -22,7 +20,7 @@ func jsonToMap(jsonBytes []byte) map[string]interface{} {
 }
 
 func ToTaskSummary(task *v1.TaskWithPayloads) gen.V1TaskSummary {
-	workflowVersionID := uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowVersionID))
+	workflowVersionID := task.WorkflowVersionID
 	additionalMetadata := jsonToMap(task.AdditionalMetadata)
 
 	var finishedAt *time.Time
@@ -44,21 +42,14 @@ func ToTaskSummary(task *v1.TaskWithPayloads) gen.V1TaskSummary {
 		durationPtr = &duration
 	}
 
-	var parentTaskExternalId *uuid.UUID
-
-	if task.ParentTaskExternalID.Valid {
-		parentTaskExternalIdValue := uuid.MustParse(sqlchelpers.UUIDToStr(task.ParentTaskExternalID))
-		parentTaskExternalId = &parentTaskExternalIdValue
-	}
-
-	taskExternalId := uuid.MustParse(sqlchelpers.UUIDToStr(task.ExternalID))
-	stepId := uuid.MustParse(sqlchelpers.UUIDToStr(task.StepID))
+	taskExternalId := task.ExternalID
+	stepId := task.StepID
 
 	retryCount := int(task.RetryCount)
 	attempt := retryCount + 1
 	return gen.V1TaskSummary{
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(task.ExternalID),
+			Id:        task.ExternalID.String(),
 			CreatedAt: task.InsertedAt.Time,
 			UpdatedAt: task.InsertedAt.Time,
 		},
@@ -72,18 +63,18 @@ func ToTaskSummary(task *v1.TaskWithPayloads) gen.V1TaskSummary {
 		AdditionalMetadata:    &additionalMetadata,
 		ErrorMessage:          &task.ErrorMessage.String,
 		Status:                gen.V1TaskStatus(task.Status),
-		TenantId:              uuid.MustParse(sqlchelpers.UUIDToStr(task.TenantID)),
-		WorkflowId:            uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowID)),
+		TenantId:              task.TenantID,
+		WorkflowId:            task.WorkflowID,
 		TaskId:                int(task.ID),
 		TaskInsertedAt:        task.InsertedAt.Time,
 		TaskExternalId:        taskExternalId,
 		StepId:                &stepId,
 		ActionId:              &task.ActionID,
-		WorkflowRunExternalId: uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowRunID)),
+		WorkflowRunExternalId: task.WorkflowRunID,
 		WorkflowVersionId:     &workflowVersionID,
 		RetryCount:            &retryCount,
 		Attempt:               &attempt,
-		ParentTaskExternalId:  parentTaskExternalId,
+		ParentTaskExternalId:  task.ParentTaskExternalID,
 	}
 }
 
@@ -148,18 +139,11 @@ func ToTaskSummaryMany(
 
 func ToTaskRunEventMany(
 	events []*sqlcv1.ListTaskEventsRow,
-	taskExternalId string,
+	taskExternalId uuid.UUID,
 ) gen.V1TaskEventList {
 	toReturn := make([]gen.V1TaskEvent, len(events))
 
 	for i, event := range events {
-		var workerId *types.UUID
-
-		if event.WorkerID.Valid {
-			workerUUid := uuid.MustParse(sqlchelpers.UUIDToStr(event.WorkerID))
-			workerId = &workerUUid
-		}
-
 		retryCount := int(event.RetryCount)
 		attempt := retryCount + 1
 
@@ -169,8 +153,8 @@ func ToTaskRunEventMany(
 			EventType:    gen.V1TaskEventType(event.EventType),
 			Message:      event.AdditionalEventMessage.String,
 			Timestamp:    event.EventTimestamp.Time,
-			WorkerId:     workerId,
-			TaskId:       uuid.MustParse(taskExternalId),
+			WorkerId:     event.WorkerID,
+			TaskId:       taskExternalId,
 			RetryCount:   &retryCount,
 			Attempt:      &attempt,
 		}
@@ -188,16 +172,7 @@ func ToWorkflowRunTaskRunEventsMany(
 	toReturn := make([]gen.V1TaskEvent, len(events))
 
 	for i, event := range events {
-		var workerId *uuid.UUID
-
-		if event.WorkerID.Valid {
-			workerUUID := uuid.MustParse(sqlchelpers.UUIDToStr(event.WorkerID))
-			workerId = &workerUUID
-		}
-
 		output := string(event.OutputPayload)
-		taskExternalId := uuid.MustParse(sqlchelpers.UUIDToStr(event.TaskExternalID))
-
 		retryCount := int(event.RetryCount)
 		attempt := retryCount + 1
 
@@ -208,9 +183,9 @@ func ToWorkflowRunTaskRunEventsMany(
 			Message:         event.AdditionalEventMessage.String,
 			Output:          &output,
 			TaskDisplayName: &event.DisplayName,
-			TaskId:          taskExternalId,
+			TaskId:          event.TaskExternalID,
 			Timestamp:       event.EventTimestamp.Time,
-			WorkerId:        workerId,
+			WorkerId:        event.WorkerID,
 			RetryCount:      &retryCount,
 			Attempt:         &attempt,
 		}
@@ -252,8 +227,8 @@ func ToTaskRunMetrics(metrics *[]v1.TaskRunMetric) gen.V1TaskRunMetrics {
 	return toReturn
 }
 
-func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId pgtype.UUID, workflowVersion *sqlcv1.GetWorkflowVersionByIdRow) gen.V1TaskSummary {
-	workflowVersionID := uuid.MustParse(sqlchelpers.UUIDToStr(taskWithData.WorkflowVersionID))
+func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId uuid.UUID, workflowVersion *sqlcv1.GetWorkflowVersionByIdRow) gen.V1TaskSummary {
+	workflowVersionID := taskWithData.WorkflowVersionID
 	additionalMetadata := jsonToMap(taskWithData.AdditionalMetadata)
 
 	var finishedAt *time.Time
@@ -283,7 +258,7 @@ func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId pgtype.UUID
 
 	input := jsonToMap(taskWithData.InputPayload)
 
-	stepId := uuid.MustParse(sqlchelpers.UUIDToStr(taskWithData.StepID))
+	stepId := taskWithData.StepID
 
 	retryCount := int(taskWithData.RetryCount)
 	attempt := retryCount + 1
@@ -296,8 +271,8 @@ func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId pgtype.UUID
 
 	var parentTaskExternalId *uuid.UUID
 
-	if taskWithData.ParentTaskExternalID.Valid {
-		parentTaskUUID, err := uuid.Parse(sqlchelpers.UUIDToStr(taskWithData.ParentTaskExternalID))
+	if taskWithData.ParentTaskExternalID != nil {
+		parentTaskUUID, err := uuid.Parse(taskWithData.ParentTaskExternalID.String())
 
 		if err == nil {
 			parentTaskExternalId = &parentTaskUUID
@@ -306,7 +281,7 @@ func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId pgtype.UUID
 
 	return gen.V1TaskSummary{
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(taskWithData.ExternalID),
+			Id:        taskWithData.ExternalID.String(),
 			CreatedAt: taskWithData.InsertedAt.Time,
 			UpdatedAt: taskWithData.InsertedAt.Time,
 		},
@@ -320,11 +295,11 @@ func ToTask(taskWithData *v1.TaskWithPayloads, workflowRunExternalId pgtype.UUID
 		Output:                output,
 		Status:                gen.V1TaskStatus(taskWithData.Status),
 		Input:                 input,
-		TenantId:              uuid.MustParse(sqlchelpers.UUIDToStr(taskWithData.TenantID)),
-		WorkflowId:            uuid.MustParse(sqlchelpers.UUIDToStr(taskWithData.WorkflowID)),
+		TenantId:              taskWithData.TenantID,
+		WorkflowId:            taskWithData.WorkflowID,
 		ErrorMessage:          &taskWithData.ErrorMessage.String,
-		WorkflowRunExternalId: uuid.MustParse(sqlchelpers.UUIDToStr(workflowRunExternalId)),
-		TaskExternalId:        uuid.MustParse(sqlchelpers.UUIDToStr(taskWithData.ExternalID)),
+		WorkflowRunExternalId: workflowRunExternalId,
+		TaskExternalId:        taskWithData.ExternalID,
 		Type:                  gen.V1WorkflowTypeTASK,
 		NumSpawnedChildren:    int(taskWithData.NumSpawnedChildren),
 		StepId:                &stepId,
@@ -342,10 +317,10 @@ func ToWorkflowRunDetails(
 	workflowRun *v1.WorkflowRunData,
 	shape []*sqlcv1.GetWorkflowShapeRow,
 	tasks []*v1.TaskWithPayloads,
-	stepIdToTaskExternalId map[pgtype.UUID]pgtype.UUID,
+	stepIdToTaskExternalId map[uuid.UUID]uuid.UUID,
 	workflowVersion *sqlcv1.GetWorkflowVersionByIdRow,
 ) (gen.V1WorkflowRunDetails, error) {
-	workflowVersionId := uuid.MustParse(sqlchelpers.UUIDToStr(workflowRun.WorkflowVersionId))
+	workflowVersionId := workflowRun.WorkflowVersionId
 	duration := int(workflowRun.FinishedAt.Time.Sub(workflowRun.StartedAt.Time).Milliseconds())
 	input := jsonToMap(workflowRun.Input)
 
@@ -357,11 +332,6 @@ func ToWorkflowRunDetails(
 
 	additionalMetadata := jsonToMap(workflowRun.AdditionalMetadata)
 
-	parentTaskExternalId := uuid.UUID{}
-	if workflowRun.ParentTaskExternalId != nil && workflowRun.ParentTaskExternalId.Valid {
-		parentTaskExternalId = uuid.MustParse(sqlchelpers.UUIDToStr(*workflowRun.ParentTaskExternalId))
-	}
-
 	parsedWorkflowRun := gen.V1WorkflowRun{
 		AdditionalMetadata:   &additionalMetadata,
 		CreatedAt:            &workflowRun.CreatedAt.Time,
@@ -369,16 +339,16 @@ func ToWorkflowRunDetails(
 		Duration:             &duration,
 		ErrorMessage:         &workflowRun.ErrorMessage,
 		FinishedAt:           &workflowRun.FinishedAt.Time,
-		ParentTaskExternalId: &parentTaskExternalId,
+		ParentTaskExternalId: workflowRun.ParentTaskExternalId,
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(workflowRun.ExternalID),
+			Id:        workflowRun.ExternalID.String(),
 			CreatedAt: workflowRun.InsertedAt.Time,
 			UpdatedAt: workflowRun.InsertedAt.Time,
 		},
 		StartedAt:         &workflowRun.StartedAt.Time,
 		Status:            gen.V1TaskStatus(workflowRun.ReadableStatus),
-		TenantId:          uuid.MustParse(sqlchelpers.UUIDToStr(workflowRun.TenantID)),
-		WorkflowId:        uuid.MustParse(sqlchelpers.UUIDToStr(workflowRun.WorkflowID)),
+		TenantId:          workflowRun.TenantID,
+		WorkflowId:        workflowRun.WorkflowID,
 		WorkflowVersionId: &workflowVersionId,
 		Input:             input,
 		Output:            output,
@@ -387,35 +357,22 @@ func ToWorkflowRunDetails(
 	shapeRows := make([]gen.WorkflowRunShapeItemForWorkflowRunDetails, len(shape))
 
 	for i, shapeRow := range shape {
-		parentExternalId := uuid.MustParse(sqlchelpers.UUIDToStr(stepIdToTaskExternalId[shapeRow.Parentstepid]))
-		ChildrenStepIds := make([]uuid.UUID, len(shapeRow.Childrenstepids))
+		parentExternalId := stepIdToTaskExternalId[shapeRow.Parentstepid]
 		taskName := shapeRow.Stepname.String
 		stepId := shapeRow.Parentstepid
 
-		for c, child := range shapeRow.Childrenstepids {
-			ChildrenStepIds[c] = uuid.MustParse(sqlchelpers.UUIDToStr(child))
-		}
-
 		shapeRows[i] = gen.WorkflowRunShapeItemForWorkflowRunDetails{
-			ChildrenStepIds: ChildrenStepIds,
+			ChildrenStepIds: shapeRow.Childrenstepids,
 			TaskExternalId:  parentExternalId,
 			TaskName:        taskName,
-			StepId:          uuid.MustParse(sqlchelpers.UUIDToStr(stepId)),
+			StepId:          stepId,
 		}
 	}
 
 	parsedTaskEvents := make([]gen.V1TaskEvent, len(taskRunEvents))
 
 	for i, event := range taskRunEvents {
-		var workerId *uuid.UUID
-
-		if event.WorkerID.Valid {
-			workerUUID := uuid.MustParse(sqlchelpers.UUIDToStr(event.WorkerID))
-			workerId = &workerUUID
-		}
-
 		output := string(event.OutputPayload)
-
 		retryCount := int(event.RetryCount)
 		attempt := retryCount + 1
 
@@ -427,8 +384,8 @@ func ToWorkflowRunDetails(
 			Output:          &output,
 			TaskDisplayName: &event.DisplayName,
 			Timestamp:       event.EventTimestamp.Time,
-			WorkerId:        workerId,
-			TaskId:          uuid.MustParse(sqlchelpers.UUIDToStr(event.TaskExternalID)),
+			WorkerId:        event.WorkerID,
+			TaskId:          event.TaskExternalID,
 			RetryCount:      &retryCount,
 			Attempt:         &attempt,
 		}
@@ -453,33 +410,34 @@ func ToWorkflowRunDetails(
 
 func ToTaskTimings(
 	timings []*sqlcv1.PopulateTaskRunDataRow,
-	idsToDepth map[string]int32,
+	idsToDepth map[uuid.UUID]int32,
 ) []gen.V1TaskTiming {
 	toReturn := make([]gen.V1TaskTiming, len(timings))
 
 	for i, timing := range timings {
-		depth := idsToDepth[sqlchelpers.UUIDToStr(timing.ExternalID)]
+		depth := idsToDepth[timing.ExternalID]
 
-		workflowRunId := uuid.MustParse(sqlchelpers.UUIDToStr(timing.WorkflowRunID))
+		workflowRunId := timing.WorkflowRunID
 		retryCount := int(timing.RetryCount)
 		attempt := retryCount + 1
 
 		toReturn[i] = gen.V1TaskTiming{
 			Metadata: gen.APIResourceMeta{
-				Id:        sqlchelpers.UUIDToStr(timing.ExternalID),
+				Id:        timing.ExternalID.String(),
 				CreatedAt: timing.InsertedAt.Time,
 				UpdatedAt: timing.InsertedAt.Time,
 			},
-			Status:          gen.V1TaskStatus(timing.Status),
-			TaskDisplayName: timing.DisplayName,
-			TaskId:          int(timing.ID),
-			TaskInsertedAt:  timing.InsertedAt.Time,
-			TaskExternalId:  uuid.MustParse(sqlchelpers.UUIDToStr(timing.ExternalID)),
-			TenantId:        uuid.MustParse(sqlchelpers.UUIDToStr(timing.TenantID)),
-			Depth:           int(depth),
-			WorkflowRunId:   &workflowRunId,
-			RetryCount:      &retryCount,
-			Attempt:         &attempt,
+			Status:               gen.V1TaskStatus(timing.Status),
+			TaskDisplayName:      timing.DisplayName,
+			TaskId:               int(timing.ID),
+			TaskInsertedAt:       timing.InsertedAt.Time,
+			TaskExternalId:       timing.ExternalID,
+			TenantId:             timing.TenantID,
+			Depth:                int(depth),
+			WorkflowRunId:        &workflowRunId,
+			RetryCount:           &retryCount,
+			Attempt:              &attempt,
+			ParentTaskExternalId: timing.ParentTaskExternalID,
 		}
 
 		if timing.QueuedAt.Valid {
@@ -493,11 +451,6 @@ func ToTaskTimings(
 		if timing.FinishedAt.Valid {
 			toReturn[i].FinishedAt = &timing.FinishedAt.Time
 		}
-
-		if timing.ParentTaskExternalID.Valid {
-			parentId := uuid.MustParse(sqlchelpers.UUIDToStr(timing.ParentTaskExternalID))
-			toReturn[i].ParentTaskExternalId = &parentId
-		}
 	}
 
 	return toReturn

api/v1/server/oas/transformers/v1/worker.go

@@ -6,7 +6,6 @@ import (
 	"github.com/google/uuid"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -19,9 +18,9 @@ func ToSlotState(slots []*sqlcv1.ListSemaphoreSlotsWithStateForWorkerRow, remain
 		var stepRunId uuid.UUID
 		var workflowRunId uuid.UUID
 
-		if slot.ExternalID.Valid {
-			stepRunId = uuid.MustParse(sqlchelpers.UUIDToStr(slot.ExternalID))
-			workflowRunId = uuid.MustParse(sqlchelpers.UUIDToStr(slot.ExternalID))
+		if slot.ExternalID != uuid.Nil {
+			stepRunId = slot.ExternalID
+			workflowRunId = slot.ExternalID
 		}
 
 		status := gen.StepRunStatusRUNNING
@@ -62,7 +61,7 @@ func ToWorkerRuntimeInfo(worker *sqlcv1.Worker) *gen.WorkerRuntimeInfo {
 
 func ToWorkerSqlc(worker *sqlcv1.Worker, remainingSlots *int, webhookUrl *string, actions []string, workflows *[]*sqlcv1.Workflow) *gen.Worker {
 
-	dispatcherId := uuid.MustParse(sqlchelpers.UUIDToStr(worker.DispatcherId))
+	dispatcherId := worker.DispatcherId
 
 	maxRuns := int(worker.MaxRuns)
 
@@ -84,23 +83,19 @@ func ToWorkerSqlc(worker *sqlcv1.Worker, remainingSlots *int, webhookUrl *string
 
 	res := &gen.Worker{
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(worker.ID),
+			Id:        worker.ID.String(),
 			CreatedAt: worker.CreatedAt.Time,
 			UpdatedAt: worker.UpdatedAt.Time,
 		},
 		Name:          worker.Name,
 		Type:          gen.WorkerType(worker.Type),
 		Status:        &status,
-		DispatcherId:  &dispatcherId,
+		DispatcherId:  dispatcherId,
 		MaxRuns:       &maxRuns,
 		AvailableRuns: &availableRuns,
 		WebhookUrl:    webhookUrl,
 		RuntimeInfo:   ToWorkerRuntimeInfo(worker),
-	}
-
-	if worker.WebhookId.Valid {
-		wid := uuid.MustParse(sqlchelpers.UUIDToStr(worker.WebhookId))
-		res.WebhookId = &wid
+		WebhookId:     worker.WebhookId,
 	}
 
 	if !worker.LastHeartbeatAt.Time.IsZero() {
@@ -111,16 +106,16 @@ func ToWorkerSqlc(worker *sqlcv1.Worker, remainingSlots *int, webhookUrl *string
 
 	if workflows != nil {
 		registeredWorkflows := make([]gen.RegisteredWorkflow, 0, len(*workflows))
-		uniqueWorkflowIds := make(map[string]struct{})
+		uniqueWorkflowIds := make(map[uuid.UUID]struct{})
 
 		for _, workflow := range *workflows {
-			if _, ok := uniqueWorkflowIds[workflow.ID.String()]; ok {
+			if _, ok := uniqueWorkflowIds[workflow.ID]; ok {
 				continue
 			}
 
-			uniqueWorkflowIds[workflow.ID.String()] = struct{}{}
+			uniqueWorkflowIds[workflow.ID] = struct{}{}
 			registeredWorkflows = append(registeredWorkflows, gen.RegisteredWorkflow{
-				Id:   uuid.MustParse(workflow.ID.String()),
+				Id:   workflow.ID,
 				Name: workflow.Name,
 			})
 		}

api/v1/server/oas/transformers/v1/workflow_runs.go

@@ -5,15 +5,13 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5/pgtype"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	v1 "github.com/hatchet-dev/hatchet/pkg/repository"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
-func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames map[pgtype.UUID]string, actionId string) gen.V1TaskSummary {
+func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames map[uuid.UUID]string, actionId string) gen.V1TaskSummary {
 	additionalMetadata := jsonToMap(task.AdditionalMetadata)
 
 	var finishedAt *time.Time
@@ -43,7 +41,7 @@ func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames
 		output = jsonToMap(task.Output)
 	}
 
-	workflowVersionId := uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowVersionId))
+	workflowVersionId := task.WorkflowVersionId
 
 	var taskId int
 	if task.TaskId != nil {
@@ -52,7 +50,7 @@ func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames
 
 	var stepId uuid.UUID
 	if task.StepId != nil {
-		stepId = uuid.MustParse(sqlchelpers.UUIDToStr(*task.StepId))
+		stepId = *task.StepId
 	} else {
 		stepId = uuid.Nil
 	}
@@ -70,14 +68,14 @@ func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames
 	attempt := retryCount + 1
 
 	var parentTaskExternalId *uuid.UUID
-	if task.ParentTaskExternalId != nil && task.ParentTaskExternalId.Valid {
-		parentTaskExternalIdValue := uuid.MustParse(sqlchelpers.UUIDToStr(*task.ParentTaskExternalId))
+	if task.ParentTaskExternalId != nil {
+		parentTaskExternalIdValue := *task.ParentTaskExternalId
 		parentTaskExternalId = &parentTaskExternalIdValue
 	}
 
 	return gen.V1TaskSummary{
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(task.ExternalID),
+			Id:        task.ExternalID.String(),
 			CreatedAt: task.InsertedAt.Time,
 			UpdatedAt: task.InsertedAt.Time,
 		},
@@ -91,17 +89,17 @@ func WorkflowRunDataToV1TaskSummary(task *v1.WorkflowRunData, workflowIdsToNames
 		AdditionalMetadata:    &additionalMetadata,
 		ErrorMessage:          &task.ErrorMessage,
 		Status:                gen.V1TaskStatus(task.ReadableStatus),
-		TenantId:              uuid.MustParse(sqlchelpers.UUIDToStr(task.TenantID)),
-		WorkflowId:            uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowID)),
+		TenantId:              task.TenantID,
+		WorkflowId:            task.WorkflowID,
 		WorkflowVersionId:     &workflowVersionId,
-		TaskExternalId:        uuid.MustParse(sqlchelpers.UUIDToStr(task.ExternalID)),
+		TaskExternalId:        task.ExternalID,
 		TaskId:                taskId,
 		TaskInsertedAt:        task.InsertedAt.Time,
 		Type:                  gen.V1WorkflowTypeDAG,
 		WorkflowName:          workflowName,
 		StepId:                &stepId,
 		ActionId:              &actionId,
-		WorkflowRunExternalId: uuid.MustParse(sqlchelpers.UUIDToStr(task.ExternalID)),
+		WorkflowRunExternalId: task.ExternalID,
 		RetryCount:            &retryCount,
 		Attempt:               &attempt,
 		ParentTaskExternalId:  parentTaskExternalId,
@@ -112,13 +110,13 @@ func ToWorkflowRunMany(
 	tasks []*v1.WorkflowRunData,
 	dagExternalIdToChildren map[uuid.UUID][]gen.V1TaskSummary,
 	taskIdToActionId map[int64]string,
-	workflowIdsToNames map[pgtype.UUID]string,
+	workflowIdsToNames map[uuid.UUID]string,
 	total int, limit, offset int64,
 ) gen.V1TaskSummaryList {
 	toReturn := make([]gen.V1TaskSummary, len(tasks))
 
 	for i, task := range tasks {
-		dagExternalId := uuid.MustParse(sqlchelpers.UUIDToStr(task.ExternalID))
+		dagExternalId := task.ExternalID
 
 		actionId := ""
 
@@ -154,7 +152,7 @@ func ToWorkflowRunMany(
 }
 
 func PopulateTaskRunDataRowToV1TaskSummary(task *v1.TaskWithPayloads, workflowName *string) gen.V1TaskSummary {
-	workflowVersionID := uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowVersionID))
+	workflowVersionID := task.WorkflowVersionID
 	additionalMetadata := jsonToMap(task.AdditionalMetadata)
 
 	var finishedAt *time.Time
@@ -179,20 +177,14 @@ func PopulateTaskRunDataRowToV1TaskSummary(task *v1.TaskWithPayloads, workflowNa
 	input := jsonToMap(task.InputPayload)
 	output := jsonToMap(task.OutputPayload)
 
-	stepId := uuid.MustParse(sqlchelpers.UUIDToStr(task.StepID))
+	stepId := task.StepID
 
 	retryCount := int(task.RetryCount)
 	attempt := retryCount + 1
 
-	var parentTaskExternalId *uuid.UUID
-	if task.ParentTaskExternalID.Valid {
-		parentTaskExternalIdValue := uuid.MustParse(sqlchelpers.UUIDToStr(task.ParentTaskExternalID))
-		parentTaskExternalId = &parentTaskExternalIdValue
-	}
-
 	return gen.V1TaskSummary{
 		Metadata: gen.APIResourceMeta{
-			Id:        sqlchelpers.UUIDToStr(task.ExternalID),
+			Id:        task.ExternalID.String(),
 			CreatedAt: task.InsertedAt.Time,
 			UpdatedAt: task.InsertedAt.Time,
 		},
@@ -206,11 +198,11 @@ func PopulateTaskRunDataRowToV1TaskSummary(task *v1.TaskWithPayloads, workflowNa
 		AdditionalMetadata:    &additionalMetadata,
 		ErrorMessage:          &task.ErrorMessage.String,
 		Status:                gen.V1TaskStatus(task.Status),
-		TenantId:              uuid.MustParse(sqlchelpers.UUIDToStr(task.TenantID)),
-		WorkflowId:            uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowID)),
+		TenantId:              task.TenantID,
+		WorkflowId:            task.WorkflowID,
 		WorkflowVersionId:     &workflowVersionID,
 		Children:              nil,
-		TaskExternalId:        uuid.MustParse(sqlchelpers.UUIDToStr(task.ExternalID)),
+		TaskExternalId:        task.ExternalID,
 		TaskId:                int(task.ID),
 		TaskInsertedAt:        task.InsertedAt.Time,
 		Type:                  gen.V1WorkflowTypeTASK,
@@ -219,8 +211,8 @@ func PopulateTaskRunDataRowToV1TaskSummary(task *v1.TaskWithPayloads, workflowNa
 		ActionId:              &task.ActionID,
 		RetryCount:            &retryCount,
 		Attempt:               &attempt,
-		WorkflowRunExternalId: uuid.MustParse(sqlchelpers.UUIDToStr(task.WorkflowRunID)),
-		ParentTaskExternalId:  parentTaskExternalId,
+		WorkflowRunExternalId: task.WorkflowRunID,
+		ParentTaskExternalId:  task.ParentTaskExternalID,
 	}
 }
 
@@ -259,7 +251,7 @@ func ToWorkflowRunDisplayNamesList(
 		result[i] = gen.V1WorkflowRunDisplayName{
 			DisplayName: record.DisplayName,
 			Metadata: gen.APIResourceMeta{
-				Id:        sqlchelpers.UUIDToStr(record.ExternalID),
+				Id:        record.ExternalID.String(),
 				CreatedAt: record.InsertedAt.Time,
 				UpdatedAt: record.InsertedAt.Time,
 			},
@@ -277,15 +269,3 @@ func ToWorkflowRunDisplayNamesList(
 		},
 	}
 }
-
-func ToWorkflowRunExternalIds(
-	externalIds []pgtype.UUID,
-) gen.V1WorkflowRunExternalIdList {
-	result := make([]uuid.UUID, len(externalIds))
-
-	for ix, id := range externalIds {
-		result[ix] = uuid.MustParse(sqlchelpers.UUIDToStr(id))
-	}
-
-	return gen.V1WorkflowRunExternalIdList(result)
-}

api/v1/server/oas/transformers/webhook_worker.go

@@ -2,7 +2,6 @@ package transformers
 
 import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -17,7 +16,7 @@ func ToWebhookWorkerRequest(webhookWorker *sqlcv1.WebhookWorkerRequest) *gen.Web
 func ToWebhookWorker(webhookWorker *sqlcv1.WebhookWorker) *gen.WebhookWorker {
 	return &gen.WebhookWorker{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(webhookWorker.ID),
+			webhookWorker.ID,
 			webhookWorker.CreatedAt.Time,
 			webhookWorker.UpdatedAt.Time,
 		),
@@ -29,7 +28,7 @@ func ToWebhookWorker(webhookWorker *sqlcv1.WebhookWorker) *gen.WebhookWorker {
 func ToWebhookWorkerCreated(webhookWorker *sqlcv1.WebhookWorker) *gen.WebhookWorkerCreated {
 	return &gen.WebhookWorkerCreated{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(webhookWorker.ID),
+			webhookWorker.ID,
 			webhookWorker.CreatedAt.Time,
 			webhookWorker.UpdatedAt.Time,
 		),

api/v1/server/oas/transformers/worker.go

@@ -5,7 +5,6 @@ import (
 	"time"
 
 	"github.com/google/uuid"
-
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
@@ -28,10 +27,9 @@ func ToWorkerLabels(labels []*sqlcv1.ListWorkerLabelsRow) *[]gen.WorkerLabel {
 			value = nil
 		}
 
-		id := fmt.Sprintf("%d", labels[i].ID)
-
 		resp[i] = gen.WorkerLabel{
-			Metadata: *toAPIMetadata(id, labels[i].CreatedAt.Time, labels[i].UpdatedAt.Time),
+			// fixme: `id` needs to be a uuid
+			Metadata: *toAPIMetadata(uuid.Nil, labels[i].CreatedAt.Time, labels[i].UpdatedAt.Time),
 			Key:      labels[i].Key,
 			Value:    value,
 		}
@@ -59,7 +57,7 @@ func ToWorkerRuntimeInfo(worker *sqlcv1.Worker) *gen.WorkerRuntimeInfo {
 
 func ToWorkerSqlc(worker *sqlcv1.Worker, remainingSlots *int, webhookUrl *string, actions []string) *gen.Worker {
 
-	dispatcherId := uuid.MustParse(pgUUIDToStr(worker.DispatcherId))
+	dispatcherId := worker.DispatcherId
 
 	maxRuns := int(worker.MaxRuns)
 
@@ -80,20 +78,16 @@ func ToWorkerSqlc(worker *sqlcv1.Worker, remainingSlots *int, webhookUrl *string
 	}
 
 	res := &gen.Worker{
-		Metadata:      *toAPIMetadata(pgUUIDToStr(worker.ID), worker.CreatedAt.Time, worker.UpdatedAt.Time),
+		Metadata:      *toAPIMetadata(worker.ID, worker.CreatedAt.Time, worker.UpdatedAt.Time),
 		Name:          worker.Name,
 		Type:          gen.WorkerType(worker.Type),
 		Status:        &status,
-		DispatcherId:  &dispatcherId,
+		DispatcherId:  dispatcherId,
 		MaxRuns:       &maxRuns,
 		AvailableRuns: &availableRuns,
 		WebhookUrl:    webhookUrl,
 		RuntimeInfo:   ToWorkerRuntimeInfo(worker),
-	}
-
-	if worker.WebhookId.Valid {
-		wid := uuid.MustParse(pgUUIDToStr(worker.WebhookId))
-		res.WebhookId = &wid
+		WebhookId:     worker.WebhookId,
 	}
 
 	if !worker.LastHeartbeatAt.Time.IsZero() {

api/v1/server/oas/transformers/workflow.go

@@ -3,10 +3,10 @@ package transformers
 import (
 	"encoding/json"
 
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -17,12 +17,12 @@ func ToWorkflow(
 
 	res := &gen.Workflow{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(workflow.ID),
+			workflow.ID,
 			workflow.CreatedAt.Time,
 			workflow.UpdatedAt.Time,
 		),
 		Name:     workflow.Name,
-		TenantId: sqlchelpers.UUIDToStr(workflow.TenantId),
+		TenantId: workflow.TenantId.String(),
 	}
 
 	res.IsPaused = &workflow.IsPaused.Bool
@@ -41,11 +41,11 @@ func ToWorkflow(
 func ToWorkflowVersionMeta(version *sqlcv1.WorkflowVersion, workflow *sqlcv1.Workflow) *gen.WorkflowVersionMeta {
 	res := &gen.WorkflowVersionMeta{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(version.ID),
+			version.ID,
 			version.CreatedAt.Time,
 			version.UpdatedAt.Time,
 		),
-		WorkflowId: sqlchelpers.UUIDToStr(version.WorkflowId),
+		WorkflowId: version.WorkflowId.String(),
 		Order:      int32(version.Order), // nolint: gosec
 		Version:    version.Version.String,
 	}
@@ -80,11 +80,11 @@ func ToWorkflowVersion(
 
 	res := &gen.WorkflowVersion{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(version.ID),
+			version.ID,
 			version.CreatedAt.Time,
 			version.UpdatedAt.Time,
 		),
-		// WorkflowId:      sqlchelpers.UUIDToStr(version.WorkflowId),
+		// WorkflowId:      version.WorkflowId.String(),
 		Order:           int32(version.Order), // nolint: gosec
 		Version:         version.Version.String,
 		ScheduleTimeout: &version.ScheduleTimeout,
@@ -105,7 +105,7 @@ func ToWorkflowVersion(
 		res.Sticky = &stickyStrategy
 	}
 
-	if version.WorkflowId.Valid {
+	if version.WorkflowId != uuid.Nil {
 		res.Workflow = ToWorkflowFromSQLC(workflow)
 	}
 
@@ -126,7 +126,7 @@ func ToWorkflowVersion(
 
 		for _, cron := range crons {
 			cronCp := cron
-			parentId := sqlchelpers.UUIDToStr(cronCp.ParentId)
+			parentId := cronCp.ParentId.String()
 			genCrons = append(genCrons, gen.WorkflowTriggerCronRef{
 				Cron:     &cronCp.Cron,
 				ParentId: &parentId,
@@ -141,8 +141,8 @@ func ToWorkflowVersion(
 
 		for _, event := range events {
 			eventCp := event
-			if eventCp.ParentId.Valid {
-				parentId := sqlchelpers.UUIDToStr(eventCp.ParentId)
+			if eventCp.ParentId != uuid.Nil {
+				parentId := eventCp.ParentId.String()
 				genEvents = append(genEvents, gen.WorkflowTriggerEventRef{
 					EventKey: &eventCp.EventKey,
 					ParentId: &parentId,
@@ -187,13 +187,13 @@ func ToV1Concurrency(workflowConcurrency *WorkflowConcurrency, taskConcurrencies
 func ToJob(job *sqlcv1.Job, steps []*sqlcv1.GetStepsForJobsRow) *gen.Job {
 	res := &gen.Job{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(job.ID),
+			job.ID,
 			job.CreatedAt.Time,
 			job.UpdatedAt.Time,
 		),
 		Name:        job.Name,
-		TenantId:    sqlchelpers.UUIDToStr(job.TenantId),
-		VersionId:   sqlchelpers.UUIDToStr(job.WorkflowVersionId),
+		TenantId:    job.TenantId.String(),
+		VersionId:   job.WorkflowVersionId.String(),
 		Description: &job.Description.String,
 		Timeout:     &job.Timeout.String,
 	}
@@ -212,16 +212,16 @@ func ToJob(job *sqlcv1.Job, steps []*sqlcv1.GetStepsForJobsRow) *gen.Job {
 	return res
 }
 
-func ToStep(step *sqlcv1.Step, parents []pgtype.UUID) *gen.Step {
+func ToStep(step *sqlcv1.Step, parents []uuid.UUID) *gen.Step {
 	res := &gen.Step{
 		Metadata: *toAPIMetadata(
-			sqlchelpers.UUIDToStr(step.ID),
+			step.ID,
 			step.CreatedAt.Time,
 			step.UpdatedAt.Time,
 		),
 		Action:     step.ActionId,
-		JobId:      sqlchelpers.UUIDToStr(step.JobId),
-		TenantId:   sqlchelpers.UUIDToStr(step.TenantId),
+		JobId:      step.JobId.String(),
+		TenantId:   step.TenantId.String(),
 		ReadableId: step.ReadableId.String,
 		Timeout:    &step.Timeout.String,
 	}
@@ -229,7 +229,7 @@ func ToStep(step *sqlcv1.Step, parents []pgtype.UUID) *gen.Step {
 	parentStr := make([]string, 0)
 
 	for i := range parents {
-		parentStr = append(parentStr, sqlchelpers.UUIDToStr(parents[i]))
+		parentStr = append(parentStr, parents[i].String())
 	}
 
 	res.Parents = &parentStr
@@ -243,7 +243,7 @@ func ToStep(step *sqlcv1.Step, parents []pgtype.UUID) *gen.Step {
 
 func ToWorkflowFromSQLC(row *sqlcv1.Workflow) *gen.Workflow {
 	res := &gen.Workflow{
-		Metadata:    *toAPIMetadata(pgUUIDToStr(row.ID), row.CreatedAt.Time, row.UpdatedAt.Time),
+		Metadata:    *toAPIMetadata(row.ID, row.CreatedAt.Time, row.UpdatedAt.Time),
 		Name:        row.Name,
 		Description: &row.Description.String,
 		IsPaused:    &row.IsPaused.Bool,
@@ -254,9 +254,9 @@ func ToWorkflowFromSQLC(row *sqlcv1.Workflow) *gen.Workflow {
 
 func ToWorkflowVersionFromSQLC(row *sqlcv1.WorkflowVersion, workflow *gen.Workflow) *gen.WorkflowVersion {
 	res := &gen.WorkflowVersion{
-		Metadata:   *toAPIMetadata(pgUUIDToStr(row.ID), row.CreatedAt.Time, row.UpdatedAt.Time),
+		Metadata:   *toAPIMetadata(row.ID, row.CreatedAt.Time, row.UpdatedAt.Time),
 		Version:    row.Version.String,
-		WorkflowId: pgUUIDToStr(row.WorkflowId),
+		WorkflowId: row.WorkflowId.String(),
 		Order:      int32(row.Order), // nolint: gosec
 		Workflow:   workflow,
 	}

api/v1/server/oas/transformers/workflow_run.go

@@ -4,10 +4,7 @@ import (
 	"encoding/json"
 	"time"
 
-	"github.com/google/uuid"
-
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -34,29 +31,22 @@ func ToScheduledWorkflowsFromSQLC(scheduled *sqlcv1.ListScheduledWorkflowsRow) *
 		workflowRunStatus = &status
 	}
 
-	var workflowRunIdPtr *uuid.UUID
-
-	if scheduled.WorkflowRunId.Valid {
-		workflowRunId := uuid.MustParse(sqlchelpers.UUIDToStr(scheduled.WorkflowRunId))
-		workflowRunIdPtr = &workflowRunId
-	}
-
 	input := make(map[string]interface{})
 	if scheduled.Input != nil {
 		json.Unmarshal(scheduled.Input, &input)
 	}
 
 	res := &gen.ScheduledWorkflows{
-		Metadata:             *toAPIMetadata(sqlchelpers.UUIDToStr(scheduled.ID), scheduled.CreatedAt.Time, scheduled.UpdatedAt.Time),
-		WorkflowVersionId:    sqlchelpers.UUIDToStr(scheduled.WorkflowVersionId),
-		WorkflowId:           sqlchelpers.UUIDToStr(scheduled.WorkflowId),
+		Metadata:             *toAPIMetadata(scheduled.ID, scheduled.CreatedAt.Time, scheduled.UpdatedAt.Time),
+		WorkflowVersionId:    scheduled.WorkflowVersionId.String(),
+		WorkflowId:           scheduled.WorkflowId.String(),
 		WorkflowName:         scheduled.Name,
-		TenantId:             sqlchelpers.UUIDToStr(scheduled.TenantId),
+		TenantId:             scheduled.TenantId.String(),
 		TriggerAt:            scheduled.TriggerAt.Time,
 		AdditionalMetadata:   &additionalMetadata,
 		WorkflowRunCreatedAt: &scheduled.WorkflowRunCreatedAt.Time,
 		WorkflowRunStatus:    workflowRunStatus,
-		WorkflowRunId:        workflowRunIdPtr,
+		WorkflowRunId:        scheduled.WorkflowRunId,
 		WorkflowRunName:      &scheduled.WorkflowRunName.String,
 		Method:               gen.ScheduledWorkflowsMethod(scheduled.Method),
 		Priority:             &scheduled.Priority,
@@ -77,11 +67,11 @@ func ToCronWorkflowsFromSQLC(cron *sqlcv1.ListCronWorkflowsRow) *gen.CronWorkflo
 	}
 
 	res := &gen.CronWorkflows{
-		Metadata:           *toAPIMetadata(sqlchelpers.UUIDToStr(cron.ID_2), cron.CreatedAt_2.Time, cron.UpdatedAt_2.Time),
-		WorkflowVersionId:  sqlchelpers.UUIDToStr(cron.WorkflowVersionId),
-		WorkflowId:         sqlchelpers.UUIDToStr(cron.WorkflowId),
+		Metadata:           *toAPIMetadata(cron.ID_2, cron.CreatedAt_2.Time, cron.UpdatedAt_2.Time),
+		WorkflowVersionId:  cron.WorkflowVersionId.String(),
+		WorkflowId:         cron.WorkflowId.String(),
 		WorkflowName:       cron.WorkflowName,
-		TenantId:           sqlchelpers.UUIDToStr(cron.TenantId),
+		TenantId:           cron.TenantId.String(),
 		Cron:               cron.Cron,
 		AdditionalMetadata: &additionalMetadata,
 		Name:               &cron.Name.String,

api/v1/server/run/run.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/getkin/kin-openapi/openapi3"
+	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
@@ -45,7 +46,6 @@ import (
 	"github.com/hatchet-dev/hatchet/api/v1/server/middleware/telemetry"
 	"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
 	"github.com/hatchet-dev/hatchet/pkg/config/server"
-	"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
 	"github.com/hatchet-dev/hatchet/pkg/repository/sqlcv1"
 )
 
@@ -230,7 +230,13 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		ctxTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		tenant, err := config.V1.Tenant().GetTenantByID(ctxTimeout, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
+		tenant, err := config.V1.Tenant().GetTenantByID(ctxTimeout, idUuid)
 
 		if err != nil {
 			return nil, "", err
@@ -243,20 +249,32 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		ctxTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		member, err := config.V1.Tenant().GetTenantMemberByID(ctxTimeout, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant member id")
+		}
+
+		member, err := config.V1.Tenant().GetTenantMemberByID(ctxTimeout, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return member, sqlchelpers.UUIDToStr(member.TenantId), nil
+		return member, member.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("api-token", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		ctxTimeout, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		apiToken, err := config.V1.APIToken().GetAPITokenById(ctxTimeout, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid api token id")
+		}
+
+		apiToken, err := config.V1.APIToken().GetAPITokenById(ctxTimeout, idUuid)
 
 		if err != nil {
 			return nil, "", err
@@ -265,73 +283,103 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		// at the moment, API tokens should have a tenant id, because there are no other types of
 		// API tokens. If we add other types of API tokens, we'll need to pass in a parent id to query
 		// for.
-		if !apiToken.TenantId.Valid {
+		if apiToken.TenantId == nil || *apiToken.TenantId == uuid.Nil {
 			return nil, "", fmt.Errorf("api token has no tenant id")
 		}
 
-		return apiToken, sqlchelpers.UUIDToStr(apiToken.TenantId), nil
+		return apiToken, apiToken.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("tenant-invite", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		tenantInvite, err := config.V1.TenantInvite().GetTenantInvite(timeoutCtx, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant invite id")
+		}
+
+		tenantInvite, err := config.V1.TenantInvite().GetTenantInvite(timeoutCtx, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return tenantInvite, sqlchelpers.UUIDToStr(tenantInvite.TenantId), nil
+		return tenantInvite, tenantInvite.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("slack", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		slackWebhook, err := config.V1.Slack().GetSlackWebhookById(timeoutCtx, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid slack integration id")
+		}
+
+		slackWebhook, err := config.V1.Slack().GetSlackWebhookById(timeoutCtx, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return slackWebhook, sqlchelpers.UUIDToStr(slackWebhook.TenantId), nil
+		return slackWebhook, slackWebhook.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("alert-email-group", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		emailGroup, err := config.V1.TenantAlertingSettings().GetTenantAlertGroupById(timeoutCtx, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid alert email group id")
+		}
+
+		emailGroup, err := config.V1.TenantAlertingSettings().GetTenantAlertGroupById(timeoutCtx, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return emailGroup, sqlchelpers.UUIDToStr(emailGroup.TenantId), nil
+		return emailGroup, emailGroup.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("sns", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		snsIntegration, err := config.V1.SNS().GetSNSIntegrationById(timeoutCtx, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid sns integration id")
+		}
+
+		snsIntegration, err := config.V1.SNS().GetSNSIntegrationById(timeoutCtx, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return snsIntegration, sqlchelpers.UUIDToStr(snsIntegration.TenantId), nil
+		return snsIntegration, snsIntegration.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("workflow", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
-		workflow, err := config.V1.Workflows().GetWorkflowById(context.Background(), id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid workflow id")
+		}
+
+		workflow, err := config.V1.Workflows().GetWorkflowById(context.Background(), idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return workflow, sqlchelpers.UUIDToStr(workflow.Workflow.TenantId), nil
+		return workflow, workflow.Workflow.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("workflow-run", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
@@ -340,7 +388,17 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 	})
 
 	populatorMW.RegisterGetter("scheduled-workflow-run", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
-		scheduled, err := config.V1.WorkflowSchedules().GetScheduledWorkflow(context.Background(), parentId, id)
+		idUuid, err := uuid.Parse(id)
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid scheduled workflow run id")
+		}
+
+		parentIdUuid, err := uuid.Parse(parentId)
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
+		scheduled, err := config.V1.WorkflowSchedules().GetScheduledWorkflow(context.Background(), parentIdUuid, idUuid)
 
 		if err != nil {
 			return nil, "", err
@@ -350,11 +408,21 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			return nil, "", echo.NewHTTPError(http.StatusNotFound, "scheduled workflow run not found")
 		}
 
-		return scheduled, sqlchelpers.UUIDToStr(scheduled.TenantId), nil
+		return scheduled, scheduled.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("cron-workflow", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
-		scheduled, err := config.V1.WorkflowSchedules().GetCronWorkflow(context.Background(), parentId, id)
+		idUuid, err := uuid.Parse(id)
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid cron workflow id")
+		}
+
+		parentIdUuid, err := uuid.Parse(parentId)
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
+		scheduled, err := config.V1.WorkflowSchedules().GetCronWorkflow(context.Background(), parentIdUuid, idUuid)
 
 		if err != nil {
 			return nil, "", err
@@ -364,7 +432,7 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			return nil, "", echo.NewHTTPError(http.StatusNotFound, "cron workflow not found")
 		}
 
-		return scheduled, sqlchelpers.UUIDToStr(scheduled.TenantId), nil
+		return scheduled, scheduled.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("step-run", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
@@ -376,13 +444,19 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		v1Event, err := t.config.V1.OLAP().GetEvent(timeoutCtx, id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid event id")
+		}
+
+		v1Event, err := t.config.V1.OLAP().GetEvent(timeoutCtx, idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		payload, err := t.config.V1.OLAP().ReadPayload(timeoutCtx, v1Event.TenantID.String(), v1Event.ExternalID)
+		payload, err := t.config.V1.OLAP().ReadPayload(timeoutCtx, v1Event.TenantID, v1Event.ExternalID)
 
 		if err != nil {
 			return nil, "", err
@@ -397,7 +471,7 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			Key:                v1Event.Key,
 		}
 
-		return event, sqlchelpers.UUIDToStr(event.TenantId), nil
+		return event, event.TenantId.String(), nil
 	})
 
 	// note: this is a hack to allow for the v0 event getter to use the pk on the v1 event lookup table
@@ -405,7 +479,19 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		timeoutCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 		defer cancel()
 
-		v1Event, err := t.config.V1.OLAP().GetEventWithPayload(timeoutCtx, id, parentId)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid event id")
+		}
+
+		parentIdUuid, err := uuid.Parse(parentId)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
+		v1Event, err := t.config.V1.OLAP().GetEventWithPayload(timeoutCtx, idUuid, parentIdUuid)
 
 		if err != nil {
 			return nil, "", err
@@ -420,17 +506,23 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			Key:                v1Event.EventKey,
 		}
 
-		return event, sqlchelpers.UUIDToStr(event.TenantId), nil
+		return event, event.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("worker", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
-		worker, err := config.V1.Workers().GetWorkerById(id)
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid worker id")
+		}
+
+		worker, err := config.V1.Workers().GetWorkerById(idUuid)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return worker, sqlchelpers.UUIDToStr(worker.Worker.TenantId), nil
+		return worker, worker.Worker.TenantId.String(), nil
 	})
 
 	populatorMW.RegisterGetter("webhook", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
@@ -443,12 +535,12 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 		defer cancel()
 
 		// Validate UUID early to avoid panics deeper in the stack.
-		var taskID pgtype.UUID
+		var taskID uuid.UUID
 		if err := taskID.Scan(id); err != nil {
 			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid task id")
 		}
 
-		task, err := config.V1.OLAP().ReadTaskRun(ctx, sqlchelpers.UUIDToStr(taskID))
+		task, err := config.V1.OLAP().ReadTaskRun(ctx, taskID)
 
 		if err != nil {
 			return nil, "", err
@@ -458,12 +550,12 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			return nil, "", echo.NewHTTPError(http.StatusNotFound, "task not found")
 		}
 
-		return task, sqlchelpers.UUIDToStr(task.TenantID), nil
+		return task, task.TenantID.String(), nil
 	})
 
 	populatorMW.RegisterGetter("v1-workflow-run", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
 		// Validate UUID early to avoid panics deeper in the stack.
-		var workflowRunID pgtype.UUID
+		var workflowRunID uuid.UUID
 		if err := workflowRunID.Scan(id); err != nil {
 			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid workflow run id")
 		}
@@ -474,41 +566,71 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			return nil, "", err
 		}
 
-		return workflowRun, sqlchelpers.UUIDToStr(workflowRun.WorkflowRun.TenantID), nil
+		return workflowRun, workflowRun.WorkflowRun.TenantID.String(), nil
 	})
 
 	populatorMW.RegisterGetter("v1-filter", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid filter id")
+		}
+
+		parentIdUuid, err := uuid.Parse(parentId)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
 		filter, err := t.config.V1.Filters().GetFilter(
 			context.Background(),
-			parentId,
-			id,
+			parentIdUuid,
+			idUuid,
 		)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return filter, sqlchelpers.UUIDToStr(filter.TenantID), nil
+		return filter, filter.TenantID.String(), nil
 	})
 
 	populatorMW.RegisterGetter("v1-event", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
+		idUuid, err := uuid.Parse(id)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid event id")
+		}
+
+		parentIdUuid, err := uuid.Parse(parentId)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
 		event, err := t.config.V1.OLAP().GetEventWithPayload(
 			context.Background(),
-			id,
-			parentId,
+			idUuid,
+			parentIdUuid,
 		)
 
 		if err != nil {
 			return nil, "", err
 		}
 
-		return event, sqlchelpers.UUIDToStr(event.TenantID), nil
+		return event, event.TenantID.String(), nil
 	})
 
 	populatorMW.RegisterGetter("v1-webhook", func(config *server.ServerConfig, parentId, id string) (result interface{}, uniqueParentId string, err error) {
+		parentIdUuid, err := uuid.Parse(parentId)
+
+		if err != nil {
+			return nil, "", echo.NewHTTPError(http.StatusBadRequest, "invalid tenant id")
+		}
+
 		webhook, err := t.config.V1.Webhooks().GetWebhook(
 			context.Background(),
-			parentId,
+			parentIdUuid,
 			id,
 		)
 
@@ -516,7 +638,7 @@ func (t *APIServer) registerSpec(g *echo.Group, spec *openapi3.T) (*populator.Po
 			return nil, "", err
 		}
 
-		return webhook, sqlchelpers.UUIDToStr(webhook.TenantID), nil
+		return webhook, webhook.TenantID.String(), nil
 	})
 
 	authnMW := authn.NewAuthN(t.config)