package store import ( "context" "database/sql" "encoding/json" "errors" "strings" ) // TaskDAVData is retained in the canonical task revision, not just a cache. // Generic SaveTask preserves it; only SaveTaskDAV can replace it. type TaskDAVData struct { Name string `json:"name"` UID string `json:"uid"` Data string `json:"data"` } var ErrTaskDAVLimit = errors.New("task DAV collection exceeds response limit") var ErrTaskDAVIdentity = errors.New("task DAV UID or resource name already exists") var ErrTaskDAVRelocated = errors.New("task DAV resource moved to a project collection; rediscover collections") func (s *Store) ensureTaskDAVSchema() error { for _, q := range []string{ `CREATE TABLE IF NOT EXISTS organizer_dav_collections(domain_uuid TEXT NOT NULL,path TEXT NOT NULL,owner_uuid TEXT NOT NULL,project_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,path),UNIQUE(domain_uuid,project_uuid))`, `CREATE TABLE IF NOT EXISTS organizer_dav_resources(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,item_uuid TEXT NOT NULL,name TEXT NOT NULL,uid TEXT NOT NULL,PRIMARY KEY(domain_uuid,item_uuid),UNIQUE(domain_uuid,owner_uuid,name),UNIQUE(domain_uuid,owner_uuid,uid))`, `CREATE TABLE IF NOT EXISTS organizer_dav_legacy_hrefs(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,name TEXT NOT NULL,item_uuid TEXT NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid,name))`, `CREATE TABLE IF NOT EXISTS organizer_dav_default_lists(domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,title TEXT NOT NULL,updated_at_ms INTEGER NOT NULL,PRIMARY KEY(domain_uuid,owner_uuid))`, `CREATE TABLE IF NOT EXISTS organizer_dav_credentials(id TEXT PRIMARY KEY,domain_uuid TEXT NOT NULL,owner_uuid TEXT NOT NULL,label TEXT NOT NULL,secret_hash TEXT NOT NULL,write_access INTEGER NOT NULL,created_ms INTEGER NOT NULL,expires_ms INTEGER NOT NULL)`, `CREATE INDEX IF NOT EXISTS organizer_dav_credentials_owner ON organizer_dav_credentials(domain_uuid,owner_uuid)`, `CREATE TABLE IF NOT EXISTS organizer_dav_scopes(credential_id TEXT PRIMARY KEY,scope TEXT NOT NULL CHECK(scope IN ('tasks','calendar','all')))`, `CREATE TABLE IF NOT EXISTS organizer_dav_compat(credential_id TEXT PRIMARY KEY)`, `CREATE TRIGGER IF NOT EXISTS organizer_dav_compat_delete AFTER DELETE ON organizer_dav_credentials BEGIN DELETE FROM organizer_dav_compat WHERE credential_id=OLD.id; END`, `CREATE TRIGGER IF NOT EXISTS organizer_dav_scopes_delete AFTER DELETE ON organizer_dav_credentials BEGIN DELETE FROM organizer_dav_scopes WHERE credential_id=OLD.id; END`, } { if _, err := s.DB.Exec(q); err != nil { return err } } // Both tables are derived indexes. Rebuild atomically, including archived // identities, so an upgrade never exposes projects in the default list or // leaves old hrefs writable after moving them to project collections. tx, err := s.DB.Begin() if err != nil { return err } defer tx.Rollback() for _, q := range []string{ // Keep upgrade tombstones: a stale client must not recreate an already // relocated task in the default list. These are migration metadata, not // a live alias that could delete/update a different collection. `INSERT OR IGNORE INTO organizer_dav_legacy_hrefs(domain_uuid,owner_uuid,name,item_uuid) SELECT r.domain_uuid,r.owner_uuid,r.name,r.item_uuid FROM organizer_dav_resources r JOIN organizer_items i ON i.domain_uuid=r.domain_uuid AND i.uuid=r.item_uuid WHERE i.project_uuid<>'' AND instr(r.name,char(0))=0`, `DELETE FROM organizer_dav_resources`, `DELETE FROM organizer_dav_collections`, `INSERT INTO organizer_dav_collections(domain_uuid,path,owner_uuid,project_uuid) SELECT domain_uuid,COALESCE(NULLIF(json_extract(data,'$.dav_collection'),''),'tasks/projects/'||uuid),owner_uuid,uuid FROM organizer_items WHERE kind='project'`, `INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) SELECT domain_uuid,owner_uuid,uuid,CASE WHEN project_uuid='' THEN '' ELSE char(0)||project_uuid||char(0) END||COALESCE(json_extract(data,'$.caldav.name'),uuid||'.ics'),CASE WHEN project_uuid='' THEN '' ELSE char(0)||project_uuid||char(0) END||COALESCE(json_extract(data,'$.caldav.uid'),uuid) FROM organizer_items WHERE kind='task'`, // Deleted identities remain reserved after an index rebuild. A stale // client PUT must not silently resurrect a deliberately removed task. `INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) SELECT domain_uuid,owner_uuid,item_uuid,dav_name,dav_uid FROM organizer_task_deletions`, } { if _, err = tx.Exec(q); err != nil { return err } } return tx.Commit() } func syncTaskDAVTx(ctx context.Context, tx *sql.Tx, domain, actor string, item TaskRecord) error { if item.Kind == "project" { _, err := tx.ExecContext(ctx, `INSERT INTO organizer_dav_collections(domain_uuid,path,owner_uuid,project_uuid) VALUES(?,?,?,?) ON CONFLICT(domain_uuid,project_uuid) DO NOTHING`, domain, item.TaskDAVCollectionPath(), actor, item.UUID) return err } if item.Kind != "task" { return nil } name, uid := item.UUID+".ics", item.UUID if item.CalDAV != nil { name, uid = item.CalDAV.Name, item.CalDAV.UID } project, err := taskDAVProjectTx(ctx, tx, domain, actor, item.ProjectUUID) if err != nil { return err } name, uid = taskDAVIndexKey(project, name), taskDAVIndexKey(project, uid) var collision bool if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_resources WHERE domain_uuid=? AND owner_uuid=? AND item_uuid<>? AND (name=? OR uid=?))`, domain, actor, item.UUID, name, uid).Scan(&collision); err != nil { return err } if collision { return ErrTaskDAVIdentity } _, err = tx.ExecContext(ctx, `INSERT INTO organizer_dav_resources(domain_uuid,owner_uuid,item_uuid,name,uid) VALUES(?,?,?,?,?) ON CONFLICT(domain_uuid,item_uuid) DO UPDATE SET name=excluded.name,uid=excluded.uid`, domain, actor, item.UUID, name, uid) return err } func (s *Store) TaskDAVByName(ctx context.Context, domain, actor, name string, project ...string) (TaskRecord, error) { if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return TaskRecord{}, err } var id string if len(project) == 1 { name = taskDAVIndexKey(project[0], name) } if err := s.DB.QueryRowContext(ctx, `SELECT item_uuid FROM organizer_dav_resources WHERE domain_uuid=? AND owner_uuid=? AND name=?`, domain, actor, name).Scan(&id); err != nil { return TaskRecord{}, err } return s.GetTask(ctx, domain, actor, id) } // A complete bounded snapshot, including completed tasks. Never silently return // a partial collection: synchronizers would mistake omitted resources for deletes. func (s *Store) TaskDAVList(ctx context.Context, domain, actor string, project ...string) ([]TaskRecord, error) { if err := taskActor(ctx, s.DB, domain, actor, false); err != nil { return nil, err } p := "" if len(project) == 1 { p = project[0] } query := `SELECT data FROM organizer_items i WHERE domain_uuid=? AND owner_uuid=? AND kind='task' AND archived=0` args := []any{domain, actor} if p != "" { query += ` AND project_uuid=?` args = append(args, p) } else { query += ` AND project_uuid=''` } rows, err := s.DB.QueryContext(ctx, query+` ORDER BY created_at_ms DESC,uuid DESC LIMIT 10001`, args...) if err != nil { return nil, err } defer rows.Close() out := []TaskRecord{} size := 0 for rows.Next() { var raw string if err = rows.Scan(&raw); err != nil { return nil, err } size += len(raw) if len(out) >= 10000 || size > 32<<20 { return nil, ErrTaskDAVLimit } var item TaskRecord if err = json.Unmarshal([]byte(raw), &item); err != nil { return nil, err } out = append(out, item) } return out, rows.Err() } func (s *Store) SaveTaskDAV(ctx context.Context, domain, actor string, item TaskRecord, expected int64, data *TaskDAVData, credential string, collectionProject ...string) (TaskRecord, error) { return s.saveTask(ctx, domain, actor, item, expected, func(tx *sql.Tx, v *TaskRecord, old TaskRecord) error { if credential != "" { if err := taskDAVCredentialAllowed(ctx, tx, domain, actor, credential, true); err != nil { return err } } if v.Kind != "task" { return ErrTaskInvalid } if len(collectionProject) == 1 { p, err := taskDAVProjectTx(ctx, tx, domain, actor, v.ProjectUUID) if err != nil { return err } if p != collectionProject[0] { return ErrTaskConflict } if p != "" { var active bool if err := tx.QueryRowContext(ctx, `SELECT archived=0 FROM organizer_items WHERE domain_uuid=? AND owner_uuid=? AND uuid=?`, domain, actor, p).Scan(&active); err != nil { return err } if !active { return ErrAccessDenied } } } if data != nil { if !ValidTaskDAVName(data.Name) || data.UID == "" || len(data.UID) > 512 || strings.ContainsAny(data.UID, "\r\n\x00") || len(data.Data) > 32768 { return ErrTaskInvalid } if old.Version > 0 { name, uid := old.UUID+".ics", old.UUID if old.CalDAV != nil { name, uid = old.CalDAV.Name, old.CalDAV.UID } if data.Name != name || data.UID != uid { return ErrTaskDAVIdentity } } else if v.ProjectUUID == "" { var relocated bool if err := tx.QueryRowContext(ctx, `SELECT EXISTS(SELECT 1 FROM organizer_dav_legacy_hrefs WHERE domain_uuid=? AND owner_uuid=? AND name=?)`, domain, actor, data.Name).Scan(&relocated); err != nil { return err } if relocated { return ErrTaskDAVRelocated } } copy := *data v.CalDAV = © } return nil }) } func ValidTaskDAVName(name string) bool { if len(name) > 128 || len(name) < 5 || !strings.HasSuffix(name, ".ics") { return false } for _, c := range name { if !(c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z' || c >= '0' && c <= '9' || strings.ContainsRune("._-", c)) { return false } } return name != "..ics" }