Extract Grammaratur, Dregarnuhr, Geduldh, Mestionora, Ordoschnellic, Schutzaria, Kunstzeal and Seheweit behind compatible application contracts. Include accumulated editor resilience, navigation and theme UX, remote CLI, storage/schema and DR groundwork, tests and design/operations documentation. Verified: uncached full Go suite; go vet ./...; race tests for all eight components; 11 targeted Chromium tests; Node suites; 19 Python CLI tests; reproducible editor build. No push, release tag or deployment in this checkpoint.
299 lines
7.9 KiB
Go
299 lines
7.9 KiB
Go
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")
|
|
}
|