mirror/hatchet
1
0
Fork 0
mirror of https://github.com/hatchet-dev/hatchet.git synced 2026-04-22 10:10:07 -05:00
Code Issues Packages Projects Releases Wiki Activity

refactor: consolidate repository methods (#2730)

Browse Source 
* refactor: remove v0 paths from codebase

* remove uiVersion references

* refactor: remove v0-exclusive database queries

* remove webhook test

* chore: move api token repository

* chore: move dispatcher repository to v1

* chore: move health repository to v1

* chore: remove event repository

* remove some unused repositories

* chore: move mq implementation to v1

* chore: consolidate rate limit implementations

* chore: move security check to v1 repository

* chore: move slack to v1 repository

* chore: move sns implementation to v1 repository

* clean up step repository

* chore: move tenant invite to v1 repository

* chore: move limits, workers, tenant alerts to v1 repository

* chore: move user, tenant, userSession to v1 repository

* chore: move ticker to v1 repository

* chore: move scheduled workflows to v1 repository

* chore: remove workflows

* fix: remove pointer for limits config file

* propagate cache value to api token

* propagate cache durations
This commit is contained in:
abelanger5
2025-12-31 16:35:46 -05:00
committed by GitHub
parent c2c3ddf962
commit f82d3bd071
338 changed files with 8780 additions and 19065 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.github/workflows/test.yml
+1 -1
View File
@@ -305,7 +305,7 @@ jobs:
strategy:
matrix:
migrate-strategy: ["latest"]
rabbitmq-enabled: ["true"]
rabbitmq-enabled: ["true", "false"]
pg-version: ["15-alpine"]
steps:
CONTRIBUTING.md
-10
View File
@@ -126,13 +126,3 @@ Generate a service account in GCP which can encrypt/decrypt on CloudKMS, then do
```
SERVER_ENCRYPTION_CLOUDKMS_CREDENTIALS_JSON='{...}'
```
## Working with Database Models
1. Create or modify the required SQL queries in `./pkg/repository/prisma/dbsqlc`
2. Add new queries files to `./pkg/repository/prisma/dbsqlc/sqlc.yaml`
3. Make schema changes in `./sql/schema/schema.sql`
4. Create a new migration file with `task migrate`
5. Rename the migration file in `./sql/migrations/` to match the latest tag.
6. Generate Go with `task generate-all`
7. Run `atlas migrate hash --dir "file://sql/migrations"` to generate the atlas hash.
Taskfile.yaml
-1
View File
@@ -202,7 +202,6 @@ tasks:
- sh ./generate.sh
generate-sqlc:
cmds:
- go run github.com/sqlc-dev/sqlc/cmd/sqlc@v1.29.0 generate --file pkg/repository/postgres/dbsqlc/sqlc.yaml
- go run github.com/sqlc-dev/sqlc/cmd/sqlc@v1.29.0 generate --file pkg/repository/v1/sqlcv1/sqlc.yaml
lint:
cmds:
api/v1/server/authn/middleware.go
+4 -4
View File
@@ -13,8 +13,8 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
type AuthN struct {
@@ -169,7 +169,7 @@ func (a *AuthN) handleCookieAuth(c echo.Context) error {
return forbidden
}
user, err := a.config.APIRepository.User().GetUserByID(c.Request().Context(), userID)
user, err := a.config.V1.User().GetUserByID(c.Request().Context(), userID)
if err != nil {
a.l.Debug().Err(err).Msg("error getting user by id")
@@ -192,7 +192,7 @@ func (a *AuthN) handleBearerAuth(c echo.Context) error {
// a tenant id must exist in the context in order for the bearer auth to succeed, since
// these tokens are tenant-scoped
queriedTenant, ok := c.Get("tenant").(*dbsqlc.Tenant)
queriedTenant, ok := c.Get("tenant").(*sqlcv1.Tenant)
if !ok {
a.l.Debug().Msgf("tenant not found in context")
api/v1/server/authn/session_helpers.go
+3 -3
View File
@@ -8,8 +8,8 @@ import (
"github.com/hatchet-dev/hatchet/pkg/config/server"
"github.com/hatchet-dev/hatchet/pkg/random"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
type SessionHelpers struct {
@@ -22,7 +22,7 @@ func NewSessionHelpers(config *server.ServerConfig) *SessionHelpers {
}
}
func (s *SessionHelpers) SaveAuthenticated(c echo.Context, user *dbsqlc.User) error {
func (s *SessionHelpers) SaveAuthenticated(c echo.Context, user *sqlcv1.User) error {
session, err := s.config.SessionStore.Get(c.Request(), s.config.SessionStore.GetName())
if err != nil {
api/v1/server/authz/middleware.go
+9 -9
View File
@@ -10,8 +10,8 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
type AuthZ struct {
@@ -68,8 +68,8 @@ func (a *AuthZ) handleCookieAuth(c echo.Context, r *middleware.RouteInfo) error
}
// if tenant is set in the context, verify that the user is a member of the tenant
if tenant, ok := c.Get("tenant").(*dbsqlc.Tenant); ok {
user, ok := c.Get("user").(*dbsqlc.User)
if tenant, ok := c.Get("tenant").(*sqlcv1.Tenant); ok {
user, ok := c.Get("user").(*sqlcv1.User)
if !ok {
a.l.Debug().Msgf("user not found in context")
@@ -78,7 +78,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.APIRepository.Tenant().GetTenantMemberByUserID(c.Request().Context(), sqlchelpers.UUIDToStr(tenant.ID), sqlchelpers.UUIDToStr(user.ID))
tenantMember, err := a.config.V1.Tenant().GetTenantMemberByUserID(c.Request().Context(), sqlchelpers.UUIDToStr(tenant.ID), sqlchelpers.UUIDToStr(user.ID))
if err != nil {
a.l.Debug().Err(err).Msgf("error getting tenant member")
@@ -141,7 +141,7 @@ var permittedWithUnverifiedEmail = []string{
}
func (a *AuthZ) ensureVerifiedEmail(c echo.Context, r *middleware.RouteInfo) error {
user, ok := c.Get("user").(*dbsqlc.User)
user, ok := c.Get("user").(*sqlcv1.User)
if !ok {
return nil
@@ -171,15 +171,15 @@ var adminAndOwnerOnly = []string{
"ApiTokenUpdateRevoke",
}
func (a *AuthZ) authorizeTenantOperations(tenant *dbsqlc.Tenant, tenantMember *dbsqlc.PopulateTenantMembersRow, r *middleware.RouteInfo) error {
func (a *AuthZ) authorizeTenantOperations(tenant *sqlcv1.Tenant, tenantMember *sqlcv1.PopulateTenantMembersRow, r *middleware.RouteInfo) error {
// if the user is an owner, they can do anything
if tenantMember.Role == dbsqlc.TenantMemberRoleOWNER {
if tenantMember.Role == sqlcv1.TenantMemberRoleOWNER {
return nil
}
// if the user is an admin, they can do anything at the moment. Some downstream handlers will case on
// admin roles, for example admins cannot mark users as owners.
if tenantMember.Role == dbsqlc.TenantMemberRoleADMIN {
if tenantMember.Role == sqlcv1.TenantMemberRoleADMIN {
return nil
}
api/v1/server/handlers/api-tokens/create.go
+4 -4
View File
@@ -8,13 +8,13 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (a *APITokenService) ApiTokenCreate(ctx echo.Context, request gen.ApiTokenCreateRequestObject) (gen.ApiTokenCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
user := ctx.Get("user").(*dbsqlc.User)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
user := ctx.Get("user").(*sqlcv1.User)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
api/v1/server/handlers/api-tokens/list.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (a *APITokenService) ApiTokenList(ctx echo.Context, request gen.ApiTokenListRequestObject) (gen.ApiTokenListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
tokens, err := a.config.APIRepository.APIToken().ListAPITokensByTenant(ctx.Request().Context(), tenantId)
tokens, err := a.config.V1.APIToken().ListAPITokensByTenant(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/api-tokens/revoke.go
+5 -5
View File
@@ -6,13 +6,13 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (a *APITokenService) ApiTokenUpdateRevoke(ctx echo.Context, request gen.ApiTokenUpdateRevokeRequestObject) (gen.ApiTokenUpdateRevokeResponseObject, error) {
apiToken := ctx.Get("api-token").(*dbsqlc.APIToken)
user := ctx.Get("user").(*dbsqlc.User)
apiToken := ctx.Get("api-token").(*sqlcv1.APIToken)
user := ctx.Get("user").(*sqlcv1.User)
if apiToken.Internal {
return gen.ApiTokenUpdateRevoke403JSONResponse(
@@ -20,7 +20,7 @@ func (a *APITokenService) ApiTokenUpdateRevoke(ctx echo.Context, request gen.Api
), nil
}
err := a.config.APIRepository.APIToken().RevokeAPIToken(ctx.Request().Context(), sqlchelpers.UUIDToStr(apiToken.ID))
err := a.config.V1.APIToken().RevokeAPIToken(ctx.Request().Context(), sqlchelpers.UUIDToStr(apiToken.ID))
if err != nil {
return nil, err
api/v1/server/handlers/events/create.go
+1 -40
View File
@@ -1,50 +1,11 @@
package events
import (
"encoding/json"
"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/metered"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
)
func (t *EventService) EventCreate(ctx echo.Context, request gen.EventCreateRequestObject) (gen.EventCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
// marshal the data object to bytes
dataBytes, err := json.Marshal(request.Body.Data)
if err != nil {
return nil, err
}
var additionalMetadata []byte
if request.Body.AdditionalMetadata != nil {
additionalMetadata, err = json.Marshal(request.Body.AdditionalMetadata)
if err != nil {
return nil, err
}
}
newEvent, err := t.config.Ingestor.IngestEvent(ctx.Request().Context(), tenant, request.Body.Key, dataBytes, additionalMetadata, request.Body.Priority, request.Body.Scope, nil)
if err != nil {
if err == metered.ErrResourceExhausted {
return gen.EventCreate429JSONResponse(
apierrors.NewAPIErrors("Event limit exceeded"),
), nil
}
return nil, err
}
return gen.EventCreate200JSONResponse(
transformers.ToEvent(newEvent),
), nil
panic("deprecated")
}
api/v1/server/handlers/events/get.go
+2 -2
View File
@@ -5,11 +5,11 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *EventService) EventGet(ctx echo.Context, request gen.EventGetRequestObject) (gen.EventGetResponseObject, error) {
event := ctx.Get("event").(*dbsqlc.Event)
event := ctx.Get("event").(*sqlcv1.Event)
return gen.EventGet200JSONResponse(
transformers.ToEvent(event),
api/v1/server/handlers/events/get_data.go
+3 -3
View File
@@ -4,7 +4,7 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *EventService) EventDataGet(ctx echo.Context, request gen.EventDataGetRequestObject) (gen.EventDataGetResponseObject, error) {
@@ -13,7 +13,7 @@ func (t *EventService) EventDataGet(ctx echo.Context, request gen.EventDataGetRe
return nil, echo.NewHTTPError(404, "event not found")
}
event, ok := eventInterface.(*dbsqlc.Event)
event, ok := eventInterface.(*sqlcv1.Event)
if !ok {
return nil, echo.NewHTTPError(500, "invalid event type in context")
}
@@ -39,7 +39,7 @@ func (t *EventService) EventDataGetWithTenant(ctx echo.Context, request gen.Even
return nil, echo.NewHTTPError(404, "event not found")
}
event, ok := eventInterface.(*dbsqlc.Event)
event, ok := eventInterface.(*sqlcv1.Event)
if !ok {
return nil, echo.NewHTTPError(500, "invalid event type in context")
}
api/v1/server/handlers/ingestors/sns.go
+2 -2
View File
@@ -34,7 +34,7 @@ func (i *IngestorsService) SnsUpdate(ctx echo.Context, req gen.SnsUpdateRequestO
tenantId := req.Tenant.String()
// verify that the tenant and the topic ARN are set in the database
snsInt, err := i.config.APIRepository.SNS().GetSNSIntegration(ctx.Request().Context(), tenantId, payload.TopicArn)
snsInt, err := i.config.V1.SNS().GetSNSIntegration(ctx.Request().Context(), tenantId, payload.TopicArn)
if err != nil {
return nil, err
@@ -44,7 +44,7 @@ func (i *IngestorsService) SnsUpdate(ctx echo.Context, req gen.SnsUpdateRequestO
return nil, fmt.Errorf("SNS integration not found for tenant %s and topic ARN %s", tenantId, payload.TopicArn)
}
tenant, err := i.config.APIRepository.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
tenant, err := i.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/ingestors/sns_create.go
+6 -6
View File
@@ -6,13 +6,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (i *IngestorsService) SnsCreate(ctx echo.Context, req gen.SnsCreateRequestObject) (gen.SnsCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// validate the request
@@ -22,12 +22,12 @@ func (i *IngestorsService) SnsCreate(ctx echo.Context, req gen.SnsCreateRequestO
return gen.SnsCreate400JSONResponse(*apiErrors), nil
}
opts := &repository.CreateSNSIntegrationOpts{
opts := &v1.CreateSNSIntegrationOpts{
TopicArn: req.Body.TopicArn,
}
// create the SNS integration
snsIntegration, err := i.config.APIRepository.SNS().CreateSNSIntegration(ctx.Request().Context(), tenantId, opts)
snsIntegration, err := i.config.V1.SNS().CreateSNSIntegration(ctx.Request().Context(), tenantId, opts)
if err != nil {
return nil, err
api/v1/server/handlers/ingestors/sns_delete.go
+5 -5
View File
@@ -5,17 +5,17 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (i *IngestorsService) SnsDelete(ctx echo.Context, req gen.SnsDeleteRequestObject) (gen.SnsDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
sns := ctx.Get("sns").(*dbsqlc.SNSIntegration)
sns := ctx.Get("sns").(*sqlcv1.SNSIntegration)
// create the SNS integration
err := i.config.APIRepository.SNS().DeleteSNSIntegration(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(sns.ID))
err := i.config.V1.SNS().DeleteSNSIntegration(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(sns.ID))
if err != nil {
return nil, err
api/v1/server/handlers/ingestors/sns_list.go
+4 -4
View File
@@ -5,16 +5,16 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (i *IngestorsService) SnsList(ctx echo.Context, req gen.SnsListRequestObject) (gen.SnsListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// create the SNS integration
snsIntegrations, err := i.config.APIRepository.SNS().ListSNSIntegrations(ctx.Request().Context(), tenantId)
snsIntegrations, err := i.config.V1.SNS().ListSNSIntegrations(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/metadata/health.go
+8 -8
View File
@@ -14,11 +14,11 @@ import (
func (u *MetadataService) collectHealthErrors(ctx context.Context) []error {
errs := []error{}
if !u.config.APIRepository.Health().IsHealthy(ctx) {
if !u.config.V1.Health().IsHealthy(ctx) {
errs = append(errs, errors.New("api repository is not healthy"))
}
if !u.config.EngineRepository.Health().IsHealthy(ctx) {
if !u.config.V1.Health().IsHealthy(ctx) {
errs = append(errs, errors.New("engine repository is not healthy"))
}
@@ -46,9 +46,9 @@ func (u *MetadataService) LivenessGet(ctx echo.Context, request gen.LivenessGetR
allErrors = append(allErrors, fmt.Errorf(
"pg connections - acquired: %d, idle: %d, total: %d",
u.config.APIRepository.Health().PgStat().AcquiredConns(),
u.config.APIRepository.Health().PgStat().IdleConns(),
u.config.APIRepository.Health().PgStat().TotalConns(),
u.config.V1.Health().PgStat().AcquiredConns(),
u.config.V1.Health().PgStat().IdleConns(),
u.config.V1.Health().PgStat().TotalConns(),
))
return gen.LivenessGet500JSONResponse(gen.APIErrors{Errors: errorsToAPIErrors(allErrors)}), nil
@@ -68,9 +68,9 @@ func (u *MetadataService) ReadinessGet(ctx echo.Context, request gen.ReadinessGe
allErrors = append(allErrors, fmt.Errorf(
"pg connections - acquired: %d, idle: %d, total: %d",
u.config.APIRepository.Health().PgStat().AcquiredConns(),
u.config.APIRepository.Health().PgStat().IdleConns(),
u.config.APIRepository.Health().PgStat().TotalConns(),
u.config.V1.Health().PgStat().AcquiredConns(),
u.config.V1.Health().PgStat().IdleConns(),
u.config.V1.Health().PgStat().TotalConns(),
))
return gen.ReadinessGet500JSONResponse(gen.APIErrors{Errors: errorsToAPIErrors(allErrors)}), nil
api/v1/server/handlers/rate-limits/list.go
+8 -8
View File
@@ -10,19 +10,19 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *RateLimitService) RateLimitList(ctx echo.Context, request gen.RateLimitListRequestObject) (gen.RateLimitListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limit := 50
offset := 0
listOpts := &repository.ListRateLimitOpts{
listOpts := &v1.ListRateLimitOpts{
Limit: &limit,
Offset: &offset,
}
@@ -32,11 +32,11 @@ func (t *RateLimitService) RateLimitList(ctx echo.Context, request gen.RateLimit
}
if request.Params.OrderByField != nil {
listOpts.OrderBy = repository.StringPtr(string(*request.Params.OrderByField))
listOpts.OrderBy = v1.StringPtr(string(*request.Params.OrderByField))
}
if request.Params.OrderByDirection != nil {
listOpts.OrderDirection = repository.StringPtr(strings.ToUpper(string(*request.Params.OrderByDirection)))
listOpts.OrderDirection = v1.StringPtr(strings.ToUpper(string(*request.Params.OrderByDirection)))
}
if request.Params.Limit != nil {
@@ -52,7 +52,7 @@ func (t *RateLimitService) RateLimitList(ctx echo.Context, request gen.RateLimit
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
listRes, err := t.config.EngineRepository.RateLimit().ListRateLimits(dbCtx, tenantId, listOpts)
listRes, err := t.config.V1.RateLimit().ListRateLimits(dbCtx, tenantId, listOpts)
if err != nil {
return nil, err
api/v1/server/handlers/slack-app/oauth_callback.go
+3 -3
View File
@@ -9,7 +9,7 @@ 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"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
)
// Note: we want all errors to redirect, otherwise the user will be greeted with raw JSON in the middle of the login flow.
@@ -61,10 +61,10 @@ func (g *SlackAppService) UserUpdateSlackOauthCallback(ctx echo.Context, _ gen.U
return nil, redirect.GetRedirectWithError(ctx, g.config.Logger, err, "Could not link Slack account. An internal error occurred.")
}
_, err = g.config.APIRepository.Slack().UpsertSlackWebhook(
_, err = g.config.V1.Slack().UpsertSlackWebhook(
ctx.Request().Context(),
tenantId,
&repository.UpsertSlackWebhookOpts{
&v1.UpsertSlackWebhookOpts{
TeamId: resp.Team.ID,
TeamName: resp.Team.Name,
ChannelId: resp.IncomingWebhook.ChannelID,
api/v1/server/handlers/slack-app/oauth_start.go
+3 -3
View File
@@ -7,13 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/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").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
oauth, ok := g.config.AdditionalOAuthConfigs["slack"]
api/v1/server/handlers/slack-app/slack_delete.go
+5 -5
View File
@@ -5,16 +5,16 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (i *SlackAppService) SlackWebhookDelete(ctx echo.Context, req gen.SlackWebhookDeleteRequestObject) (gen.SlackWebhookDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
slack := ctx.Get("slack").(*dbsqlc.SlackAppWebhook)
slack := ctx.Get("slack").(*sqlcv1.SlackAppWebhook)
err := i.config.APIRepository.Slack().DeleteSlackWebhook(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(slack.ID))
err := i.config.V1.Slack().DeleteSlackWebhook(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(slack.ID))
if err != nil {
return nil, err
api/v1/server/handlers/slack-app/slack_list.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (s *SlackAppService) SlackWebhookList(ctx echo.Context, req gen.SlackWebhookListRequestObject) (gen.SlackWebhookListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
webhooks, err := s.config.APIRepository.Slack().ListSlackWebhooks(ctx.Request().Context(), tenantId)
webhooks, err := s.config.V1.Slack().ListSlackWebhooks(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/create.go
+11 -11
View File
@@ -10,13 +10,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateRequestObject) (gen.TenantCreateResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
if !t.config.Runtime.AllowCreateTenant {
return gen.TenantCreate400JSONResponse(
@@ -32,7 +32,7 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
}
// determine if a tenant with the slug already exists
_, err := t.config.APIRepository.Tenant().GetTenantBySlug(ctx.Request().Context(), request.Body.Slug)
_, err := t.config.V1.Tenant().GetTenantBySlug(ctx.Request().Context(), request.Body.Slug)
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
return nil, err
@@ -45,7 +45,7 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
), nil
}
createOpts := &repository.CreateTenantOpts{
createOpts := &v1.CreateTenantOpts{
Slug: request.Body.Slug,
Name: request.Body.Name,
}
@@ -63,17 +63,17 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
createOpts.DataRetentionPeriod = &t.config.Runtime.Limits.DefaultTenantRetentionPeriod
}
var engineVersion *dbsqlc.TenantMajorEngineVersion
var engineVersion *sqlcv1.TenantMajorEngineVersion
if request.Body.EngineVersion != nil {
ver := dbsqlc.TenantMajorEngineVersion(*request.Body.EngineVersion)
ver := sqlcv1.TenantMajorEngineVersion(*request.Body.EngineVersion)
engineVersion = &ver
}
createOpts.EngineVersion = engineVersion
// write the user to the db
tenant, err := t.config.APIRepository.Tenant().CreateTenant(ctx.Request().Context(), createOpts)
tenant, err := t.config.V1.Tenant().CreateTenant(ctx.Request().Context(), createOpts)
if err != nil {
return nil, err
@@ -81,14 +81,14 @@ func (t *TenantService) TenantCreate(ctx echo.Context, request gen.TenantCreateR
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
err = t.config.EntitlementRepository.TenantLimit().SelectOrInsertTenantLimits(context.Background(), tenantId, nil)
err = t.config.V1.TenantLimit().SelectOrInsertTenantLimits(context.Background(), tenantId, nil)
if err != nil {
return nil, err
}
// add the user as an owner of the tenant
_, err = t.config.APIRepository.Tenant().CreateTenantMember(ctx.Request().Context(), tenantId, &repository.CreateTenantMemberOpts{
_, err = t.config.V1.Tenant().CreateTenantMember(ctx.Request().Context(), tenantId, &v1.CreateTenantMemberOpts{
UserId: sqlchelpers.UUIDToStr(user.ID),
Role: "OWNER",
})
api/v1/server/handlers/tenants/create_email_group.go
+6 -6
View File
@@ -5,13 +5,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) AlertEmailGroupCreate(ctx echo.Context, request gen.AlertEmailGroupCreateRequestObject) (gen.AlertEmailGroupCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// validate the request
@@ -22,11 +22,11 @@ func (t *TenantService) AlertEmailGroupCreate(ctx echo.Context, request gen.Aler
}
// construct the database query
createOpts := &repository.CreateTenantAlertGroupOpts{
createOpts := &v1.CreateTenantAlertGroupOpts{
Emails: request.Body.Emails,
}
emailGroup, err := t.config.APIRepository.TenantAlertingSettings().CreateTenantAlertGroup(ctx.Request().Context(), tenantId, createOpts)
emailGroup, err := t.config.V1.TenantAlertingSettings().CreateTenantAlertGroup(ctx.Request().Context(), tenantId, createOpts)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/create_invite.go
+10 -10
View File
@@ -10,16 +10,16 @@ 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/integrations/email"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantInviteCreateRequestObject) (gen.TenantInviteCreateResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
user := ctx.Get("user").(*sqlcv1.User)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
tenantMember := ctx.Get("tenant-member").(*dbsqlc.PopulateTenantMembersRow)
tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
if !t.config.Runtime.AllowInvites {
t.config.Logger.Warn().Msg("tenant invites are disabled")
return gen.TenantInviteCreate400JSONResponse(
@@ -36,7 +36,7 @@ func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantI
}
// ensure that this user isn't already a member of the tenant
if _, err := t.config.APIRepository.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), tenantId, request.Body.Email); err == nil {
if _, err := t.config.V1.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), tenantId, request.Body.Email); err == nil {
t.config.Logger.Warn().Msg("this user is already a member of this tenant")
return gen.TenantInviteCreate400JSONResponse(
apierrors.NewAPIErrors("this user is already a member of this tenant"),
@@ -44,7 +44,7 @@ func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantI
}
// if user is not an owner, they cannot change a role to owner
if tenantMember.Role != dbsqlc.TenantMemberRoleOWNER && request.Body.Role == gen.OWNER {
if tenantMember.Role != sqlcv1.TenantMemberRoleOWNER && request.Body.Role == gen.OWNER {
t.config.Logger.Warn().Msg("only an owner can change a role to owner")
return gen.TenantInviteCreate400JSONResponse(
apierrors.NewAPIErrors("only an owner can change a role to owner"),
@@ -52,7 +52,7 @@ func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantI
}
// construct the database query
createOpts := &repository.CreateTenantInviteOpts{
createOpts := &v1.CreateTenantInviteOpts{
InviteeEmail: request.Body.Email,
InviterEmail: user.Email,
ExpiresAt: time.Now().Add(7 * 24 * time.Hour), // 1 week expiration
@@ -61,7 +61,7 @@ func (t *TenantService) TenantInviteCreate(ctx echo.Context, request gen.TenantI
}
// create the invite
invite, err := t.config.APIRepository.TenantInvite().CreateTenantInvite(ctx.Request().Context(), tenantId, createOpts)
invite, err := t.config.V1.TenantInvite().CreateTenantInvite(ctx.Request().Context(), tenantId, createOpts)
if err != nil {
t.config.Logger.Err(err).Msg("could not create tenant invite")
api/v1/server/handlers/tenants/delete_email_group.go
+5 -5
View File
@@ -4,17 +4,17 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) AlertEmailGroupDelete(ctx echo.Context, request gen.AlertEmailGroupDeleteRequestObject) (gen.AlertEmailGroupDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
emailGroup := ctx.Get("alert-email-group").(*dbsqlc.TenantAlertEmailGroup)
emailGroup := ctx.Get("alert-email-group").(*sqlcv1.TenantAlertEmailGroup)
// delete the invite
err := t.config.APIRepository.TenantAlertingSettings().DeleteTenantAlertGroup(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(emailGroup.ID))
err := t.config.V1.TenantAlertingSettings().DeleteTenantAlertGroup(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(emailGroup.ID))
if err != nil {
return nil, err
api/v1/server/handlers/tenants/delete_invite.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantInviteDelete(ctx echo.Context, request gen.TenantInviteDeleteRequestObject) (gen.TenantInviteDeleteResponseObject, error) {
invite := ctx.Get("tenant-invite").(*dbsqlc.TenantInviteLink)
invite := ctx.Get("tenant-invite").(*sqlcv1.TenantInviteLink)
// delete the invite
err := t.config.APIRepository.TenantInvite().DeleteTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID))
err := t.config.V1.TenantInvite().DeleteTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID))
if err != nil {
return nil, err
api/v1/server/handlers/tenants/delete_member.go
+7 -7
View File
@@ -6,17 +6,17 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantMemberDelete(ctx echo.Context, request gen.TenantMemberDeleteRequestObject) (gen.TenantMemberDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
tenantMember := ctx.Get("tenant-member").(*dbsqlc.PopulateTenantMembersRow)
memberToDelete := ctx.Get("member").(*dbsqlc.PopulateTenantMembersRow)
tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
memberToDelete := ctx.Get("member").(*sqlcv1.PopulateTenantMembersRow)
if tenantMember.Role != dbsqlc.TenantMemberRoleOWNER {
if tenantMember.Role != sqlcv1.TenantMemberRoleOWNER {
return gen.TenantMemberDelete403JSONResponse(
apierrors.NewAPIErrors("Only owners can delete members"),
), nil
@@ -34,7 +34,7 @@ func (t *TenantService) TenantMemberDelete(ctx echo.Context, request gen.TenantM
), nil
}
err := t.config.APIRepository.Tenant().DeleteTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToDelete.ID))
err := t.config.V1.Tenant().DeleteTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToDelete.ID))
if err != nil {
return nil, err
api/v1/server/handlers/tenants/get.go
+2 -2
View File
@@ -5,11 +5,11 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantGet(ctx echo.Context, request gen.TenantGetRequestObject) (gen.TenantGetResponseObject, error) {
maybeTenant := ctx.Get("tenant").(*dbsqlc.Tenant)
maybeTenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenant := transformers.ToTenant(maybeTenant)
api/v1/server/handlers/tenants/get_alerting_settings.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantAlertingSettingsGet(ctx echo.Context, request gen.TenantAlertingSettingsGetRequestObject) (gen.TenantAlertingSettingsGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
tenantAlerting, err := t.config.APIRepository.TenantAlertingSettings().GetTenantAlertingSettings(ctx.Request().Context(), tenantId)
tenantAlerting, err := t.config.V1.TenantAlertingSettings().GetTenantAlertingSettings(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/get_prometheus_metrics.go
+3 -3
View File
@@ -9,12 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantGetPrometheusMetrics(ctx echo.Context, request gen.TenantGetPrometheusMetricsRequestObject) (gen.TenantGetPrometheusMetricsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
var response string
api/v1/server/handlers/tenants/get_resource_policy.go
+4 -4
View File
@@ -7,15 +7,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantResourcePolicyGet(ctx echo.Context, request gen.TenantResourcePolicyGetRequestObject) (gen.TenantResourcePolicyGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limits, err := t.config.EntitlementRepository.TenantLimit().GetLimits(context.Background(), tenantId)
limits, err := t.config.V1.TenantLimit().GetLimits(context.Background(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/get_step_run_queue_metrics.go
+3 -3
View File
@@ -4,12 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantGetStepRunQueueMetrics(ctx echo.Context, request gen.TenantGetStepRunQueueMetricsRequestObject) (gen.TenantGetStepRunQueueMetricsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
stepRunQueueCounts, err := t.config.V1.Tasks().GetQueueCounts(ctx.Request().Context(), tenantId)
api/v1/server/handlers/tenants/get_task_stats.go
+2 -2
View File
@@ -5,11 +5,11 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantGetTaskStats(ctx echo.Context, request gen.TenantGetTaskStatsRequestObject) (gen.TenantGetTaskStatsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
stats, err := t.config.V1.Tasks().GetTaskStats(ctx.Request().Context(), tenant.ID.String())
if err != nil {
api/v1/server/handlers/tenants/list_email_groups.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) AlertEmailGroupList(ctx echo.Context, request gen.AlertEmailGroupListRequestObject) (gen.AlertEmailGroupListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
emailGroups, err := t.config.APIRepository.TenantAlertingSettings().ListTenantAlertGroups(ctx.Request().Context(), tenantId)
emailGroups, err := t.config.V1.TenantAlertingSettings().ListTenantAlertGroups(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/list_invites.go
+7 -7
View File
@@ -5,18 +5,18 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantInviteList(ctx echo.Context, request gen.TenantInviteListRequestObject) (gen.TenantInviteListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
tenantInvites, err := t.config.APIRepository.TenantInvite().ListTenantInvitesByTenantId(ctx.Request().Context(), tenantId, &repository.ListTenantInvitesOpts{
Expired: repository.BoolPtr(false),
Status: repository.StringPtr("PENDING"),
tenantInvites, err := t.config.V1.TenantInvite().ListTenantInvitesByTenantId(ctx.Request().Context(), tenantId, &v1.ListTenantInvitesOpts{
Expired: v1.BoolPtr(false),
Status: v1.StringPtr("PENDING"),
})
if err != nil {
api/v1/server/handlers/tenants/list_members.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantMemberList(ctx echo.Context, request gen.TenantMemberListRequestObject) (gen.TenantMemberListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
members, err := t.config.APIRepository.Tenant().ListTenantMembers(ctx.Request().Context(), tenantId)
members, err := t.config.V1.Tenant().ListTenantMembers(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/update.go
+8 -15
View File
@@ -5,13 +5,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantUpdate(ctx echo.Context, request gen.TenantUpdateRequestObject) (gen.TenantUpdateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// validate the request
@@ -38,7 +38,7 @@ func (t *TenantService) TenantUpdate(ctx echo.Context, request gen.TenantUpdateR
), nil
}
// construct the database query
updateOpts := &repository.UpdateTenantOpts{}
updateOpts := &v1.UpdateTenantOpts{}
if request.Body.AnalyticsOptOut != nil {
updateOpts.AnalyticsOptOut = request.Body.AnalyticsOptOut
@@ -52,15 +52,8 @@ func (t *TenantService) TenantUpdate(ctx echo.Context, request gen.TenantUpdateR
updateOpts.Name = request.Body.Name
}
if request.Body.Version != nil {
updateOpts.Version = &dbsqlc.NullTenantMajorEngineVersion{
Valid: true,
TenantMajorEngineVersion: dbsqlc.TenantMajorEngineVersion(*request.Body.Version),
}
}
// update the tenant
tenant, err := t.config.APIRepository.Tenant().UpdateTenant(ctx.Request().Context(), tenantId, updateOpts)
tenant, err := t.config.V1.Tenant().UpdateTenant(ctx.Request().Context(), tenantId, updateOpts)
if err != nil {
return nil, err
@@ -71,10 +64,10 @@ func (t *TenantService) TenantUpdate(ctx echo.Context, request gen.TenantUpdateR
request.Body.EnableTenantResourceLimitAlerts != nil ||
request.Body.EnableWorkflowRunFailureAlerts != nil {
_, err = t.config.APIRepository.TenantAlertingSettings().UpsertTenantAlertingSettings(
_, err = t.config.V1.TenantAlertingSettings().UpsertTenantAlertingSettings(
ctx.Request().Context(),
tenantId,
&repository.UpsertTenantAlertingSettingsOpts{
&v1.UpsertTenantAlertingSettingsOpts{
MaxFrequency: request.Body.MaxAlertingFrequency,
EnableExpiringTokenAlerts: request.Body.EnableExpiringTokenAlerts,
EnableWorkflowRunFailureAlerts: request.Body.EnableWorkflowRunFailureAlerts,
api/v1/server/handlers/tenants/update_email_group.go
+6 -6
View File
@@ -5,13 +5,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) AlertEmailGroupUpdate(ctx echo.Context, request gen.AlertEmailGroupUpdateRequestObject) (gen.AlertEmailGroupUpdateResponseObject, error) {
emailGroup := ctx.Get("alert-email-group").(*dbsqlc.TenantAlertEmailGroup)
emailGroup := ctx.Get("alert-email-group").(*sqlcv1.TenantAlertEmailGroup)
// validate the request
if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -21,11 +21,11 @@ func (t *TenantService) AlertEmailGroupUpdate(ctx echo.Context, request gen.Aler
}
// construct the database query
updateOpts := &repository.UpdateTenantAlertGroupOpts{
updateOpts := &v1.UpdateTenantAlertGroupOpts{
Emails: request.Body.Emails,
}
emailGroup, err := t.config.APIRepository.TenantAlertingSettings().UpdateTenantAlertGroup(ctx.Request().Context(), sqlchelpers.UUIDToStr(emailGroup.ID), updateOpts)
emailGroup, err := t.config.V1.TenantAlertingSettings().UpdateTenantAlertGroup(ctx.Request().Context(), sqlchelpers.UUIDToStr(emailGroup.ID), updateOpts)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/update_invite.go
+9 -9
View File
@@ -6,14 +6,14 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantInviteUpdate(ctx echo.Context, request gen.TenantInviteUpdateRequestObject) (gen.TenantInviteUpdateResponseObject, error) {
tenantMember := ctx.Get("tenant-member").(*dbsqlc.PopulateTenantMembersRow)
invite := ctx.Get("tenant-invite").(*dbsqlc.TenantInviteLink)
tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
invite := ctx.Get("tenant-invite").(*sqlcv1.TenantInviteLink)
// validate the request
if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -23,19 +23,19 @@ func (t *TenantService) TenantInviteUpdate(ctx echo.Context, request gen.TenantI
}
// if user is not an owner, they cannot change a role to owner
if tenantMember.Role != dbsqlc.TenantMemberRoleOWNER && request.Body.Role == gen.OWNER {
if tenantMember.Role != sqlcv1.TenantMemberRoleOWNER && request.Body.Role == gen.OWNER {
return gen.TenantInviteUpdate400JSONResponse(
apierrors.NewAPIErrors("only an owner can change a role to owner"),
), nil
}
// construct the database query
updateOpts := &repository.UpdateTenantInviteOpts{
Role: repository.StringPtr(string(request.Body.Role)),
updateOpts := &v1.UpdateTenantInviteOpts{
Role: v1.StringPtr(string(request.Body.Role)),
}
// update the invite
invite, err := t.config.APIRepository.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
invite, err := t.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
if err != nil {
return nil, err
api/v1/server/handlers/tenants/update_member.go
+11 -11
View File
@@ -6,14 +6,14 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantMemberUpdateRequestObject) (gen.TenantMemberUpdateResponseObject, error) {
tenantMember := ctx.Get("tenant-member").(*dbsqlc.PopulateTenantMembersRow)
memberToUpdate := ctx.Get("member").(*dbsqlc.PopulateTenantMembersRow)
tenantMember := ctx.Get("tenant-member").(*sqlcv1.PopulateTenantMembersRow)
memberToUpdate := ctx.Get("member").(*sqlcv1.PopulateTenantMembersRow)
if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {
return nil, err
@@ -22,14 +22,14 @@ func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantM
}
// Check if the user has permission to update roles
if tenantMember.Role == dbsqlc.TenantMemberRoleMEMBER {
if tenantMember.Role == sqlcv1.TenantMemberRoleMEMBER {
return gen.TenantMemberUpdate403JSONResponse(
apierrors.NewAPIErrors("Only admins and owners can update member roles"),
), nil
}
// if user is not an owner, they cannot change a role to owner or change owner roles
if tenantMember.Role != dbsqlc.TenantMemberRoleOWNER {
if tenantMember.Role != sqlcv1.TenantMemberRoleOWNER {
if request.Body.Role == gen.OWNER {
return gen.TenantMemberUpdate400JSONResponse(
apierrors.NewAPIErrors("only an owner can change a role to owner"),
@@ -37,7 +37,7 @@ func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantM
}
// Cannot change role of an owner
if memberToUpdate.Role == dbsqlc.TenantMemberRoleOWNER {
if memberToUpdate.Role == sqlcv1.TenantMemberRoleOWNER {
return gen.TenantMemberUpdate400JSONResponse(
apierrors.NewAPIErrors("only an owner can change the role of another owner"),
), nil
@@ -51,11 +51,11 @@ func (t *TenantService) TenantMemberUpdate(ctx echo.Context, request gen.TenantM
), nil
}
updateOpts := &repository.UpdateTenantMemberOpts{
Role: repository.StringPtr(string(request.Body.Role)),
updateOpts := &v1.UpdateTenantMemberOpts{
Role: v1.StringPtr(string(request.Body.Role)),
}
updatedMember, err := t.config.APIRepository.Tenant().UpdateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToUpdate.ID), updateOpts)
updatedMember, err := t.config.V1.Tenant().UpdateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(memberToUpdate.ID), updateOpts)
if err != nil {
return nil, err
api/v1/server/handlers/users/accept_invite.go
+12 -12
View File
@@ -10,13 +10,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInviteAcceptRequestObject) (gen.TenantInviteAcceptResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
userId := sqlchelpers.UUIDToStr(user.ID)
// validate the request
@@ -33,7 +33,7 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
}
// get the invite
invite, err := u.config.APIRepository.TenantInvite().GetTenantInvite(ctx.Request().Context(), inviteId)
invite, err := u.config.V1.TenantInvite().GetTenantInvite(ctx.Request().Context(), inviteId)
if err != nil {
return nil, err
@@ -50,12 +50,12 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
}
// ensure invite is in a pending state
if invite.Status != dbsqlc.InviteLinkStatusPENDING {
if invite.Status != sqlcv1.InviteLinkStatusPENDING {
return gen.TenantInviteAccept400JSONResponse(apierrors.NewAPIErrors("invite has already been used")), nil
}
// ensure the user is not already a member of the tenant
_, err = u.config.APIRepository.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), user.Email)
_, err = u.config.V1.Tenant().GetTenantMemberByEmail(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), user.Email)
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
return nil, err
@@ -64,19 +64,19 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
}
// construct the database query
updateOpts := &repository.UpdateTenantInviteOpts{
Status: repository.StringPtr(string(dbsqlc.InviteLinkStatusACCEPTED)),
updateOpts := &v1.UpdateTenantInviteOpts{
Status: v1.StringPtr(string(sqlcv1.InviteLinkStatusACCEPTED)),
}
// update the invite
invite, err = u.config.APIRepository.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
if err != nil {
return nil, err
}
// add the user to the tenant
member, err := u.config.APIRepository.Tenant().CreateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), &repository.CreateTenantMemberOpts{
member, err := u.config.V1.Tenant().CreateTenantMember(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.TenantId), &v1.CreateTenantMemberOpts{
UserId: userId,
Role: string(invite.Role),
})
@@ -101,7 +101,7 @@ func (u *UserService) TenantInviteAccept(ctx echo.Context, request gen.TenantInv
ctx.Set("tenant-member", member)
tenant, err := u.config.APIRepository.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
tenant, err := u.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
if err != nil {
return nil, err
}
api/v1/server/handlers/users/create.go
+8 -8
View File
@@ -9,8 +9,8 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/api/v1/server/authn"
)
@@ -42,7 +42,7 @@ func (u *UserService) UserCreate(ctx echo.Context, request gen.UserCreateRequest
}
// determine if the user exists before attempting to write the user
_, err := u.config.APIRepository.User().GetUserByEmail(ctx.Request().Context(), string(request.Body.Email))
_, err := u.config.V1.User().GetUserByEmail(ctx.Request().Context(), string(request.Body.Email))
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
u.config.Logger.Err(err).Msg("failed to get user by email")
@@ -58,7 +58,7 @@ func (u *UserService) UserCreate(ctx echo.Context, request gen.UserCreateRequest
), nil
}
hashedPw, err := repository.HashPassword(request.Body.Password)
hashedPw, err := v1.HashPassword(request.Body.Password)
if err != nil {
u.config.Logger.Err(err).Msg("failed to hash password")
@@ -74,15 +74,15 @@ func (u *UserService) UserCreate(ctx echo.Context, request gen.UserCreateRequest
), nil
}
createOpts := &repository.CreateUserOpts{
createOpts := &v1.CreateUserOpts{
Email: string(request.Body.Email),
EmailVerified: repository.BoolPtr(u.config.Auth.ConfigFile.SetEmailVerified),
Name: repository.StringPtr(request.Body.Name),
EmailVerified: v1.BoolPtr(u.config.Auth.ConfigFile.SetEmailVerified),
Name: v1.StringPtr(request.Body.Name),
Password: hashedPw,
}
// write the user to the db
user, err := u.config.APIRepository.User().CreateUser(ctx.Request().Context(), createOpts)
user, err := u.config.V1.User().CreateUser(ctx.Request().Context(), createOpts)
if err != nil {
u.config.Logger.Err(err).Msg("failed to create user")
return gen.UserCreate400JSONResponse(
api/v1/server/handlers/users/get_current.go
+4 -4
View File
@@ -11,17 +11,17 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (u *UserService) UserGetCurrent(ctx echo.Context, request gen.UserGetCurrentRequestObject) (gen.UserGetCurrentResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
userId := sqlchelpers.UUIDToStr(user.ID)
var hasPass bool
_, err := u.config.APIRepository.User().GetUserPassword(ctx.Request().Context(), userId)
_, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), userId)
if err != nil && !errors.Is(err, pgx.ErrNoRows) {
return nil, err
api/v1/server/handlers/users/github_oauth_callback.go
+12 -12
View File
@@ -14,9 +14,9 @@ import (
"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/config/server"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
// Note: we want all errors to redirect, otherwise the user will be greeted with raw JSON in the middle of the login flow.
@@ -68,7 +68,7 @@ func (u *UserService) UserUpdateGithubOauthCallback(ctx echo.Context, _ gen.User
}, nil
}
func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *server.ServerConfig, tok *oauth2.Token) (*dbsqlc.User, error) {
func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *server.ServerConfig, tok *oauth2.Token) (*sqlcv1.User, error) {
gInfo, err := u.getGithubEmailFromToken(tok)
if err != nil {
@@ -94,7 +94,7 @@ func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *ser
return nil, fmt.Errorf("failed to encrypt refresh token: %s", err.Error())
}
oauthOpts := &repository.OAuthOpts{
oauthOpts := &v1.OAuthOpts{
Provider: "github",
ProviderUserId: gInfo.ID,
AccessToken: accessTokenEncrypted,
@@ -102,13 +102,13 @@ func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *ser
ExpiresAt: &expiresAt,
}
user, err := u.config.APIRepository.User().GetUserByEmail(ctx, gInfo.Email)
user, err := u.config.V1.User().GetUserByEmail(ctx, gInfo.Email)
switch err {
case nil:
user, err = u.config.APIRepository.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &repository.UpdateUserOpts{
EmailVerified: repository.BoolPtr(gInfo.EmailVerified),
Name: repository.StringPtr(gInfo.Name),
user, err = u.config.V1.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &v1.UpdateUserOpts{
EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
Name: v1.StringPtr(gInfo.Name),
OAuth: oauthOpts,
})
@@ -116,10 +116,10 @@ func (u *UserService) upsertGithubUserFromToken(ctx context.Context, config *ser
return nil, fmt.Errorf("failed to update user: %s", err.Error())
}
case pgx.ErrNoRows:
user, err = u.config.APIRepository.User().CreateUser(ctx, &repository.CreateUserOpts{
user, err = u.config.V1.User().CreateUser(ctx, &v1.CreateUserOpts{
Email: gInfo.Email,
EmailVerified: repository.BoolPtr(gInfo.EmailVerified),
Name: repository.StringPtr(gInfo.Name),
EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
Name: v1.StringPtr(gInfo.Name),
OAuth: oauthOpts,
})
api/v1/server/handlers/users/google_oauth_callback.go
+12 -12
View File
@@ -16,9 +16,9 @@ import (
"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/config/server"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
// Note: we want all errors to redirect, otherwise the user will be greeted with raw JSON in the middle of the login flow.
@@ -62,7 +62,7 @@ func (u *UserService) UserUpdateGoogleOauthCallback(ctx echo.Context, _ gen.User
}, nil
}
func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *server.ServerConfig, tok *oauth2.Token) (*dbsqlc.User, error) {
func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *server.ServerConfig, tok *oauth2.Token) (*sqlcv1.User, error) {
gInfo, err := getGoogleUserInfoFromToken(tok)
if err != nil {
return nil, err
@@ -87,7 +87,7 @@ func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *ser
return nil, fmt.Errorf("failed to encrypt refresh token: %s", err.Error())
}
oauthOpts := &repository.OAuthOpts{
oauthOpts := &v1.OAuthOpts{
Provider: "google",
ProviderUserId: gInfo.Sub,
AccessToken: accessTokenEncrypted,
@@ -95,13 +95,13 @@ func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *ser
ExpiresAt: &expiresAt,
}
user, err := u.config.APIRepository.User().GetUserByEmail(ctx, gInfo.Email)
user, err := u.config.V1.User().GetUserByEmail(ctx, gInfo.Email)
switch err {
case nil:
user, err = u.config.APIRepository.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &repository.UpdateUserOpts{
EmailVerified: repository.BoolPtr(gInfo.EmailVerified),
Name: repository.StringPtr(gInfo.Name),
user, err = u.config.V1.User().UpdateUser(ctx, sqlchelpers.UUIDToStr(user.ID), &v1.UpdateUserOpts{
EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
Name: v1.StringPtr(gInfo.Name),
OAuth: oauthOpts,
})
@@ -109,10 +109,10 @@ func (u *UserService) upsertGoogleUserFromToken(ctx context.Context, config *ser
return nil, fmt.Errorf("failed to update user: %s", err.Error())
}
case pgx.ErrNoRows:
user, err = u.config.APIRepository.User().CreateUser(ctx, &repository.CreateUserOpts{
user, err = u.config.V1.User().CreateUser(ctx, &v1.CreateUserOpts{
Email: gInfo.Email,
EmailVerified: repository.BoolPtr(gInfo.EmailVerified),
Name: repository.StringPtr(gInfo.Name),
EmailVerified: v1.BoolPtr(gInfo.EmailVerified),
Name: v1.StringPtr(gInfo.Name),
OAuth: oauthOpts,
})
api/v1/server/handlers/users/list_memberships.go
+4 -4
View File
@@ -5,15 +5,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *UserService) TenantMembershipsList(ctx echo.Context, request gen.TenantMembershipsListRequestObject) (gen.TenantMembershipsListResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
userId := sqlchelpers.UUIDToStr(user.ID)
memberships, err := t.config.APIRepository.User().ListTenantMemberships(ctx.Request().Context(), userId)
memberships, err := t.config.V1.User().ListTenantMemberships(ctx.Request().Context(), userId)
if err != nil {
return nil, err
api/v1/server/handlers/users/list_tenant_invites.go
+3 -3
View File
@@ -5,13 +5,13 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *UserService) UserListTenantInvites(ctx echo.Context, request gen.UserListTenantInvitesRequestObject) (gen.UserListTenantInvitesResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
invites, err := t.config.APIRepository.TenantInvite().ListTenantInvitesByEmail(ctx.Request().Context(), user.Email)
invites, err := t.config.V1.TenantInvite().ListTenantInvitesByEmail(ctx.Request().Context(), user.Email)
if err != nil {
return nil, err
api/v1/server/handlers/users/reject_invite.go
+9 -9
View File
@@ -8,13 +8,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInviteRejectRequestObject) (gen.TenantInviteRejectResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
userId := sqlchelpers.UUIDToStr(user.ID)
// validate the request
@@ -31,7 +31,7 @@ func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInv
}
// get the invite
invite, err := u.config.APIRepository.TenantInvite().GetTenantInvite(ctx.Request().Context(), inviteId)
invite, err := u.config.V1.TenantInvite().GetTenantInvite(ctx.Request().Context(), inviteId)
if err != nil {
return nil, err
@@ -48,17 +48,17 @@ func (u *UserService) TenantInviteReject(ctx echo.Context, request gen.TenantInv
}
// ensure invite is in a pending state
if invite.Status != dbsqlc.InviteLinkStatusPENDING {
if invite.Status != sqlcv1.InviteLinkStatusPENDING {
return gen.TenantInviteReject400JSONResponse(apierrors.NewAPIErrors("invite has already been used")), nil
}
// construct the database query
updateOpts := &repository.UpdateTenantInviteOpts{
Status: repository.StringPtr(string(dbsqlc.InviteLinkStatusREJECTED)),
updateOpts := &v1.UpdateTenantInviteOpts{
Status: v1.StringPtr(string(sqlcv1.InviteLinkStatusREJECTED)),
}
// update the invite
invite, err = u.config.APIRepository.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
invite, err = u.config.V1.TenantInvite().UpdateTenantInvite(ctx.Request().Context(), sqlchelpers.UUIDToStr(invite.ID), updateOpts)
if err != nil {
return nil, err
api/v1/server/handlers/users/update_login.go
+5 -5
View File
@@ -10,8 +10,8 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
)
func (u *UserService) UserUpdateLogin(ctx echo.Context, request gen.UserUpdateLoginRequestObject) (gen.UserUpdateLoginResponseObject, error) {
@@ -37,7 +37,7 @@ func (u *UserService) UserUpdateLogin(ctx echo.Context, request gen.UserUpdateLo
}
// determine if the user exists before attempting to write the user
existingUser, err := u.config.APIRepository.User().GetUserByEmail(ctx.Request().Context(), string(request.Body.Email))
existingUser, err := u.config.V1.User().GetUserByEmail(ctx.Request().Context(), string(request.Body.Email))
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return gen.UserUpdateLogin400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
@@ -47,14 +47,14 @@ func (u *UserService) UserUpdateLogin(ctx echo.Context, request gen.UserUpdateLo
return gen.UserUpdateLogin400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
userPass, err := u.config.APIRepository.User().GetUserPassword(ctx.Request().Context(), sqlchelpers.UUIDToStr(existingUser.ID))
userPass, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), sqlchelpers.UUIDToStr(existingUser.ID))
if err != nil {
u.config.Logger.Err(err).Msg("failed to get user password")
return gen.UserUpdateLogin400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
if verified, err := repository.VerifyPassword(userPass.Hash, request.Body.Password); !verified || err != nil {
if verified, err := v1.VerifyPassword(userPass.Hash, request.Body.Password); !verified || err != nil {
return gen.UserUpdateLogin400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
api/v1/server/handlers/users/update_logout.go
+2 -2
View File
@@ -6,11 +6,11 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/authn"
"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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (u *UserService) UserUpdateLogout(ctx echo.Context, request gen.UserUpdateLogoutRequestObject) (gen.UserUpdateLogoutResponseObject, error) {
user := ctx.Get("user").(*dbsqlc.User)
user := ctx.Get("user").(*sqlcv1.User)
if err := authn.NewSessionHelpers(u.config).SaveUnauthenticated(ctx); err != nil {
return nil, err
api/v1/server/handlers/users/update_password.go
+8 -8
View File
@@ -6,14 +6,14 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (u *UserService) UserUpdatePassword(ctx echo.Context, request gen.UserUpdatePasswordRequestObject) (gen.UserUpdatePasswordResponseObject, error) {
// determine if the user exists before attempting to write the user
existingUser := ctx.Get("user").(*dbsqlc.User)
existingUser := ctx.Get("user").(*sqlcv1.User)
if !u.config.Runtime.AllowChangePassword {
return gen.UserUpdatePassword405JSONResponse(
@@ -37,27 +37,27 @@ func (u *UserService) UserUpdatePassword(ctx echo.Context, request gen.UserUpdat
userId := sqlchelpers.UUIDToStr(existingUser.ID)
userPass, err := u.config.APIRepository.User().GetUserPassword(ctx.Request().Context(), userId)
userPass, err := u.config.V1.User().GetUserPassword(ctx.Request().Context(), userId)
if err != nil {
u.config.Logger.Err(err).Msg("failed to get user password")
return gen.UserUpdatePassword400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
if verified, err := repository.VerifyPassword(userPass.Hash, request.Body.Password); !verified || err != nil {
if verified, err := v1.VerifyPassword(userPass.Hash, request.Body.Password); !verified || err != nil {
return gen.UserUpdatePassword400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
// Update the user
newPass, err := repository.HashPassword(request.Body.NewPassword)
newPass, err := v1.HashPassword(request.Body.NewPassword)
if err != nil {
u.config.Logger.Err(err).Msg("failed to hash new password")
return gen.UserUpdatePassword400JSONResponse(apierrors.NewAPIErrors(ErrInvalidCredentials)), nil
}
user, err := u.config.APIRepository.User().UpdateUser(ctx.Request().Context(), userId, &repository.UpdateUserOpts{
user, err := u.config.V1.User().UpdateUser(ctx.Request().Context(), userId, &v1.UpdateUserOpts{
Password: newPass,
})
api/v1/server/handlers/v1/events/list.go
+2 -3
View File
@@ -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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *V1EventsService) V1EventList(ctx echo.Context, request gen.V1EventListRequestObject) (gen.V1EventListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limit := int64(50)
api/v1/server/handlers/v1/events/list_keys.go
+3 -3
View File
@@ -4,12 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *V1EventsService) V1EventKeyList(ctx echo.Context, request gen.V1EventKeyListRequestObject) (gen.V1EventKeyListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
eventKeys, err := t.config.V1.OLAP().ListEventKeys(ctx.Request().Context(), tenantId)
api/v1/server/handlers/v1/filters/create.go
+3 -3
View File
@@ -7,14 +7,14 @@ 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/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/labstack/echo/v4"
)
func (t *V1FiltersService) V1FilterCreate(ctx echo.Context, request gen.V1FilterCreateRequestObject) (gen.V1FilterCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
payload := []byte("{}")
if request.Body.Payload != nil {
api/v1/server/handlers/v1/filters/list.go
+3 -3
View File
@@ -4,15 +4,15 @@ 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/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/jackc/pgx/v5/pgtype"
"github.com/labstack/echo/v4"
)
func (t *V1FiltersService) V1FilterList(ctx echo.Context, request gen.V1FilterListRequestObject) (gen.V1FilterListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
scopes := request.Params.Scopes
workflowIds := request.Params.WorkflowIds
api/v1/server/handlers/v1/filters/update.go
+1 -2
View File
@@ -7,14 +7,13 @@ 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/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/labstack/echo/v4"
)
func (t *V1FiltersService) V1FilterUpdate(ctx echo.Context, request gen.V1FilterUpdateRequestObject) (gen.V1FilterUpdateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
filter := ctx.Get("v1-filter").(*sqlcv1.V1Filter)
var payload []byte
api/v1/server/handlers/v1/proxy/proxy.go
+4 -4
View File
@@ -6,8 +6,8 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
type Proxy[in, out any] struct {
@@ -22,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 *dbsqlc.Tenant, input *in) (*out, error) {
func (p *Proxy[in, out]) Do(ctx context.Context, tenant *sqlcv1.Tenant, input *in) (*out, error) {
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
expiresAt := time.Now().Add(5 * time.Minute).UTC()
@@ -39,7 +39,7 @@ func (p *Proxy[in, out]) Do(ctx context.Context, tenant *dbsqlc.Tenant, input *i
defer cancel()
// delete the API token
err = p.config.APIRepository.APIToken().DeleteAPIToken(deleteCtx, tenantId, tok.TokenId)
err = p.config.V1.APIToken().DeleteAPIToken(deleteCtx, tenantId, tok.TokenId)
if err != nil {
p.config.Logger.Error().Err(err).Msg("failed to delete API token")
api/v1/server/handlers/v1/tasks/cancel.go
+2 -2
View File
@@ -7,11 +7,11 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
contracts "github.com/hatchet-dev/hatchet/internal/services/shared/proto/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TasksService) V1TaskCancel(ctx echo.Context, request gen.V1TaskCancelRequestObject) (gen.V1TaskCancelResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
var err error
api/v1/server/handlers/v1/tasks/get.go
+1 -1
View File
@@ -53,7 +53,7 @@ func (t *TasksService) V1TaskGet(ctx echo.Context, request gen.V1TaskGetRequestO
return nil, err
}
workflowVersion, _, _, _, err := t.config.APIRepository.Workflow().GetWorkflowVersionById(task.TenantID.String(), taskWithData.WorkflowVersionID.String())
workflowVersion, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), task.TenantID.String(), taskWithData.WorkflowVersionID.String())
if err != nil {
return nil, err
api/v1/server/handlers/v1/tasks/get_metrics.go
+3 -3
View File
@@ -7,9 +7,9 @@ import (
"github.com/jackc/pgx/v5/pgtype"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/labstack/echo/v4"
@@ -17,7 +17,7 @@ import (
)
func (t *TasksService) V1TaskListStatusMetrics(ctx echo.Context, request gen.V1TaskListStatusMetricsRequestObject) (gen.V1TaskListStatusMetricsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
var workflowIds []uuid.UUID
api/v1/server/handlers/v1/tasks/get_point_metrics.go
+2 -3
View File
@@ -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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TasksService) V1TaskGetPointMetrics(ctx echo.Context, request gen.V1TaskGetPointMetricsRequestObject) (gen.V1TaskGetPointMetricsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// 24 hours ago, rounded to the nearest minute
api/v1/server/handlers/v1/tasks/list_by_dag_id.go
+1 -1
View File
@@ -5,7 +5,7 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
)
api/v1/server/handlers/v1/tasks/list_events.go
+2 -3
View File
@@ -4,15 +4,14 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
)
func (t *TasksService) V1TaskEventList(ctx echo.Context, request gen.V1TaskEventListRequestObject) (gen.V1TaskEventListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
task := ctx.Get("task").(*sqlcv1.V1TasksOlap)
api/v1/server/handlers/v1/tasks/list_logs.go
+2 -3
View File
@@ -6,8 +6,7 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/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").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
task := ctx.Get("task").(*sqlcv1.V1TasksOlap)
api/v1/server/handlers/v1/tasks/replay.go
+2 -2
View File
@@ -7,11 +7,11 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
contracts "github.com/hatchet-dev/hatchet/internal/services/shared/proto/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *TasksService) V1TaskReplay(ctx echo.Context, request gen.V1TaskReplayRequestObject) (gen.V1TaskReplayResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
var err error
api/v1/server/handlers/v1/webhooks/create.go
+3 -4
View File
@@ -8,16 +8,15 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (w *V1WebhooksService) V1WebhookCreate(ctx echo.Context, request gen.V1WebhookCreateRequestObject) (gen.V1WebhookCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
canCreate, _, err := w.config.EntitlementRepository.TenantLimit().CanCreate(ctx.Request().Context(), dbsqlc.LimitResourceINCOMINGWEBHOOK, tenant.ID.String(), 1)
canCreate, _, err := w.config.V1.TenantLimit().CanCreate(ctx.Request().Context(), sqlcv1.LimitResourceINCOMINGWEBHOOK, tenant.ID.String(), 1)
if err != nil {
return nil, fmt.Errorf("failed to check if webhook can be created: %w", err)
api/v1/server/handlers/v1/webhooks/list.go
+1 -2
View File
@@ -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/api/v1/server/oas/transformers/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (w *V1WebhooksService) V1WebhookList(ctx echo.Context, request gen.V1WebhookListRequestObject) (gen.V1WebhookListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
var sourceNames []sqlcv1.V1IncomingWebhookSourceName
var webhookNames []string
api/v1/server/handlers/v1/webhooks/receive.go
+1 -1
View File
@@ -32,7 +32,7 @@ func (w *V1WebhooksService) V1WebhookReceive(ctx echo.Context, request gen.V1Web
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")
tenant, err := w.config.APIRepository.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
tenant, err := w.config.V1.Tenant().GetTenantByID(ctx.Request().Context(), tenantId)
if err != nil || tenant == nil {
return gen.V1WebhookReceive400JSONResponse{
api/v1/server/handlers/v1/workflow-runs/get-timings.go
+3 -3
View File
@@ -7,9 +7,9 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
@@ -17,7 +17,7 @@ import (
)
func (t *V1WorkflowRunsService) V1WorkflowRunGetTimings(ctx echo.Context, request gen.V1WorkflowRunGetTimingsRequestObject) (gen.V1WorkflowRunGetTimingsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
api/v1/server/handlers/v1/workflow-runs/get.go
+5 -5
View File
@@ -8,15 +8,15 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
)
func (t *V1WorkflowRunsService) V1WorkflowRunGet(ctx echo.Context, request gen.V1WorkflowRunGetRequestObject) (gen.V1WorkflowRunGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
@@ -76,7 +76,7 @@ func (t *V1WorkflowRunsService) getWorkflowRunDetails(
workflowVersionId := uuid.MustParse(sqlchelpers.UUIDToStr(workflowRun.WorkflowVersionId))
shape, err := t.config.APIRepository.WorkflowRun().GetWorkflowRunShape(
shape, err := t.config.V1.Workflows().GetWorkflowShape(
ctx, workflowVersionId,
)
@@ -84,7 +84,7 @@ func (t *V1WorkflowRunsService) getWorkflowRunDetails(
return nil, err
}
workflowVersion, _, _, _, err := t.config.APIRepository.Workflow().GetWorkflowVersionById(tenantId, workflowRun.WorkflowVersionId.String())
workflowVersion, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx, tenantId, workflowRun.WorkflowVersionId.String())
if err != nil {
return nil, err
api/v1/server/handlers/v1/workflow-runs/list-task-events.go
+3 -3
View File
@@ -4,15 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
transformers "github.com/hatchet-dev/hatchet/api/v1/server/oas/transformers/v1"
)
func (t *V1WorkflowRunsService) V1WorkflowRunTaskEventsList(ctx echo.Context, request gen.V1WorkflowRunTaskEventsListRequestObject) (gen.V1WorkflowRunTaskEventsListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
rawWorkflowRun := ctx.Get("v1-workflow-run").(*v1.V1WorkflowRunPopulator)
api/v1/server/handlers/v1/workflow-runs/list.go
+4 -5
View File
@@ -9,8 +9,7 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/hatchet-dev/hatchet/pkg/telemetry"
@@ -294,7 +293,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").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
spanContext, span := telemetry.NewSpan(ctx.Request().Context(), "v1-workflow-runs-list")
@@ -308,7 +307,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").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
externalIds := make([]pgtype.UUID, len(request.Params.ExternalIds))
@@ -334,7 +333,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").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := tenant.ID.String()
spanCtx, span := telemetry.NewSpan(ctx.Request().Context(), "v1-workflow-runs-list-external-ids")
defer span.End()
api/v1/server/handlers/v1/workflow-runs/trigger.go
+3 -3
View File
@@ -15,13 +15,13 @@ import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
contracts "github.com/hatchet-dev/hatchet/internal/services/shared/proto/v1"
"github.com/hatchet-dev/hatchet/pkg/constants"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *V1WorkflowRunsService) V1WorkflowRunCreate(ctx echo.Context, request gen.V1WorkflowRunCreateRequestObject) (gen.V1WorkflowRunCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
// make sure input can be marshalled and unmarshalled to input type
api/v1/server/handlers/workers/get.go
+8 -8
View File
@@ -8,18 +8,18 @@ import (
"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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkerService) WorkerGet(ctx echo.Context, request gen.WorkerGetRequestObject) (gen.WorkerGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
return t.workerGetV1(ctx, tenant, request)
}
func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *dbsqlc.Tenant, request gen.WorkerGetRequestObject) (gen.WorkerGetResponseObject, error) {
workerV0 := ctx.Get("worker").(*dbsqlc.GetWorkerByIdRow)
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))
@@ -37,7 +37,7 @@ func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *dbsqlc.Tenant, req
return nil, err
}
workerIdToActions, err := t.config.APIRepository.Worker().GetWorkerActionsByWorkerId(
workerIdToActions, err := t.config.V1.Workers().GetWorkerActionsByWorkerId(
sqlchelpers.UUIDToStr(worker.Worker.TenantId),
[]string{sqlchelpers.UUIDToStr(worker.Worker.ID)},
)
@@ -46,7 +46,7 @@ func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *dbsqlc.Tenant, req
return nil, err
}
workerWorkflows, err := t.config.APIRepository.Worker().GetWorkerWorkflowsByWorkerId(tenant.ID.String(), worker.Worker.ID.String())
workerWorkflows, err := t.config.V1.Workers().GetWorkerWorkflowsByWorkerId(tenant.ID.String(), worker.Worker.ID.String())
if err != nil {
return nil, err
@@ -66,7 +66,7 @@ func (t *WorkerService) workerGetV1(ctx echo.Context, tenant *dbsqlc.Tenant, req
workerResp.RecentStepRuns = &respStepRuns
workerResp.Slots = transformersv1.ToSlotState(slotState, slots)
affinity, err := t.config.APIRepository.Worker().ListWorkerLabels(
affinity, err := t.config.V1.Workers().ListWorkerLabels(
sqlchelpers.UUIDToStr(worker.Worker.TenantId),
sqlchelpers.UUIDToStr(worker.Worker.ID),
)
api/v1/server/handlers/workers/list.go
+12 -12
View File
@@ -9,19 +9,19 @@ import (
"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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/hatchet-dev/hatchet/pkg/telemetry"
)
func (t *WorkerService) WorkerList(ctx echo.Context, request gen.WorkerListRequestObject) (gen.WorkerListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
switch tenant.Version {
case dbsqlc.TenantMajorEngineVersionV0:
case sqlcv1.TenantMajorEngineVersionV0:
return t.workerListV0(ctx, tenant, request)
case dbsqlc.TenantMajorEngineVersionV1:
case sqlcv1.TenantMajorEngineVersionV1:
return t.workerListV1(ctx, tenant, request)
default:
err := fmt.Errorf("unsupported tenant version: %s", string(tenant.Version))
@@ -29,13 +29,13 @@ func (t *WorkerService) WorkerList(ctx echo.Context, request gen.WorkerListReque
}
}
func (t *WorkerService) workerListV0(ctx echo.Context, tenant *dbsqlc.Tenant, request gen.WorkerListRequestObject) (gen.WorkerListResponseObject, error) {
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)
sixSecAgo := time.Now().Add(-24 * time.Hour)
opts := &repository.ListWorkersOpts{
opts := &v1.ListWorkersOpts{
LastHeartbeatAfter: &sixSecAgo,
}
@@ -46,7 +46,7 @@ func (t *WorkerService) workerListV0(ctx echo.Context, tenant *dbsqlc.Tenant, re
telemetry.AttributeKV{Key: "tenant.id", Value: tenant.ID},
)
workers, err := t.config.APIRepository.Worker().ListWorkers(tenantId, opts)
workers, err := t.config.V1.Workers().ListWorkers(tenantId, opts)
if err != nil {
listSpan.RecordError(err)
@@ -73,13 +73,13 @@ func (t *WorkerService) workerListV0(ctx echo.Context, tenant *dbsqlc.Tenant, re
), nil
}
func (t *WorkerService) workerListV1(ctx echo.Context, tenant *dbsqlc.Tenant, request gen.WorkerListRequestObject) (gen.WorkerListResponseObject, error) {
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)
sixSecAgo := time.Now().Add(-24 * time.Hour)
opts := &repository.ListWorkersOpts{
opts := &v1.ListWorkersOpts{
LastHeartbeatAfter: &sixSecAgo,
}
@@ -119,7 +119,7 @@ func (t *WorkerService) workerListV1(ctx echo.Context, tenant *dbsqlc.Tenant, re
telemetry.AttributeKV{Key: "workers.unique_ids.count", Value: len(workerIds)},
)
workerIdToActionIds, err := t.config.APIRepository.Worker().GetWorkerActionsByWorkerId(
workerIdToActionIds, err := t.config.V1.Workers().GetWorkerActionsByWorkerId(
sqlchelpers.UUIDToStr(tenant.ID),
workerIds,
)
api/v1/server/handlers/workers/update.go
+9 -7
View File
@@ -5,13 +5,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkerService) WorkerUpdate(ctx echo.Context, request gen.WorkerUpdateRequestObject) (gen.WorkerUpdateResponseObject, error) {
worker := ctx.Get("worker").(*dbsqlc.GetWorkerByIdRow)
worker := ctx.Get("worker").(*sqlcv1.GetWorkerByIdRow)
// validate the request
if apiErrors, err := t.config.Validator.ValidateAPI(request.Body); err != nil {
@@ -20,16 +20,18 @@ func (t *WorkerService) WorkerUpdate(ctx echo.Context, request gen.WorkerUpdateR
return gen.WorkerUpdate400JSONResponse(*apiErrors), nil
}
update := repository.ApiUpdateWorkerOpts{}
update := &v1.UpdateWorkerOpts{}
if request.Body.IsPaused != nil {
update.IsPaused = request.Body.IsPaused
}
updatedWorker, err := t.config.APIRepository.Worker().UpdateWorker(
updatedWorker, err := t.config.V1.Workers().UpdateWorker(
ctx.Request().Context(),
sqlchelpers.UUIDToStr(worker.Worker.TenantId),
sqlchelpers.UUIDToStr(worker.Worker.ID),
update)
update,
)
if err != nil {
return nil, err
api/v1/server/handlers/workflows/bulk_delete_scheduled.go
+9 -9
View File
@@ -11,13 +11,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request gen.WorkflowScheduledBulkDeleteRequestObject) (gen.WorkflowScheduledBulkDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
if request.Body == nil {
@@ -50,7 +50,7 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
orderBy := "triggerAt"
orderDirection := "DESC"
opts := &repository.ListScheduledWorkflowsOpts{
opts := &v1.ListScheduledWorkflowsOpts{
Limit: &limit,
Offset: &offset,
OrderBy: &orderBy,
@@ -82,9 +82,9 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
opts.AdditionalMetadata = additionalMetadata
}
all := make([]*dbsqlc.ListScheduledWorkflowsRow, 0)
all := make([]*sqlcv1.ListScheduledWorkflowsRow, 0)
for {
rows, count, err := t.config.APIRepository.WorkflowRun().ListScheduledWorkflows(dbCtx, tenantId, opts)
rows, count, err := t.config.V1.WorkflowSchedules().ListScheduledWorkflows(dbCtx, tenantId, opts)
if err != nil {
return nil, err
}
@@ -109,7 +109,7 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
continue
}
if row.Method != dbsqlc.WorkflowTriggerScheduledRefMethodsAPI {
if row.Method != sqlcv1.WorkflowTriggerScheduledRefMethodsAPI {
idCp := idUUID
errors = append(errors, gen.ScheduledWorkflowsBulkError{Id: &idCp, Error: "Cannot delete scheduled run created via code definition."})
continue
@@ -142,7 +142,7 @@ func (t *WorkflowService) WorkflowScheduledBulkDelete(ctx echo.Context, request
chunkUUIDByStr[idStr] = id
}
deletedIds, err := t.config.APIRepository.WorkflowRun().BulkDeleteScheduledWorkflows(dbCtx, tenantId, chunkStr)
deletedIds, err := t.config.V1.WorkflowSchedules().BulkDeleteScheduledWorkflows(dbCtx, tenantId, chunkStr)
if err != nil {
return nil, err
}
api/v1/server/handlers/workflows/bulk_update_scheduled.go
+8 -8
View File
@@ -8,13 +8,13 @@ import (
openapi_types "github.com/oapi-codegen/runtime/types"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request gen.WorkflowScheduledBulkUpdateRequestObject) (gen.WorkflowScheduledBulkUpdateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
if request.Body == nil {
@@ -45,12 +45,12 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
chunkUUIDByStr[idStr] = u.Id
}
metaById, err := t.config.APIRepository.WorkflowRun().ScheduledWorkflowMetaByIds(dbCtx, tenantId, chunkIds)
metaById, err := t.config.V1.WorkflowSchedules().ScheduledWorkflowMetaByIds(dbCtx, tenantId, chunkIds)
if err != nil {
return nil, err
}
toUpdate := make([]repository.ScheduledWorkflowUpdate, 0, len(chunk))
toUpdate := make([]v1.ScheduledWorkflowUpdate, 0, len(chunk))
for _, u := range chunk {
id := u.Id
idStr := id.String()
@@ -68,13 +68,13 @@ func (t *WorkflowService) WorkflowScheduledBulkUpdate(ctx echo.Context, request
continue
}
toUpdate = append(toUpdate, repository.ScheduledWorkflowUpdate{
toUpdate = append(toUpdate, v1.ScheduledWorkflowUpdate{
Id: idStr,
TriggerAt: u.TriggerAt,
})
}
updatedIds, err := t.config.APIRepository.WorkflowRun().BulkUpdateScheduledWorkflows(dbCtx, tenantId, toUpdate)
updatedIds, err := t.config.V1.WorkflowSchedules().BulkUpdateScheduledWorkflows(dbCtx, tenantId, toUpdate)
if err != nil {
return nil, err
}
api/v1/server/handlers/workflows/create_cron.go
+9 -9
View File
@@ -9,20 +9,20 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) CronWorkflowTriggerCreate(ctx echo.Context, request gen.CronWorkflowTriggerCreateRequestObject) (gen.CronWorkflowTriggerCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
if request.Body.CronName == "" {
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors("cron name is required")), nil
}
workflow, err := t.config.EngineRepository.Workflow().GetWorkflowByName(ctx.Request().Context(), tenantId, request.Workflow)
workflow, err := t.config.V1.Workflows().GetWorkflowByName(ctx.Request().Context(), tenantId, request.Workflow)
if err != nil {
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors("workflow not found")), nil
@@ -40,7 +40,7 @@ func (t *WorkflowService) CronWorkflowTriggerCreate(ctx echo.Context, request ge
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors("invalid input format")), nil
}
if err := repository.ValidateJSONB(inputBytes, "input"); err != nil {
if err := v1.ValidateJSONB(inputBytes, "input"); err != nil {
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors(err.Error())), nil
}
@@ -50,12 +50,12 @@ func (t *WorkflowService) CronWorkflowTriggerCreate(ctx echo.Context, request ge
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors("invalid additional metadata format")), nil
}
if err := repository.ValidateJSONB(additionalMetaBytes, "additionalMetadata"); err != nil {
if err := v1.ValidateJSONB(additionalMetaBytes, "additionalMetadata"); err != nil {
return gen.CronWorkflowTriggerCreate400JSONResponse(apierrors.NewAPIErrors(err.Error())), nil
}
cronTrigger, err := t.config.APIRepository.Workflow().CreateCronWorkflow(
ctx.Request().Context(), tenantId, &repository.CreateCronWorkflowTriggerOpts{
cronTrigger, err := t.config.V1.WorkflowSchedules().CreateCronWorkflow(
ctx.Request().Context(), tenantId, &v1.CreateCronWorkflowTriggerOpts{
Name: request.Body.CronName,
Cron: request.Body.CronExpression,
Input: request.Body.Input,
api/v1/server/handlers/workflows/create_scheduled.go
+32 -8
View File
@@ -1,22 +1,24 @@
package workflows
import (
"encoding/json"
"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/constants"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) ScheduledWorkflowRunCreate(ctx echo.Context, request gen.ScheduledWorkflowRunCreateRequestObject) (gen.ScheduledWorkflowRunCreateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow, err := t.config.EngineRepository.Workflow().GetWorkflowByName(ctx.Request().Context(), tenantId, request.Workflow)
workflow, err := t.config.V1.Workflows().GetWorkflowByName(ctx.Request().Context(), tenantId, request.Workflow)
if err != nil {
return gen.ScheduledWorkflowRunCreate400JSONResponse(apierrors.NewAPIErrors("workflow not found")), nil
@@ -28,10 +30,32 @@ func (t *WorkflowService) ScheduledWorkflowRunCreate(ctx echo.Context, request g
priority = *request.Body.Priority
}
scheduled, err := t.config.APIRepository.Workflow().CreateScheduledWorkflow(ctx.Request().Context(), tenantId, &repository.CreateScheduledWorkflowRunForWorkflowOpts{
var input, additionalMetadata []byte
if request.Body.Input != nil {
input, err = json.Marshal(request.Body.Input)
if err != nil {
return gen.ScheduledWorkflowRunCreate400JSONResponse(
apierrors.NewAPIErrors("could not marshal input"),
), nil
}
}
if request.Body.AdditionalMetadata != nil {
additionalMetadata, err = json.Marshal(request.Body.AdditionalMetadata)
if err != nil {
return gen.ScheduledWorkflowRunCreate400JSONResponse(
apierrors.NewAPIErrors("could not marshal additionalMetadata"),
), nil
}
}
scheduled, err := t.config.V1.WorkflowSchedules().CreateScheduledWorkflow(ctx.Request().Context(), tenantId, &v1.CreateScheduledWorkflowRunForWorkflowOpts{
ScheduledTrigger: request.Body.TriggerAt,
Input: request.Body.Input,
AdditionalMetadata: request.Body.AdditionalMetadata,
Input: input,
AdditionalMetadata: additionalMetadata,
WorkflowId: sqlchelpers.UUIDToStr(workflow.ID),
Priority: &priority,
})
api/v1/server/handlers/workflows/delete.go
+5 -5
View File
@@ -4,16 +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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowDelete(ctx echo.Context, request gen.WorkflowDeleteRequestObject) (gen.WorkflowDeleteResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
_, err := t.config.APIRepository.Workflow().DeleteWorkflow(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.Workflow.ID))
_, err := t.config.V1.Workflows().DeleteWorkflow(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.Workflow.ID))
if err != nil {
return nil, err
api/v1/server/handlers/workflows/delete_cron.go
+5 -5
View File
@@ -7,18 +7,18 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowCronDelete(ctx echo.Context, request gen.WorkflowCronDeleteRequestObject) (gen.WorkflowCronDeleteResponseObject, error) {
_ = ctx.Get("tenant").(*dbsqlc.Tenant)
cron := ctx.Get("cron-workflow").(*dbsqlc.ListCronWorkflowsRow)
_ = ctx.Get("tenant").(*sqlcv1.Tenant)
cron := ctx.Get("cron-workflow").(*sqlcv1.ListCronWorkflowsRow)
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
err := t.config.APIRepository.Workflow().DeleteCronWorkflow(dbCtx,
err := t.config.V1.WorkflowSchedules().DeleteCronWorkflow(dbCtx,
sqlchelpers.UUIDToStr(cron.TenantId),
sqlchelpers.UUIDToStr(cron.CronId),
)
api/v1/server/handlers/workflows/delete_scheduled.go
+5 -5
View File
@@ -7,15 +7,15 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledDelete(ctx echo.Context, request gen.WorkflowScheduledDeleteRequestObject) (gen.WorkflowScheduledDeleteResponseObject, error) {
scheduled := ctx.Get("scheduled-workflow-run").(*dbsqlc.ListScheduledWorkflowsRow)
scheduled := ctx.Get("scheduled-workflow-run").(*sqlcv1.ListScheduledWorkflowsRow)
// Only allow deleting scheduled runs created via API.
if scheduled.Method != dbsqlc.WorkflowTriggerScheduledRefMethodsAPI {
if scheduled.Method != sqlcv1.WorkflowTriggerScheduledRefMethodsAPI {
return gen.WorkflowScheduledDelete403JSONResponse(gen.APIError{
Description: "Cannot delete scheduled run created via code definition.",
}), nil
@@ -24,7 +24,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.APIRepository.WorkflowRun().DeleteScheduledWorkflow(dbCtx, sqlchelpers.UUIDToStr(scheduled.TenantId), request.ScheduledWorkflowRun.String())
err := t.config.V1.WorkflowSchedules().DeleteScheduledWorkflow(dbCtx, sqlchelpers.UUIDToStr(scheduled.TenantId), request.ScheduledWorkflowRun.String())
if err != nil {
return nil, err
api/v1/server/handlers/workflows/get.go
+5 -5
View File
@@ -5,20 +5,20 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowGet(ctx echo.Context, request gen.WorkflowGetRequestObject) (gen.WorkflowGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
if workflow == nil || !workflow.WorkflowVersionId.Valid {
return gen.WorkflowGet404JSONResponse(gen.APIErrors{}), nil
}
version, _, _, _, err := t.config.APIRepository.Workflow().GetWorkflowVersionById(tenantId, sqlchelpers.UUIDToStr(workflow.WorkflowVersionId))
version, _, _, _, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.WorkflowVersionId))
if err != nil {
return nil, err
api/v1/server/handlers/workflows/get_cron.go
+4 -4
View File
@@ -9,18 +9,18 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowCronGet(ctx echo.Context, request gen.WorkflowCronGetRequestObject) (gen.WorkflowCronGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
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.APIRepository.Workflow().GetCronWorkflow(dbCtx, tenantId, request.CronWorkflow.String())
scheduled, err := t.config.V1.WorkflowSchedules().GetCronWorkflow(dbCtx, tenantId, request.CronWorkflow.String())
if err != nil {
return nil, err
api/v1/server/handlers/workflows/get_metrics.go
+1 -37
View File
@@ -1,47 +1,11 @@
package workflows
import (
"errors"
"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/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
)
func (t *WorkflowService) WorkflowGetMetrics(ctx echo.Context, request gen.WorkflowGetMetricsRequestObject) (gen.WorkflowGetMetricsResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
opts := &repository.GetWorkflowMetricsOpts{}
if request.Params.Status != nil {
opts.Status = (*string)(request.Params.Status)
}
if request.Params.GroupKey != nil {
opts.GroupKey = request.Params.GroupKey
}
metrics, err := t.config.APIRepository.Workflow().GetWorkflowMetrics(tenantId, sqlchelpers.UUIDToStr(workflow.Workflow.ID), opts)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return gen.WorkflowGetMetrics404JSONResponse(
apierrors.NewAPIErrors("workflow not found"),
), nil
}
return nil, err
}
return gen.WorkflowGetMetrics200JSONResponse(gen.WorkflowMetrics{
GroupKeyCount: &metrics.GroupKeyCount,
GroupKeyRunsCount: &metrics.GroupKeyRunsCount,
}), nil
panic("deprecated")
}
api/v1/server/handlers/workflows/get_scheduled.go
+2 -2
View File
@@ -6,11 +6,11 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledGet(ctx echo.Context, request gen.WorkflowScheduledGetRequestObject) (gen.WorkflowScheduledGetResponseObject, error) {
scheduled := ctx.Get("scheduled-workflow-run").(*dbsqlc.ListScheduledWorkflowsRow)
scheduled := ctx.Get("scheduled-workflow-run").(*sqlcv1.ListScheduledWorkflowsRow)
if scheduled == nil {
return gen.WorkflowScheduledGet404JSONResponse(apierrors.NewAPIErrors("Scheduled workflow not found.")), nil
api/v1/server/handlers/workflows/get_version.go
+6 -6
View File
@@ -10,21 +10,21 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowVersionGet(ctx echo.Context, request gen.WorkflowVersionGetRequestObject) (gen.WorkflowVersionGetResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
workflow := ctx.Get("workflow").(*sqlcv1.GetWorkflowByIdRow)
var workflowVersionId string
if request.Params.Version != nil {
workflowVersionId = request.Params.Version.String()
} else {
row, err := t.config.APIRepository.Workflow().GetWorkflowById(
row, err := t.config.V1.Workflows().GetWorkflowById(
ctx.Request().Context(),
sqlchelpers.UUIDToStr(workflow.Workflow.ID),
)
@@ -43,7 +43,7 @@ func (t *WorkflowService) WorkflowVersionGet(ctx echo.Context, request gen.Workf
workflowVersionId = sqlchelpers.UUIDToStr(row.WorkflowVersionId)
}
row, crons, events, scheduleT, err := t.config.APIRepository.Workflow().GetWorkflowVersionById(tenantId, workflowVersionId)
row, crons, events, scheduleT, err := t.config.V1.Workflows().GetWorkflowVersionWithTriggers(ctx.Request().Context(), tenantId, workflowVersionId)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
api/v1/server/handlers/workflows/get_worker_count.go
+1 -29
View File
@@ -1,39 +1,11 @@
package workflows
import (
"errors"
"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/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
)
func (t *WorkflowService) WorkflowGetWorkersCount(ctx echo.Context, request gen.WorkflowGetWorkersCountRequestObject) (gen.WorkflowGetWorkersCountResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
w := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
workflow := sqlchelpers.UUIDToStr(w.Workflow.ID)
freeSlotCount, maxSlotCount, err := t.config.APIRepository.Workflow().GetWorkflowWorkerCount(tenantId, workflow)
if err != nil {
if errors.Is(err, pgx.ErrNoRows) {
return gen.WorkflowGetWorkersCount400JSONResponse(
apierrors.NewAPIErrors("workflow not found"),
), nil
}
return nil, err
}
return gen.WorkflowGetWorkersCount200JSONResponse(gen.WorkflowWorkersCount{
FreeSlotCount: &freeSlotCount,
MaxSlotCount: &maxSlotCount,
WorkflowRunId: &workflow,
}), nil
panic("deprecated")
}
api/v1/server/handlers/workflows/list.go
+6 -6
View File
@@ -7,13 +7,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowList(ctx echo.Context, request gen.WorkflowListRequestObject) (gen.WorkflowListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limit := 50
@@ -40,13 +40,13 @@ func (t *WorkflowService) WorkflowList(ctx echo.Context, request gen.WorkflowLis
offset = 0
}
listOpts := &repository.ListWorkflowsOpts{
listOpts := &v1.ListWorkflowsOpts{
Limit: &limit,
Offset: &offset,
Name: &name,
}
listResp, err := t.config.APIRepository.Workflow().ListWorkflows(tenantId, listOpts)
listResp, err := t.config.V1.Workflows().ListWorkflows(tenantId, listOpts)
if err != nil {
return nil, err
api/v1/server/handlers/workflows/list_crons.go
+6 -6
View File
@@ -12,13 +12,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWorkflowListRequestObject) (gen.CronWorkflowListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limit := 50
@@ -26,7 +26,7 @@ func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWor
orderDirection := "DESC"
orderBy := "createdAt"
listOpts := &repository.ListCronWorkflowsOpts{
listOpts := &v1.ListCronWorkflowsOpts{
Limit: &limit,
Offset: &offset,
OrderBy: &orderBy,
@@ -86,7 +86,7 @@ func (t *WorkflowService) CronWorkflowList(ctx echo.Context, request gen.CronWor
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
crons, count, err := t.config.APIRepository.Workflow().ListCronWorkflows(dbCtx, tenantId, listOpts)
crons, count, err := t.config.V1.WorkflowSchedules().ListCronWorkflows(dbCtx, tenantId, listOpts)
if err != nil {
return nil, err
api/v1/server/handlers/workflows/list_scheduled.go
+8 -8
View File
@@ -12,13 +12,13 @@ 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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.WorkflowScheduledListRequestObject) (gen.WorkflowScheduledListResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenant := ctx.Get("tenant").(*sqlcv1.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
limit := 50
@@ -26,7 +26,7 @@ func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.Wo
orderDirection := "DESC"
orderBy := "triggerAt"
listOpts := &repository.ListScheduledWorkflowsOpts{
listOpts := &v1.ListScheduledWorkflowsOpts{
Limit: &limit,
Offset: &offset,
OrderBy: &orderBy,
@@ -59,10 +59,10 @@ func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.Wo
}
if request.Params.Statuses != nil {
statuses := make([]dbsqlc.WorkflowRunStatus, len(*request.Params.Statuses))
statuses := make([]sqlcv1.WorkflowRunStatus, len(*request.Params.Statuses))
for i, status := range *request.Params.Statuses {
statuses[i] = dbsqlc.WorkflowRunStatus(status)
statuses[i] = sqlcv1.WorkflowRunStatus(status)
}
listOpts.Statuses = &statuses
@@ -88,7 +88,7 @@ func (t *WorkflowService) WorkflowScheduledList(ctx echo.Context, request gen.Wo
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
scheduled, count, err := t.config.APIRepository.WorkflowRun().ListScheduledWorkflows(dbCtx, tenantId, listOpts)
scheduled, count, err := t.config.V1.WorkflowSchedules().ListScheduledWorkflows(dbCtx, tenantId, listOpts)
if err != nil {
return nil, err
api/v1/server/handlers/workflows/update.go
+1 -21
View File
@@ -4,28 +4,8 @@ import (
"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"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
)
func (t *WorkflowService) WorkflowUpdate(ctx echo.Context, request gen.WorkflowUpdateRequestObject) (gen.WorkflowUpdateResponseObject, error) {
tenant := ctx.Get("tenant").(*dbsqlc.Tenant)
tenantId := sqlchelpers.UUIDToStr(tenant.ID)
workflow := ctx.Get("workflow").(*dbsqlc.GetWorkflowByIdRow)
opts := repository.UpdateWorkflowOpts{
IsPaused: request.Body.IsPaused,
}
updated, err := t.config.APIRepository.Workflow().UpdateWorkflow(ctx.Request().Context(), tenantId, sqlchelpers.UUIDToStr(workflow.Workflow.ID), &opts)
if err != nil {
return nil, err
}
resp := transformers.ToWorkflowFromSQLC(updated)
return gen.WorkflowUpdate200JSONResponse(*resp), nil
panic("deprecated")
}
api/v1/server/handlers/workflows/update_cron.go
+7 -7
View File
@@ -7,23 +7,23 @@ import (
"github.com/labstack/echo/v4"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowCronUpdate(ctx echo.Context, request gen.WorkflowCronUpdateRequestObject) (gen.WorkflowCronUpdateResponseObject, error) {
_ = ctx.Get("tenant").(*dbsqlc.Tenant)
cron := ctx.Get("cron-workflow").(*dbsqlc.ListCronWorkflowsRow)
_ = ctx.Get("tenant").(*sqlcv1.Tenant)
cron := ctx.Get("cron-workflow").(*sqlcv1.ListCronWorkflowsRow)
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
err := t.config.APIRepository.Workflow().UpdateCronWorkflow(
err := t.config.V1.WorkflowSchedules().UpdateCronWorkflow(
dbCtx,
sqlchelpers.UUIDToStr(cron.TenantId),
sqlchelpers.UUIDToStr(cron.CronId),
&repository.UpdateCronOpts{
&v1.UpdateCronOpts{
Enabled: request.Body.Enabled,
},
)
api/v1/server/handlers/workflows/update_scheduled.go
+6 -6
View File
@@ -9,19 +9,19 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.WorkflowScheduledUpdateRequestObject) (gen.WorkflowScheduledUpdateResponseObject, error) {
scheduled := ctx.Get("scheduled-workflow-run").(*dbsqlc.ListScheduledWorkflowsRow)
scheduled := ctx.Get("scheduled-workflow-run").(*sqlcv1.ListScheduledWorkflowsRow)
if request.Body == nil {
return gen.WorkflowScheduledUpdate400JSONResponse(apierrors.NewAPIErrors("Request body is required.")), nil
}
// Only allow updating scheduled runs created via API.
if scheduled.Method != dbsqlc.WorkflowTriggerScheduledRefMethodsAPI {
if scheduled.Method != sqlcv1.WorkflowTriggerScheduledRefMethodsAPI {
return gen.WorkflowScheduledUpdate403JSONResponse(apierrors.NewAPIErrors("Cannot update scheduled run created via code definition.")), nil
}
@@ -33,7 +33,7 @@ func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.
dbCtx, cancel := context.WithTimeout(ctx.Request().Context(), 30*time.Second)
defer cancel()
err := t.config.APIRepository.WorkflowRun().UpdateScheduledWorkflow(
err := t.config.V1.WorkflowSchedules().UpdateScheduledWorkflow(
dbCtx,
sqlchelpers.UUIDToStr(scheduled.TenantId),
request.ScheduledWorkflowRun.String(),
@@ -43,7 +43,7 @@ func (t *WorkflowService) WorkflowScheduledUpdate(ctx echo.Context, request gen.
return nil, err
}
updated, err := t.config.APIRepository.WorkflowRun().GetScheduledWorkflow(
updated, err := t.config.V1.WorkflowSchedules().GetScheduledWorkflow(
dbCtx,
sqlchelpers.UUIDToStr(scheduled.TenantId),
request.ScheduledWorkflowRun.String(),
api/v1/server/middleware/populator/populator.go
+2 -2
View File
@@ -11,7 +11,7 @@ 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/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/hatchet-dev/hatchet/pkg/telemetry"
"github.com/hatchet-dev/hatchet/pkg/telemetry/servertel"
)
@@ -111,7 +111,7 @@ func (p *Populator) populate(c echo.Context, r *middleware.RouteInfo) error {
ctx := c.Request().Context()
span := trace.SpanFromContext(ctx)
if tenant, ok := c.Get("tenant").(*dbsqlc.Tenant); ok && tenant != nil {
if tenant, ok := c.Get("tenant").(*sqlcv1.Tenant); ok && tenant != nil {
telemetry.WithAttributes(span, servertel.TenantId(tenant.ID))
} else if tenantId := c.Param("tenant"); tenantId != "" {
telemetry.WithAttributes(span, telemetry.AttributeKV{Key: "tenant.id", Value: tenantId})
api/v1/server/oas/transformers/api_token.go
+3 -3
View File
@@ -2,11 +2,11 @@ package transformers
import (
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func ToAPIToken(token *dbsqlc.APIToken) *gen.APIToken {
func ToAPIToken(token *sqlcv1.APIToken) *gen.APIToken {
res := &gen.APIToken{
Metadata: *toAPIMetadata(sqlchelpers.UUIDToStr(token.ID), token.CreatedAt.Time, token.UpdatedAt.Time),
}
api/v1/server/oas/transformers/event.go
+4 -4
View File
@@ -5,14 +5,14 @@ import (
"fmt"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/sqlchelpers"
"github.com/hatchet-dev/hatchet/pkg/repository/sqlchelpers"
v1 "github.com/hatchet-dev/hatchet/pkg/repository/v1"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
"github.com/jackc/pgx/v5/pgtype"
)
func ToEventList(events []*dbsqlc.Event) []gen.Event {
func ToEventList(events []*sqlcv1.Event) []gen.Event {
res := make([]gen.Event, len(events))
for i, event := range events {
@@ -22,7 +22,7 @@ func ToEventList(events []*dbsqlc.Event) []gen.Event {
return res
}
func ToEvent(event *dbsqlc.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),
Key: event.Key,
api/v1/server/oas/transformers/log.go
+2 -2
View File
@@ -4,10 +4,10 @@ import (
"encoding/json"
"github.com/hatchet-dev/hatchet/api/v1/server/oas/gen"
"github.com/hatchet-dev/hatchet/pkg/repository/postgres/dbsqlc"
"github.com/hatchet-dev/hatchet/pkg/repository/v1/sqlcv1"
)
func ToLogFromSQLC(log *dbsqlc.LogLine) *gen.LogLine {
func ToLogFromSQLC(log *sqlcv1.LogLine) *gen.LogLine {
res := &gen.LogLine{
CreatedAt: log.CreatedAt.Time,
Message: log.Message,

Some files were not shown because too many files have changed in this diff Show More