Files
pages/internal/store/list_children.go
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

262 lines
5.6 KiB
Go

package store
import (
"fmt"
"os"
"strings"
)
func (s *Store) ListChildPaths(
parent string,
) ([]string, error) {
domainUUID, err := s.defaultDomainUUID()
if err != nil {
return nil, err
}
return s.ListChildPathsInDomain(domainUUID, parent)
}
func (s *Store) ListChildPathsInDomain(
domainUUID string,
parent string,
) ([]string, error) {
parent = strings.TrimRight(parent, "/")
if parent == "/" {
parent = ""
}
cacheKey := domainUUID + "\x00" + parent
s.pathCacheMu.RLock()
cached, ok := s.childCache[cacheKey]
s.pathCacheMu.RUnlock()
if ok {
return append([]string(nil), cached...), nil
}
rows, err := s.DB.Query(`
SELECT path
FROM paths
WHERE domain_uuid = ?
ORDER BY path ASC
`, domainUUID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
seen := map[string]bool{}
for rows.Next() {
var path string
err := rows.Scan(
&path,
)
if err != nil {
return nil, err
}
if parent != "" {
if !strings.HasPrefix(
path,
parent+"/",
) {
continue
}
} else {
if !strings.HasPrefix(
path,
"/",
) {
continue
}
}
trimmed :=
strings.TrimPrefix(
path,
parent,
)
trimmed =
strings.TrimPrefix(
trimmed,
"/",
)
if trimmed == "" {
continue
}
if slash := strings.Index(trimmed, "/"); slash >= 0 {
trimmed = trimmed[:slash]
}
child := parent + "/" + trimmed
if !seen[child] {
seen[child] = true
out = append(out, child)
}
}
s.pathCacheMu.Lock()
s.childCache[cacheKey] = append([]string(nil), out...)
s.pathCacheMu.Unlock()
return out, nil
}
func (s *Store) InvalidatePathCaches() {
s.pathCacheMu.Lock()
s.childCache = map[string][]string{}
s.pathCacheMu.Unlock()
}
// ListChildEntriesPageInDomain uses the cached direct-child index first, then
// fetches metadata only for the requested page. Virtual folders therefore do
// not require a Revision scan, and very large directories remain bounded.
func (s *Store) ListChildEntriesPageInDomain(
domainUUID, parent string,
offset, limit int,
) ([]BrowserEntry, int, error) {
children, err := s.ListChildPathsInDomain(domainUUID, parent)
if err != nil {
return nil, 0, err
}
total := len(children)
if offset < 0 {
offset = 0
}
if limit <= 0 || limit > 400 {
limit = 120
}
if offset >= total {
return []BrowserEntry{}, total, nil
}
end := offset + limit
if end > total {
end = total
}
page := children[offset:end]
entries, _, err := s.ListSelectedChildEntriesInDomain(domainUUID, parent, page)
return entries, total, err
}
// The caller supplies a permission-filtered page, so hidden entries do not
// consume pagination slots and private virtual-parent metadata is never read.
func (s *Store) ListSelectedChildEntriesInDomain(domainUUID, parent string, page []string) ([]BrowserEntry, int, error) {
total := len(page)
if total == 0 {
return []BrowserEntry{}, 0, nil
}
if total > 400 {
return nil, 0, ErrNavigationBudget
}
var values strings.Builder
args := make([]any, 0, len(page)*2+1)
for index, child := range page {
if index > 0 {
values.WriteByte(',')
}
values.WriteString("(?,?)")
args = append(args, child, index)
}
args = append(args, domainUUID)
query := fmt.Sprintf(`
WITH requested(path, ord) AS (VALUES %s),
resolved AS (
SELECT
requested.path,
requested.ord,
COALESCE(paths.object_uuid, '') AS object_uuid
FROM requested
LEFT JOIN paths
ON paths.domain_uuid = ?
AND paths.path = requested.path
),
latest AS (
SELECT
r.object_uuid,
r.uuid AS revision_uuid,
COALESCE(r.document_hash, '') AS document_hash,
COALESCE(r.created_at, 0) AS updated_at,
COALESCE(NULLIF(r.content_type, ''), 'application/octet-stream') AS content_type,
COALESCE(r.filename, '') AS filename,
COALESCE(substr(CAST(r.body AS TEXT), 1, 65536), '') AS source_prefix,
ROW_NUMBER() OVER (
PARTITION BY r.object_uuid
ORDER BY COALESCE(r.created_at_ms, r.created_at * 1000) DESC, r.rowid DESC
) AS rn
FROM revisions r
JOIN resolved
ON resolved.object_uuid = r.object_uuid
)
SELECT
resolved.path,
resolved.object_uuid,
COALESCE(latest.revision_uuid, ''),
COALESCE(latest.document_hash, ''),
COALESCE(latest.updated_at, 0),
COALESCE(latest.content_type, ''),
COALESCE(latest.filename, ''),
COALESCE(latest.source_prefix, '')
FROM resolved
LEFT JOIN latest
ON latest.object_uuid = resolved.object_uuid
AND latest.rn = 1
ORDER BY resolved.ord
`, values.String())
rows, err := s.DB.Query(query, args...)
if err != nil {
return nil, total, err
}
defer rows.Close()
entries := make([]BrowserEntry, 0, len(page))
for rows.Next() {
var entry BrowserEntry
var documentHash string
var sourcePrefix string
if err := rows.Scan(
&entry.Path,
&entry.ObjectUUID,
&entry.RevisionUUID,
&documentHash,
&entry.UpdatedAt,
&entry.ContentType,
&entry.Filename,
&sourcePrefix,
); err != nil {
return nil, total, err
}
entry.Name = strings.TrimPrefix(
strings.TrimPrefix(entry.Path, strings.TrimRight(parent, "/")),
"/",
)
entry.IsDir = entry.ObjectUUID == ""
entry.DocumentHash = documentHash
if !entry.IsDir {
entry.Title = firstHTMLHeading(sourcePrefix)
}
if documentHash != "" && s.DocumentRoot != "" {
if path, pathErr := s.documentPath(documentHash); pathErr == nil {
if info, statErr := os.Stat(path); statErr == nil {
entry.Size = int(info.Size())
}
}
}
entries = append(entries, entry)
}
if err := rows.Err(); err != nil {
return nil, total, err
}
return entries, total, nil
}