at least use contextx

Signed-off-by: Sarah Funkhouser <147884153+golanglemonade@users.noreply.github.com>

Author: golanglemonade

internal/ent/hooks/contextx/context.go

@@ -1,22 +1,28 @@
 package contextx
 
-import "context"
+import (
+	"context"
 
-// SkipCustomEnumDeleteKey is the context key used to skip the "in use" errors check during enum deletion.
-// This is used during organization cascade deletion where the deletion order is handled by EdgeCleanup.
-// else the custom deletion by default will check if the enum is being used by another other object.
-// But with this, we can just skip the check because when the org itself is deleted, it cascades to delete the
-// custom enums too
-type SkipCustomEnumDeleteKey string
-
-const (
-	// SkipCustomEnumInUseCheck is the context value that triggers skipping the "in use" check/error during enum deletion.
-	SkipCustomEnumInUseCheck SkipCustomEnumDeleteKey = "custom_enum_cascade_delete_operation"
+	utilsctx "github.com/theopenlane/utils/contextx"
 )
 
+// skipEnumInUseCheckKey skips the "in use" check during custom enum deletion.
+// This is used during organization cascade deletion where the deletion order is handled by
+// EdgeCleanup, the custom enum deletion would otherwise check whether the enum is still used by
+// another object. When the organization itself is deleted the cascade removes those objects too,
+// so the check has nothing useful to say
+var skipEnumInUseCheckKey = utilsctx.NewKey[bool]()
+
 // WithSkipEnumInUseCheck returns a new context with the skip flag set for custom enums deletion.
 // This should be used when deleting CustomTypeEnums as part of a cascade delete
-// where the deletion order is handled by EdgeCleanup.
+// where the deletion order is handled by EdgeCleanup
 func WithSkipEnumInUseCheck(ctx context.Context) context.Context {
-	return context.WithValue(ctx, SkipCustomEnumInUseCheck, true)
+	return skipEnumInUseCheckKey.Set(ctx, true)
+}
+
+// SkipEnumInUseCheckEnabled reports whether the custom enum "in use" check should be skipped
+func SkipEnumInUseCheckEnabled(ctx context.Context) bool {
+	skip, _ := skipEnumInUseCheckKey.Get(ctx)
+
+	return skip
 }

internal/ent/hooks/contextx/purgehistory.go

@@ -1,26 +1,24 @@
 package contextx
 
-import "context"
+import (
+	"context"
 
-// PurgeHistoryKey is the context key used to opt a cascade delete into purging the
-// history rows of every record it removes
-type PurgeHistoryKey string
-
-const (
-	// PurgeHistory is the context value that triggers the history purge during a cascade delete
-	PurgeHistory PurgeHistoryKey = "cascade_delete_purge_history"
+	utilsctx "github.com/theopenlane/utils/contextx"
 )
 
+// purgeHistoryKey marks a cascade delete as purging history rather than recording it
+var purgeHistoryKey = utilsctx.NewKey[bool]()
+
 // WithPurgeHistory returns a new context that opts the cascade delete into purging history rows.
 // EdgeCleanup deletes the history for each record it removes only when this is set, so callers that
 // want to keep the audit trail are unaffected
 func WithPurgeHistory(ctx context.Context) context.Context {
-	return context.WithValue(ctx, PurgeHistory, true)
+	return purgeHistoryKey.Set(ctx, true)
 }
 
 // PurgeHistoryEnabled reports whether the cascade delete should purge history rows
 func PurgeHistoryEnabled(ctx context.Context) bool {
-	purge, ok := ctx.Value(PurgeHistory).(bool)
+	purge, _ := purgeHistoryKey.Get(ctx)
 
-	return ok && purge
+	return purge
 }

internal/ent/hooks/contextx/tuplecleanup.go

@@ -1,25 +1,25 @@
 package contextx
 
-import "context"
+import (
+	"context"
 
-// TupleCleanupKey is the context key used to force relationship tuple cleanup on delete
-type TupleCleanupKey string
-
-const (
-	// TupleCleanup is the context value that forces tuple cleanup even for internal requests
-	TupleCleanup TupleCleanupKey = "cascade_delete_tuple_cleanup"
+	utilsctx "github.com/theopenlane/utils/contextx"
 )
 
+// tupleCleanupKey forces relationship tuple cleanup on delete even for internal requests
+var tupleCleanupKey = utilsctx.NewKey[bool]()
+
 // WithTupleCleanup returns a new context that forces the delete permissions hook to run even though
 // the request is an internal one. The organization cascade delete runs as an internal caller so it
-// can bypass privacy rules, but the records it removes still need their tuples cleaned out of FGA
+// can bypass privacy rules, but the records it removes still need their tuples cleaned out of FGA,
+// otherwise every cascaded object leaves its relationships behind pointing at rows that are gone
 func WithTupleCleanup(ctx context.Context) context.Context {
-	return context.WithValue(ctx, TupleCleanup, true)
+	return tupleCleanupKey.Set(ctx, true)
 }
 
 // TupleCleanupEnabled reports whether tuple cleanup should run despite an internal request
 func TupleCleanupEnabled(ctx context.Context) bool {
-	cleanup, ok := ctx.Value(TupleCleanup).(bool)
+	cleanup, _ := tupleCleanupKey.Get(ctx)
 
-	return ok && cleanup
+	return cleanup
 }

internal/ent/hooks/customenums.go

@@ -281,7 +281,7 @@ func HookCustomTypeEnumDelete() ent.Hook {
 
 			// skip the "in use" error/check when deleting via organization cascade
 			// the organization edge cleanup needs to cascade deletes
-			if ctx.Value(contextx.SkipCustomEnumInUseCheck) == true {
+			if contextx.SkipEnumInUseCheckEnabled(ctx) {
 				return next.Mutate(ctx, m)
 			}