validate rules.json by json schema

Author: sestinj

cmd/publish.go

@@ -10,6 +10,7 @@ import (
 	"rules-cli/internal/auth"
 	"rules-cli/internal/registry"
 	"rules-cli/internal/ruleset"
+	"rules-cli/internal/validation"
 
 	"github.com/fatih/color"
 	"github.com/spf13/cobra"
@@ -40,12 +41,6 @@ Examples:
 
 // runPublishCommand implements the main logic for the publish command
 func runPublishCommand(cmd *cobra.Command, args []string) error {
-	// Ensure the user is authenticated
-	authenticated, err := auth.EnsureAuthenticated(true)
-	if err != nil || !authenticated {
-		return fmt.Errorf("authentication required to publish rules")
-	}
-
 	// Validate the visibility
 	if visibility != "public" && visibility != "private" {
 		return fmt.Errorf("visibility must be either 'public' or 'private'")
@@ -57,6 +52,28 @@ func runPublishCommand(cmd *cobra.Command, args []string) error {
 		rulesPath = args[0]
 	}
 
+	// Determine the rules.json file path
+	var rulesJSONPath string
+	if rulesPath != "" {
+		// If a path was specified, look for rules.json in that directory
+		stat, err := os.Stat(rulesPath)
+		if err == nil && stat.IsDir() {
+			rulesJSONPath = filepath.Join(rulesPath, "rules.json")
+		} else {
+			rulesJSONPath = rulesPath
+		}
+	} else {
+		// Look in current directory for rules.json
+		rulesJSONPath = "rules.json"
+	}
+
+	// Validate the rules.json file against the schema FIRST
+	color.Cyan("Validating rules.json against schema...")
+	if err := validation.ValidateRulesJSONFromFile(rulesJSONPath); err != nil {
+		return fmt.Errorf("schema validation failed: %w", err)
+	}
+	color.Green("✓ rules.json is valid")
+
 	// Load ruleset from the specified path or current directory
 	rs, err := ruleset.LoadRuleSetFromPath(rulesPath)
 	if err != nil {
@@ -68,6 +85,12 @@ func runPublishCommand(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("rules.json must have a 'name' field")
 	}
 
+	// NOW ensure the user is authenticated (after validation passes)
+	authenticated, err := auth.EnsureAuthenticated(true)
+	if err != nil || !authenticated {
+		return fmt.Errorf("authentication required to publish rules")
+	}
+
 	// Create registry client and get user info
 	authConfig := auth.LoadAuthConfig()
 	client := registry.NewClient(cfg.RegistryURL)
@@ -155,17 +178,17 @@ func isValidSlug(slug string) bool {
 	if slug == "" {
 		return false
 	}
-	
+
 	// Check if slug contains only valid characters
 	for _, char := range slug {
-		if !((char >= 'a' && char <= 'z') || 
-			 (char >= 'A' && char <= 'Z') || 
-			 (char >= '0' && char <= '9') || 
-			 char == '-' || char == '_') {
+		if !((char >= 'a' && char <= 'z') ||
+			(char >= 'A' && char <= 'Z') ||
+			(char >= '0' && char <= '9') ||
+			char == '-' || char == '_') {
 			return false
 		}
 	}
-	
+
 	return true
 }
 
@@ -174,4 +197,4 @@ func init() {
 
 	// Add flags
 	publishCmd.Flags().StringVar(&visibility, "visibility", "public", "Set the visibility of the rule to 'public' or 'private'")
-}
+}

internal/validation/schema.go

@@ -1,221 +1,69 @@
 package validation
 
 import (
-	_ "embed"
+	"embed"
 	"encoding/json"
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/xeipuuv/gojsonschema"
-	"gopkg.in/yaml.v3"
 )
 
-// RuleFrontmatterSchema contains the embedded JSON schema for rule frontmatter
-//
-//go:embed rule_frontmatter_schema.json
-var RuleFrontmatterSchema string
+//go:embed schema/rules-schema.json
+var schemaFS embed.FS
 
-// RuleFrontmatter represents the structure of rule frontmatter
-type RuleFrontmatter struct {
-	AlwaysApply bool     `yaml:"alwaysApply,omitempty" json:"alwaysApply,omitempty"`
-	Description string   `yaml:"description,omitempty" json:"description,omitempty"`
-	Globs       string   `yaml:"globs,omitempty" json:"globs,omitempty"`
-	Tags        []string `yaml:"tags,omitempty" json:"tags,omitempty"`
-}
-
-// ValidationError represents a validation error with context
-type ValidationError struct {
-	Field      string      `json:"field"`
-	Message    string      `json:"message"`
-	Value      interface{} `json:"value,omitempty"`
-	Type       string      `json:"type,omitempty"`
-	SchemaPath string      `json:"schemaPath,omitempty"`
-	Context    string      `json:"context,omitempty"`
-}
-
-// ValidationResult contains the validation results
-type ValidationResult struct {
-	Valid  bool              `json:"valid"`
-	Errors []ValidationError `json:"errors,omitempty"`
-}
-
-var (
-	// compiledSchema holds the compiled JSON schema for reuse
-	compiledSchema *gojsonschema.Schema
-)
-
-// init compiles the schema once at startup
-func init() {
-	schemaLoader := gojsonschema.NewStringLoader(RuleFrontmatterSchema)
-	schema, err := gojsonschema.NewSchema(schemaLoader)
-	if err != nil {
-		panic(fmt.Errorf("failed to compile frontmatter schema: %w", err))
-	}
-	compiledSchema = schema
-}
-
-// ValidateRuleFile validates a markdown rule file's frontmatter against the schema
-func ValidateRuleFile(filePath string) (*ValidationResult, error) {
-	// Read the file
-	content, err := os.ReadFile(filePath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to read file %s: %w", filePath, err)
-	}
-
-	// Parse frontmatter
-	frontmatter, err := extractFrontmatter(content)
+// ValidateRulesJSON validates a rules.json file against the JSON schema
+func ValidateRulesJSON(rulesData []byte) error {
+	// Load the schema from embedded file
+	schemaBytes, err := schemaFS.ReadFile("schema/rules-schema.json")
 	if err != nil {
-		return &ValidationResult{
-			Valid: false,
-			Errors: []ValidationError{
-				{
-					Field:   "frontmatter",
-					Message: fmt.Sprintf("Failed to parse frontmatter: %v", err),
-				},
-			},
-		}, nil
+		return fmt.Errorf("failed to load embedded schema: %w", err)
 	}
 
-	// If no frontmatter found, consider it valid (rules without frontmatter are allowed)
-	if frontmatter == nil {
-		return &ValidationResult{Valid: true}, nil
-	}
+	// Create schema loader
+	schemaLoader := gojsonschema.NewBytesLoader(schemaBytes)
 
-	return ValidateFrontmatter(frontmatter)
-}
+	// Create document loader with the rules data
+	documentLoader := gojsonschema.NewBytesLoader(rulesData)
 
-// ValidateFrontmatter validates frontmatter data against the JSON schema
-func ValidateFrontmatter(frontmatter map[string]interface{}) (*ValidationResult, error) {
-	// Create a document loader from the frontmatter data
-	documentLoader := gojsonschema.NewGoLoader(frontmatter)
-
-	// Validate against the compiled schema
-	result, err := compiledSchema.Validate(documentLoader)
+	// Validate
+	result, err := gojsonschema.Validate(schemaLoader, documentLoader)
 	if err != nil {
-		return nil, fmt.Errorf("validation failed: %w", err)
-	}
-
-	validationResult := &ValidationResult{
-		Valid:  result.Valid(),
-		Errors: make([]ValidationError, 0),
+		return fmt.Errorf("failed to validate JSON schema: %w", err)
 	}
 
-	// Convert validation errors to our format
 	if !result.Valid() {
-		for _, err := range result.Errors() {
-			validationErr := ValidationError{
-				Field:   extractFieldName(err.Field()),
-				Message: err.Description(),
-				Type:    err.Type(),
-				Context: err.Context().String(),
-				Value:   err.Value(),
-			}
-
-			// Safely extract schema path from details
-			if details := err.Details(); details != nil {
-				if property, ok := details["property"]; ok && property != nil {
-					validationErr.SchemaPath = fmt.Sprintf("%v", property)
-				}
+		var errorMsg string
+		for i, validationError := range result.Errors() {
+			if i > 0 {
+				errorMsg += "\n"
 			}
-
-			validationResult.Errors = append(validationResult.Errors, validationErr)
+			errorMsg += fmt.Sprintf("  - %s", validationError.String())
 		}
+		return fmt.Errorf("rules.json validation failed:\n%s", errorMsg)
 	}
 
-	return validationResult, nil
-}
-
-// extractFieldName cleans up the field name for better display
-func extractFieldName(field string) string {
-	// Remove (root). prefix and return clean field name
-	cleanField := strings.TrimPrefix(field, "(root).")
-	if cleanField == "(root)" {
-		return "root"
-	}
-	return cleanField
+	return nil
 }
 
-// extractFrontmatter extracts YAML frontmatter from markdown content
-func extractFrontmatter(content []byte) (map[string]interface{}, error) {
-	lines := string(content)
-
-	// Check if content starts with frontmatter delimiter
-	if len(lines) < 4 || lines[:4] != "---\n" {
-		return nil, nil // No frontmatter
-	}
-
-	// Find the end of frontmatter
-	endDelimiter := "\n---\n"
-	endIndex := strings.Index(lines[4:], endDelimiter)
-	if endIndex == -1 {
-		return nil, fmt.Errorf("unterminated frontmatter: missing closing ---")
-	}
-
-	// Extract frontmatter content
-	frontmatterContent := lines[4 : 4+endIndex]
-	if strings.TrimSpace(frontmatterContent) == "" {
-		return nil, nil // Empty frontmatter
-	}
-
-	// Parse YAML
-	var frontmatter map[string]interface{}
-	if err := yaml.Unmarshal([]byte(frontmatterContent), &frontmatter); err != nil {
-		return nil, fmt.Errorf("invalid YAML frontmatter: %w", err)
-	}
-
-	return frontmatter, nil
-}
-
-// GetSchema returns the JSON schema as a string for external use
-func GetSchema() string {
-	return RuleFrontmatterSchema
-}
-
-// ValidateJSON validates JSON data directly against the schema
-func ValidateJSON(data []byte) (*ValidationResult, error) {
-	var jsonData interface{}
-	if err := json.Unmarshal(data, &jsonData); err != nil {
-		return &ValidationResult{
-			Valid: false,
-			Errors: []ValidationError{
-				{
-					Field:   "json",
-					Message: fmt.Sprintf("Invalid JSON: %v", err),
-				},
-			},
-		}, nil
-	}
-
-	if jsonMap, ok := jsonData.(map[string]interface{}); ok {
-		return ValidateFrontmatter(jsonMap)
+// ValidateRulesJSONFromFile validates a rules.json file from disk
+func ValidateRulesJSONFromFile(filePath string) error {
+	// Read the file content
+	rulesData, err := os.ReadFile(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to read rules file: %w", err)
 	}
 
-	return &ValidationResult{
-		Valid: false,
-		Errors: []ValidationError{
-			{
-				Field:   "root",
-				Message: "JSON data must be an object",
-			},
-		},
-	}, nil
+	return ValidateRulesJSON(rulesData)
 }
 
-// ValidateYAML validates YAML data directly against the schema
-func ValidateYAML(data []byte) (*ValidationResult, error) {
-	var yamlData map[string]interface{}
-	if err := yaml.Unmarshal(data, &yamlData); err != nil {
-		return &ValidationResult{
-			Valid: false,
-			Errors: []ValidationError{
-				{
-					Field:   "yaml",
-					Message: fmt.Sprintf("Invalid YAML: %v", err),
-				},
-			},
-		}, nil
+// ValidateRulesObject validates a rules object directly
+func ValidateRulesObject(rules interface{}) error {
+	// Convert the rules object to JSON bytes
+	rulesBytes, err := json.Marshal(rules)
+	if err != nil {
+		return fmt.Errorf("failed to marshal rules object: %w", err)
 	}
 
-	return ValidateFrontmatter(yamlData)
+	return ValidateRulesJSON(rulesBytes)
 }