From 58bc285748b7540a9238361d04638c21461c90cf Mon Sep 17 00:00:00 2001 From: MangoPig Date: Mon, 6 Jul 2026 13:06:32 +0100 Subject: [PATCH] Refactor: migrate POSIX scaffolding to CBOR and JSONC --- Backend/go.mod | 3 + Backend/go.sum | 8 + .../bootstrap/project_disk_bootstrap.go | 117 ++++++-- .../bootstrap/project_disk_folders.go | 20 +- .../bootstrap/project_disk_helpers.go | 103 ++++++- .../internal/bootstrap/project_disk_items.go | 18 +- Backend/internal/bootstrap/project_order.go | 274 +++++++++++++----- Backend/internal/bootstrap/project_queries.go | 13 +- Backend/internal/bootstrap/service_test.go | 126 +++++--- .../internal/posixproj/projector_classify.go | 108 +++++-- Backend/internal/posixproj/projector_scan.go | 104 ++++++- Backend/internal/posixproj/projector_test.go | 150 +++++++--- Documentation/POSIX-Structure.md | 78 ++--- Documentation/TODO.md | 6 +- 14 files changed, 860 insertions(+), 268 deletions(-) diff --git a/Backend/go.mod b/Backend/go.mod index 710c502..217331e 100644 --- a/Backend/go.mod +++ b/Backend/go.mod @@ -3,11 +3,13 @@ module moku-backend go 1.25.7 require ( + github.com/fxamacker/cbor/v2 v2.9.0 github.com/go-chi/chi/v5 v5.3.0 github.com/google/uuid v1.6.0 github.com/jackc/pgx/v5 v5.10.0 github.com/pressly/goose/v3 v3.27.1 github.com/redis/go-redis/v9 v9.20.1 + github.com/tailscale/hujson v0.0.0-20250605163823-992244df8c5a ) require ( @@ -17,6 +19,7 @@ require ( github.com/jackc/puddle/v2 v2.2.2 // indirect github.com/mfridman/interpolate v0.0.2 // indirect github.com/sethvargo/go-retry v0.3.0 // indirect + github.com/x448/float16 v0.8.4 // indirect go.uber.org/atomic v1.11.0 // indirect go.uber.org/multierr v1.11.0 // indirect golang.org/x/sync v0.20.0 // indirect diff --git a/Backend/go.sum b/Backend/go.sum index e94fe05..cd150a2 100644 --- a/Backend/go.sum +++ b/Backend/go.sum @@ -9,8 +9,12 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= +github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM= +github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ= github.com/go-chi/chi/v5 v5.3.0 h1:halUjDxhshgXHMrao5bB8eNBXo/rnzwr8m5m36glehM= github.com/go-chi/chi/v5 v5.3.0/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= +github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM= @@ -44,6 +48,10 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/tailscale/hujson v0.0.0-20250605163823-992244df8c5a h1:a6TNDN9CgG+cYjaeN8l2mc4kSz2iMiCDQxPEyltUV/I= +github.com/tailscale/hujson v0.0.0-20250605163823-992244df8c5a/go.mod h1:EbW0wDK/qEUYI0A5bqq0C2kF8JTQwWONmGDBbzsxxHo= +github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM= +github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg= github.com/zeebo/xxh3 v1.1.0 h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= github.com/zeebo/xxh3 v1.1.0/go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE= diff --git a/Backend/internal/bootstrap/project_disk_bootstrap.go b/Backend/internal/bootstrap/project_disk_bootstrap.go index 716bcf4..871cae7 100644 --- a/Backend/internal/bootstrap/project_disk_bootstrap.go +++ b/Backend/internal/bootstrap/project_disk_bootstrap.go @@ -26,7 +26,7 @@ func (service *Service) ensureBootstrapPOSIXSkeleton( return fmt.Errorf("create POSIX root: %w", err) } - if err := writeJSONFile(filepath.Join(rootPath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(rootPath, posixSettingsFileName), map[string]any{ "installation": map[string]any{ "id": installation.ID, "name": installation.Name, @@ -42,17 +42,17 @@ func (service *Service) ensureBootstrapPOSIXSkeleton( "slug": organization.Slug, }, }); err != nil { - return fmt.Errorf("write tenant settings.json: %w", err) + return fmt.Errorf("write tenant %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(rootPath, "layout.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(rootPath, posixLayoutFileName), map[string]any{ "version": 1, "type": "tenant-layout", "home": map[string]any{ "defaultProjectSlug": project.Slug, }, }); err != nil { - return fmt.Errorf("write tenant layout.json: %w", err) + return fmt.Errorf("write tenant %s: %w", posixLayoutFileName, err) } if err := os.MkdirAll(filepath.Join(rootPath, "catalog", "packs"), 0o755); err != nil { @@ -63,6 +63,67 @@ func (service *Service) ensureBootstrapPOSIXSkeleton( return fmt.Errorf("create catalog standalone root: %w", err) } + corePackPath := filepath.Join(rootPath, "catalog", "packs", "pack-core") + corePackEntriesPath := filepath.Join(corePackPath, "entries") + coreAppEntryPath := filepath.Join(corePackEntriesPath, "app-shell") + standaloneAppPath := filepath.Join(rootPath, "catalog", "standalone", "app-shell") + + for _, dirPath := range []string{corePackPath, corePackEntriesPath, coreAppEntryPath, standaloneAppPath} { + if err := os.MkdirAll(dirPath, 0o755); err != nil { + return fmt.Errorf("create catalog directory %s: %w", dirPath, err) + } + } + + if err := writeJSONCFile(filepath.Join(corePackPath, posixManifestFileName), map[string]any{ + "id": "pack-core", + "slug": "core", + "type": "pack", + "name": "Core Pack", + "version": "0.1.0", + "description": "First-party shared package of starter Moku surfaces.", + "entries": []map[string]any{{ + "slug": "app-shell", + "path": "entries/app-shell", + }}, + "capabilities": []string{"first-party", "bootstrap", "catalog-pack"}, + }); err != nil { + return fmt.Errorf("write catalog pack %s: %w", posixManifestFileName, err) + } + + if err := writeJSONCFile(filepath.Join(coreAppEntryPath, posixManifestFileName), map[string]any{ + "id": "app-shell", + "slug": "app-shell", + "type": "app", + "name": "App Shell", + "version": "0.1.0", + "description": "Primary shell surface for navigating the installation.", + "source": "pack-core", + "runtime": map[string]any{ + "kind": "route", + "path": "/v1/app-shell", + }, + "capabilities": []string{"shell", "navigation", "workspace"}, + }); err != nil { + return fmt.Errorf("write catalog entry %s: %w", posixManifestFileName, err) + } + + if err := writeJSONCFile(filepath.Join(standaloneAppPath, posixManifestFileName), map[string]any{ + "id": "app-shell", + "slug": "app-shell", + "type": "app", + "name": "App Shell", + "version": "0.1.0", + "description": "Standalone registration for the primary shell surface.", + "source": "standalone", + "runtime": map[string]any{ + "kind": "route", + "path": "/v1/app-shell", + }, + "capabilities": []string{"shell", "navigation", "standalone"}, + }); err != nil { + return fmt.Errorf("write standalone entry %s: %w", posixManifestFileName, err) + } + departmentPath := filepath.Join(rootPath, "departments", slugDir("department", department.Slug)) teamPath := filepath.Join(departmentPath, "teams", slugDir("team", team.Slug)) projectPath := filepath.Join(rootPath, "projects", slugDir("project", project.Slug)) @@ -89,107 +150,107 @@ func (service *Service) ensureBootstrapPOSIXSkeleton( } } - if err := writeJSONFile(filepath.Join(departmentPath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(departmentPath, posixSettingsFileName), map[string]any{ "id": department.ID, "name": department.Name, "slug": department.Slug, "type": "department", }); err != nil { - return fmt.Errorf("write department settings.json: %w", err) + return fmt.Errorf("write department %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(departmentPath, "users.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(departmentPath, posixUsersFileName), map[string]any{ "owners": []map[string]string{{ "id": admin.ID, "email": admin.Email, "displayName": admin.DisplayName, }}, }); err != nil { - return fmt.Errorf("write department users.json: %w", err) + return fmt.Errorf("write department %s: %w", posixUsersFileName, err) } - if err := writeJSONFile(filepath.Join(teamPath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(teamPath, posixSettingsFileName), map[string]any{ "id": team.ID, "name": team.Name, "slug": team.Slug, "type": "team", }); err != nil { - return fmt.Errorf("write team settings.json: %w", err) + return fmt.Errorf("write team %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(teamPath, "users.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(teamPath, posixUsersFileName), map[string]any{ "owners": []map[string]string{{ "id": admin.ID, "email": admin.Email, "displayName": admin.DisplayName, }}, }); err != nil { - return fmt.Errorf("write team users.json: %w", err) + return fmt.Errorf("write team %s: %w", posixUsersFileName, err) } - if err := writeJSONFile(filepath.Join(projectPath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(projectPath, posixSettingsFileName), map[string]any{ "id": project.ID, "name": project.Name, "slug": project.Slug, "type": "project", }); err != nil { - return fmt.Errorf("write project settings.json: %w", err) + return fmt.Errorf("write project %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(projectPath, "home.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(projectPath, posixHomeFileName), map[string]any{ "type": "project-home", "title": project.Name, }); err != nil { - return fmt.Errorf("write project home.json: %w", err) + return fmt.Errorf("write project %s: %w", posixHomeFileName, err) } - if err := writeJSONFile(filepath.Join(projectPath, "acl.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(projectPath, posixACLFileName), map[string]any{ "version": 1, "inherits": true, "rules": []any{}, }); err != nil { - return fmt.Errorf("write project acl.json: %w", err) + return fmt.Errorf("write project %s: %w", posixACLFileName, err) } - if err := writeJSONFile(filepath.Join(usersPath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(usersPath, posixSettingsFileName), map[string]any{ "primaryAdminId": admin.ID, }); err != nil { - return fmt.Errorf("write users settings.json: %w", err) + return fmt.Errorf("write users %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(usersPath, "data.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(usersPath, posixDataFileName), map[string]any{ "admins": []map[string]string{{ "id": admin.ID, "email": admin.Email, "displayName": admin.DisplayName, }}, }); err != nil { - return fmt.Errorf("write users data.json: %w", err) + return fmt.Errorf("write users %s: %w", posixDataFileName, err) } - if err := writeJSONFile(filepath.Join(personalHomePath, "settings.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(personalHomePath, posixSettingsFileName), map[string]any{ "type": "personal", "name": personalName, "slug": personalSlug, }); err != nil { - return fmt.Errorf("write personal settings.json: %w", err) + return fmt.Errorf("write personal %s: %w", posixSettingsFileName, err) } - if err := writeJSONFile(filepath.Join(personalHomePath, "layout.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(personalHomePath, posixLayoutFileName), map[string]any{ "version": 1, "type": "personal-layout", "home": map[string]any{ "defaultProjectSlug": project.Slug, }, }); err != nil { - return fmt.Errorf("write personal layout.json: %w", err) + return fmt.Errorf("write personal %s: %w", posixLayoutFileName, err) } - if err := writeJSONFile(filepath.Join(personalHomePath, "home.json"), map[string]any{ + if err := writeCBORFile(filepath.Join(personalHomePath, posixHomeFileName), map[string]any{ "type": "personal-home", "title": personalHomeTitle(personalName), }); err != nil { - return fmt.Errorf("write personal home.json: %w", err) + return fmt.Errorf("write personal %s: %w", posixHomeFileName, err) } return nil diff --git a/Backend/internal/bootstrap/project_disk_folders.go b/Backend/internal/bootstrap/project_disk_folders.go index 4059051..6be543f 100644 --- a/Backend/internal/bootstrap/project_disk_folders.go +++ b/Backend/internal/bootstrap/project_disk_folders.go @@ -57,11 +57,11 @@ func (service *Service) createProjectFolderOnDisk(projectSlug, parentFolderID, n return "", "", fmt.Errorf("create project hierarchy folder: %w", err) } folderID := uuid.NewString() - if err := writeJSONFile(filepath.Join(folderDir, "folder.json"), map[string]any{"id": folderID, "name": trimmedName, "slug": folderSlug, "type": "folder"}); err != nil { - return "", "", fmt.Errorf("write project folder.json: %w", err) + if err := writeCBORFile(filepath.Join(folderDir, posixFolderFileName), map[string]any{"id": folderID, "name": trimmedName, "slug": folderSlug, "type": "folder"}); err != nil { + return "", "", fmt.Errorf("write project %s: %w", posixFolderFileName, err) } - if err := writeJSONFile(filepath.Join(folderDir, "acl.json"), map[string]any{"version": 1, "inherits": true, "rules": []any{}}); err != nil { - return "", "", fmt.Errorf("write project acl.json: %w", err) + if err := writeCBORFile(filepath.Join(folderDir, posixACLFileName), map[string]any{"version": 1, "inherits": true, "rules": []any{}}); err != nil { + return "", "", fmt.Errorf("write project %s: %w", posixACLFileName, err) } return filepath.ToSlash(filepath.Join(containerProjectionPath, folderName)), folderSlug, nil } @@ -150,13 +150,13 @@ func (service *Service) renameProjectFolderOnDisk(projectSlug, folderID, name st return "", "", fmt.Errorf("rename project folder: %w", err) } } - folderPayload := readJSONFileMap(filepath.Join(destinationDir, "folder.json")) + folderPayload := readStructuredFileMap(filepath.Join(destinationDir, posixFolderFileName)) folderMetadataID, _ := folderPayload["id"].(string) if strings.TrimSpace(folderMetadataID) == "" { folderMetadataID = uuid.NewString() } - if err := writeJSONFile(filepath.Join(destinationDir, "folder.json"), map[string]any{"id": folderMetadataID, "name": trimmedName, "slug": folderSlug, "type": "folder"}); err != nil { - return "", "", fmt.Errorf("write renamed project folder.json: %w", err) + if err := writeCBORFile(filepath.Join(destinationDir, posixFolderFileName), map[string]any{"id": folderMetadataID, "name": trimmedName, "slug": folderSlug, "type": "folder"}); err != nil { + return "", "", fmt.Errorf("write renamed project %s: %w", posixFolderFileName, err) } return folderProjectionPath, renamedProjectionPath, nil } @@ -210,7 +210,7 @@ func (service *Service) moveProjectFolderOnDisk(projectSlug, folderID, parentFol if samePath(currentParentDir, parentDir) { return folderProjectionPath, folderProjectionPath, nil } - folderPayload := readJSONFileMap(filepath.Join(folderDir, "folder.json")) + folderPayload := readStructuredFileMap(filepath.Join(folderDir, posixFolderFileName)) folderMetadataID, _ := folderPayload["id"].(string) if strings.TrimSpace(folderMetadataID) == "" { folderMetadataID = uuid.NewString() @@ -244,8 +244,8 @@ func (service *Service) moveProjectFolderOnDisk(projectSlug, folderID, parentFol folderPayload["name"] = folderName folderPayload["slug"] = folderSlug folderPayload["type"] = "folder" - if err := writeJSONFile(filepath.Join(destinationDir, "folder.json"), folderPayload); err != nil { - return "", "", fmt.Errorf("write moved project folder.json: %w", err) + if err := writeCBORFile(filepath.Join(destinationDir, posixFolderFileName), folderPayload); err != nil { + return "", "", fmt.Errorf("write moved project %s: %w", posixFolderFileName, err) } movedProjectionPath := filepath.ToSlash(filepath.Join(parentChildrenProjectionPath, folderDirName)) return folderProjectionPath, movedProjectionPath, nil diff --git a/Backend/internal/bootstrap/project_disk_helpers.go b/Backend/internal/bootstrap/project_disk_helpers.go index 80571a9..1aa07cf 100644 --- a/Backend/internal/bootstrap/project_disk_helpers.go +++ b/Backend/internal/bootstrap/project_disk_helpers.go @@ -9,6 +9,22 @@ import ( "path/filepath" "strings" "unicode" + + "github.com/fxamacker/cbor/v2" + "github.com/tailscale/hujson" +) + +const ( + posixSettingsFileName = "settings.cbor" + posixLayoutFileName = "layout.cbor" + posixHomeFileName = "home.cbor" + posixUsersFileName = "users.cbor" + posixACLFileName = "acl.cbor" + posixFolderFileName = "folder.cbor" + posixItemFileName = "item.cbor" + posixDataFileName = "data.cbor" + posixSchemaFileName = "schema.json" + posixManifestFileName = "manifest.jsonc" ) func samePath(left, right string) bool { @@ -125,14 +141,93 @@ func writeJSONFile(path string, payload any) error { return os.WriteFile(path, data, 0o644) } -func readJSONFileMap(path string) map[string]any { +func writeJSONCFile(path string, payload any) error { + parentDir := filepath.Dir(path) + if err := os.MkdirAll(parentDir, 0o755); err != nil { + return err + } + data, err := json.MarshalIndent(payload, "", " ") + if err != nil { + return err + } + content := append([]byte("// This file is JSONC. Comments and trailing commas are allowed.\n"), data...) + content = append(content, '\n') + return os.WriteFile(path, content, 0o644) +} + +func writeCBORFile(path string, payload any) error { + parentDir := filepath.Dir(path) + if err := os.MkdirAll(parentDir, 0o755); err != nil { + return err + } + data, err := cbor.Marshal(payload) + if err != nil { + return err + } + return os.WriteFile(path, data, 0o644) +} + +func readStructuredFileMap(path string) map[string]any { data, err := os.ReadFile(path) if err != nil { return map[string]any{} } - var payload map[string]any - if err := json.Unmarshal(data, &payload); err != nil || payload == nil { + var payload any + switch strings.ToLower(filepath.Ext(path)) { + case ".cbor": + err = cbor.Unmarshal(data, &payload) + case ".json": + err = json.Unmarshal(data, &payload) + case ".jsonc": + payload, err = decodeJSONCToAny(data) + default: return map[string]any{} } - return payload + if err != nil || payload == nil { + return map[string]any{} + } + normalized, ok := normalizeStructuredValue(payload).(map[string]any) + if !ok || normalized == nil { + return map[string]any{} + } + return normalized +} + +func decodeJSONCToAny(data []byte) (any, error) { + ast, err := hujson.Parse(data) + if err != nil { + return nil, err + } + ast.Standardize() + standardized := ast.Pack() + var payload any + if err := json.Unmarshal(standardized, &payload); err != nil { + return nil, err + } + return payload, nil +} + +func normalizeStructuredValue(value any) any { + switch typed := value.(type) { + case map[string]any: + normalized := make(map[string]any, len(typed)) + for key, child := range typed { + normalized[key] = normalizeStructuredValue(child) + } + return normalized + case map[any]any: + normalized := make(map[string]any, len(typed)) + for key, child := range typed { + normalized[fmt.Sprint(key)] = normalizeStructuredValue(child) + } + return normalized + case []any: + normalized := make([]any, len(typed)) + for index, child := range typed { + normalized[index] = normalizeStructuredValue(child) + } + return normalized + default: + return value + } } diff --git a/Backend/internal/bootstrap/project_disk_items.go b/Backend/internal/bootstrap/project_disk_items.go index f31682b..be6d89e 100644 --- a/Backend/internal/bootstrap/project_disk_items.go +++ b/Backend/internal/bootstrap/project_disk_items.go @@ -58,14 +58,14 @@ func (service *Service) createProjectTreeItemOnDisk(projectSlug, parentFolderPat return "", fmt.Errorf("create project item: %w", err) } itemID := uuid.NewString() - if err := writeJSONFile(filepath.Join(itemDir, "item.json"), map[string]any{"id": itemID, "name": trimmedName, "slug": itemSlug, "type": canonicalItemType}); err != nil { - return "", fmt.Errorf("write project item.json: %w", err) + if err := writeCBORFile(filepath.Join(itemDir, posixItemFileName), map[string]any{"id": itemID, "name": trimmedName, "slug": itemSlug, "type": canonicalItemType}); err != nil { + return "", fmt.Errorf("write project %s: %w", posixItemFileName, err) } - if err := writeJSONFile(filepath.Join(itemDir, "schema.json"), defaultProjectTreeItemSchema(canonicalItemType)); err != nil { - return "", fmt.Errorf("write project schema.json: %w", err) + if err := writeJSONFile(filepath.Join(itemDir, posixSchemaFileName), defaultProjectTreeItemSchema(canonicalItemType)); err != nil { + return "", fmt.Errorf("write project %s: %w", posixSchemaFileName, err) } - if err := writeJSONFile(filepath.Join(itemDir, "data.json"), defaultProjectTreeItemData(canonicalItemType, trimmedName)); err != nil { - return "", fmt.Errorf("write project data.json: %w", err) + if err := writeCBORFile(filepath.Join(itemDir, posixDataFileName), defaultProjectTreeItemData(canonicalItemType, trimmedName)); err != nil { + return "", fmt.Errorf("write project %s: %w", posixDataFileName, err) } return filepath.ToSlash(filepath.Join(containerProjectionPath, itemDirName)), nil } @@ -140,7 +140,7 @@ func (service *Service) moveProjectTreeItemOnDisk(projectSlug, itemPath, parentF } currentParentDir := filepath.Dir(itemDir) currentBase := filepath.Base(itemDir) - itemPayload := readJSONFileMap(filepath.Join(itemDir, "item.json")) + itemPayload := readStructuredFileMap(filepath.Join(itemDir, posixItemFileName)) itemID, _ := itemPayload["id"].(string) if strings.TrimSpace(itemID) == "" { itemID = uuid.NewString() @@ -182,8 +182,8 @@ func (service *Service) moveProjectTreeItemOnDisk(projectSlug, itemPath, parentF itemPayload["name"] = itemName itemPayload["slug"] = itemSlug itemPayload["type"] = canonicalItemType - if err := writeJSONFile(filepath.Join(destinationDir, "item.json"), itemPayload); err != nil { - return "", "", fmt.Errorf("write moved project item.json: %w", err) + if err := writeCBORFile(filepath.Join(destinationDir, posixItemFileName), itemPayload); err != nil { + return "", "", fmt.Errorf("write moved project %s: %w", posixItemFileName, err) } return itemProjectionPath, movedProjectionPath, nil } diff --git a/Backend/internal/bootstrap/project_order.go b/Backend/internal/bootstrap/project_order.go index 3fa13ae..a343695 100644 --- a/Backend/internal/bootstrap/project_order.go +++ b/Backend/internal/bootstrap/project_order.go @@ -11,18 +11,26 @@ import ( func (service *Service) readProjectFolderOrder(projectSlug, rootProjectionPath string) map[string][]string { settingsPath := service.projectSettingsPath(projectSlug) - settingsPayload := readJSONFileMap(settingsPath) + settingsPayload := readStructuredFileMap(settingsPath) folderOrderPayload, _ := settingsPayload["folderOrder"].(map[string]any) - if folderOrderPayload == nil { return map[string][]string{} } + if folderOrderPayload == nil { + return map[string][]string{} + } scopePayload, _ := folderOrderPayload[projectFolderOrderScope(rootProjectionPath)].(map[string]any) - if scopePayload == nil { return map[string][]string{} } + if scopePayload == nil { + return map[string][]string{} + } byParentPayload, _ := scopePayload["byParent"].(map[string]any) - if byParentPayload == nil { return map[string][]string{} } + if byParentPayload == nil { + return map[string][]string{} + } order := make(map[string][]string, len(byParentPayload)) for key, raw := range byParentPayload { for _, id := range stringSliceValue(raw) { trimmedID := strings.TrimSpace(id) - if trimmedID == "" || slicesContains(order[key], trimmedID) { continue } + if trimmedID == "" || slicesContains(order[key], trimmedID) { + continue + } order[key] = append(order[key], trimmedID) } } @@ -31,37 +39,53 @@ func (service *Service) readProjectFolderOrder(projectSlug, rootProjectionPath s func (service *Service) writeProjectFolderOrder(projectSlug, rootProjectionPath string, folderOrder map[string][]string) error { settingsPath := service.projectSettingsPath(projectSlug) - settingsPayload := readJSONFileMap(settingsPath) - if settingsPayload == nil { settingsPayload = map[string]any{} } + settingsPayload := readStructuredFileMap(settingsPath) + if settingsPayload == nil { + settingsPayload = map[string]any{} + } folderOrderPayload, _ := settingsPayload["folderOrder"].(map[string]any) - if folderOrderPayload == nil { folderOrderPayload = map[string]any{} } + if folderOrderPayload == nil { + folderOrderPayload = map[string]any{} + } scopeKey := projectFolderOrderScope(rootProjectionPath) scopePayload, _ := folderOrderPayload[scopeKey].(map[string]any) - if scopePayload == nil { scopePayload = map[string]any{} } + if scopePayload == nil { + scopePayload = map[string]any{} + } byParentPayload := map[string]any{} for key, ids := range folderOrder { - if len(ids) == 0 { continue } + if len(ids) == 0 { + continue + } copied := make([]string, 0, len(ids)) for _, id := range ids { trimmedID := strings.TrimSpace(id) - if trimmedID == "" || slicesContains(copied, trimmedID) { continue } + if trimmedID == "" || slicesContains(copied, trimmedID) { + continue + } copied = append(copied, trimmedID) } - if len(copied) > 0 { byParentPayload[key] = copied } + if len(copied) > 0 { + byParentPayload[key] = copied + } } scopePayload["byParent"] = byParentPayload folderOrderPayload[scopeKey] = scopePayload settingsPayload["folderOrder"] = folderOrderPayload - if err := writeJSONFile(settingsPath, settingsPayload); err != nil { return fmt.Errorf("write project settings.json: %w", err) } + if err := writeCBORFile(settingsPath, settingsPayload); err != nil { + return fmt.Errorf("write project %s: %w", posixSettingsFileName, err) + } return nil } func (service *Service) projectSettingsPath(projectSlug string) string { - return filepath.Join(strings.TrimSpace(service.posixRoot), "projects", slugDir("project", projectSlug), "settings.json") + return filepath.Join(strings.TrimSpace(service.posixRoot), "projects", slugDir("project", projectSlug), posixSettingsFileName) } func projectFolderOrderScope(rootProjectionPath string) string { - if strings.HasSuffix(rootProjectionPath, "/tree") { return projectFolderOrderTree } + if strings.HasSuffix(rootProjectionPath, "/tree") { + return projectFolderOrderTree + } return projectFolderOrderHierarchy } @@ -70,19 +94,33 @@ func applyProjectHierarchyFolderOrdering(folders []ProjectHierarchyFolderRecord, } func applyProjectHierarchyFolderOrderingForParent(folders []ProjectHierarchyFolderRecord, parentID string, folderOrder map[string][]string) []ProjectHierarchyFolderRecord { - if len(folders) == 0 { return folders } + if len(folders) == 0 { + return folders + } nextFolders := make([]ProjectHierarchyFolderRecord, len(folders)) copy(nextFolders, folders) - for index := range nextFolders { nextFolders[index].Children = applyProjectHierarchyFolderOrderingForParent(nextFolders[index].Children, nextFolders[index].ID, folderOrder) } + for index := range nextFolders { + nextFolders[index].Children = applyProjectHierarchyFolderOrderingForParent(nextFolders[index].Children, nextFolders[index].ID, folderOrder) + } orderIDs := folderOrder[projectFolderOrderParentKey(parentID)] - if len(orderIDs) == 0 { return nextFolders } + if len(orderIDs) == 0 { + return nextFolders + } rankByID := make(map[string]int, len(orderIDs)) - for index, id := range orderIDs { if _, exists := rankByID[id]; !exists { rankByID[id] = index } } + for index, id := range orderIDs { + if _, exists := rankByID[id]; !exists { + rankByID[id] = index + } + } sort.SliceStable(nextFolders, func(left, right int) bool { leftRank, leftOrdered := rankByID[nextFolders[left].ID] rightRank, rightOrdered := rankByID[nextFolders[right].ID] - if leftOrdered && rightOrdered { return leftRank < rightRank } - if leftOrdered != rightOrdered { return leftOrdered } + if leftOrdered && rightOrdered { + return leftRank < rightRank + } + if leftOrdered != rightOrdered { + return leftOrdered + } return false }) return nextFolders @@ -91,32 +129,47 @@ func applyProjectHierarchyFolderOrderingForParent(folders []ProjectHierarchyFold func removeFolderOrder(folderOrder map[string][]string, folderID string) { removeFolderOrderReference(folderOrder, folderID) trimmedFolderID := strings.TrimSpace(folderID) - if trimmedFolderID == "" { return } + if trimmedFolderID == "" { + return + } delete(folderOrder, projectFolderOrderParentKey(trimmedFolderID)) } func removeFolderOrderReference(folderOrder map[string][]string, folderID string) { trimmedFolderID := strings.TrimSpace(folderID) - if trimmedFolderID == "" { return } + if trimmedFolderID == "" { + return + } for key, ids := range folderOrder { nextIDs := ids[:0] for _, id := range ids { - if strings.TrimSpace(id) == trimmedFolderID { continue } + if strings.TrimSpace(id) == trimmedFolderID { + continue + } nextIDs = append(nextIDs, id) } - if len(nextIDs) == 0 { delete(folderOrder, key); continue } + if len(nextIDs) == 0 { + delete(folderOrder, key) + continue + } folderOrder[key] = append([]string(nil), nextIDs...) } } func insertFolderOrder(folderOrder map[string][]string, parentID, folderID string, index int) { trimmedFolderID := strings.TrimSpace(folderID) - if trimmedFolderID == "" { return } + if trimmedFolderID == "" { + return + } removeFolderOrderReference(folderOrder, trimmedFolderID) parentKey := projectFolderOrderParentKey(parentID) children := append([]string(nil), folderOrder[parentKey]...) - if index < 0 { index = 0 } - if index > len(children) { index = len(children) } + if index < 0 { + index = 0 + } + if index > len(children) { + index = len(children) + } children = slicesInsert(children, index, trimmedFolderID) folderOrder[parentKey] = children } @@ -126,17 +179,24 @@ func seedFolderOrderParent(folderOrder map[string][]string, folders []ProjectHie trimmedParentID := strings.TrimSpace(parentID) if trimmedParentID != "" { parent, found := findProjectHierarchyFolder(folders, trimmedParentID) - if !found { return } + if !found { + return + } children = parent.Children } parentKey := projectFolderOrderParentKey(trimmedParentID) seeded := make([]string, 0, len(children)) for _, child := range children { childID := strings.TrimSpace(child.ID) - if childID == "" || slicesContains(seeded, childID) { continue } + if childID == "" || slicesContains(seeded, childID) { + continue + } seeded = append(seeded, childID) } - if len(seeded) == 0 { delete(folderOrder, parentKey); return } + if len(seeded) == 0 { + delete(folderOrder, parentKey) + return + } folderOrder[parentKey] = seeded } @@ -146,23 +206,35 @@ func folderOrderChildren(folderOrder map[string][]string, parentID string) []str func projectFolderOrderParentKey(parentID string) string { trimmedParentID := strings.TrimSpace(parentID) - if trimmedParentID == "" { return projectFolderOrderRootKey } + if trimmedParentID == "" { + return projectFolderOrderRootKey + } return trimmedParentID } func stringSliceValue(value any) []string { items, ok := value.([]any) if !ok { - if typed, ok := value.([]string); ok { return typed } + if typed, ok := value.([]string); ok { + return typed + } return nil } result := make([]string, 0, len(items)) - for _, item := range items { if text, ok := item.(string); ok { result = append(result, text) } } + for _, item := range items { + if text, ok := item.(string); ok { + result = append(result, text) + } + } return result } func slicesContains(values []string, value string) bool { - for _, existing := range values { if existing == value { return true } } + for _, existing := range values { + if existing == value { + return true + } + } return false } @@ -174,25 +246,35 @@ func slicesInsert(values []string, index int, value string) []string { } func buildProjectHierarchyFolderTree(rows []projectHierarchyFolderRow, rootParentPath string) []ProjectHierarchyFolderRecord { - if len(rows) == 0 { return nil } + if len(rows) == 0 { + return nil + } nodesByPath := make(map[string]*ProjectHierarchyFolderRecord, len(rows)) childrenByParent := make(map[string][]string) for _, row := range rows { folderID := strings.TrimSpace(row.ID) - if folderID == "" { folderID = row.Path } + if folderID == "" { + folderID = row.Path + } label := strings.TrimSpace(row.Label) - if label == "" { label = fallbackFolderLabel(row.Path) } + if label == "" { + label = fallbackFolderLabel(row.Path) + } nodesByPath[row.Path] = &ProjectHierarchyFolderRecord{ID: folderID, Path: row.Path, Label: label, Children: []ProjectHierarchyFolderRecord{}} childrenByParent[row.ParentPath] = append(childrenByParent[row.ParentPath], row.Path) } var build func(parentPath string) []ProjectHierarchyFolderRecord build = func(parentPath string) []ProjectHierarchyFolderRecord { childPaths := childrenByParent[parentPath] - if len(childPaths) == 0 { return nil } + if len(childPaths) == 0 { + return nil + } folders := make([]ProjectHierarchyFolderRecord, 0, len(childPaths)) for _, childPath := range childPaths { node := nodesByPath[childPath] - if node == nil { continue } + if node == nil { + continue + } folder := ProjectHierarchyFolderRecord{ID: node.ID, Path: node.Path, Label: node.Label, Children: build(filepath.ToSlash(filepath.Join(childPath, "children")))} folders = append(folders, folder) } @@ -202,15 +284,25 @@ func buildProjectHierarchyFolderTree(rows []projectHierarchyFolderRow, rootParen } func buildProjectTreeNodeTree(rows []projectTreeNodeRow, rootParentPath string) []ProjectTreeNodeRecord { - if len(rows) == 0 { return nil } + if len(rows) == 0 { + return nil + } nodesByPath := make(map[string]*ProjectTreeNodeRecord, len(rows)) childrenByParent := make(map[string][]string) for _, row := range rows { nodeKind := normalizeProjectTreeNodeKind(row.Kind) nodeID := strings.TrimSpace(row.ID) - if nodeID == "" { nodeID = row.Path } + if nodeID == "" { + nodeID = row.Path + } label := strings.TrimSpace(row.Label) - if label == "" { if nodeKind == "item" { label = fallbackItemLabel(row.Path) } else { label = fallbackFolderLabel(row.Path) } } + if label == "" { + if nodeKind == "item" { + label = fallbackItemLabel(row.Path) + } else { + label = fallbackFolderLabel(row.Path) + } + } nodesByPath[row.Path] = &ProjectTreeNodeRecord{ID: nodeID, Path: row.Path, Label: label, Kind: nodeKind, ItemType: normalizeProjectTreeItemType(row.ItemType), Children: []ProjectTreeNodeRecord{}} parentKey := normalizeProjectTreeParentPath(nodeKind, row.ParentPath) childrenByParent[parentKey] = append(childrenByParent[parentKey], row.Path) @@ -218,13 +310,19 @@ func buildProjectTreeNodeTree(rows []projectTreeNodeRow, rootParentPath string) var build func(parentPath string) []ProjectTreeNodeRecord build = func(parentPath string) []ProjectTreeNodeRecord { childPaths := childrenByParent[parentPath] - if len(childPaths) == 0 { return nil } + if len(childPaths) == 0 { + return nil + } nodes := make([]ProjectTreeNodeRecord, 0, len(childPaths)) for _, childPath := range childPaths { node := nodesByPath[childPath] - if node == nil { continue } + if node == nil { + continue + } nextNode := ProjectTreeNodeRecord{ID: node.ID, Path: node.Path, Label: node.Label, Kind: node.Kind, ItemType: node.ItemType} - if node.Kind == "folder" { nextNode.Children = build(node.Path) } + if node.Kind == "folder" { + nextNode.Children = build(node.Path) + } nodes = append(nodes, nextNode) } return nodes @@ -233,7 +331,9 @@ func buildProjectTreeNodeTree(rows []projectTreeNodeRow, rootParentPath string) } func normalizeProjectTreeParentPath(kind, parentPath string) string { - if kind == "folder" && strings.HasSuffix(parentPath, "/children") { return filepath.ToSlash(filepath.Dir(parentPath)) } + if kind == "folder" && strings.HasSuffix(parentPath, "/children") { + return filepath.ToSlash(filepath.Dir(parentPath)) + } return parentPath } @@ -253,19 +353,35 @@ func applyProjectTreeNodeOrdering(nodes []ProjectTreeNodeRecord, folderOrder map } func applyProjectTreeNodeOrderingForParent(nodes []ProjectTreeNodeRecord, parentID string, folderOrder map[string][]string) []ProjectTreeNodeRecord { - if len(nodes) == 0 { return nodes } + if len(nodes) == 0 { + return nodes + } nextNodes := make([]ProjectTreeNodeRecord, len(nodes)) copy(nextNodes, nodes) - for index := range nextNodes { if nextNodes[index].Kind == "folder" { nextNodes[index].Children = applyProjectTreeNodeOrderingForParent(nextNodes[index].Children, nextNodes[index].ID, folderOrder) } } + for index := range nextNodes { + if nextNodes[index].Kind == "folder" { + nextNodes[index].Children = applyProjectTreeNodeOrderingForParent(nextNodes[index].Children, nextNodes[index].ID, folderOrder) + } + } orderIDs := folderOrder[projectFolderOrderParentKey(parentID)] - if len(orderIDs) == 0 { return nextNodes } + if len(orderIDs) == 0 { + return nextNodes + } rankByID := make(map[string]int, len(orderIDs)) - for index, id := range orderIDs { if _, exists := rankByID[id]; !exists { rankByID[id] = index } } + for index, id := range orderIDs { + if _, exists := rankByID[id]; !exists { + rankByID[id] = index + } + } sort.SliceStable(nextNodes, func(left, right int) bool { leftRank, leftOrdered := rankByID[nextNodes[left].ID] rightRank, rightOrdered := rankByID[nextNodes[right].ID] - if leftOrdered && rightOrdered { return leftRank < rightRank } - if leftOrdered != rightOrdered { return leftOrdered } + if leftOrdered && rightOrdered { + return leftRank < rightRank + } + if leftOrdered != rightOrdered { + return leftOrdered + } return false }) return nextNodes @@ -273,39 +389,57 @@ func applyProjectTreeNodeOrderingForParent(nodes []ProjectTreeNodeRecord, parent func findProjectHierarchyFolder(folders []ProjectHierarchyFolderRecord, folderID string) (ProjectHierarchyFolderRecord, bool) { for _, folder := range folders { - if folder.ID == folderID { return folder, true } - if child, ok := findProjectHierarchyFolder(folder.Children, folderID); ok { return child, true } + if folder.ID == folderID { + return folder, true + } + if child, ok := findProjectHierarchyFolder(folder.Children, folderID); ok { + return child, true + } } return ProjectHierarchyFolderRecord{}, false } func findProjectHierarchyFolderByPath(folders []ProjectHierarchyFolderRecord, folderPath string) (ProjectHierarchyFolderRecord, bool) { for _, folder := range folders { - if folder.Path == folderPath { return folder, true } - if child, ok := findProjectHierarchyFolderByPath(folder.Children, folderPath); ok { return child, true } + if folder.Path == folderPath { + return folder, true + } + if child, ok := findProjectHierarchyFolderByPath(folder.Children, folderPath); ok { + return child, true + } } return ProjectHierarchyFolderRecord{}, false } func findProjectTreeNode(nodes []ProjectTreeNodeRecord, nodeID string) (ProjectTreeNodeRecord, bool) { for _, node := range nodes { - if node.ID == nodeID { return node, true } - if child, ok := findProjectTreeNode(node.Children, nodeID); ok { return child, true } + if node.ID == nodeID { + return node, true + } + if child, ok := findProjectTreeNode(node.Children, nodeID); ok { + return child, true + } } return ProjectTreeNodeRecord{}, false } func findProjectTreeNodeByPath(nodes []ProjectTreeNodeRecord, nodePath string) (ProjectTreeNodeRecord, bool) { for _, node := range nodes { - if node.Path == nodePath { return node, true } - if child, ok := findProjectTreeNodeByPath(node.Children, nodePath); ok { return child, true } + if node.Path == nodePath { + return node, true + } + if child, ok := findProjectTreeNodeByPath(node.Children, nodePath); ok { + return child, true + } } return ProjectTreeNodeRecord{}, false } func findProjectTreeFolderByPath(nodes []ProjectTreeNodeRecord, folderPath string) (ProjectTreeNodeRecord, bool) { node, ok := findProjectTreeNodeByPath(nodes, folderPath) - if !ok || node.Kind != "folder" { return ProjectTreeNodeRecord{}, false } + if !ok || node.Kind != "folder" { + return ProjectTreeNodeRecord{}, false + } return node, true } @@ -314,16 +448,24 @@ func seedProjectTreeOrderParent(folderOrder map[string][]string, nodes []Project trimmedParentID := strings.TrimSpace(parentID) if trimmedParentID != "" { parent, found := findProjectTreeNode(nodes, trimmedParentID) - if !found || parent.Kind != "folder" { return } + if !found || parent.Kind != "folder" { + return + } children = parent.Children } parentKey := projectFolderOrderParentKey(parentID) - if len(folderOrder[parentKey]) > 0 { return } + if len(folderOrder[parentKey]) > 0 { + return + } orderedIDs := make([]string, 0, len(children)) for _, child := range children { trimmedChildID := strings.TrimSpace(child.ID) - if trimmedChildID == "" || slicesContains(orderedIDs, trimmedChildID) { continue } + if trimmedChildID == "" || slicesContains(orderedIDs, trimmedChildID) { + continue + } orderedIDs = append(orderedIDs, trimmedChildID) } - if len(orderedIDs) > 0 { folderOrder[parentKey] = orderedIDs } + if len(orderedIDs) > 0 { + folderOrder[parentKey] = orderedIDs + } } diff --git a/Backend/internal/bootstrap/project_queries.go b/Backend/internal/bootstrap/project_queries.go index dd0afd4..fc5beca 100644 --- a/Backend/internal/bootstrap/project_queries.go +++ b/Backend/internal/bootstrap/project_queries.go @@ -232,7 +232,7 @@ func (service *Service) getProjectHierarchyFoldersByRootPath( COALESCE(folder_meta.resource_name, directories.resource_name, '') FROM posix_nodes AS directories LEFT JOIN posix_nodes AS folder_meta - ON folder_meta.path = directories.path || '/folder.json' + ON folder_meta.path = directories.path || '/folder.cbor' AND folder_meta.node_kind = 'file'::posix_node_kind WHERE directories.node_kind = 'directory'::posix_node_kind AND directories.logical_type = 'hierarchy_folder' @@ -286,12 +286,11 @@ func (service *Service) getProjectTreeNodesByRootPath( COALESCE(node_meta.content_json->>'type', directories.content_json->>'type', '') FROM posix_nodes AS directories LEFT JOIN posix_nodes AS node_meta - ON node_meta.path = directories.path || CASE - WHEN directories.logical_type = 'hierarchy_folder' THEN '/folder.json' - WHEN directories.logical_type = 'item' THEN '/item.json' - ELSE '' - END - AND node_meta.node_kind = 'file'::posix_node_kind + ON node_meta.node_kind = 'file'::posix_node_kind + AND ( + (directories.logical_type = 'hierarchy_folder' AND node_meta.path = directories.path || '/folder.cbor') + OR (directories.logical_type = 'item' AND node_meta.path = directories.path || '/item.cbor') + ) WHERE directories.node_kind = 'directory'::posix_node_kind AND directories.logical_type IN ('hierarchy_folder', 'item') AND directories.project_slug = $1 diff --git a/Backend/internal/bootstrap/service_test.go b/Backend/internal/bootstrap/service_test.go index fb9b56e..5939153 100644 --- a/Backend/internal/bootstrap/service_test.go +++ b/Backend/internal/bootstrap/service_test.go @@ -7,6 +7,9 @@ import ( "path/filepath" "strings" "testing" + + "github.com/fxamacker/cbor/v2" + "github.com/tailscale/hujson" ) type fakeRow struct { @@ -104,25 +107,28 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) { } requiredPaths := []string{ - filepath.Join(rootPath, "settings.json"), - filepath.Join(rootPath, "layout.json"), + filepath.Join(rootPath, posixSettingsFileName), + filepath.Join(rootPath, posixLayoutFileName), filepath.Join(rootPath, "catalog", "packs"), filepath.Join(rootPath, "catalog", "standalone"), - filepath.Join(rootPath, "departments", "department-primary-department", "settings.json"), - filepath.Join(rootPath, "departments", "department-primary-department", "users.json"), - filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "settings.json"), - filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", "users.json"), - filepath.Join(rootPath, "projects", "project-primary-project", "settings.json"), - filepath.Join(rootPath, "projects", "project-primary-project", "home.json"), - filepath.Join(rootPath, "projects", "project-primary-project", "acl.json"), + filepath.Join(rootPath, "catalog", "packs", "pack-core", posixManifestFileName), + filepath.Join(rootPath, "catalog", "packs", "pack-core", "entries", "app-shell", posixManifestFileName), + filepath.Join(rootPath, "catalog", "standalone", "app-shell", posixManifestFileName), + filepath.Join(rootPath, "departments", "department-primary-department", posixSettingsFileName), + filepath.Join(rootPath, "departments", "department-primary-department", posixUsersFileName), + filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", posixSettingsFileName), + filepath.Join(rootPath, "departments", "department-primary-department", "teams", "team-primary-team", posixUsersFileName), + filepath.Join(rootPath, "projects", "project-primary-project", posixSettingsFileName), + filepath.Join(rootPath, "projects", "project-primary-project", posixHomeFileName), + filepath.Join(rootPath, "projects", "project-primary-project", posixACLFileName), filepath.Join(rootPath, "projects", "project-primary-project", "children"), filepath.Join(rootPath, "projects", "project-primary-project", "tree"), - filepath.Join(rootPath, "users", "settings.json"), - filepath.Join(rootPath, "users", "data.json"), + filepath.Join(rootPath, "users", posixSettingsFileName), + filepath.Join(rootPath, "users", posixDataFileName), filepath.Join(rootPath, "users", "personals"), - filepath.Join(rootPath, "users", "personals", "personal-ronald", "settings.json"), - filepath.Join(rootPath, "users", "personals", "personal-ronald", "layout.json"), - filepath.Join(rootPath, "users", "personals", "personal-ronald", "home.json"), + filepath.Join(rootPath, "users", "personals", "personal-ronald", posixSettingsFileName), + filepath.Join(rootPath, "users", "personals", "personal-ronald", posixLayoutFileName), + filepath.Join(rootPath, "users", "personals", "personal-ronald", posixHomeFileName), filepath.Join(rootPath, "users", "personals", "personal-ronald", "tree"), } @@ -132,10 +138,10 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) { } } - settingsPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "settings.json")) + settingsPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, posixSettingsFileName)) installationPayload, ok := settingsPayload["installation"].(map[string]any) if !ok { - t.Fatalf("settings.json missing installation object: %#v", settingsPayload) + t.Fatalf("%s missing installation object: %#v", posixSettingsFileName, settingsPayload) } if installationPayload["name"] != "MangoPig" { t.Fatalf("expected installation name MangoPig, got %#v", installationPayload["name"]) @@ -144,31 +150,53 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) { t.Fatalf("expected installation to be bootstrapped, got %#v", installationPayload["isBootstrapped"]) } - layoutPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "layout.json")) + layoutPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, posixLayoutFileName)) homePayload, ok := layoutPayload["home"].(map[string]any) if !ok { - t.Fatalf("layout.json missing home object: %#v", layoutPayload) + t.Fatalf("%s missing home object: %#v", posixLayoutFileName, layoutPayload) } if homePayload["defaultProjectSlug"] != "primary-project" { t.Fatalf("expected default project slug primary-project, got %#v", homePayload["defaultProjectSlug"]) } - projectSettings := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", "settings.json")) + packManifest := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "catalog", "packs", "pack-core", posixManifestFileName)) + if packManifest["type"] != "pack" { + t.Fatalf("expected pack manifest type pack, got %#v", packManifest["type"]) + } + if packManifest["slug"] != "core" { + t.Fatalf("expected pack manifest slug core, got %#v", packManifest["slug"]) + } + + entryManifest := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "catalog", "packs", "pack-core", "entries", "app-shell", posixManifestFileName)) + runtimePayload, ok := entryManifest["runtime"].(map[string]any) + if !ok { + t.Fatalf("%s missing runtime object: %#v", posixManifestFileName, entryManifest) + } + if runtimePayload["path"] != "/v1/app-shell" { + t.Fatalf("expected app-shell runtime path /v1/app-shell, got %#v", runtimePayload["path"]) + } + + standaloneManifest := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "catalog", "standalone", "app-shell", posixManifestFileName)) + if standaloneManifest["source"] != "standalone" { + t.Fatalf("expected standalone manifest source standalone, got %#v", standaloneManifest["source"]) + } + + projectSettings := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", posixSettingsFileName)) if projectSettings["type"] != "project" { t.Fatalf("expected project settings type project, got %#v", projectSettings["type"]) } - projectACL := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", "acl.json")) + projectACL := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "projects", "project-primary-project", posixACLFileName)) if projectACL["inherits"] != true { t.Fatalf("expected project acl to inherit by default, got %#v", projectACL["inherits"]) } - usersSettings := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "settings.json")) + usersSettings := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "users", posixSettingsFileName)) if usersSettings["primaryAdminId"] != "admin-1" { t.Fatalf("expected primary admin id admin-1, got %#v", usersSettings["primaryAdminId"]) } - personalSettings := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "personals", "personal-ronald", "settings.json")) + personalSettings := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "personals", "personal-ronald", posixSettingsFileName)) if personalSettings["type"] != "personal" { t.Fatalf("expected personal settings type personal, got %#v", personalSettings["type"]) } @@ -179,7 +207,7 @@ func TestEnsureBootstrapPOSIXSkeletonInitializesEmptyRoot(t *testing.T) { t.Fatalf("expected personal slug ronald, got %#v", personalSettings["slug"]) } - personalHome := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "personals", "personal-ronald", "home.json")) + personalHome := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, "users", "personals", "personal-ronald", posixHomeFileName)) if personalHome["type"] != "personal-home" { t.Fatalf("expected personal home type personal-home, got %#v", personalHome["type"]) } @@ -217,8 +245,8 @@ func TestCreateProjectHierarchyFolderOnDiskCreatesExpectedFolderShape(t *testing createdFolderPath := filepath.Join(rootPath, "projects", "project-primary-project", "children", "folder-design-system") for _, path := range []string{ - filepath.Join(createdFolderPath, "folder.json"), - filepath.Join(createdFolderPath, "acl.json"), + filepath.Join(createdFolderPath, posixFolderFileName), + filepath.Join(createdFolderPath, posixACLFileName), filepath.Join(createdFolderPath, "children"), } { if _, err := os.Stat(path); err != nil { @@ -226,7 +254,7 @@ func TestCreateProjectHierarchyFolderOnDiskCreatesExpectedFolderShape(t *testing } } - folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(createdFolderPath, "folder.json")) + folderPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(createdFolderPath, posixFolderFileName)) if strings.TrimSpace(asStringForTest(folderPayload["id"])) == "" { t.Fatalf("expected created folder to have stable id, got %#v", folderPayload["id"]) } @@ -278,8 +306,8 @@ func TestCreateProjectTreeFolderOnDiskCreatesExpectedFolderShape(t *testing.T) { createdFolderPath := filepath.Join(rootPath, "projects", "project-primary-project", "tree", "folder-docs") for _, path := range []string{ - filepath.Join(createdFolderPath, "folder.json"), - filepath.Join(createdFolderPath, "acl.json"), + filepath.Join(createdFolderPath, posixFolderFileName), + filepath.Join(createdFolderPath, posixACLFileName), filepath.Join(createdFolderPath, "children"), } { if _, err := os.Stat(path); err != nil { @@ -345,7 +373,7 @@ func TestRenameProjectHierarchyFolderOnDiskRenamesFolderShape(t *testing.T) { t.Fatalf("expected nested child folder to move with renamed parent: %v", err) } - folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(renamedFolderPath, "folder.json")) + folderPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(renamedFolderPath, posixFolderFileName)) if strings.TrimSpace(asStringForTest(folderPayload["id"])) == "" { t.Fatalf("expected renamed folder to preserve stable id, got %#v", folderPayload["id"]) } @@ -392,7 +420,7 @@ func TestRenameProjectTreeFolderOnDiskRenamesFolderShape(t *testing.T) { t.Fatalf("unexpected renamed path: %s", renamedPath) } - folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, filepath.FromSlash(renamedPath), "folder.json")) + folderPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, filepath.FromSlash(renamedPath), posixFolderFileName)) if folderPayload["name"] != "Specifications" { t.Fatalf("expected renamed folder name Specifications, got %#v", folderPayload["name"]) } @@ -454,7 +482,7 @@ func TestMoveProjectHierarchyFolderOnDiskMovesFolderToNewParent(t *testing.T) { t.Fatalf("expected nested child folder to move with moved parent: %v", err) } - folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(movedFolderPath, "folder.json")) + folderPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(movedFolderPath, posixFolderFileName)) if strings.TrimSpace(asStringForTest(folderPayload["id"])) == "" { t.Fatalf("expected moved folder to preserve stable id, got %#v", folderPayload["id"]) } @@ -505,7 +533,7 @@ func TestMoveProjectTreeFolderOnDiskMovesFolderToNewParent(t *testing.T) { t.Fatalf("unexpected moved path: %s", movedPath) } - folderPayload := readJSONFileForTest[map[string]any](t, filepath.Join(rootPath, filepath.FromSlash(movedPath), "folder.json")) + folderPayload := readStructuredFileForTest[map[string]any](t, filepath.Join(rootPath, filepath.FromSlash(movedPath), posixFolderFileName)) if folderPayload["name"] != "Docs" { t.Fatalf("expected moved folder name Docs, got %#v", folderPayload["name"]) } @@ -622,7 +650,7 @@ func asStringForTest(value any) string { return text } -func readJSONFileForTest[T any](t *testing.T, path string) T { +func readStructuredFileForTest[T any](t *testing.T, path string) T { t.Helper() data, err := os.ReadFile(path) @@ -630,9 +658,37 @@ func readJSONFileForTest[T any](t *testing.T, path string) T { t.Fatalf("read %s: %v", path, err) } + var raw any + switch strings.ToLower(filepath.Ext(path)) { + case ".cbor": + if err := cbor.Unmarshal(data, &raw); err != nil { + t.Fatalf("unmarshal %s: %v", path, err) + } + case ".json": + if err := json.Unmarshal(data, &raw); err != nil { + t.Fatalf("unmarshal %s: %v", path, err) + } + case ".jsonc": + ast, err := hujson.Parse(data) + if err != nil { + t.Fatalf("parse jsonc %s: %v", path, err) + } + ast.Standardize() + if err := json.Unmarshal(ast.Pack(), &raw); err != nil { + t.Fatalf("unmarshal standardized %s: %v", path, err) + } + default: + t.Fatalf("unsupported structured test file %s", path) + } + + normalizedBytes, err := json.Marshal(normalizeStructuredValue(raw)) + if err != nil { + t.Fatalf("normalize %s: %v", path, err) + } + var payload T - if err := json.Unmarshal(data, &payload); err != nil { - t.Fatalf("unmarshal %s: %v", path, err) + if err := json.Unmarshal(normalizedBytes, &payload); err != nil { + t.Fatalf("decode normalized %s: %v", path, err) } return payload diff --git a/Backend/internal/posixproj/projector_classify.go b/Backend/internal/posixproj/projector_classify.go index f48e299..76e0413 100644 --- a/Backend/internal/posixproj/projector_classify.go +++ b/Backend/internal/posixproj/projector_classify.go @@ -28,8 +28,10 @@ func deriveScope(relPath string, rootScope Scope) Scope { func classifyPath(relPath string, isDir bool) (logicalType, fileRole string) { parts := strings.Split(relPath, "/") name := parts[len(parts)-1] + ext := strings.ToLower(filepath.Ext(name)) + structuredRole := strings.TrimSuffix(name, filepath.Ext(name)) if !isDir { - fileRole = strings.TrimSuffix(name, filepath.Ext(name)) + fileRole = structuredRole } hasChildrenAncestor := pathContainsSegment(parts, "children") @@ -40,9 +42,9 @@ func classifyPath(relPath string, isDir bool) (logicalType, fileRole string) { } switch { - case relPath == "settings.json": + case !isDir && structuredRole == "settings" && len(parts) == 1 && ext == ".cbor": return "tenant", "settings" - case relPath == "layout.json": + case !isDir && structuredRole == "layout" && len(parts) == 1 && ext == ".cbor": return "tenant", "layout" case len(parts) >= 1 && parts[0] == "catalog": if isDir { @@ -50,60 +52,110 @@ func classifyPath(relPath string, isDir bool) (logicalType, fileRole string) { return "catalog", "" } if len(parts) >= 2 && parts[1] == "packs" { - if len(parts) == 2 { return "catalog_packs", "" } - if len(parts) == 3 { return "catalog_pack", "" } - if len(parts) >= 4 && parts[3] == "entries" { return "catalog_pack_entries", "" } + if len(parts) == 2 { + return "catalog_packs", "" + } + if len(parts) == 3 { + return "catalog_pack", "" + } + if len(parts) >= 4 && parts[3] == "entries" { + return "catalog_pack_entries", "" + } return "catalog_entry", "" } if len(parts) >= 2 && parts[1] == "standalone" { - if len(parts) == 2 { return "catalog_standalone", "" } + if len(parts) == 2 { + return "catalog_standalone", "" + } return "catalog_entry", "" } } return "catalog", fileRole case len(parts) >= 2 && parts[0] == "departments" && strings.HasPrefix(parts[1], "department-"): if isDir { - if len(parts) == 2 { return "department", "" } - if len(parts) == 3 && parts[2] == "teams" { return "department_teams", "" } - if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") { return "team", "" } + if len(parts) == 2 { + return "department", "" + } + if len(parts) == 3 && parts[2] == "teams" { + return "department_teams", "" + } + if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") { + return "team", "" + } + } + if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") { + return "team", fileRole } - if len(parts) >= 4 && strings.HasPrefix(parts[3], "team-") { return "team", fileRole } return "department", fileRole case len(parts) >= 2 && parts[0] == "projects" && strings.HasPrefix(parts[1], "project-"): if isDir { - if strings.HasPrefix(name, "project-") { return "project", "" } - if name == "children" { return "project_children", "" } - if name == "tree" { return "project_tree", "" } - if hasChildrenAncestor && strings.HasPrefix(name, "folder-") { return "hierarchy_folder", "" } - if hasTreeAncestor && strings.HasPrefix(name, "folder-") { return "hierarchy_folder", "" } - if hasTreeAncestor && strings.HasPrefix(name, "item-") { return "item", "" } + if strings.HasPrefix(name, "project-") { + return "project", "" + } + if name == "children" { + return "project_children", "" + } + if name == "tree" { + return "project_tree", "" + } + if hasChildrenAncestor && strings.HasPrefix(name, "folder-") { + return "hierarchy_folder", "" + } + if hasTreeAncestor && strings.HasPrefix(name, "folder-") { + return "hierarchy_folder", "" + } + if hasTreeAncestor && strings.HasPrefix(name, "item-") { + return "item", "" + } + } + if hasChildrenAncestor && strings.HasPrefix(parentName, "folder-") { + return "hierarchy_folder", fileRole } - if hasChildrenAncestor && strings.HasPrefix(parentName, "folder-") { return "hierarchy_folder", fileRole } if hasTreeAncestor { - if strings.HasPrefix(parentName, "item-") { return "item", fileRole } - if strings.HasPrefix(parentName, "folder-") { return "hierarchy_folder", fileRole } + if strings.HasPrefix(parentName, "item-") { + return "item", fileRole + } + if strings.HasPrefix(parentName, "folder-") { + return "hierarchy_folder", fileRole + } } return "project", fileRole case len(parts) >= 1 && parts[0] == "users": if isDir { - if len(parts) == 1 { return "users", "" } - if len(parts) == 2 && parts[1] == "personals" { return "personals", "" } - if len(parts) >= 3 && parts[1] == "personals" && strings.HasPrefix(parts[2], "personal-") { return "personal", "" } + if len(parts) == 1 { + return "users", "" + } + if len(parts) == 2 && parts[1] == "personals" { + return "personals", "" + } + if len(parts) >= 3 && parts[1] == "personals" && strings.HasPrefix(parts[2], "personal-") { + return "personal", "" + } if strings.Contains(relPath, "/tree/") || strings.HasSuffix(relPath, "/tree") { - if strings.HasPrefix(name, "folder-") { return "folder", "" } - if strings.HasPrefix(name, "item-") { return "item", "" } + if strings.HasPrefix(name, "folder-") { + return "folder", "" + } + if strings.HasPrefix(name, "item-") { + return "item", "" + } } } if len(parts) >= 3 && parts[1] == "personals" && strings.HasPrefix(parts[2], "personal-") { if strings.Contains(relPath, "/tree/") { - if strings.HasPrefix(parts[len(parts)-2], "item-") { return "item", fileRole } - if strings.HasPrefix(parts[len(parts)-2], "folder-") { return "folder", fileRole } + if strings.HasPrefix(parts[len(parts)-2], "item-") { + return "item", fileRole + } + if strings.HasPrefix(parts[len(parts)-2], "folder-") { + return "folder", fileRole + } } return "personal", fileRole } return "users", fileRole default: - if isDir { return "directory", "" } + if isDir { + return "directory", "" + } return "file", fileRole } } diff --git a/Backend/internal/posixproj/projector_scan.go b/Backend/internal/posixproj/projector_scan.go index d1aa352..dd35ea0 100644 --- a/Backend/internal/posixproj/projector_scan.go +++ b/Backend/internal/posixproj/projector_scan.go @@ -11,6 +11,13 @@ import ( "os" "path/filepath" "strings" + + "github.com/fxamacker/cbor/v2" + "github.com/tailscale/hujson" +) + +const ( + settingsCBORPath = "settings.cbor" ) func ScanRoot(root string) ([]Node, error) { @@ -77,18 +84,21 @@ func ScanRoot(root string) ([]Node, error) { } func loadRootScope(rootPath string) (Scope, error) { - settingsPath := filepath.Join(rootPath, "settings.json") + settingsPath := filepath.Join(rootPath, settingsCBORPath) content, err := os.ReadFile(settingsPath) if err != nil { if errorsIsNotExist(err) { return Scope{}, nil } - return Scope{}, fmt.Errorf("read root settings.json: %w", err) + return Scope{}, fmt.Errorf("read root %s: %w", filepath.Base(settingsPath), err) } - var payload map[string]any - if err := json.Unmarshal(content, &payload); err != nil { - return Scope{}, fmt.Errorf("decode root settings.json: %w", err) + payload, err := decodeStructuredMap(settingsPath, content) + if err != nil { + return Scope{}, fmt.Errorf("decode root %s: %w", filepath.Base(settingsPath), err) + } + if len(payload) == 0 { + return Scope{}, nil } installation, _ := payload["installation"].(map[string]any) @@ -138,9 +148,9 @@ func buildNode(rootPath, relPath string, entry fs.DirEntry, rootScope Scope) (No node.SizeBytes = int64(len(content)) node.Checksum = hex.EncodeToString(hash[:]) - if strings.EqualFold(filepath.Ext(entry.Name()), ".json") { - var payload map[string]any - if err := json.Unmarshal(content, &payload); err == nil { + if isStructuredProjectionFile(entry.Name()) { + payload, err := decodeStructuredMap(absPath, content) + if err == nil { jsonContent, err := json.Marshal(payload) if err != nil { return Node{}, fmt.Errorf("remarshal POSIX file %s: %w", relPath, err) @@ -171,6 +181,84 @@ func buildNode(rootPath, relPath string, entry fs.DirEntry, rootScope Scope) (No return node, nil } +func isStructuredProjectionFile(name string) bool { + switch strings.ToLower(filepath.Ext(name)) { + case ".json", ".jsonc", ".cbor": + return true + default: + return false + } +} + +func decodeStructuredMap(path string, content []byte) (map[string]any, error) { + var payload any + switch strings.ToLower(filepath.Ext(path)) { + case ".cbor": + if err := cbor.Unmarshal(content, &payload); err != nil { + return nil, err + } + case ".json": + if err := json.Unmarshal(content, &payload); err != nil { + return nil, err + } + case ".jsonc": + decoded, err := decodeJSONCToAny(content) + if err != nil { + return nil, err + } + payload = decoded + default: + return nil, fmt.Errorf("unsupported structured file extension %q", filepath.Ext(path)) + } + if payload == nil { + return map[string]any{}, nil + } + normalized, ok := normalizeStructuredValue(payload).(map[string]any) + if !ok || normalized == nil { + return map[string]any{}, nil + } + return normalized, nil +} + +func decodeJSONCToAny(content []byte) (any, error) { + ast, err := hujson.Parse(content) + if err != nil { + return nil, err + } + ast.Standardize() + standardized := ast.Pack() + var payload any + if err := json.Unmarshal(standardized, &payload); err != nil { + return nil, err + } + return payload, nil +} + +func normalizeStructuredValue(value any) any { + switch typed := value.(type) { + case map[string]any: + normalized := make(map[string]any, len(typed)) + for key, child := range typed { + normalized[key] = normalizeStructuredValue(child) + } + return normalized + case map[any]any: + normalized := make(map[string]any, len(typed)) + for key, child := range typed { + normalized[fmt.Sprint(key)] = normalizeStructuredValue(child) + } + return normalized + case []any: + normalized := make([]any, len(typed)) + for index, child := range typed { + normalized[index] = normalizeStructuredValue(child) + } + return normalized + default: + return value + } +} + func summarizeNodes(nodes []Node) RebuildSummary { summary := RebuildSummary{TotalNodes: len(nodes)} for _, node := range nodes { diff --git a/Backend/internal/posixproj/projector_test.go b/Backend/internal/posixproj/projector_test.go index 788fd81..908a9b9 100644 --- a/Backend/internal/posixproj/projector_test.go +++ b/Backend/internal/posixproj/projector_test.go @@ -7,6 +7,21 @@ import ( "os" "path/filepath" "testing" + + "github.com/fxamacker/cbor/v2" +) + +const ( + testSettingsFileName = "settings.cbor" + testLayoutFileName = "layout.cbor" + testHomeFileName = "home.cbor" + testUsersFileName = "users.cbor" + testACLFileName = "acl.cbor" + testFolderFileName = "folder.cbor" + testItemFileName = "item.cbor" + testDataFileName = "data.cbor" + testSchemaFileName = "schema.json" + testManifestFileName = "manifest.jsonc" ) func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { @@ -14,6 +29,8 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { mustMkdirAll(t, filepath.Join(root, "catalog", "packs")) mustMkdirAll(t, filepath.Join(root, "catalog", "standalone")) + mustMkdirAll(t, filepath.Join(root, "catalog", "packs", "pack-core", "entries", "app-shell")) + mustMkdirAll(t, filepath.Join(root, "catalog", "standalone", "app-shell")) mustMkdirAll(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team")) mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "children")) mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "tree")) @@ -22,7 +39,7 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { mustMkdirAll(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap")) mustMkdirAll(t, filepath.Join(root, "users", "personals")) - mustWriteJSON(t, filepath.Join(root, "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, testSettingsFileName), map[string]any{ "installation": map[string]any{ "id": "installation-1", "name": "MangoPig", @@ -34,81 +51,103 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { "slug": "primary-organization", }, }) - mustWriteJSON(t, filepath.Join(root, "layout.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, testLayoutFileName), map[string]any{ "type": "tenant-layout", "home": map[string]any{"defaultProjectSlug": "primary-project"}, }) - mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "catalog", "packs", "pack-core", testManifestFileName), map[string]any{ + "id": "pack-core", + "slug": "core", + "type": "pack", + "name": "Core Pack", + "entries": []map[string]any{{"slug": "app-shell", "path": "entries/app-shell"}}, + }) + mustWriteStructured(t, filepath.Join(root, "catalog", "packs", "pack-core", "entries", "app-shell", testManifestFileName), map[string]any{ + "id": "app-shell", + "slug": "app-shell", + "type": "app", + "runtime": map[string]any{ + "kind": "route", + "path": "/v1/app-shell", + }, + }) + mustWriteStructured(t, filepath.Join(root, "catalog", "standalone", "app-shell", testManifestFileName), map[string]any{ + "id": "app-shell", + "slug": "app-shell", + "type": "app", + "source": "standalone", + }) + mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", testSettingsFileName), map[string]any{ "id": "dept-1", "name": "Primary Department", "slug": "primary-department", "type": "department", }) - mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "users.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", testUsersFileName), map[string]any{ "users": []map[string]any{{"id": "admin-1"}}, }) - mustWriteJSON(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team", "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "departments", "department-primary-department", "teams", "team-primary-team", testSettingsFileName), map[string]any{ "id": "team-1", "name": "Primary Team", "slug": "primary-team", "type": "team", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testSettingsFileName), map[string]any{ "id": "project-1", "name": "Primary Project", "slug": "primary-project", "type": "project", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "home.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testHomeFileName), map[string]any{ "type": "project-home", "project": "primary-project", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "acl.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", testACLFileName), map[string]any{ "inherits": true, "rules": []any{}, }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "folder.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", testFolderFileName), map[string]any{ "name": "Design", "slug": "design", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "acl.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", testACLFileName), map[string]any{ "inherits": true, "rules": []any{}, }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testSettingsFileName), map[string]any{ "id": "project-2", "name": "Web Project", "slug": "web", "type": "project", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "home.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testHomeFileName), map[string]any{ "type": "project-home", "project": "web", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", "acl.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "children", "folder-design", "children", "project-web", testACLFileName), map[string]any{ "inherits": true, "rules": []any{}, }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "folder.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", testFolderFileName), map[string]any{ "name": "Docs", "slug": "docs", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "item.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testItemFileName), map[string]any{ "id": "item-1", "name": "Roadmap", "slug": "roadmap", "type": "board", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "schema.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testSchemaFileName), map[string]any{ "type": "object", }) - mustWriteJSON(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", "data.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testDataFileName), map[string]any{ "title": "Roadmap", }) - mustWriteJSON(t, filepath.Join(root, "users", "settings.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "users", testSettingsFileName), map[string]any{ "primaryAdminId": "admin-1", }) - mustWriteJSON(t, filepath.Join(root, "users", "data.json"), map[string]any{ + mustWriteStructured(t, filepath.Join(root, "users", testDataFileName), map[string]any{ "users": []map[string]any{{"id": "admin-1", "email": "ronald@example.com"}}, }) @@ -133,7 +172,7 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("expected root organization slug primary-organization, got %q", rootNode.OrganizationSlug) } - tenantSettings := index["settings.json"] + tenantSettings := index[testSettingsFileName] if tenantSettings.LogicalType != "tenant" || tenantSettings.FileRole != "settings" { t.Fatalf("unexpected tenant settings classification: %#v", tenantSettings) } @@ -141,7 +180,31 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("expected installation id installation-1, got %q", tenantSettings.InstallationID) } - deptSettings := index["departments/department-primary-department/settings.json"] + packManifest := index[filepath.ToSlash(filepath.Join("catalog", "packs", "pack-core", testManifestFileName))] + if packManifest.LogicalType != "catalog" || packManifest.FileRole != "manifest" { + t.Fatalf("unexpected pack manifest classification: %#v", packManifest) + } + if packManifest.ResourceSlug != "core" { + t.Fatalf("expected pack manifest resource slug core, got %q", packManifest.ResourceSlug) + } + + entryManifest := index[filepath.ToSlash(filepath.Join("catalog", "packs", "pack-core", "entries", "app-shell", testManifestFileName))] + if entryManifest.LogicalType != "catalog" || entryManifest.FileRole != "manifest" { + t.Fatalf("unexpected catalog entry manifest classification: %#v", entryManifest) + } + if entryManifest.ResourceID != "app-shell" { + t.Fatalf("expected catalog entry manifest resource id app-shell, got %q", entryManifest.ResourceID) + } + + standaloneManifest := index[filepath.ToSlash(filepath.Join("catalog", "standalone", "app-shell", testManifestFileName))] + if standaloneManifest.LogicalType != "catalog" || standaloneManifest.FileRole != "manifest" { + t.Fatalf("unexpected standalone manifest classification: %#v", standaloneManifest) + } + if standaloneManifest.ResourceSlug != "app-shell" { + t.Fatalf("expected standalone manifest resource slug app-shell, got %q", standaloneManifest.ResourceSlug) + } + + deptSettings := index[filepath.ToSlash(filepath.Join("departments", "department-primary-department", testSettingsFileName))] if deptSettings.DepartmentSlug != "primary-department" { t.Fatalf("expected department slug primary-department, got %q", deptSettings.DepartmentSlug) } @@ -149,12 +212,12 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("expected department resource id dept-1, got %q", deptSettings.ResourceID) } - teamSettings := index["departments/department-primary-department/teams/team-primary-team/settings.json"] + teamSettings := index[filepath.ToSlash(filepath.Join("departments", "department-primary-department", "teams", "team-primary-team", testSettingsFileName))] if teamSettings.TeamSlug != "primary-team" { t.Fatalf("expected team slug primary-team, got %q", teamSettings.TeamSlug) } - projectSettings := index["projects/project-primary-project/settings.json"] + projectSettings := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", testSettingsFileName))] if projectSettings.ProjectSlug != "primary-project" { t.Fatalf("expected project slug primary-project, got %q", projectSettings.ProjectSlug) } @@ -177,12 +240,12 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("unexpected hierarchy folder node: %#v", hierarchyFolder) } - hierarchyFolderACL := index["projects/project-primary-project/children/folder-design/acl.json"] + hierarchyFolderACL := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "children", "folder-design", testACLFileName))] if hierarchyFolderACL.LogicalType != "hierarchy_folder" || hierarchyFolderACL.FileRole != "acl" { t.Fatalf("unexpected hierarchy folder acl classification: %#v", hierarchyFolderACL) } - childProjectSettings := index["projects/project-primary-project/children/folder-design/children/project-web/settings.json"] + childProjectSettings := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "children", "folder-design", "children", "project-web", testSettingsFileName))] if childProjectSettings.LogicalType != "project" || childProjectSettings.ProjectSlug != "web" { t.Fatalf("unexpected child project classification: %#v", childProjectSettings) } @@ -192,12 +255,12 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("unexpected tree folder node: %#v", treeFolder) } - treeFolderACL := index["projects/project-primary-project/tree/folder-docs/folder.json"] + treeFolderACL := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "tree", "folder-docs", testFolderFileName))] if treeFolderACL.LogicalType != "hierarchy_folder" || treeFolderACL.FileRole != "folder" { t.Fatalf("unexpected tree folder file classification: %#v", treeFolderACL) } - treeItem := index["projects/project-primary-project/tree/folder-docs/item-roadmap/item.json"] + treeItem := index[filepath.ToSlash(filepath.Join("projects", "project-primary-project", "tree", "folder-docs", "item-roadmap", testItemFileName))] if treeItem.LogicalType != "item" || treeItem.FileRole != "item" { t.Fatalf("unexpected tree item classification: %#v", treeItem) } @@ -205,12 +268,12 @@ func TestScanRootBuildsProjectedNodesFromBootstrapShape(t *testing.T) { t.Fatalf("expected tree item resource slug roadmap, got %#v", treeItem.ResourceSlug) } - usersData := index["users/data.json"] + usersData := index[filepath.ToSlash(filepath.Join("users", testDataFileName))] if usersData.LogicalType != "users" || usersData.FileRole != "data" { t.Fatalf("unexpected users data classification: %#v", usersData) } if usersData.Checksum == "" || usersData.SizeBytes == 0 { - t.Fatalf("expected users/data.json checksum and size to be populated: %#v", usersData) + t.Fatalf("expected users/%s checksum and size to be populated: %#v", testDataFileName, usersData) } } @@ -221,13 +284,32 @@ func mustMkdirAll(t *testing.T, path string) { } } -func mustWriteJSON(t *testing.T, path string, payload any) { +func mustWriteStructured(t *testing.T, path string, payload any) { t.Helper() - bytes, err := json.MarshalIndent(payload, "", " ") - if err != nil { - t.Fatalf("MarshalIndent(%q) error = %v", path, err) + var ( + bytes []byte + err error + ) + switch filepath.Ext(path) { + case ".cbor": + bytes, err = cbor.Marshal(payload) + case ".json": + bytes, err = json.MarshalIndent(payload, "", " ") + if err == nil { + bytes = append(bytes, '\n') + } + case ".jsonc": + bytes, err = json.MarshalIndent(payload, "", " ") + if err == nil { + bytes = append([]byte("// Fixture JSONC with comments and trailing commas enabled.\n"), bytes...) + bytes = append(bytes[:len(bytes)-2], []byte(",\n}\n")...) + } + default: + t.Fatalf("unsupported structured fixture file %q", path) + } + if err != nil { + t.Fatalf("marshal %q error = %v", path, err) } - bytes = append(bytes, '\n') if err := os.WriteFile(path, bytes, 0o644); err != nil { t.Fatalf("WriteFile(%q) error = %v", path, err) } diff --git a/Documentation/POSIX-Structure.md b/Documentation/POSIX-Structure.md index eeb6241..030811d 100644 --- a/Documentation/POSIX-Structure.md +++ b/Documentation/POSIX-Structure.md @@ -1,75 +1,81 @@ # POSIX Structure -[Filetree Link](https://tree.nathanfriend.com/?s=(%27optiUs!(%27fancy!Yue~fullPath!fbq~YailingSlash!Yue~rootDot!fbq)~R(%27R%27PJ%20or%20OrganizatiU%20%7Bqrver%7DM*46layout6cNlog7packs7*pack37A2*enYies75W5A_standbUe7WA6HwH30LZ2teamw5teamGL5Z6FwF30LKTC058T5C7XFG5LXKXTXC7XI7I05QG5BN2*8QG5BN6Z04_dN_pJw*pJGlayout2L*KI70%27)~vEiU!%271%27)*%20%200M52_*3-%3Cslug%3E4qttings5**69M*7%2F08VG*V259.jsUA5manifestBQ25*schema25*dCchildrenEersFprojectG305HdepartmentI*YeeJEUbKhome2L*42M%5CnNataQitemRsource!Tacl2UonVfolderW*app37X55YtrZusE_90balqsews0%01wqb_ZYXWVUTRQNMLKJIHGFECBA987654320*) +Note: regenerate the external filetree link if you want the hosted visual tree to reflect the new `.cbor` and `.jsonc` paths. ``` markdown Personal or Organization (server)/ -├── settings.json -├── layout.json +├── settings.cbor ├── catalog/ │ ├── packs/ │ │ └── pack-/ -│ │ ├── manifest.json +│ │ ├── manifest.jsonc │ │ └── entries/ │ │ └── app-/ -│ │ └── manifest.json +│ │ └── manifest.jsonc │ └── standalone/ │ └── app-/ -│ └── manifest.json +│ └── manifest.jsonc ├── departments/ │ └── department-/ -│ ├── settings.json -│ ├── users.json +│ ├── settings.cbor +│ ├── users.cbor │ └── teams/ │ └── team-/ -│ ├── settings.json -│ └── users.json +│ ├── settings.cbor +│ └── users.cbor ├── projects/ │ └── project-/ -│ ├── settings.json -│ ├── home.json -│ ├── acl.json +│ ├── settings.cbor +│ ├── home.cbor +│ ├── acl.cbor │ ├── children/ │ │ └── folder-/ -│ │ ├── folder.json -│ │ ├── acl.json +│ │ ├── folder.cbor +│ │ ├── acl.cbor │ │ └── children/ │ │ └── project-/ -│ │ ├── settings.json -│ │ ├── home.json -│ │ ├── acl.json +│ │ ├── settings.cbor +│ │ ├── home.cbor +│ │ ├── acl.cbor │ │ ├── children/ │ │ └── tree/ │ └── tree/ │ ├── item-/ -│ │ ├── item.json +│ │ ├── item.cbor │ │ ├── schema.json -│ │ └── data.json +│ │ └── data.cbor │ └── folder-/ -│ ├── folder.json +│ ├── folder.cbor │ └── item-/ -│ ├── item.json +│ ├── item.cbor │ ├── schema.json -│ └── data.json +│ └── data.cbor └── users/ - ├── settings.json - ├── data.json + ├── settings.cbor + ├── data.cbor └── personals/ └── personal-/ - ├── layout.json - ├── settings.json - ├── home.json + ├── layout.cbor + ├── settings.cbor + ├── home.cbor └── tree/ ``` ## File Responsibilities -- `settings.json` — Metadata and presentation config for the thing, such as display name, icon, description, and simple settings. -- `layout.json` — Layout configuration for the current server or personal space. -- `home.json` — Home surface configuration, such as widgets, sections, and how they are arranged. -- `folder.json` — Metadata for a folder node in a tree. -- `item.json` — Instance metadata for a created item, including what it is and how it should behave. +- `settings.cbor` — Machine-owned metadata and presentation config for the thing, such as display name, icon, description, and simple settings. +- `layout.cbor` — Machine-owned layout configuration for the current server or personal space. +- `home.cbor` — Machine-owned home surface configuration, such as widgets, sections, and how they are arranged. +- `folder.cbor` — Machine-owned metadata for a folder node in a tree. +- `item.cbor` — Machine-owned instance metadata for a created item, including what it is and how it should behave. - `schema.json` — The structure expected by that item's data. -- `data.json` — The actual content or state data for that item. -- `manifest.json` — Catalog definition metadata, including versioning, description, and capabilities for reusable apps or entries. -- `users.json` — User membership or assignment data for departments and teams. +- `data.cbor` — The machine-owned content or state data for that item. +- `manifest.jsonc` — Human-facing catalog definition metadata, including versioning, description, capabilities, and comments for reusable apps or entries. +- `users.cbor` — Machine-owned user membership or assignment data for departments and teams. +- `acl.cbor` — Machine-owned access control data for projects and folders. + +## Format Rules + +- Use `*.jsonc` for catalog manifests that may be authored or reviewed by humans. +- Use `*.cbor` for machine-owned POSIX state and metadata files where parse speed, compactness, and backupability matter more than direct editability. +- Keep `schema.json` as JSON so it remains compatible with JSON Schema tooling and validation flows. diff --git a/Documentation/TODO.md b/Documentation/TODO.md index d6de8fe..f051b86 100644 --- a/Documentation/TODO.md +++ b/Documentation/TODO.md @@ -63,11 +63,11 @@ - [ ] POSIX-Lite-File-Persistence-Foundation - [ ] Mounted-Storage-Root-Config - [ ] Project-Folder-Creation-On-Backend - - [ ] moku.project.json + - [ ] manifest.jsonc - [ ] Item-Folder-Creation - - [ ] item.json + - [ ] item.cbor - [ ] schema.json - - [ ] data.json + - [ ] data.cbor - [ ] DB-To-Files-Write-Flow - [ ] User-and-Workspace-Domain-Readiness - [ ] Base-Workspace