fix: cache invalidation on delete and not-found errors for deletes

- Invalidate ristretto cache entries when schemas/versions are deleted,
  preventing stale data from being served after recreation (#180)
- Return not-found error when deleting non-existent namespaces,
  schemas, or versions by checking RowsAffected (#145)
- Add Del method to Cache interface for cache invalidation

Fixes #180
Fixes #145

Author: ravisuhag

core/schema/mocks/schema_cache.go

@@ -55,6 +55,7 @@ type Provider interface {
 type Cache interface {
 	Get(interface{}) (interface{}, bool)
 	Set(interface{}, interface{}, int64) bool
+	Del(interface{})
 }
 
 // Schema represents a schema entity with its configuration.

core/schema/schema.go

@@ -122,14 +122,25 @@ func (s *Service) Get(ctx context.Context, namespace string, schemaName string,
 	return s.withMetadata(ctx, namespace, schemaName, func() ([]byte, error) { return s.cachedGetSchema(ctx, namespace, schemaName, version) })
 }
 
-// Delete removes a schema and all its versions.
+// Delete removes a schema and all its versions, and invalidates cached entries.
 func (s *Service) Delete(ctx context.Context, namespace string, schemaName string) error {
-	return s.repo.Delete(ctx, namespace, schemaName)
+	versions, _ := s.repo.ListVersions(ctx, namespace, schemaName)
+	err := s.repo.Delete(ctx, namespace, schemaName)
+	if err == nil {
+		for _, v := range versions {
+			s.cache.Del(schemaKeyFunc(namespace, schemaName, v))
+		}
+	}
+	return err
 }
 
-// DeleteVersion removes a specific version of a schema.
+// DeleteVersion removes a specific version of a schema and invalidates the cached entry.
 func (s *Service) DeleteVersion(ctx context.Context, namespace string, schemaName string, version int32) error {
-	return s.repo.DeleteVersion(ctx, namespace, schemaName, version)
+	err := s.repo.DeleteVersion(ctx, namespace, schemaName, version)
+	if err == nil {
+		s.cache.Del(schemaKeyFunc(namespace, schemaName, version))
+	}
+	return err
 }
 
 // GetLatest retrieves the latest version of a schema.

core/schema/service.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/georgysavva/scany/pgxscan"
 	"github.com/raystack/stencil/core/namespace"
+	"github.com/raystack/stencil/internal/store"
 )
 
 const namespaceListQuery = `
@@ -60,11 +61,17 @@ func (r *NamespaceRepository) Get(ctx context.Context, id string) (namespace.Nam
 }
 
 func (r *NamespaceRepository) Delete(ctx context.Context, id string) error {
-	_, err := r.db.Exec(ctx, namespaceDeleteQuery, id)
+	ct, err := r.db.Exec(ctx, namespaceDeleteQuery, id)
+	if err != nil {
+		return wrapError(err, "%s", id)
+	}
+	if ct.RowsAffected() == 0 {
+		return store.NoRowsErr.WithErr(nil, id)
+	}
 	if _, execErr := r.db.Exec(ctx, deleteOrphanedData); execErr != nil {
 		return wrapError(execErr, "%s", id)
 	}
-	return wrapError(err, "%s", id)
+	return nil
 }
 
 func (r *NamespaceRepository) List(ctx context.Context) ([]namespace.Namespace, error) {

internal/store/postgres/namespace_repository.go

@@ -7,6 +7,7 @@ import (
 	"github.com/jackc/pgx/v4"
 	"github.com/pkg/errors"
 	"github.com/raystack/stencil/core/schema"
+	"github.com/raystack/stencil/internal/store"
 )
 
 type SchemaRepository struct {
@@ -84,12 +85,18 @@ func (r *SchemaRepository) List(ctx context.Context, namespaceID string) ([]sche
 }
 
 func (r *SchemaRepository) Delete(ctx context.Context, ns string, sc string) error {
-	_, err := r.db.Exec(ctx, deleteSchemaQuery, ns, sc)
+	ct, err := r.db.Exec(ctx, deleteSchemaQuery, ns, sc)
+	if err != nil {
+		return wrapError(err, "delete schema")
+	}
+	if ct.RowsAffected() == 0 {
+		return store.NoRowsErr.WithErr(nil, "schema")
+	}
 	// Idempotent operation to clean orphaned data.
 	if _, execErr := r.db.Exec(ctx, deleteOrphanedData); execErr != nil {
 		return wrapError(execErr, "delete schema")
 	}
-	return wrapError(err, "delete schema")
+	return nil
 }
 
 func (r *SchemaRepository) ListVersions(ctx context.Context, ns string, sc string) ([]int32, error) {
@@ -99,12 +106,18 @@ func (r *SchemaRepository) ListVersions(ctx context.Context, ns string, sc strin
 }
 
 func (r *SchemaRepository) DeleteVersion(ctx context.Context, ns string, sc string, version int32) error {
-	_, err := r.db.Exec(ctx, deleteVersionQuery, ns, sc, version)
+	ct, err := r.db.Exec(ctx, deleteVersionQuery, ns, sc, version)
+	if err != nil {
+		return wrapError(err, "delete version")
+	}
+	if ct.RowsAffected() == 0 {
+		return store.NoRowsErr.WithErr(nil, "version")
+	}
 	// Idempotent operation to clean orphaned data.
 	if _, execErr := r.db.Exec(ctx, deleteOrphanedData); execErr != nil {
 		return wrapError(execErr, "delete version")
 	}
-	return wrapError(err, "delete version")
+	return nil
 }
 
 const schemaInsertQuery = `