functional, caching dynamic graphql server

Author: grokspawn

internal/catalogd/graphql/graphql.go

@@ -53,17 +53,44 @@ func remapFieldName(name string) string {
 	re := regexp.MustCompile(`[^a-zA-Z0-9_]`)
 	clean := re.ReplaceAllString(name, "_")
 
+	// Collapse multiple consecutive underscores
+	clean = regexp.MustCompile(`_+`).ReplaceAllString(clean, "_")
+
+	// Trim leading underscores only (keep trailing to detect them)
+	clean = strings.TrimLeft(clean, "_")
+
 	// Split on underscores and camelCase
 	parts := strings.Split(clean, "_")
 	result := ""
+	hasContent := false
 	for i, part := range parts {
 		if part == "" {
+			// If we have an empty part after having content, it means there was a trailing separator
+			// Add a capitalized version of the last word
+			if hasContent && i == len(parts)-1 {
+				// Get the base word (first non-empty part)
+				for _, p := range parts {
+					if p != "" {
+						result += strings.ToUpper(string(p[0])) + strings.ToLower(p[1:])
+						break
+					}
+				}
+			}
 			continue
 		}
-		if i == 0 {
-			result = strings.ToLower(part)
+		hasContent = true
+		if i == 0 || result == "" {
+			// For the first part, check if it's all uppercase
+			if strings.ToUpper(part) == part {
+				// If all uppercase, convert entirely to lowercase
+				result = strings.ToLower(part)
+			} else {
+				// Otherwise, make only the first character lowercase
+				result = strings.ToLower(string(part[0])) + part[1:]
+			}
 		} else {
-			result += strings.Title(strings.ToLower(part))
+			// For subsequent parts, capitalize first letter, lowercase rest
+			result += strings.ToUpper(string(part[0])) + strings.ToLower(part[1:])
 		}
 	}
 
@@ -330,7 +357,7 @@ func buildGraphQLObjectType(schemaName string, info *SchemaInfo) *graphql.Object
 	}
 
 	return graphql.NewObject(graphql.ObjectConfig{
-		Name:   strings.Title(strings.ToLower(schemaName)),
+		Name:   sanitizeTypeName(schemaName),
 		Fields: fields,
 	})
 }
@@ -414,12 +441,16 @@ func sanitizeTypeName(propType string) string {
 	// Remove dots and other invalid characters, capitalize words
 	re := regexp.MustCompile(`[^a-zA-Z0-9]`)
 	clean := re.ReplaceAllString(propType, "_")
+
+	// Strip leading digits
+	clean = regexp.MustCompile(`^[0-9]+`).ReplaceAllString(clean, "")
+
 	parts := strings.Split(clean, "_")
 
 	result := ""
 	for _, part := range parts {
 		if part != "" {
-			result += strings.Title(strings.ToLower(part))
+			result += strings.ToUpper(string(part[0])) + strings.ToLower(part[1:])
 		}
 	}
 
@@ -443,7 +474,9 @@ func BuildDynamicGraphQLSchema(catalogSchema *CatalogSchema, metasBySchema map[s
 	queryFields := graphql.Fields{}
 
 	for schemaName, objectType := range objectTypes {
-		fieldName := strings.ToLower(schemaName) + "s" // e.g., "bundles", "packages"
+		// Sanitize schema name by removing dots and special characters for GraphQL field name
+		sanitized := regexp.MustCompile(`[^a-zA-Z0-9]`).ReplaceAllString(schemaName, "")
+		fieldName := strings.ToLower(sanitized) + "s" // e.g., "olmbundles", "olmpackages"
 
 		queryFields[fieldName] = &graphql.Field{
 			Type: graphql.NewList(objectType),
@@ -463,7 +496,8 @@ func BuildDynamicGraphQLSchema(catalogSchema *CatalogSchema, metasBySchema map[s
 				// Get the schema name from the field name
 				currentSchemaName := ""
 				for sn := range catalogSchema.Schemas {
-					if strings.ToLower(sn)+"s" == p.Info.FieldName {
+					sanitized := regexp.MustCompile(`[^a-zA-Z0-9]`).ReplaceAllString(sn, "")
+					if strings.ToLower(sanitized)+"s" == p.Info.FieldName {
 						currentSchemaName = sn
 						break
 					}

internal/catalogd/storage/localdir.go

@@ -41,6 +41,11 @@ type LocalDirV1 struct {
 	// the loaded index. This avoids lots of unnecessary open/decode/close cycles when concurrent
 	// requests are being handled, which improves overall performance and decreases response latency.
 	sf singleflight.Group
+
+	// GraphQL schema cache: maps catalog name to its dynamically generated schema
+	// This cache is invalidated when a catalog is updated via Store()
+	schemaCacheMux sync.RWMutex
+	schemaCache    map[string]*gql.DynamicSchema
 }
 
 var (
@@ -103,10 +108,20 @@ func (s *LocalDirV1) Store(ctx context.Context, catalog string, fsys fs.FS) erro
 	}
 
 	catalogDir := s.catalogDir(catalog)
-	return errors.Join(
+	err = errors.Join(
 		os.RemoveAll(catalogDir),
 		os.Rename(tmpCatalogDir, catalogDir),
 	)
+	if err != nil {
+		return err
+	}
+
+	// Invalidate GraphQL schema cache for this catalog
+	s.schemaCacheMux.Lock()
+	delete(s.schemaCache, catalog)
+	s.schemaCacheMux.Unlock()
+
+	return nil
 }
 
 func (s *LocalDirV1) Delete(catalog string) error {
@@ -313,7 +328,7 @@ func (s *LocalDirV1) handleV1GraphQL(w http.ResponseWriter, r *http.Request) {
 	}
 
 	// Build dynamic GraphQL schema for this catalog
-	dynamicSchema, err := s.buildCatalogGraphQLSchema(catalogFS)
+	dynamicSchema, err := s.buildCatalogGraphQLSchema(catalog, catalogFS)
 	if err != nil {
 		httpError(w, err)
 		return
@@ -356,6 +371,8 @@ func httpError(w http.ResponseWriter, err error) {
 	default:
 		code = http.StatusInternalServerError
 	}
+	// Log the actual error for debugging
+	fmt.Printf("HTTP Error %d: %v\n", code, err)
 	http.Error(w, fmt.Sprintf("%d %s", code, http.StatusText(code)), code)
 }
 
@@ -399,7 +416,17 @@ func (s *LocalDirV1) createCatalogFS(catalog string) (fs.FS, error) {
 }
 
 // buildCatalogGraphQLSchema builds a dynamic GraphQL schema for the given catalog
-func (s *LocalDirV1) buildCatalogGraphQLSchema(catalogFS fs.FS) (*gql.DynamicSchema, error) {
+// Uses a cache to avoid rebuilding the schema on every request
+func (s *LocalDirV1) buildCatalogGraphQLSchema(catalog string, catalogFS fs.FS) (*gql.DynamicSchema, error) {
+	// Check cache first (read lock)
+	s.schemaCacheMux.RLock()
+	if cachedSchema, ok := s.schemaCache[catalog]; ok {
+		s.schemaCacheMux.RUnlock()
+		return cachedSchema, nil
+	}
+	s.schemaCacheMux.RUnlock()
+
+	// Schema not in cache, build it
 	var metas []*declcfg.Meta
 
 	// Collect all metas from the catalog filesystem
@@ -436,5 +463,13 @@ func (s *LocalDirV1) buildCatalogGraphQLSchema(catalogFS fs.FS) (*gql.DynamicSch
 		return nil, fmt.Errorf("error building GraphQL schema: %w", err)
 	}
 
+	// Cache the result (write lock)
+	s.schemaCacheMux.Lock()
+	if s.schemaCache == nil {
+		s.schemaCache = make(map[string]*gql.DynamicSchema)
+	}
+	s.schemaCache[catalog] = dynamicSchema
+	s.schemaCacheMux.Unlock()
+
 	return dynamicSchema, nil
 }