package server import ( "encoding/json" "errors" "fmt" "net/http" "strconv" "strings" ) const maxJSONStructureItems = 200 type jsonStructureItem struct { Key string `json:"key"` Path string `json:"path"` Kind string `json:"kind"` Preview string `json:"preview,omitempty"` Expandable bool `json:"expandable"` } type jsonStructurePage struct { Path string `json:"path"` Kind string `json:"kind"` Items []jsonStructureItem `json:"items"` Offset int `json:"offset"` NextOffset int `json:"next_offset,omitempty"` Truncated bool `json:"truncated"` } func (s *Server) handleJSONStructure(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodGet { w.Header().Set("Allow", "GET") http.Error(w, "method not allowed", 405) return } address := strings.TrimPrefix(r.URL.Path, "/v/json/") if !strings.HasPrefix(address, "rev:") { http.Error(w, "JSON structure requires rev:", 400) return } revision, err := s.store.GetRevisionMetadata(strings.TrimPrefix(address, "rev:")) if err != nil || !s.store.ObjectBoundInDomain(s.domainUUIDForRequest(r), revision.ObjectUUID) { http.NotFound(w, r) return } authorized := false links, _ := s.store.ListPathLinksInDomain(s.domainUUIDForRequest(r), revision.ObjectUUID) for _, link := range links { if s.authorizePathRequest(r, "read", link.Path) == nil { authorized = true break } } if !authorized { http.NotFound(w, r) return } reader, err := s.store.OpenDocumentContext(r.Context(), revision.DocumentHash) if err != nil { http.NotFound(w, r) return } defer reader.Close() offset, _ := strconv.Atoi(r.URL.Query().Get("offset")) if offset < 0 { offset = 0 } limit, _ := strconv.Atoi(r.URL.Query().Get("limit")) if limit < 1 { limit = 100 } if limit > maxJSONStructureItems { limit = maxJSONStructureItems } pointer := r.URL.Query().Get("pointer") page, err := readJSONStructure(json.NewDecoder(reader), pointer, offset, limit) if err != nil { http.Error(w, err.Error(), 400) return } w.Header().Set("Content-Type", "application/json; charset=utf-8") w.Header().Set("Cache-Control", "private, max-age=31536000, immutable") w.Header().Set("ETag", `"json-`+revision.DocumentHash+`-`+strconv.Itoa(offset)+`"`) setDocumentIdentityHeaders(w.Header(), revision.ObjectUUID, revision.UUID, revision.DocumentHash) _ = json.NewEncoder(w).Encode(page) } func readJSONStructure(decoder *json.Decoder, pointer string, offset, limit int) (jsonStructurePage, error) { segments, err := parseJSONPointer(pointer) if err != nil { return jsonStructurePage{}, err } first, err := decoder.Token() if err != nil { return jsonStructurePage{}, err } return locateJSONValue(decoder, first, segments, pointer, offset, limit) } func locateJSONValue(decoder *json.Decoder, token json.Token, segments []string, pointer string, offset, limit int) (jsonStructurePage, error) { if len(segments) == 0 { return collectJSONChildren(decoder, token, pointer, offset, limit) } delim, ok := token.(json.Delim) if !ok { return jsonStructurePage{}, errors.New("JSON pointer targets a scalar") } switch delim { case '{': for decoder.More() { keyToken, err := decoder.Token() if err != nil { return jsonStructurePage{}, err } key := keyToken.(string) value, err := decoder.Token() if err != nil { return jsonStructurePage{}, err } if key == segments[0] { return locateJSONValue(decoder, value, segments[1:], pointer, offset, limit) } if err := skipJSONValue(decoder, value); err != nil { return jsonStructurePage{}, err } } case '[': wanted, err := strconv.Atoi(segments[0]) if err != nil || wanted < 0 { return jsonStructurePage{}, errors.New("invalid JSON array index") } index := 0 for decoder.More() { value, err := decoder.Token() if err != nil { return jsonStructurePage{}, err } if index == wanted { return locateJSONValue(decoder, value, segments[1:], pointer, offset, limit) } if err := skipJSONValue(decoder, value); err != nil { return jsonStructurePage{}, err } index++ } default: return jsonStructurePage{}, errors.New("invalid JSON container") } return jsonStructurePage{}, errors.New("JSON pointer not found") } func collectJSONChildren(decoder *json.Decoder, token json.Token, pointer string, offset, limit int) (jsonStructurePage, error) { delim, ok := token.(json.Delim) if !ok { return jsonStructurePage{Path: pointer, Kind: jsonTokenKind(token), Items: []jsonStructureItem{{Path: pointer, Kind: jsonTokenKind(token), Preview: jsonScalarPreview(token)}}}, nil } page := jsonStructurePage{Path: pointer, Items: []jsonStructureItem{}} index := 0 added := 0 switch delim { case '{': page.Kind = "object" for decoder.More() { keyToken, err := decoder.Token() if err != nil { return page, err } key := keyToken.(string) value, err := decoder.Token() if err != nil { return page, err } if index >= offset && added < limit { item, err := summarizeJSONValue(decoder, value, key, jsonPointerJoin(pointer, key)) if err != nil { return page, err } page.Items = append(page.Items, item) added++ } else if err := skipJSONValue(decoder, value); err != nil { return page, err } index++ } case '[': page.Kind = "array" for decoder.More() { value, err := decoder.Token() if err != nil { return page, err } key := strconv.Itoa(index) if index >= offset && added < limit { item, err := summarizeJSONValue(decoder, value, key, jsonPointerJoin(pointer, key)) if err != nil { return page, err } page.Items = append(page.Items, item) added++ } else if err := skipJSONValue(decoder, value); err != nil { return page, err } index++ } default: return page, errors.New("invalid JSON root") } page.Truncated = index > offset+added if page.Truncated { page.NextOffset = offset + added } return page, nil } func summarizeJSONValue(decoder *json.Decoder, token json.Token, key, path string) (jsonStructureItem, error) { kind := jsonTokenKind(token) item := jsonStructureItem{Key: key, Path: path, Kind: kind, Expandable: kind == "object" || kind == "array"} if item.Expandable { if err := skipJSONValue(decoder, token); err != nil { return item, err } } else { item.Preview = jsonScalarPreview(token) } return item, nil } func skipJSONValue(decoder *json.Decoder, token json.Token) error { delim, ok := token.(json.Delim) if !ok { return nil } if delim != '{' && delim != '[' { return nil } for decoder.More() { if delim == '{' { if _, err := decoder.Token(); err != nil { return err } } value, err := decoder.Token() if err != nil { return err } if err := skipJSONValue(decoder, value); err != nil { return err } } _, err := decoder.Token() return err } func jsonTokenKind(token json.Token) string { if delim, ok := token.(json.Delim); ok { if delim == '{' { return "object" } if delim == '[' { return "array" } } switch token.(type) { case nil: return "null" case bool: return "boolean" case json.Number, float64: return "number" default: return "string" } } func jsonScalarPreview(token json.Token) string { if token == nil { return "null" } value := fmt.Sprint(token) if len(value) > 240 { value = value[:240] + "…" } return value } func parseJSONPointer(pointer string) ([]string, error) { if pointer == "" { return nil, nil } if !strings.HasPrefix(pointer, "/") { return nil, errors.New("invalid JSON pointer") } parts := strings.Split(strings.TrimPrefix(pointer, "/"), "/") for i := range parts { parts[i] = strings.ReplaceAll(strings.ReplaceAll(parts[i], "~1", "/"), "~0", "~") } return parts, nil } func jsonPointerJoin(pointer, key string) string { return pointer + "/" + strings.ReplaceAll(strings.ReplaceAll(key, "~", "~0"), "/", "~1") }