Files
pages/internal/store/object_listing.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

221 lines
7.6 KiB
Go

package store
import (
"context"
"database/sql"
"encoding/json"
"errors"
"strings"
"time"
)
const ObjectListCandidateLimit = 400
const objectListBindingLimit = 8000
var ErrObjectListBudget = errors.New("object listing authorization exceeds the bounded request budget")
type ObjectListPosition struct {
CreatedAt int64 `json:"created_at"`
UUID string `json:"uuid"`
}
type objectListCursor struct {
Purpose string `json:"purpose"`
Domain string `json:"domain"`
Principal string `json:"principal"`
Expires int64 `json:"expires"`
Position ObjectListPosition `json:"position"`
}
func (s *Store) EnsureObjectListingSchema() error {
var available bool
if err := s.DB.QueryRow(`SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='objects') AND EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='paths')`).Scan(&available); err != nil {
return err
}
// Domain-only migration fixtures/installations may not have installed the
// Object schema yet. Their migration must not depend on the listing index.
if !available {
return nil
}
_, err := s.DB.Exec(`CREATE INDEX IF NOT EXISTS idx_objects_metadata_page ON objects(COALESCE(created_at,0) DESC,uuid ASC);
CREATE INDEX IF NOT EXISTS idx_paths_object_domain_page ON paths(object_uuid,domain_uuid,path)`)
return err
}
// Cursors are encrypted: a denied-only page must not expose a hidden Object's
// UUID or timestamp through a base64-encoded pagination bookmark.
func (s *Store) EncodeObjectListCursor(domain, principal string, position ObjectListPosition) (string, error) {
raw, err := json.Marshal(objectListCursor{Purpose: "object-metadata-v1", Domain: domain, Principal: principal, Expires: time.Now().Add(15 * time.Minute).Unix(), Position: position})
if err != nil {
return "", err
}
encoded, err := s.encryptAuthSecret(raw)
return strings.NewReplacer("+", "-", "/", "_").Replace(encoded), err
}
func (s *Store) DecodeObjectListCursor(encoded, domain, principal string) (*ObjectListPosition, error) {
if encoded == "" {
return nil, nil
}
if len(encoded) > 2048 {
return nil, errors.New("invalid object-list cursor")
}
raw, err := s.decryptAuthSecret(strings.NewReplacer("-", "+", "_", "/").Replace(encoded))
var cursor objectListCursor
if err != nil || json.Unmarshal(raw, &cursor) != nil || cursor.Purpose != "object-metadata-v1" || cursor.Domain != domain || cursor.Principal != principal || cursor.Expires <= time.Now().Unix() || cursor.Position.UUID == "" || len(cursor.Position.UUID) > 128 || cursor.Position.CreatedAt < 0 {
return nil, errors.New("invalid object-list cursor")
}
return &cursor.Position, nil
}
// LoadObjectListReadGrants adds direct Object authority to the separate Path
// filter. Broad grants apply only to candidates already scoped by live Domain
// bindings, never to globally identified Objects in another Domain.
func (s *Store) LoadObjectListReadGrants(ctx context.Context, domain, principal string) (map[string]bool, bool, error) {
exact := make(map[string]bool)
rows, err := s.DB.QueryContext(ctx, `SELECT g.target_type,g.target_id FROM principals p
JOIN domain_memberships m ON m.principal_uuid=p.uuid AND m.domain_uuid=? AND m.state='active'
JOIN auth_role_bindings b ON b.membership_uuid=m.uuid
JOIN auth_roles r ON r.uuid=b.role_uuid AND r.domain_uuid=m.domain_uuid
JOIN auth_capability_grants g ON g.role_uuid=r.uuid AND g.capability='read'
WHERE p.uuid=? AND p.state IN ('active','readonly') AND g.target_type IN ('domain','object') LIMIT 4097`, domain, principal)
if err != nil {
return nil, false, err
}
defer rows.Close()
broad, count := false, 0
for rows.Next() {
count++
if count > 4096 {
return nil, false, ErrObjectListBudget
}
var kind, target string
if err := rows.Scan(&kind, &target); err != nil {
return nil, false, err
}
if kind == "domain" && target == domain || kind == "object" && target == "*" {
broad = true
} else if kind == "object" {
exact[target] = true
}
}
return exact, broad, rows.Err()
}
// ListObjectMetadataPage consumes at most 400 Object candidates and 8,000
// binding rows. The next position advances even when no candidate is readable.
// Paths stay internal and are never included in the returned metadata.
func (s *Store) ListObjectMetadataPage(ctx context.Context, domain string, after *ObjectListPosition, limit int, allowedPath func(string) bool, exact map[string]bool, broad bool) ([]Object, *ObjectListPosition, error) {
if limit <= 0 || limit > 200 {
limit = 100
}
if !broad && allowedPath == nil {
return nil, nil, ErrAccessDenied
}
tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{ReadOnly: true})
if err != nil {
return nil, nil, err
}
defer tx.Rollback()
type branch struct {
predicate string
args []any
}
branches := []branch{{args: []any{domain}}}
if after != nil {
// Separate the equality and older-time ranges so SQLite can seek by
// UUID within large same-second import batches instead of re-scanning
// every earlier UUID in that timestamp on each page.
branches = []branch{
{` AND COALESCE(o.created_at,0)=? AND o.uuid>?`, []any{domain, after.CreatedAt, after.UUID}},
{` AND COALESCE(o.created_at,0)<?`, []any{domain, after.CreatedAt}},
}
}
candidates := make([]Object, 0, ObjectListCandidateLimit+1)
for _, part := range branches {
remaining := ObjectListCandidateLimit + 1 - len(candidates)
if remaining <= 0 {
break
}
rows, err := tx.QueryContext(ctx, `SELECT o.uuid,COALESCE(o.kind,''),COALESCE(o.created_at,0) FROM objects o
WHERE EXISTS(SELECT 1 FROM paths p WHERE p.domain_uuid=? AND p.object_uuid=o.uuid)`+part.predicate+` ORDER BY COALESCE(o.created_at,0) DESC,o.uuid ASC LIMIT ?`, append(part.args, remaining)...)
if err != nil {
return nil, nil, err
}
for rows.Next() {
var object Object
if err := rows.Scan(&object.UUID, &object.Kind, &object.CreatedAt); err != nil {
rows.Close()
return nil, nil, err
}
candidates = append(candidates, object)
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, nil, err
}
}
more := len(candidates) > ObjectListCandidateLimit
if more {
candidates = candidates[:ObjectListCandidateLimit]
}
visible := make(map[string]bool)
args := []any{domain}
for _, object := range candidates {
if broad || exact[object.UUID] {
visible[object.UUID] = true
} else {
args = append(args, object.UUID)
}
}
if len(args) > 1 {
rows, err := tx.QueryContext(ctx, `SELECT object_uuid,path FROM paths WHERE domain_uuid=? AND object_uuid IN (`+strings.TrimRight(strings.Repeat("?,", len(args)-1), ",")+`) LIMIT 8001`, args...)
if err != nil {
return nil, nil, err
}
count := 0
for rows.Next() {
count++
if count > objectListBindingLimit {
rows.Close()
return nil, nil, ErrObjectListBudget
}
var id, path string
if err := rows.Scan(&id, &path); err != nil {
rows.Close()
return nil, nil, err
}
if allowedPath(path) {
visible[id] = true
}
if len(visible) == len(candidates) {
break
}
}
err = rows.Err()
rows.Close()
if err != nil {
return nil, nil, err
}
}
out := make([]Object, 0, min(limit, len(candidates)))
var next *ObjectListPosition
for i, object := range candidates {
if visible[object.UUID] {
out = append(out, object)
}
if len(out) == limit {
if i+1 < len(candidates) || more {
next = &ObjectListPosition{CreatedAt: object.CreatedAt, UUID: object.UUID}
}
return out, next, nil
}
}
if more && len(candidates) != 0 {
last := candidates[len(candidates)-1]
next = &ObjectListPosition{CreatedAt: last.CreatedAt, UUID: last.UUID}
}
return out, next, nil
}