chore: ctx refactor to keep up with main

Feyko · Feyko · commit 5537a1c3b4f6 · 2022-01-19T23:38:42.000+01:00
diff --git a/db/postgres/guide.go b/db/postgres/guide.go
@@ -49,10 +49,10 @@ func GetGuideByID(ctx context.Context, guideID string) *Guide {
 		return guide.(*Guide)
 	}
 
-	return GetGuideByIDNoCache(guideID, ctx)
+	return GetGuideByIDNoCache(ctx, guideID)
 }
 
-func GetGuideByIDNoCache(guideID string, ctx *context.Context) *Guide {
+func GetGuideByIDNoCache(ctx context.Context, guideID string) *Guide {
 	var guide Guide
 	DBCtx(ctx).Preload("Tags").Find(&guide, "id = ?", guideID)
 
@@ -159,39 +159,39 @@ func GetUserGuides(ctx context.Context, userID string) []Guide {
 	return guides
 }
 
-func ClearGuideTags(guideID string, ctx *context.Context) error {
+func ClearGuideTags(ctx context.Context, guideID string) error {
 	r := DBCtx(ctx).Where("guide_id = ?", guideID).Delete(&GuideTag{})
 	return r.Error
 }
 
-func SetGuideTags(guideID string, tagIDs []string, ctx *context.Context) error {
+func SetGuideTags(ctx context.Context, guideID string, tagIDs []string) error {
 	for _, tag := range tagIDs {
-		err := AddGuideTag(guideID, tag, ctx)
+		err := AddGuideTag(ctx, guideID, tag)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func ResetGuideTags(guideID string, tagIDs []string, ctx *context.Context) error {
-	err := ClearGuideTags(guideID, ctx)
+func ResetGuideTags(ctx context.Context, guideID string, tagIDs []string) error {
+	err := ClearGuideTags(ctx, guideID)
 	if err != nil {
 		return err
 	}
-	err = SetGuideTags(guideID, tagIDs, ctx)
+	err = SetGuideTags(ctx, guideID, tagIDs)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func AddGuideTag(guideID string, tagID string, ctx *context.Context) error {
+func AddGuideTag(ctx context.Context, guideID string, tagID string) error {
 	r := DBCtx(ctx).Create(&GuideTag{GuideID: guideID, TagID: tagID})
 	return r.Error
 }
 
-func RemoveGuideTag(guideID string, tagID string, ctx *context.Context) error {
+func RemoveGuideTag(ctx context.Context, guideID string, tagID string) error {
 	r := DBCtx(ctx).Delete(&GuideTag{GuideID: guideID, TagID: tagID})
 	return r.Error
 }
diff --git a/db/postgres/mod.go b/db/postgres/mod.go
@@ -21,10 +21,10 @@ func GetModByID(ctx context.Context, modID string) *Mod {
 		return mod.(*Mod)
 	}
 
-	return GetModByIDNoCache(modID, ctx)
+	return GetModByIDNoCache(ctx, modID)
 }
 
-func GetModByIDNoCache(modID string, ctx *context.Context) *Mod {
+func GetModByIDNoCache(ctx context.Context, modID string) *Mod {
 	var mod Mod
 	DBCtx(ctx).Preload("Tags").Find(&mod, "id = ?", modID)
 
@@ -286,34 +286,34 @@ func ClearModTags(modID string, ctx *context.Context) error {
 	return r.Error
 }
 
-func SetModTags(modID string, tagIDs []string, ctx *context.Context) error {
+func SetModTags(ctx context.Context, modID string, tagIDs []string) error {
 	for _, tag := range tagIDs {
-		err := AddModTag(modID, tag, ctx)
+		err := AddModTag(ctx, modID, tag)
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func ResetModTags(modID string, tagIDs []string, ctx *context.Context) error {
-	err := ClearModTags(modID, ctx)
+func ResetModTags(ctx context.Context, modID string, tagIDs []string) error {
+	err := ClearModTags(ctx, modID)
 	if err != nil {
 		return err
 	}
-	err = SetModTags(modID, tagIDs, ctx)
+	err = SetModTags(ctx, modID, tagIDs)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func AddModTag(modID string, tagID string, ctx *context.Context) error {
+func AddModTag(ctx context.Context, modID string, tagID string) error {
 	r := DBCtx(ctx).Create(&ModTag{ModID: modID, TagID: tagID})
 	return r.Error
 }
 
-func RemoveModTag(modID string, tagID string, ctx *context.Context) error {
+func RemoveModTag(ctx context.Context, modID string, tagID string) error {
 	r := DBCtx(ctx).Delete(&ModTag{ModID: modID, TagID: tagID})
 	return r.Error
 }
diff --git a/db/postgres/tags.go b/db/postgres/tags.go
@@ -32,13 +32,13 @@ func ValidateTagName(tag string) error {
 	return nil
 }
 
-func CreateTag(tag *Tag, ctx *context.Context, ratelimit bool) (*Tag, error) {
+func CreateTag(ctx context.Context, tag *Tag, ratelimit bool) (*Tag, error) {
 	err := ValidateTagName(tag.Name)
 	if err != nil {
 		return nil, err
 	}
 
-	if GetTagByName(tag.Name, ctx) != nil {
+	if GetTagByName(ctx, tag.Name) != nil {
 		return nil, fmt.Errorf("Tag %v already exists", tag.Name)
 	}
 
@@ -74,7 +74,7 @@ func CreateTag(tag *Tag, ctx *context.Context, ratelimit bool) (*Tag, error) {
 	return tag, nil
 }
 
-func GetTagByName(tagName string, ctx *context.Context) *Tag {
+func GetTagByName(ctx context.Context, tagName string) *Tag {
 	cacheKey := "GetTagByName_" + tagName
 
 	if tag, ok := dbCache.Get(cacheKey); ok {
@@ -93,7 +93,7 @@ func GetTagByName(tagName string, ctx *context.Context) *Tag {
 	return &tag
 }
 
-func GetTagByID(tagID string, ctx *context.Context) *Tag {
+func GetTagByID(ctx context.Context, tagID string) *Tag {
 	cacheKey := "GetTagById_" + tagID
 
 	if tag, ok := dbCache.Get(cacheKey); ok {
@@ -112,7 +112,7 @@ func GetTagByID(tagID string, ctx *context.Context) *Tag {
 	return &tag
 }
 
-func GetTags(ctx *context.Context, filter *generated.TagFilter) []Tag {
+func GetTags(ctx context.Context, filter *generated.TagFilter) []Tag {
 	cacheKey := ""
 	hash, err := hashstructure.Hash(filter, hashstructure.FormatV2, nil)
 	if err == nil {
diff --git a/gql/directive.go b/gql/directive.go
@@ -228,7 +228,7 @@ func canEditAnnouncements(ctx context.Context, obj interface{}, next graphql.Res
 func canManageTags(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) {
 	user := ctx.Value(postgres.UserKey{}).(*postgres.User)
 
-	if user.Has(auth.RoleManageTags, &ctx) {
+	if user.Has(ctx, auth.RoleManageTags) {
 		return next(ctx)
 	}
 
diff --git a/gql/resolver_guides.go b/gql/resolver_guides.go
@@ -41,14 +41,14 @@ func (r *mutationResolver) CreateGuide(ctx context.Context, guide generated.NewG
 		return nil, err
 	}
 
-	err = postgres.SetGuideTags(resultGuide.ID, guide.TagIDs, &newCtx)
+	err = postgres.SetGuideTags(newCtx, resultGuide.ID, guide.TagIDs)
 
 	if err != nil {
 		return nil, err
 	}
 
 	// Need to get the guide again to populate tags
-	return DBGuideToGenerated(postgres.GetGuideByIDNoCache(resultGuide.ID, &newCtx)), nil
+	return DBGuideToGenerated(postgres.GetGuideByIDNoCache(newCtx, resultGuide.ID)), nil
 }
 
 func (r *mutationResolver) UpdateGuide(ctx context.Context, guideID string, guide generated.UpdateGuide) (*generated.Guide, error) {
@@ -60,12 +60,12 @@ func (r *mutationResolver) UpdateGuide(ctx context.Context, guideID string, guid
 		return nil, errors.Wrap(err, "validation failed")
 	}
 
-	err := postgres.ResetGuideTags(guideID, guide.TagIDs, &newCtx)
+	err := postgres.ResetGuideTags(newCtx, guideID, guide.TagIDs)
 	if err != nil {
 		return nil, err
 	}
 
-	dbGuide := postgres.GetGuideByIDNoCache(guideID, &newCtx)
+	dbGuide := postgres.GetGuideByIDNoCache(newCtx, guideID)
 
 	if dbGuide == nil {
 		return nil, errors.New("guide not found")
diff --git a/gql/resolver_mods.go b/gql/resolver_mods.go
@@ -83,14 +83,14 @@ func (r *mutationResolver) CreateMod(ctx context.Context, mod generated.NewMod)
 		}
 	}
 
-	err = postgres.SetModTags(resultMod.ID, mod.TagIDs, &newCtx)
+	err = postgres.SetModTags(newCtx, resultMod.ID, mod.TagIDs)
 
 	if err != nil {
 		return nil, err
 	}
 
 	// Need to get the mod again to populate tags
-	return DBModToGenerated(postgres.GetModByIDNoCache(resultMod.ID, &newCtx)), nil
+	return DBModToGenerated(postgres.GetModByIDNoCache(newCtx, resultMod.ID)), nil
 }
 
 func (r *mutationResolver) UpdateMod(ctx context.Context, modID string, mod generated.UpdateMod) (*generated.Mod, error) {
@@ -102,13 +102,13 @@ func (r *mutationResolver) UpdateMod(ctx context.Context, modID string, mod gene
 		return nil, errors.Wrap(err, "validation failed")
 	}
 
-	err := postgres.ResetModTags(modID, mod.TagIDs, &newCtx)
+	err := postgres.ResetModTags(newCtx, modID, mod.TagIDs)
 
 	if err != nil {
 		return nil, err
 	}
 
-	dbMod := postgres.GetModByIDNoCache(modID, &newCtx)
+	dbMod := postgres.GetModByIDNoCache(newCtx, modID)
 
 	if dbMod == nil {
 		return nil, errors.New("mod not found")
diff --git a/gql/resolver_tags.go b/gql/resolver_tags.go
@@ -17,7 +17,7 @@ func (r *mutationResolver) CreateTag(ctx context.Context, tagName string) (*gene
 		Name: tagName,
 	}
 
-	resultTag, err := postgres.CreateTag(dbTag, &newCtx, true)
+	resultTag, err := postgres.CreateTag(newCtx, dbTag, true)
 	if err != nil {
 		return nil, err
 	}
@@ -35,7 +35,7 @@ func (r *mutationResolver) CreateMultipleTags(ctx context.Context, tagNames []st
 			Name: tagName,
 		}
 
-		resultTag, err := postgres.CreateTag(dbTag, &newCtx, false)
+		resultTag, err := postgres.CreateTag(newCtx, dbTag, false)
 		if err != nil {
 			return nil, err
 		}
@@ -50,13 +50,13 @@ func (r *mutationResolver) DeleteTag(ctx context.Context, id string) (bool, erro
 	wrapper, newCtx := WrapMutationTrace(ctx, "deleteTag")
 	defer wrapper.end()
 
-	dbTag := postgres.GetTagByID(id, &newCtx)
+	dbTag := postgres.GetTagByID(newCtx, id)
 
 	if dbTag == nil {
 		return false, errors.New("Tag not found")
 	}
 
-	postgres.Delete(&dbTag, &newCtx)
+	postgres.Delete(newCtx, &dbTag)
 
 	return true, nil
 }
@@ -65,7 +65,7 @@ func (r *mutationResolver) UpdateTag(ctx context.Context, id string, newName str
 	wrapper, newCtx := WrapMutationTrace(ctx, "updateTag")
 	defer wrapper.end()
 
-	dbTag := postgres.GetTagByID(id, &newCtx)
+	dbTag := postgres.GetTagByID(newCtx, id)
 
 	if dbTag == nil {
 		return nil, errors.New("Tag not found")
@@ -78,7 +78,7 @@ func (r *mutationResolver) UpdateTag(ctx context.Context, id string, newName str
 
 	SetStringINNOE(&newName, &dbTag.Name)
 
-	postgres.Save(&dbTag, &newCtx)
+	postgres.Save(newCtx, &dbTag)
 
 	return DBTagToGenerated(dbTag), nil
 }
@@ -87,7 +87,7 @@ func (r *queryResolver) GetTag(ctx context.Context, id string) (*generated.Tag,
 	wrapper, newCtx := WrapQueryTrace(ctx, "getTag_"+id)
 	defer wrapper.end()
 
-	tag := postgres.GetTagByID(id, &newCtx)
+	tag := postgres.GetTagByID(newCtx, id)
 
 	return DBTagToGenerated(tag), nil
 }
@@ -97,7 +97,7 @@ func (r *queryResolver) GetTags(ctx context.Context, filter *generated.TagFilter
 	defer wrapper.end()
 
 	insertFilterDefaults(filter)
-	tags := postgres.GetTags(&newCtx, filter)
+	tags := postgres.GetTags(newCtx, filter)
 
 	return DBTagsToGeneratedSlice(tags), nil
 }

Original file line number	Diff line number	Diff line change
`@@ -49,10 +49,10 @@ func GetGuideByID(ctx context.Context, guideID string) *Guide {`
`49`	`49`	`return guide.(*Guide)`
`50`	`50`	`}`
`51`	`51`
`52`		`- return GetGuideByIDNoCache(guideID, ctx)`
	`52`	`+ return GetGuideByIDNoCache(ctx, guideID)`
`53`	`53`	`}`
`54`	`54`
`55`		`-func GetGuideByIDNoCache(guideID string, ctx context.Context) Guide {`
	`55`	`+func GetGuideByIDNoCache(ctx context.Context, guideID string) *Guide {`
`56`	`56`	`var guide Guide`
`57`	`57`	`DBCtx(ctx).Preload("Tags").Find(&guide, "id = ?", guideID)`
`58`	`58`
`@@ -159,39 +159,39 @@ func GetUserGuides(ctx context.Context, userID string) []Guide {`
`159`	`159`	`return guides`
`160`	`160`	`}`
`161`	`161`
`162`		`-func ClearGuideTags(guideID string, ctx *context.Context) error {`
	`162`	`+func ClearGuideTags(ctx context.Context, guideID string) error {`
`163`	`163`	`r := DBCtx(ctx).Where("guide_id = ?", guideID).Delete(&GuideTag{})`
`164`	`164`	`return r.Error`
`165`	`165`	`}`
`166`	`166`
`167`		`-func SetGuideTags(guideID string, tagIDs []string, ctx *context.Context) error {`
	`167`	`+func SetGuideTags(ctx context.Context, guideID string, tagIDs []string) error {`
`168`	`168`	`for _, tag := range tagIDs {`
`169`		`- err := AddGuideTag(guideID, tag, ctx)`
	`169`	`+ err := AddGuideTag(ctx, guideID, tag)`
`170`	`170`	`if err != nil {`
`171`	`171`	`return err`
`172`	`172`	`}`
`173`	`173`	`}`
`174`	`174`	`return nil`
`175`	`175`	`}`
`176`	`176`
`177`		`-func ResetGuideTags(guideID string, tagIDs []string, ctx *context.Context) error {`
`178`		`- err := ClearGuideTags(guideID, ctx)`
	`177`	`+func ResetGuideTags(ctx context.Context, guideID string, tagIDs []string) error {`
	`178`	`+ err := ClearGuideTags(ctx, guideID)`
`179`	`179`	`if err != nil {`
`180`	`180`	`return err`
`181`	`181`	`}`
`182`		`- err = SetGuideTags(guideID, tagIDs, ctx)`
	`182`	`+ err = SetGuideTags(ctx, guideID, tagIDs)`
`183`	`183`	`if err != nil {`
`184`	`184`	`return err`
`185`	`185`	`}`
`186`	`186`	`return nil`
`187`	`187`	`}`
`188`	`188`
`189`		`-func AddGuideTag(guideID string, tagID string, ctx *context.Context) error {`
	`189`	`+func AddGuideTag(ctx context.Context, guideID string, tagID string) error {`
`190`	`190`	`r := DBCtx(ctx).Create(&GuideTag{GuideID: guideID, TagID: tagID})`
`191`	`191`	`return r.Error`
`192`	`192`	`}`
`193`	`193`
`194`		`-func RemoveGuideTag(guideID string, tagID string, ctx *context.Context) error {`
	`194`	`+func RemoveGuideTag(ctx context.Context, guideID string, tagID string) error {`
`195`	`195`	`r := DBCtx(ctx).Delete(&GuideTag{GuideID: guideID, TagID: tagID})`
`196`	`196`	`return r.Error`
`197`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,10 @@ func GetModByID(ctx context.Context, modID string) *Mod {`
`21`	`21`	`return mod.(*Mod)`
`22`	`22`	`}`
`23`	`23`
`24`		`- return GetModByIDNoCache(modID, ctx)`
	`24`	`+ return GetModByIDNoCache(ctx, modID)`
`25`	`25`	`}`
`26`	`26`
`27`		`-func GetModByIDNoCache(modID string, ctx context.Context) Mod {`
	`27`	`+func GetModByIDNoCache(ctx context.Context, modID string) *Mod {`
`28`	`28`	`var mod Mod`
`29`	`29`	`DBCtx(ctx).Preload("Tags").Find(&mod, "id = ?", modID)`
`30`	`30`
`@@ -286,34 +286,34 @@ func ClearModTags(modID string, ctx *context.Context) error {`
`286`	`286`	`return r.Error`
`287`	`287`	`}`
`288`	`288`
`289`		`-func SetModTags(modID string, tagIDs []string, ctx *context.Context) error {`
	`289`	`+func SetModTags(ctx context.Context, modID string, tagIDs []string) error {`
`290`	`290`	`for _, tag := range tagIDs {`
`291`		`- err := AddModTag(modID, tag, ctx)`
	`291`	`+ err := AddModTag(ctx, modID, tag)`
`292`	`292`	`if err != nil {`
`293`	`293`	`return err`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`	`return nil`
`297`	`297`	`}`
`298`	`298`
`299`		`-func ResetModTags(modID string, tagIDs []string, ctx *context.Context) error {`
`300`		`- err := ClearModTags(modID, ctx)`
	`299`	`+func ResetModTags(ctx context.Context, modID string, tagIDs []string) error {`
	`300`	`+ err := ClearModTags(ctx, modID)`
`301`	`301`	`if err != nil {`
`302`	`302`	`return err`
`303`	`303`	`}`
`304`		`- err = SetModTags(modID, tagIDs, ctx)`
	`304`	`+ err = SetModTags(ctx, modID, tagIDs)`
`305`	`305`	`if err != nil {`
`306`	`306`	`return err`
`307`	`307`	`}`
`308`	`308`	`return nil`
`309`	`309`	`}`
`310`	`310`
`311`		`-func AddModTag(modID string, tagID string, ctx *context.Context) error {`
	`311`	`+func AddModTag(ctx context.Context, modID string, tagID string) error {`
`312`	`312`	`r := DBCtx(ctx).Create(&ModTag{ModID: modID, TagID: tagID})`
`313`	`313`	`return r.Error`
`314`	`314`	`}`
`315`	`315`
`316`		`-func RemoveModTag(modID string, tagID string, ctx *context.Context) error {`
	`316`	`+func RemoveModTag(ctx context.Context, modID string, tagID string) error {`
`317`	`317`	`r := DBCtx(ctx).Delete(&ModTag{ModID: modID, TagID: tagID})`
`318`	`318`	`return r.Error`
`319`	`319`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,13 +32,13 @@ func ValidateTagName(tag string) error {`
`32`	`32`	`return nil`
`33`	`33`	`}`
`34`	`34`
`35`		`-func CreateTag(tag Tag, ctx context.Context, ratelimit bool) (*Tag, error) {`
	`35`	`+func CreateTag(ctx context.Context, tag Tag, ratelimit bool) (Tag, error) {`
`36`	`36`	`err := ValidateTagName(tag.Name)`
`37`	`37`	`if err != nil {`
`38`	`38`	`return nil, err`
`39`	`39`	`}`
`40`	`40`
`41`		`- if GetTagByName(tag.Name, ctx) != nil {`
	`41`	`+ if GetTagByName(ctx, tag.Name) != nil {`
`42`	`42`	`return nil, fmt.Errorf("Tag %v already exists", tag.Name)`
`43`	`43`	`}`
`44`	`44`
`@@ -74,7 +74,7 @@ func CreateTag(tag Tag, ctx context.Context, ratelimit bool) (*Tag, error) {`
`74`	`74`	`return tag, nil`
`75`	`75`	`}`
`76`	`76`
`77`		`-func GetTagByName(tagName string, ctx context.Context) Tag {`
	`77`	`+func GetTagByName(ctx context.Context, tagName string) *Tag {`
`78`	`78`	`cacheKey := "GetTagByName_" + tagName`
`79`	`79`
`80`	`80`	`if tag, ok := dbCache.Get(cacheKey); ok {`
`@@ -93,7 +93,7 @@ func GetTagByName(tagName string, ctx context.Context) Tag {`
`93`	`93`	`return &tag`
`94`	`94`	`}`
`95`	`95`
`96`		`-func GetTagByID(tagID string, ctx context.Context) Tag {`
	`96`	`+func GetTagByID(ctx context.Context, tagID string) *Tag {`
`97`	`97`	`cacheKey := "GetTagById_" + tagID`
`98`	`98`
`99`	`99`	`if tag, ok := dbCache.Get(cacheKey); ok {`
`@@ -112,7 +112,7 @@ func GetTagByID(tagID string, ctx context.Context) Tag {`
`112`	`112`	`return &tag`
`113`	`113`	`}`
`114`	`114`
`115`		`-func GetTags(ctx context.Context, filter generated.TagFilter) []Tag {`
	`115`	`+func GetTags(ctx context.Context, filter *generated.TagFilter) []Tag {`
`116`	`116`	`cacheKey := ""`
`117`	`117`	`hash, err := hashstructure.Hash(filter, hashstructure.FormatV2, nil)`
`118`	`118`	`if err == nil {`
Original file line number	Diff line number	Diff line change
`@@ -228,7 +228,7 @@ func canEditAnnouncements(ctx context.Context, obj interface{}, next graphql.Res`
`228`	`228`	`func canManageTags(ctx context.Context, obj interface{}, next graphql.Resolver) (res interface{}, err error) {`
`229`	`229`	`user := ctx.Value(postgres.UserKey{}).(*postgres.User)`
`230`	`230`
`231`		`- if user.Has(auth.RoleManageTags, &ctx) {`
	`231`	`+ if user.Has(ctx, auth.RoleManageTags) {`
`232`	`232`	`return next(ctx)`
`233`	`233`	`}`
`234`	`234`
Original file line number	Diff line number	Diff line change
`@@ -41,14 +41,14 @@ func (r *mutationResolver) CreateGuide(ctx context.Context, guide generated.NewG`
`41`	`41`	`return nil, err`
`42`	`42`	`}`
`43`	`43`
`44`		`- err = postgres.SetGuideTags(resultGuide.ID, guide.TagIDs, &newCtx)`
	`44`	`+ err = postgres.SetGuideTags(newCtx, resultGuide.ID, guide.TagIDs)`
`45`	`45`
`46`	`46`	`if err != nil {`
`47`	`47`	`return nil, err`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`// Need to get the guide again to populate tags`
`51`		`- return DBGuideToGenerated(postgres.GetGuideByIDNoCache(resultGuide.ID, &newCtx)), nil`
	`51`	`+ return DBGuideToGenerated(postgres.GetGuideByIDNoCache(newCtx, resultGuide.ID)), nil`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`func (r mutationResolver) UpdateGuide(ctx context.Context, guideID string, guide generated.UpdateGuide) (generated.Guide, error) {`
`@@ -60,12 +60,12 @@ func (r *mutationResolver) UpdateGuide(ctx context.Context, guideID string, guid`
`60`	`60`	`return nil, errors.Wrap(err, "validation failed")`
`61`	`61`	`}`
`62`	`62`
`63`		`- err := postgres.ResetGuideTags(guideID, guide.TagIDs, &newCtx)`
	`63`	`+ err := postgres.ResetGuideTags(newCtx, guideID, guide.TagIDs)`
`64`	`64`	`if err != nil {`
`65`	`65`	`return nil, err`
`66`	`66`	`}`
`67`	`67`
`68`		`- dbGuide := postgres.GetGuideByIDNoCache(guideID, &newCtx)`
	`68`	`+ dbGuide := postgres.GetGuideByIDNoCache(newCtx, guideID)`
`69`	`69`
`70`	`70`	`if dbGuide == nil {`
`71`	`71`	`return nil, errors.New("guide not found")`
Original file line number	Diff line number	Diff line change
`@@ -83,14 +83,14 @@ func (r *mutationResolver) CreateMod(ctx context.Context, mod generated.NewMod)`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`- err = postgres.SetModTags(resultMod.ID, mod.TagIDs, &newCtx)`
	`86`	`+ err = postgres.SetModTags(newCtx, resultMod.ID, mod.TagIDs)`
`87`	`87`
`88`	`88`	`if err != nil {`
`89`	`89`	`return nil, err`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`// Need to get the mod again to populate tags`
`93`		`- return DBModToGenerated(postgres.GetModByIDNoCache(resultMod.ID, &newCtx)), nil`
	`93`	`+ return DBModToGenerated(postgres.GetModByIDNoCache(newCtx, resultMod.ID)), nil`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`func (r mutationResolver) UpdateMod(ctx context.Context, modID string, mod generated.UpdateMod) (generated.Mod, error) {`
`@@ -102,13 +102,13 @@ func (r *mutationResolver) UpdateMod(ctx context.Context, modID string, mod gene`
`102`	`102`	`return nil, errors.Wrap(err, "validation failed")`
`103`	`103`	`}`
`104`	`104`
`105`		`- err := postgres.ResetModTags(modID, mod.TagIDs, &newCtx)`
	`105`	`+ err := postgres.ResetModTags(newCtx, modID, mod.TagIDs)`
`106`	`106`
`107`	`107`	`if err != nil {`
`108`	`108`	`return nil, err`
`109`	`109`	`}`
`110`	`110`
`111`		`- dbMod := postgres.GetModByIDNoCache(modID, &newCtx)`
	`111`	`+ dbMod := postgres.GetModByIDNoCache(newCtx, modID)`
`112`	`112`
`113`	`113`	`if dbMod == nil {`
`114`	`114`	`return nil, errors.New("mod not found")`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ func (r mutationResolver) CreateTag(ctx context.Context, tagName string) (gene`
`17`	`17`	`Name: tagName,`
`18`	`18`	`}`
`19`	`19`
`20`		`- resultTag, err := postgres.CreateTag(dbTag, &newCtx, true)`
	`20`	`+ resultTag, err := postgres.CreateTag(newCtx, dbTag, true)`
`21`	`21`	`if err != nil {`
`22`	`22`	`return nil, err`
`23`	`23`	`}`
`@@ -35,7 +35,7 @@ func (r *mutationResolver) CreateMultipleTags(ctx context.Context, tagNames []st`
`35`	`35`	`Name: tagName,`
`36`	`36`	`}`
`37`	`37`
`38`		`- resultTag, err := postgres.CreateTag(dbTag, &newCtx, false)`
	`38`	`+ resultTag, err := postgres.CreateTag(newCtx, dbTag, false)`
`39`	`39`	`if err != nil {`
`40`	`40`	`return nil, err`
`41`	`41`	`}`
`@@ -50,13 +50,13 @@ func (r *mutationResolver) DeleteTag(ctx context.Context, id string) (bool, erro`
`50`	`50`	`wrapper, newCtx := WrapMutationTrace(ctx, "deleteTag")`
`51`	`51`	`defer wrapper.end()`
`52`	`52`
`53`		`- dbTag := postgres.GetTagByID(id, &newCtx)`
	`53`	`+ dbTag := postgres.GetTagByID(newCtx, id)`
`54`	`54`
`55`	`55`	`if dbTag == nil {`
`56`	`56`	`return false, errors.New("Tag not found")`
`57`	`57`	`}`
`58`	`58`
`59`		`- postgres.Delete(&dbTag, &newCtx)`
	`59`	`+ postgres.Delete(newCtx, &dbTag)`
`60`	`60`
`61`	`61`	`return true, nil`
`62`	`62`	`}`
`@@ -65,7 +65,7 @@ func (r *mutationResolver) UpdateTag(ctx context.Context, id string, newName str`
`65`	`65`	`wrapper, newCtx := WrapMutationTrace(ctx, "updateTag")`
`66`	`66`	`defer wrapper.end()`
`67`	`67`
`68`		`- dbTag := postgres.GetTagByID(id, &newCtx)`
	`68`	`+ dbTag := postgres.GetTagByID(newCtx, id)`
`69`	`69`
`70`	`70`	`if dbTag == nil {`
`71`	`71`	`return nil, errors.New("Tag not found")`
`@@ -78,7 +78,7 @@ func (r *mutationResolver) UpdateTag(ctx context.Context, id string, newName str`
`78`	`78`
`79`	`79`	`SetStringINNOE(&newName, &dbTag.Name)`
`80`	`80`
`81`		`- postgres.Save(&dbTag, &newCtx)`
	`81`	`+ postgres.Save(newCtx, &dbTag)`
`82`	`82`
`83`	`83`	`return DBTagToGenerated(dbTag), nil`
`84`	`84`	`}`
`@@ -87,7 +87,7 @@ func (r queryResolver) GetTag(ctx context.Context, id string) (generated.Tag,`
`87`	`87`	`wrapper, newCtx := WrapQueryTrace(ctx, "getTag_"+id)`
`88`	`88`	`defer wrapper.end()`
`89`	`89`
`90`		`- tag := postgres.GetTagByID(id, &newCtx)`
	`90`	`+ tag := postgres.GetTagByID(newCtx, id)`
`91`	`91`
`92`	`92`	`return DBTagToGenerated(tag), nil`
`93`	`93`	`}`
`@@ -97,7 +97,7 @@ func (r queryResolver) GetTags(ctx context.Context, filter generated.TagFilter`
`97`	`97`	`defer wrapper.end()`
`98`	`98`
`99`	`99`	`insertFilterDefaults(filter)`
`100`		`- tags := postgres.GetTags(&newCtx, filter)`
	`100`	`+ tags := postgres.GetTags(newCtx, filter)`
`101`	`101`
`102`	`102`	`return DBTagsToGeneratedSlice(tags), nil`
`103`	`103`	`}`