Unify inline and bound schema preparation

This commit is contained in:
2026-11-20 15:31:30 +00:00
parent be5a508554
commit 2d96dfa696
7 changed files with 223 additions and 389 deletions

View File

@@ -9,38 +9,21 @@ import (
"io"
"io/fs"
"net/url"
"os"
"path"
"path/filepath"
"runtime"
"strings"
"github.com/santhosh-tekuri/jsonschema/v6"
"go.maximumdirect.net/promptkit/internal/domain"
"go.maximumdirect.net/promptkit/internal/filecatalog"
)
const jsonSchemaDraft2020 = "https://json-schema.org/draft/2020-12/schema"
const schemaReadChunkSize = 64 * 1024
// StandardValidator provides basic, JSON, and JSON Schema output validation.
type StandardValidator struct {
schemaBaseDir string
}
// Validator prepares source-neutral output validation plans.
type Validator struct{}
type FSValidator struct {
fsys fs.FS
root string
}
func NewStandardValidator(schemaBaseDir string) *StandardValidator {
return &StandardValidator{schemaBaseDir: schemaBaseDir}
}
func NewFSValidator(fsys fs.FS, root string) *FSValidator {
return &FSValidator{fsys: fsys, root: root}
}
func NewValidator() *Validator { return &Validator{} }
type preparedValidation struct {
contract domain.OutputContract
@@ -56,43 +39,43 @@ func (p *preparedValidation) SchemaDocument() any {
return p.schemaDocument
}
func (v *StandardValidator) PrepareValidation(ctx context.Context, contract domain.OutputContract) (PreparedValidation, error) {
func (v *Validator) PrepareValidation(ctx context.Context, input Input) (PreparedValidation, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
contract := input.Contract
prepared := &preparedValidation{contract: contract}
if contract.ValidationMode != domain.ValidationJSONSchema {
return prepared, nil
}
name, err := v.resolveSchemaPath(ctx, contract.SchemaPath)
if err != nil {
return nil, err
document := contract.Schema
name := "inline schema"
resourceURL := "promptkit-schema:///inline.json"
if input.File != nil {
if input.File.FS == nil {
return nil, errors.New("schema filesystem is nil")
}
name = input.File.Path
resourceURL = fsSchemaResourceURL(name).String()
raw, err := readSchemaFile(ctx, func() (fs.File, error) { return input.File.FS.Open(name) })
if err != nil {
return nil, fmt.Errorf("failed to read schema file %q: %w", name, err)
}
document, err = decodeJSONValue(ctx, raw)
if err != nil {
return nil, fmt.Errorf("failed to decode JSON schema %q: %w", name, err)
}
}
document, err := loadJSONSchemaFile(ctx, name)
if err != nil {
return nil, fmt.Errorf("failed to compile JSON schema %q: %w", name, err)
if document == nil && input.File == nil {
return nil, errors.New("JSON schema document is missing")
}
schema, err := compileSchemaDocument(ctx, fileSchemaResourceURL(name).String(), document)
if err != nil {
return nil, fmt.Errorf("failed to compile JSON schema %q: %w", name, err)
if err := validateSchemaDialect(document); err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return nil, contextErr
}
return nil, fmt.Errorf("failed to decode JSON schema %q: %w", name, err)
}
prepared.schemaDocument, prepared.schema = document, schema
return prepared, nil
}
func (v *FSValidator) PrepareValidation(ctx context.Context, contract domain.OutputContract) (PreparedValidation, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
prepared := &preparedValidation{contract: contract}
if contract.ValidationMode != domain.ValidationJSONSchema {
return prepared, nil
}
name, document, err := v.loadSchemaDocument(ctx, contract.SchemaPath)
if err != nil {
return nil, err
}
schema, err := compileSchemaDocument(ctx, fsSchemaResourceURL(name).String(), document)
schema, err := compileSchemaDocument(ctx, resourceURL, document)
if err != nil {
return nil, fmt.Errorf("failed to compile JSON schema %q: %w", name, err)
}
@@ -185,7 +168,13 @@ func validateArtifact(ctx context.Context, artifact *domain.Artifact, contract d
// DecodeInlineSchema converts a caller-supplied value to an owned JSON document.
func DecodeInlineSchema(ctx context.Context, value any) (any, error) {
if err := ctx.Err(); err != nil {
return nil, err
}
encoded, err := json.Marshal(value)
if contextErr := ctx.Err(); contextErr != nil {
return nil, contextErr
}
if err != nil {
return nil, err
}
@@ -221,159 +210,6 @@ func decodeJSONValue(ctx context.Context, body []byte) (any, error) {
return nil, errors.New("multiple JSON values")
}
func (v *StandardValidator) resolveSchemaPath(ctx context.Context, schemaPath string) (string, error) {
if err := ctx.Err(); err != nil {
return "", err
}
if strings.TrimSpace(schemaPath) == "" {
return "", errors.New("schema path is required for json_schema validation")
}
root, err := v.schemaRoot()
if err != nil {
return "", err
}
if err := ctx.Err(); err != nil {
return "", err
}
resolved, err := containedFilesystemPath(root, schemaPath)
if err != nil {
return "", err
}
if err := ctx.Err(); err != nil {
return "", err
}
if _, err := os.Stat(resolved); err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return "", contextErr
}
return "", fmt.Errorf("failed to access schema file %q: %w", resolved, err)
}
if err := ctx.Err(); err != nil {
return "", err
}
return resolved, nil
}
func (v *StandardValidator) schemaRoot() (string, error) {
root := v.schemaBaseDir
if strings.TrimSpace(root) == "" {
root = "."
}
absolute, err := filepath.Abs(root)
if err != nil {
return "", fmt.Errorf("failed to resolve schema source %q: %w", root, err)
}
resolved, err := filepath.EvalSymlinks(absolute)
if err != nil {
return "", fmt.Errorf("failed to access schema source %q: %w", root, err)
}
return resolved, nil
}
func (v *FSValidator) loadSchemaDocument(ctx context.Context, schemaPath string) (string, any, error) {
resolved, err := v.resolveSchemaPath(ctx, schemaPath)
if err != nil {
return "", nil, err
}
raw, err := readSchemaFile(ctx, func() (fs.File, error) {
return v.fsys.Open(resolved)
})
if err != nil {
return "", nil, fmt.Errorf("failed to read schema file %q: %w", resolved, err)
}
doc, err := decodeJSONValue(ctx, raw)
if err != nil {
return "", nil, fmt.Errorf("failed to decode JSON schema %q: %w", resolved, err)
}
if err := validateSchemaDialect(doc); err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return "", nil, contextErr
}
return "", nil, fmt.Errorf("failed to decode JSON schema %q: %w", resolved, err)
}
if err := ctx.Err(); err != nil {
return "", nil, err
}
return resolved, doc, nil
}
func (v *FSValidator) resolveSchemaPath(ctx context.Context, schemaPath string) (string, error) {
if err := ctx.Err(); err != nil {
return "", err
}
if strings.TrimSpace(schemaPath) == "" {
return "", errors.New("schema path is required for json_schema validation")
}
if v.fsys == nil {
return "", errors.New("schema filesystem is nil")
}
cleanRoot := filecatalog.CleanFSRoot(v.root)
rootInfo, err := fs.Stat(v.fsys, cleanRoot)
if err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return "", contextErr
}
return "", fmt.Errorf("failed to access schema source %q: %w", cleanRoot, err)
}
if err := ctx.Err(); err != nil {
return "", err
}
var resolved string
if rootInfo.IsDir() {
resolvedPath, _, err := filecatalog.ResolveFSPath(cleanRoot, cleanRoot, schemaPath)
if err != nil {
return "", err
}
resolved = resolvedPath
} else {
cleanSchemaPath, err := cleanSchemaFSPath(schemaPath)
if err != nil {
return "", err
}
if cleanSchemaPath != strings.TrimSpace(path.Base(cleanRoot)) {
return "", fmt.Errorf("schema path %q does not match schema file %q", cleanSchemaPath, path.Base(cleanRoot))
}
resolved = cleanRoot
}
if _, err := fs.Stat(v.fsys, resolved); err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return "", contextErr
}
return "", fmt.Errorf("failed to access schema file %q: %w", resolved, err)
}
if err := ctx.Err(); err != nil {
return "", err
}
return resolved, nil
}
func cleanSchemaFSPath(schemaPath string) (string, error) {
cleaned := strings.TrimSpace(schemaPath)
if cleaned == "" {
return "", errors.New("schema path is required for json_schema validation")
}
cleaned = path.Clean(cleaned)
if path.IsAbs(cleaned) {
return "", fmt.Errorf("schema path %q must be relative", schemaPath)
}
return cleaned, nil
}
func fileSchemaResourceURL(schemaName string) *url.URL {
filePath := filepath.ToSlash(schemaName)
if runtime.GOOS == "windows" && !strings.HasPrefix(filePath, "/") {
filePath = "/" + filePath
}
return &url.URL{Scheme: "file", Path: filePath}
}
func fsSchemaResourceURL(schemaName string) *url.URL {
return &url.URL{
Scheme: "promptkit-schema",
@@ -475,52 +311,6 @@ func validateSchemaDialect(doc any) error {
return nil
}
func containedFilesystemPath(root, name string) (string, error) {
candidate := name
if !filepath.IsAbs(candidate) {
candidate = filepath.Join(root, candidate)
}
candidate, err := filepath.Abs(candidate)
if err != nil {
return "", fmt.Errorf("failed to resolve schema path %q: %w", name, err)
}
candidate, err = filepath.EvalSymlinks(candidate)
if err != nil {
return "", fmt.Errorf("failed to access schema file %q: %w", candidate, err)
}
relative, err := filepath.Rel(root, candidate)
if err != nil {
return "", fmt.Errorf("failed to compare schema path %q with source root: %w", candidate, err)
}
if relative == ".." || strings.HasPrefix(relative, ".."+string(filepath.Separator)) {
return "", fmt.Errorf("schema path %q escapes source root", name)
}
return candidate, nil
}
func loadJSONSchemaFile(ctx context.Context, name string) (any, error) {
raw, err := readSchemaFile(ctx, func() (fs.File, error) {
return os.Open(name)
})
if err != nil {
return nil, err
}
doc, err := decodeJSONValue(ctx, raw)
if err != nil {
return nil, err
}
if err := validateSchemaDialect(doc); err != nil {
if contextErr := ctx.Err(); contextErr != nil {
return nil, contextErr
}
return nil, err
}
if err := ctx.Err(); err != nil {
return nil, err
}
return doc, nil
}
func readSchemaFile(ctx context.Context, open func() (fs.File, error)) ([]byte, error) {
if err := ctx.Err(); err != nil {
return nil, err