package store import ( "context" "encoding/base64" "errors" "slices" "sort" "strconv" "strings" "time" "droboticflow/internal/domain" "go.mongodb.org/mongo-driver/bson" "go.mongodb.org/mongo-driver/mongo" "go.mongodb.org/mongo-driver/mongo/options" ) var ( ErrObjectSyncLeaseHeld = errors.New("object sync resource lease is held by another item") ) type ObjectSyncStore interface { ListObjectSyncSpaces(context.Context, string) ([]domain.ObjectSyncSpaceRecord, error) GetObjectSyncSpace(context.Context, string) (*domain.ObjectSyncSpaceRecord, error) UpsertObjectSyncSpace(context.Context, domain.ObjectSyncSpaceRecord) error ListObjectSyncDevices(context.Context, string) ([]domain.ObjectSyncDeviceRecord, error) GetObjectSyncDevice(context.Context, string) (*domain.ObjectSyncDeviceRecord, error) UpsertObjectSyncDevice(context.Context, domain.ObjectSyncDeviceRecord) error ListObjectSyncAuthorizations(context.Context, string, string) ([]domain.ObjectSyncDeviceAuthorizationRecord, error) GetObjectSyncAuthorization(context.Context, string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) GetObjectSyncAuthorizationByDeviceCodeHash(context.Context, string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) GetObjectSyncAuthorizationByUserCode(context.Context, string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) UpsertObjectSyncAuthorization(context.Context, domain.ObjectSyncDeviceAuthorizationRecord) error ListObjectSyncCredentials(context.Context, string) ([]domain.ObjectSyncCredentialRecord, error) GetObjectSyncCredential(context.Context, string) (*domain.ObjectSyncCredentialRecord, error) GetObjectSyncCredentialByAccessKeyID(context.Context, string) (*domain.ObjectSyncCredentialRecord, error) GetObjectSyncCredentialByTokenHash(context.Context, string) (*domain.ObjectSyncCredentialRecord, error) UpsertObjectSyncCredential(context.Context, domain.ObjectSyncCredentialRecord) error ListObjectSyncSessions(context.Context, domain.ObjectSyncListQuery) (domain.ObjectSyncSessionPage, error) GetObjectSyncSession(context.Context, string) (*domain.ObjectSyncSessionRecord, error) UpsertObjectSyncSession(context.Context, domain.ObjectSyncSessionRecord) error ClaimObjectSyncSession(context.Context, domain.ObjectSyncSessionStatus, domain.ObjectSyncSessionStatus, string) (*domain.ObjectSyncSessionRecord, error) GetObjectSyncItem(context.Context, string) (*domain.ObjectSyncItemRecord, error) UpsertObjectSyncItems(context.Context, []domain.ObjectSyncItemRecord) error ListObjectSyncItems(context.Context, domain.ObjectSyncListQuery) (domain.ObjectSyncItemPage, error) ClaimObjectSyncItem(context.Context, string, time.Duration) (*domain.ObjectSyncItemRecord, error) ClaimObjectSyncCleanupItem(context.Context, string, time.Time, time.Duration) (*domain.ObjectSyncItemRecord, error) AcquireObjectSyncLease(context.Context, domain.ObjectSyncLeaseRecord, time.Duration) (*domain.ObjectSyncLeaseRecord, bool, error) RenewObjectSyncLease(context.Context, string, string, string, int64, time.Duration) (bool, error) ReleaseObjectSyncLease(context.Context, string, string, string, int64) error ForceReleaseObjectSyncLease(context.Context, string) (*domain.ObjectSyncLeaseRecord, bool, error) GetObjectSyncHead(context.Context, string, string, string) (*domain.ObjectSyncObjectHeadRecord, error) UpsertObjectSyncHead(context.Context, domain.ObjectSyncObjectHeadRecord) error ListObjectSyncHeads(context.Context, string, string, string, int) (domain.ObjectSyncHeadPage, error) InsertObjectSyncVersion(context.Context, domain.ObjectSyncVersionRecord) error AppendObjectSyncAudit(context.Context, domain.ObjectSyncAuditEvent) error ListObjectSyncAudit(context.Context, domain.ObjectSyncListQuery) ([]domain.ObjectSyncAuditEvent, error) ListObjectSyncAuditRange(context.Context, string, string, string, string, int) (domain.ObjectSyncAuditPage, error) GetLatestObjectSyncAudit(context.Context, string) (*domain.ObjectSyncAuditEvent, error) GetObjectSyncAuditSeal(context.Context, string, string) (*domain.ObjectSyncAuditSealRecord, error) InsertObjectSyncAuditSeal(context.Context, domain.ObjectSyncAuditSealRecord) error ListObjectSyncReleases(context.Context, string) ([]domain.ObjectSyncReleaseRecord, error) UpsertObjectSyncRelease(context.Context, domain.ObjectSyncReleaseRecord) error ClaimObjectSyncRelease(context.Context, string, time.Duration) (*domain.ObjectSyncReleaseRecord, error) ListObjectSyncClientReleases(context.Context) ([]domain.ObjectSyncClientReleaseRecord, error) UpsertObjectSyncClientRelease(context.Context, domain.ObjectSyncClientReleaseRecord) error UpsertObjectSyncReconcile(context.Context, domain.ObjectSyncReconcileRecord) error ClaimObjectSyncReconcile(context.Context, string, time.Duration) (*domain.ObjectSyncReconcileRecord, error) BeginObjectSyncIdempotency(context.Context, domain.ObjectSyncIdempotencyRecord) (*domain.ObjectSyncIdempotencyRecord, bool, error) CompleteObjectSyncIdempotency(context.Context, domain.ObjectSyncIdempotencyRecord) error DeleteObjectSyncIdempotency(context.Context, string, string) error ConsumeObjectSyncRateLimit(context.Context, domain.ObjectSyncRateLimitRecord, int64) (domain.ObjectSyncRateLimitRecord, bool, error) } func AsObjectSyncStore(value Store) (ObjectSyncStore, bool) { target, ok := value.(ObjectSyncStore) return target, ok } func objectSyncLimit(value int) int { if value <= 0 { return 100 } if value > 1000 { return 1000 } return value } func decodeObjectSyncCursor(value string) string { if value == "" { return "" } decoded, err := base64.RawURLEncoding.DecodeString(value) if err != nil { return value } return string(decoded) } func encodeObjectSyncCursor(value string) string { if value == "" { return "" } return base64.RawURLEncoding.EncodeToString([]byte(value)) } func objectSyncSessionCursor(item domain.ObjectSyncSessionRecord) string { return item.CreatedAt + "\x00" + item.ID } func (store *MemoryStore) BeginObjectSyncIdempotency(_ context.Context, requested domain.ObjectSyncIdempotencyRecord) (*domain.ObjectSyncIdempotencyRecord, bool, error) { store.mu.Lock() defer store.mu.Unlock() if item, ok := store.objectSyncIdempotency[requested.ID]; ok { copy := item return ©, false, nil } store.objectSyncIdempotency[requested.ID] = requested copy := requested return ©, true, nil } func (store *MemoryStore) ConsumeObjectSyncRateLimit(_ context.Context, requested domain.ObjectSyncRateLimitRecord, limit int64) (domain.ObjectSyncRateLimitRecord, bool, error) { store.mu.Lock() defer store.mu.Unlock() item, exists := store.objectSyncRateLimits[requested.ID] if !exists || (!item.ExpiresAt.IsZero() && item.ExpiresAt.Before(time.Now().UTC())) { item = requested item.Count = 0 } item.Count++ store.objectSyncRateLimits[requested.ID] = item return item, limit <= 0 || item.Count <= limit, nil } func (store *MemoryStore) UpsertObjectSyncReconcile(_ context.Context, item domain.ObjectSyncReconcileRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncReconciles[item.ID] = item return nil } func (store *MemoryStore) ClaimObjectSyncReconcile(_ context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncReconcileRecord, error) { store.mu.Lock() defer store.mu.Unlock() now := time.Now().UTC() for id, item := range store.objectSyncReconciles { if item.Status != "pending" || (item.CoordinatorOwner != "" && item.CoordinatorLeaseUntil.After(now)) { continue } item.Status = "running" item.CoordinatorOwner = owner item.CoordinatorLeaseUntil = now.Add(ttl) item.UpdatedAt = now.Format(time.RFC3339Nano) store.objectSyncReconciles[id] = item copy := item return ©, nil } return nil, nil } func (store *MemoryStore) CompleteObjectSyncIdempotency(_ context.Context, item domain.ObjectSyncIdempotencyRecord) error { store.mu.Lock() defer store.mu.Unlock() existing, ok := store.objectSyncIdempotency[item.ID] if !ok || existing.RequestDigest != item.RequestDigest { return mongo.ErrNoDocuments } store.objectSyncIdempotency[item.ID] = item return nil } func (store *MemoryStore) DeleteObjectSyncIdempotency(_ context.Context, id, requestDigest string) error { store.mu.Lock() defer store.mu.Unlock() if item, ok := store.objectSyncIdempotency[id]; ok && item.RequestDigest == requestDigest { delete(store.objectSyncIdempotency, id) } return nil } func (store *MemoryStore) ListObjectSyncSpaces(_ context.Context, organizationID string) ([]domain.ObjectSyncSpaceRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncSpaceRecord, 0) for _, item := range store.objectSyncSpaces { if item.OrganizationID == normalizedOrganizationID(organizationID) { items = append(items, item) } } sort.Slice(items, func(i, j int) bool { return items[i].UpdatedAt > items[j].UpdatedAt }) return items, nil } func (store *MemoryStore) GetObjectSyncSpace(_ context.Context, id string) (*domain.ObjectSyncSpaceRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncSpaces[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) UpsertObjectSyncSpace(_ context.Context, item domain.ObjectSyncSpaceRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncSpaces[item.ID] = item return nil } func (store *MemoryStore) ListObjectSyncDevices(_ context.Context, organizationID string) ([]domain.ObjectSyncDeviceRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncDeviceRecord, 0) for _, item := range store.objectSyncDevices { if item.OrganizationID == normalizedOrganizationID(organizationID) { items = append(items, item) } } sort.Slice(items, func(i, j int) bool { return items[i].UpdatedAt > items[j].UpdatedAt }) return items, nil } func (store *MemoryStore) GetObjectSyncDevice(_ context.Context, id string) (*domain.ObjectSyncDeviceRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncDevices[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) UpsertObjectSyncDevice(_ context.Context, item domain.ObjectSyncDeviceRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncDevices[item.ID] = item return nil } func (store *MemoryStore) ListObjectSyncAuthorizations(_ context.Context, organizationID, status string) ([]domain.ObjectSyncDeviceAuthorizationRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncDeviceAuthorizationRecord, 0) for _, item := range store.objectSyncAuthorizations { if organizationID != "" && item.OrganizationID != normalizedOrganizationID(organizationID) { continue } if status != "" && item.Status != status { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return items[i].CreatedAt > items[j].CreatedAt }) return items, nil } func (store *MemoryStore) GetObjectSyncAuthorization(_ context.Context, id string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncAuthorizations[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) GetObjectSyncAuthorizationByDeviceCodeHash(_ context.Context, hash string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { store.mu.Lock() defer store.mu.Unlock() for _, item := range store.objectSyncAuthorizations { if item.DeviceCodeHash == hash { copy := item return ©, nil } } return nil, nil } func (store *MemoryStore) GetObjectSyncAuthorizationByUserCode(_ context.Context, code string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { store.mu.Lock() defer store.mu.Unlock() for _, item := range store.objectSyncAuthorizations { if item.UserCode == code { copy := item return ©, nil } } return nil, nil } func (store *MemoryStore) UpsertObjectSyncAuthorization(_ context.Context, item domain.ObjectSyncDeviceAuthorizationRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncAuthorizations[item.ID] = item return nil } func (store *MemoryStore) ListObjectSyncCredentials(_ context.Context, organizationID string) ([]domain.ObjectSyncCredentialRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncCredentialRecord, 0) for _, item := range store.objectSyncCredentials { if item.OrganizationID == normalizedOrganizationID(organizationID) { items = append(items, item) } } sort.Slice(items, func(i, j int) bool { return items[i].CreatedAt > items[j].CreatedAt }) return items, nil } func (store *MemoryStore) GetObjectSyncCredential(_ context.Context, id string) (*domain.ObjectSyncCredentialRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncCredentials[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) GetObjectSyncCredentialByAccessKeyID(_ context.Context, accessKeyID string) (*domain.ObjectSyncCredentialRecord, error) { store.mu.Lock() defer store.mu.Unlock() for _, item := range store.objectSyncCredentials { if item.AccessKeyID == accessKeyID { copy := item return ©, nil } } return nil, nil } func (store *MemoryStore) GetObjectSyncCredentialByTokenHash(_ context.Context, hash string) (*domain.ObjectSyncCredentialRecord, error) { store.mu.Lock() defer store.mu.Unlock() for _, item := range store.objectSyncCredentials { if item.TokenHash == hash { copy := item return ©, nil } for _, candidate := range item.TokenHashes { if candidate == hash { copy := item return ©, nil } } for _, binding := range item.TokenBindings { if binding.TokenHash == hash { copy := item return ©, nil } } } return nil, nil } func (store *MemoryStore) UpsertObjectSyncCredential(_ context.Context, item domain.ObjectSyncCredentialRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncCredentials[item.ID] = item return nil } func (store *MemoryStore) ListObjectSyncSessions(_ context.Context, query domain.ObjectSyncListQuery) (domain.ObjectSyncSessionPage, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncSessionRecord, 0) decodedCursor := decodeObjectSyncCursor(query.Cursor) for _, item := range store.objectSyncSessions { if query.OrganizationID != "" && item.OrganizationID != normalizedOrganizationID(query.OrganizationID) { continue } if len(query.SyncSpaceIDs) > 0 && !slices.Contains(query.SyncSpaceIDs, item.SyncSpaceID) { continue } if query.Status != "" && string(item.Status) != query.Status { continue } if decodedCursor != "" && objectSyncSessionCursor(item) >= decodedCursor { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return objectSyncSessionCursor(items[i]) > objectSyncSessionCursor(items[j]) }) limit := objectSyncLimit(query.Limit) page := domain.ObjectSyncSessionPage{Items: items} if len(items) > limit { page.Items = items[:limit] page.NextCursor = encodeObjectSyncCursor(objectSyncSessionCursor(page.Items[len(page.Items)-1])) } return page, nil } func (store *MemoryStore) GetObjectSyncSession(_ context.Context, id string) (*domain.ObjectSyncSessionRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncSessions[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) UpsertObjectSyncSession(_ context.Context, item domain.ObjectSyncSessionRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncSessions[item.ID] = item return nil } func (store *MemoryStore) ClaimObjectSyncSession(_ context.Context, from, to domain.ObjectSyncSessionStatus, operationID string) (*domain.ObjectSyncSessionRecord, error) { store.mu.Lock() defer store.mu.Unlock() for id, item := range store.objectSyncSessions { if item.Status != from { continue } item.Status = to item.OperationID = operationID item.UpdatedAt = nowISO() store.objectSyncSessions[id] = item copy := item return ©, nil } return nil, nil } func (store *MemoryStore) GetObjectSyncItem(_ context.Context, id string) (*domain.ObjectSyncItemRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncItems[id] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) UpsertObjectSyncItems(_ context.Context, items []domain.ObjectSyncItemRecord) error { store.mu.Lock() defer store.mu.Unlock() for _, item := range items { store.objectSyncItems[item.ID] = item } return nil } func (store *MemoryStore) ListObjectSyncItems(_ context.Context, query domain.ObjectSyncListQuery) (domain.ObjectSyncItemPage, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncItemRecord, 0) for _, item := range store.objectSyncItems { if query.SessionID != "" && item.SessionID != query.SessionID { continue } if query.OrganizationID != "" && item.OrganizationID != normalizedOrganizationID(query.OrganizationID) { continue } if query.Status != "" && string(item.Status) != query.Status { continue } if cursor := decodeObjectSyncCursor(query.Cursor); cursor != "" && item.ID <= cursor { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return items[i].ID < items[j].ID }) limit := objectSyncLimit(query.Limit) page := domain.ObjectSyncItemPage{Items: items} if len(items) > limit { page.Items = items[:limit] page.NextCursor = encodeObjectSyncCursor(page.Items[len(page.Items)-1].ID) } return page, nil } func (store *MemoryStore) ClaimObjectSyncItem(_ context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncItemRecord, error) { store.mu.Lock() defer store.mu.Unlock() now := time.Now().UTC() for id, item := range store.objectSyncItems { if item.Status != domain.ObjectSyncItemCommitting || (item.CoordinatorOwner != "" && item.CoordinatorLeaseUntil.After(now)) { continue } item.CoordinatorOwner = owner item.CoordinatorLeaseUntil = now.Add(ttl) item.UpdatedAt = now.Format(time.RFC3339Nano) store.objectSyncItems[id] = item copy := item return ©, nil } return nil, nil } func (store *MemoryStore) ClaimObjectSyncCleanupItem(_ context.Context, owner string, before time.Time, ttl time.Duration) (*domain.ObjectSyncItemRecord, error) { store.mu.Lock() defer store.mu.Unlock() now := time.Now().UTC() for id, item := range store.objectSyncItems { if item.StagingKey == "" || (item.CoordinatorOwner != "" && item.CoordinatorLeaseUntil.After(now)) { continue } switch item.Status { case domain.ObjectSyncItemUploading, domain.ObjectSyncItemUploaded, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired, domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth: default: continue } updatedAt, err := time.Parse(time.RFC3339Nano, item.UpdatedAt) if err != nil || updatedAt.After(before) { continue } item.CoordinatorOwner = owner item.CoordinatorLeaseUntil = now.Add(ttl) store.objectSyncItems[id] = item copy := item return ©, nil } return nil, nil } func (store *MemoryStore) AcquireObjectSyncLease(_ context.Context, requested domain.ObjectSyncLeaseRecord, ttl time.Duration) (*domain.ObjectSyncLeaseRecord, bool, error) { store.mu.Lock() defer store.mu.Unlock() now := time.Now().UTC() item, exists := store.objectSyncLeases[requested.ResourceHash] if exists && item.OwnerItemID != "" && item.ExpiresAtTime.After(now) && item.OwnerItemID != requested.OwnerItemID { copy := item return ©, false, nil } requested.FencingToken = item.FencingToken + 1 requested.ID = item.ID if requested.ID == "" { requested.ID = domain.NewID("synclease") } requested.ExpiresAtTime = now.Add(ttl) requested.ExpiresAt = requested.ExpiresAtTime.Format(time.RFC3339Nano) requested.LastHeartbeatAt = now.Format(time.RFC3339Nano) requested.UpdatedAt = requested.LastHeartbeatAt store.objectSyncLeases[requested.ResourceHash] = requested copy := requested return ©, true, nil } func (store *MemoryStore) RenewObjectSyncLease(_ context.Context, resourceHash, sessionID, itemID string, fencingToken int64, ttl time.Duration) (bool, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncLeases[resourceHash] resolvedHash := resourceHash if !ok { for hash, candidate := range store.objectSyncLeases { if candidate.ID == resourceHash { item = candidate resolvedHash = hash ok = true break } } } if !ok || item.OwnerSessionID != sessionID || item.OwnerItemID != itemID || item.FencingToken != fencingToken { return false, nil } now := time.Now().UTC() item.ExpiresAtTime = now.Add(ttl) item.ExpiresAt = item.ExpiresAtTime.Format(time.RFC3339Nano) item.LastHeartbeatAt = now.Format(time.RFC3339Nano) item.UpdatedAt = item.LastHeartbeatAt store.objectSyncLeases[resolvedHash] = item return true, nil } func (store *MemoryStore) ReleaseObjectSyncLease(_ context.Context, resourceHash, sessionID, itemID string, fencingToken int64) error { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncLeases[resourceHash] resolvedHash := resourceHash if !ok { for hash, candidate := range store.objectSyncLeases { if candidate.ID == resourceHash { item = candidate resolvedHash = hash ok = true break } } } if !ok || item.OwnerSessionID != sessionID || item.OwnerItemID != itemID || item.FencingToken != fencingToken { return nil } item.OwnerSessionID = "" item.OwnerItemID = "" item.ExpiresAt = "" item.ExpiresAtTime = time.Time{} item.UpdatedAt = nowISO() store.objectSyncLeases[resolvedHash] = item return nil } func (store *MemoryStore) ForceReleaseObjectSyncLease(_ context.Context, id string) (*domain.ObjectSyncLeaseRecord, bool, error) { store.mu.Lock() defer store.mu.Unlock() for hash, item := range store.objectSyncLeases { if item.ID != id { continue } item.OwnerSessionID = "" item.OwnerItemID = "" item.ExpiresAt = "" item.ExpiresAtTime = time.Time{} item.UpdatedAt = nowISO() store.objectSyncLeases[hash] = item copy := item return ©, true, nil } return nil, false, nil } func objectSyncHeadKey(organizationID, syncSpaceID, key string) string { return normalizedOrganizationID(organizationID) + "|" + syncSpaceID + "|" + key } func (store *MemoryStore) GetObjectSyncHead(_ context.Context, organizationID, syncSpaceID, key string) (*domain.ObjectSyncObjectHeadRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncHeads[objectSyncHeadKey(organizationID, syncSpaceID, key)] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) UpsertObjectSyncHead(_ context.Context, item domain.ObjectSyncObjectHeadRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncHeads[objectSyncHeadKey(item.OrganizationID, item.SyncSpaceID, item.Key)] = item return nil } func (store *MemoryStore) ListObjectSyncHeads(_ context.Context, organizationID, syncSpaceID, cursor string, limit int) (domain.ObjectSyncHeadPage, error) { store.mu.Lock() defer store.mu.Unlock() decodedCursor := decodeObjectSyncCursor(cursor) items := make([]domain.ObjectSyncObjectHeadRecord, 0) for _, item := range store.objectSyncHeads { if item.OrganizationID != normalizedOrganizationID(organizationID) || item.SyncSpaceID != syncSpaceID || (decodedCursor != "" && item.Key <= decodedCursor) { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return items[i].Key < items[j].Key }) page := domain.ObjectSyncHeadPage{Items: items} pageLimit := objectSyncLimit(limit) if len(items) > pageLimit { page.Items = items[:pageLimit] page.NextCursor = encodeObjectSyncCursor(page.Items[len(page.Items)-1].Key) } return page, nil } func (store *MemoryStore) InsertObjectSyncVersion(_ context.Context, item domain.ObjectSyncVersionRecord) error { store.mu.Lock() defer store.mu.Unlock() key := item.OrganizationID + "|" + item.SyncSpaceID + "|" + item.Key + "|" + strconv.FormatInt(item.PlatformVersion, 10) store.objectSyncVersions[key] = item return nil } func (store *MemoryStore) AppendObjectSyncAudit(_ context.Context, item domain.ObjectSyncAuditEvent) error { store.mu.Lock() defer store.mu.Unlock() for _, existing := range store.objectSyncAuditEvents { if existing.EventKey == item.EventKey { return nil } } store.objectSyncAuditEvents[item.ID] = item return nil } func (store *MemoryStore) ListObjectSyncAudit(_ context.Context, query domain.ObjectSyncListQuery) ([]domain.ObjectSyncAuditEvent, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncAuditEvent, 0) for _, item := range store.objectSyncAuditEvents { if query.OrganizationID != "" && item.OrganizationID != normalizedOrganizationID(query.OrganizationID) { continue } if query.SessionID != "" && item.SessionID != query.SessionID { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return items[i].OccurredAt > items[j].OccurredAt }) if len(items) > objectSyncLimit(query.Limit) { items = items[:objectSyncLimit(query.Limit)] } return items, nil } func (store *MemoryStore) GetLatestObjectSyncAudit(_ context.Context, organizationID string) (*domain.ObjectSyncAuditEvent, error) { items, err := store.ListObjectSyncAudit(context.Background(), domain.ObjectSyncListQuery{OrganizationID: organizationID, Limit: 1}) if err != nil || len(items) == 0 { return nil, err } return &items[0], nil } func (store *MemoryStore) ListObjectSyncReleases(_ context.Context, organizationID string) ([]domain.ObjectSyncReleaseRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncReleaseRecord, 0) for _, item := range store.objectSyncReleases { if item.OrganizationID == normalizedOrganizationID(organizationID) { items = append(items, item) } } sort.Slice(items, func(i, j int) bool { return items[i].CreatedAt > items[j].CreatedAt }) return items, nil } func (store *MemoryStore) UpsertObjectSyncRelease(_ context.Context, item domain.ObjectSyncReleaseRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncReleases[item.ID] = item return nil } func (store *MemoryStore) ClaimObjectSyncRelease(_ context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncReleaseRecord, error) { store.mu.Lock() defer store.mu.Unlock() now := time.Now().UTC() for id, item := range store.objectSyncReleases { if item.Status != "pending" || (item.CoordinatorOwner != "" && item.CoordinatorLeaseUntil.After(now)) { continue } item.CoordinatorOwner = owner item.CoordinatorLeaseUntil = now.Add(ttl) store.objectSyncReleases[id] = item copy := item return ©, nil } return nil, nil } func objectSyncAuditCursor(item domain.ObjectSyncAuditEvent) string { return item.OccurredAt + "\x00" + item.ID } func (store *MemoryStore) ListObjectSyncAuditRange(_ context.Context, organizationID, start, end, cursor string, limit int) (domain.ObjectSyncAuditPage, error) { store.mu.Lock() defer store.mu.Unlock() decodedCursor := decodeObjectSyncCursor(cursor) items := make([]domain.ObjectSyncAuditEvent, 0) for _, item := range store.objectSyncAuditEvents { if item.OrganizationID != normalizedOrganizationID(organizationID) || item.OccurredAt < start || item.OccurredAt >= end || (decodedCursor != "" && objectSyncAuditCursor(item) <= decodedCursor) { continue } items = append(items, item) } sort.Slice(items, func(i, j int) bool { return objectSyncAuditCursor(items[i]) < objectSyncAuditCursor(items[j]) }) pageLimit := objectSyncLimit(limit) page := domain.ObjectSyncAuditPage{Items: items} if len(items) > pageLimit { page.Items = items[:pageLimit] page.NextCursor = encodeObjectSyncCursor(objectSyncAuditCursor(page.Items[len(page.Items)-1])) } return page, nil } func (store *MemoryStore) GetObjectSyncAuditSeal(_ context.Context, organizationID, dayUTC string) (*domain.ObjectSyncAuditSealRecord, error) { store.mu.Lock() defer store.mu.Unlock() item, ok := store.objectSyncAuditSeals[normalizedOrganizationID(organizationID)+"\x00"+dayUTC] if !ok { return nil, nil } copy := item return ©, nil } func (store *MemoryStore) InsertObjectSyncAuditSeal(_ context.Context, item domain.ObjectSyncAuditSealRecord) error { store.mu.Lock() defer store.mu.Unlock() key := normalizedOrganizationID(item.OrganizationID) + "\x00" + item.DayUTC if _, exists := store.objectSyncAuditSeals[key]; exists { return nil } store.objectSyncAuditSeals[key] = item return nil } func (store *MemoryStore) ListObjectSyncClientReleases(_ context.Context) ([]domain.ObjectSyncClientReleaseRecord, error) { store.mu.Lock() defer store.mu.Unlock() items := make([]domain.ObjectSyncClientReleaseRecord, 0, len(store.objectSyncClientReleases)) for _, item := range store.objectSyncClientReleases { items = append(items, item) } sort.Slice(items, func(i, j int) bool { return items[i].CreatedAt > items[j].CreatedAt }) return items, nil } func (store *MemoryStore) UpsertObjectSyncClientRelease(_ context.Context, item domain.ObjectSyncClientReleaseRecord) error { store.mu.Lock() defer store.mu.Unlock() store.objectSyncClientReleases[item.ID] = item return nil } func (store *MongoStore) ListObjectSyncSpaces(ctx context.Context, organizationID string) ([]domain.ObjectSyncSpaceRecord, error) { cursor, err := store.objectSyncSpaces.Find(ctx, orgCompatibilityFilter(organizationID), options.Find().SetSort(bson.D{{Key: "updatedAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncSpaceRecord](ctx, cursor) } func mongoObjectSyncGet[T any](ctx context.Context, collection mongoCollection, filter bson.M) (*T, error) { var item T err := collection.FindOne(ctx, filter).Decode(&item) if err == mongo.ErrNoDocuments { return nil, nil } if err != nil { return nil, err } return &item, nil } func mongoObjectSyncUpsert(ctx context.Context, collection mongoCollection, id string, item any) error { _, err := collection.UpdateOne(ctx, bson.M{"id": id}, bson.M{"$set": item}, options.Update().SetUpsert(true)) return err } func (store *MongoStore) GetObjectSyncSpace(ctx context.Context, id string) (*domain.ObjectSyncSpaceRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncSpaceRecord](ctx, store.objectSyncSpaces, bson.M{"id": id}) } func (store *MongoStore) UpsertObjectSyncSpace(ctx context.Context, item domain.ObjectSyncSpaceRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncSpaces, item.ID, item) } func (store *MongoStore) ListObjectSyncDevices(ctx context.Context, organizationID string) ([]domain.ObjectSyncDeviceRecord, error) { cursor, err := store.objectSyncDevices.Find(ctx, orgCompatibilityFilter(organizationID), options.Find().SetSort(bson.D{{Key: "updatedAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncDeviceRecord](ctx, cursor) } func (store *MongoStore) GetObjectSyncDevice(ctx context.Context, id string) (*domain.ObjectSyncDeviceRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncDeviceRecord](ctx, store.objectSyncDevices, bson.M{"id": id}) } func (store *MongoStore) UpsertObjectSyncDevice(ctx context.Context, item domain.ObjectSyncDeviceRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncDevices, item.ID, item) } func (store *MongoStore) ListObjectSyncAuthorizations(ctx context.Context, organizationID, status string) ([]domain.ObjectSyncDeviceAuthorizationRecord, error) { filter := bson.M{} if organizationID != "" { // Public short-code requests are intentionally unowned until an // administrator resolves the code. Never broadcast those records to // the default organization through the legacy compatibility filter. filter["organizationId"] = normalizedOrganizationID(organizationID) } if status != "" { filter["status"] = status } cursor, err := store.objectSyncAuthorizations.Find(ctx, filter, options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncDeviceAuthorizationRecord](ctx, cursor) } func (store *MongoStore) GetObjectSyncAuthorization(ctx context.Context, id string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncDeviceAuthorizationRecord](ctx, store.objectSyncAuthorizations, bson.M{"id": id}) } func (store *MongoStore) GetObjectSyncAuthorizationByDeviceCodeHash(ctx context.Context, hash string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncDeviceAuthorizationRecord](ctx, store.objectSyncAuthorizations, bson.M{"deviceCodeHash": hash}) } func (store *MongoStore) GetObjectSyncAuthorizationByUserCode(ctx context.Context, code string) (*domain.ObjectSyncDeviceAuthorizationRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncDeviceAuthorizationRecord](ctx, store.objectSyncAuthorizations, bson.M{"userCode": code}) } func (store *MongoStore) UpsertObjectSyncAuthorization(ctx context.Context, item domain.ObjectSyncDeviceAuthorizationRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncAuthorizations, item.ID, item) } func (store *MongoStore) ListObjectSyncCredentials(ctx context.Context, organizationID string) ([]domain.ObjectSyncCredentialRecord, error) { cursor, err := store.objectSyncCredentials.Find(ctx, orgCompatibilityFilter(organizationID), options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncCredentialRecord](ctx, cursor) } func (store *MongoStore) GetObjectSyncCredential(ctx context.Context, id string) (*domain.ObjectSyncCredentialRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncCredentialRecord](ctx, store.objectSyncCredentials, bson.M{"id": id}) } func (store *MongoStore) GetObjectSyncCredentialByAccessKeyID(ctx context.Context, accessKeyID string) (*domain.ObjectSyncCredentialRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncCredentialRecord](ctx, store.objectSyncCredentials, bson.M{"accessKeyId": accessKeyID}) } func (store *MongoStore) GetObjectSyncCredentialByTokenHash(ctx context.Context, hash string) (*domain.ObjectSyncCredentialRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncCredentialRecord](ctx, store.objectSyncCredentials, bson.M{"$or": bson.A{ bson.M{"tokenHash": hash}, bson.M{"tokenHashes": hash}, bson.M{"tokenBindings.tokenHash": hash}, }}) } func (store *MongoStore) UpsertObjectSyncCredential(ctx context.Context, item domain.ObjectSyncCredentialRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncCredentials, item.ID, item) } func (store *MongoStore) ListObjectSyncSessions(ctx context.Context, query domain.ObjectSyncListQuery) (domain.ObjectSyncSessionPage, error) { clauses := bson.A{} if query.OrganizationID != "" { clauses = append(clauses, orgCompatibilityFilter(query.OrganizationID)) } if query.Status != "" { clauses = append(clauses, bson.M{"status": query.Status}) } if len(query.SyncSpaceIDs) > 0 { clauses = append(clauses, bson.M{"syncSpaceId": bson.M{"$in": query.SyncSpaceIDs}}) } if decoded := decodeObjectSyncCursor(query.Cursor); decoded != "" { if createdAt, id, ok := strings.Cut(decoded, "\x00"); ok && createdAt != "" && id != "" { clauses = append(clauses, bson.M{"$or": bson.A{ bson.M{"createdAt": bson.M{"$lt": createdAt}}, bson.M{"createdAt": createdAt, "id": bson.M{"$lt": id}}, }}) } } filter := bson.M{} if len(clauses) == 1 { filter = clauses[0].(bson.M) } else if len(clauses) > 1 { filter = bson.M{"$and": clauses} } limit := objectSyncLimit(query.Limit) cursor, err := store.objectSyncSessions.Find( ctx, filter, options.Find(). SetSort(bson.D{{Key: "createdAt", Value: -1}, {Key: "id", Value: -1}}). SetLimit(int64(limit+1)), ) if err != nil { return domain.ObjectSyncSessionPage{}, err } items, err := decodeMany[domain.ObjectSyncSessionRecord](ctx, cursor) if err != nil { return domain.ObjectSyncSessionPage{}, err } page := domain.ObjectSyncSessionPage{Items: items} if len(items) > limit { page.Items = items[:limit] page.NextCursor = encodeObjectSyncCursor(objectSyncSessionCursor(page.Items[len(page.Items)-1])) } return page, nil } func (store *MongoStore) GetObjectSyncSession(ctx context.Context, id string) (*domain.ObjectSyncSessionRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncSessionRecord](ctx, store.objectSyncSessions, bson.M{"id": id}) } func (store *MongoStore) UpsertObjectSyncSession(ctx context.Context, item domain.ObjectSyncSessionRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncSessions, item.ID, item) } func (store *MongoStore) ClaimObjectSyncSession(ctx context.Context, from, to domain.ObjectSyncSessionStatus, operationID string) (*domain.ObjectSyncSessionRecord, error) { result := store.objectSyncSessions.FindOneAndUpdate( ctx, bson.M{"status": string(from)}, bson.M{"$set": bson.M{"status": string(to), "operationId": operationID, "updatedAt": nowISO()}}, options.FindOneAndUpdate().SetSort(bson.D{{Key: "updatedAt", Value: 1}}).SetReturnDocument(options.After), ) var item domain.ObjectSyncSessionRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, nil } else if err != nil { return nil, err } return &item, nil } func (store *MongoStore) GetObjectSyncItem(ctx context.Context, id string) (*domain.ObjectSyncItemRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncItemRecord](ctx, store.objectSyncItems, bson.M{"id": id}) } func (store *MongoStore) UpsertObjectSyncItems(ctx context.Context, items []domain.ObjectSyncItemRecord) error { if len(items) == 0 { return nil } models := make([]mongo.WriteModel, 0, len(items)) for _, item := range items { models = append(models, mongo.NewUpdateOneModel().SetFilter(bson.M{"id": item.ID}).SetUpdate(bson.M{"$set": item}).SetUpsert(true)) } _, err := store.objectSyncItems.BulkWrite(ctx, models, options.BulkWrite().SetOrdered(false)) return err } func (store *MongoStore) ListObjectSyncItems(ctx context.Context, query domain.ObjectSyncListQuery) (domain.ObjectSyncItemPage, error) { filter := bson.M{} if query.SessionID != "" { filter["sessionId"] = query.SessionID } if query.OrganizationID != "" { filter["organizationId"] = normalizedOrganizationID(query.OrganizationID) } if query.Status != "" { filter["status"] = query.Status } if cursor := decodeObjectSyncCursor(query.Cursor); cursor != "" { filter["id"] = bson.M{"$gt": cursor} } limit := objectSyncLimit(query.Limit) cursor, err := store.objectSyncItems.Find(ctx, filter, options.Find().SetSort(bson.D{{Key: "id", Value: 1}}).SetLimit(int64(limit+1))) if err != nil { return domain.ObjectSyncItemPage{}, err } items, err := decodeMany[domain.ObjectSyncItemRecord](ctx, cursor) if err != nil { return domain.ObjectSyncItemPage{}, err } page := domain.ObjectSyncItemPage{Items: items} if len(items) > limit { page.Items = items[:limit] page.NextCursor = encodeObjectSyncCursor(page.Items[len(page.Items)-1].ID) } return page, nil } func (store *MongoStore) ClaimObjectSyncItem(ctx context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncItemRecord, error) { now := time.Now().UTC() result := store.objectSyncItems.FindOneAndUpdate( ctx, bson.M{ "status": string(domain.ObjectSyncItemCommitting), "$or": bson.A{ bson.M{"coordinatorOwner": ""}, bson.M{"coordinatorOwner": bson.M{"$exists": false}}, bson.M{"coordinatorLeaseUntil": bson.M{"$lte": now}}, }, }, bson.M{"$set": bson.M{ "coordinatorOwner": owner, "coordinatorLeaseUntil": now.Add(ttl), "updatedAt": now.Format(time.RFC3339Nano), }}, options.FindOneAndUpdate().SetSort(bson.D{{Key: "updatedAt", Value: 1}}).SetReturnDocument(options.After), ) var item domain.ObjectSyncItemRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, nil } else if err != nil { return nil, err } return &item, nil } func (store *MongoStore) ClaimObjectSyncCleanupItem(ctx context.Context, owner string, before time.Time, ttl time.Duration) (*domain.ObjectSyncItemRecord, error) { now := time.Now().UTC() result := store.objectSyncItems.FindOneAndUpdate( ctx, bson.M{ "stagingKey": bson.M{"$ne": ""}, "status": bson.M{"$in": bson.A{ domain.ObjectSyncItemUploading, domain.ObjectSyncItemUploaded, domain.ObjectSyncItemFailed, domain.ObjectSyncItemAborted, domain.ObjectSyncItemExpired, domain.ObjectSyncItemCommitted, domain.ObjectSyncItemKeptBoth, }}, "updatedAt": bson.M{"$lte": before.UTC().Format(time.RFC3339Nano)}, "$or": bson.A{ bson.M{"coordinatorOwner": ""}, bson.M{"coordinatorOwner": bson.M{"$exists": false}}, bson.M{"coordinatorLeaseUntil": bson.M{"$lte": now}}, }, }, bson.M{"$set": bson.M{ "coordinatorOwner": owner, "coordinatorLeaseUntil": now.Add(ttl), }}, options.FindOneAndUpdate().SetSort(bson.D{{Key: "updatedAt", Value: 1}}).SetReturnDocument(options.After), ) var item domain.ObjectSyncItemRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, nil } else if err != nil { return nil, err } return &item, nil } func (store *MongoStore) AcquireObjectSyncLease(ctx context.Context, requested domain.ObjectSyncLeaseRecord, ttl time.Duration) (*domain.ObjectSyncLeaseRecord, bool, error) { now := time.Now().UTC() expiresAt := now.Add(ttl) set := bson.M{ "id": requested.ID, "organizationId": requested.OrganizationID, "resourceHash": requested.ResourceHash, "resourceType": requested.ResourceType, "connectionId": requested.ConnectionID, "bucket": requested.Bucket, "keyOrPrefix": requested.KeyOrPrefix, "ownerSessionId": requested.OwnerSessionID, "ownerItemId": requested.OwnerItemID, "expiresAt": expiresAt.Format(time.RFC3339Nano), "expiresAtTime": expiresAt, "lastHeartbeatAt": now.Format(time.RFC3339Nano), "updatedAt": now.Format(time.RFC3339Nano), } result := store.objectSyncLeases.FindOneAndUpdate( ctx, bson.M{ "organizationId": requested.OrganizationID, "resourceHash": requested.ResourceHash, "$or": bson.A{ bson.M{"ownerItemId": requested.OwnerItemID}, bson.M{"ownerItemId": ""}, bson.M{"ownerItemId": bson.M{"$exists": false}}, bson.M{"expiresAtTime": bson.M{"$lte": now}}, }, }, bson.M{"$set": set, "$inc": bson.M{"fencingToken": 1}}, options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After), ) var item domain.ObjectSyncLeaseRecord err := result.Decode(&item) if mongo.IsDuplicateKeyError(err) || err == mongo.ErrNoDocuments { current, getErr := mongoObjectSyncGet[domain.ObjectSyncLeaseRecord](ctx, store.objectSyncLeases, bson.M{ "organizationId": requested.OrganizationID, "resourceHash": requested.ResourceHash, }) return current, false, getErr } if err != nil { return nil, false, err } return &item, true, nil } func (store *MongoStore) RenewObjectSyncLease(ctx context.Context, resourceHash, sessionID, itemID string, fencingToken int64, ttl time.Duration) (bool, error) { now := time.Now().UTC() expiresAt := now.Add(ttl) result, err := store.objectSyncLeases.UpdateOne(ctx, bson.M{ "$or": bson.A{bson.M{"resourceHash": resourceHash}, bson.M{"id": resourceHash}}, "ownerSessionId": sessionID, "ownerItemId": itemID, "fencingToken": fencingToken, }, bson.M{"$set": bson.M{ "expiresAt": expiresAt.Format(time.RFC3339Nano), "expiresAtTime": expiresAt, "lastHeartbeatAt": now.Format(time.RFC3339Nano), "updatedAt": now.Format(time.RFC3339Nano), }}) return err == nil && result.MatchedCount > 0, err } func (store *MongoStore) ReleaseObjectSyncLease(ctx context.Context, resourceHash, sessionID, itemID string, fencingToken int64) error { _, err := store.objectSyncLeases.UpdateOne(ctx, bson.M{ "$or": bson.A{bson.M{"resourceHash": resourceHash}, bson.M{"id": resourceHash}}, "ownerSessionId": sessionID, "ownerItemId": itemID, "fencingToken": fencingToken, }, bson.M{"$set": bson.M{ "ownerSessionId": "", "ownerItemId": "", "expiresAt": "", "updatedAt": nowISO(), }, "$unset": bson.M{"expiresAtTime": ""}}) return err } func (store *MongoStore) ForceReleaseObjectSyncLease(ctx context.Context, id string) (*domain.ObjectSyncLeaseRecord, bool, error) { result := store.objectSyncLeases.FindOneAndUpdate(ctx, bson.M{"id": id}, bson.M{ "$set": bson.M{"ownerSessionId": "", "ownerItemId": "", "expiresAt": "", "updatedAt": nowISO()}, "$unset": bson.M{"expiresAtTime": ""}, }, options.FindOneAndUpdate().SetReturnDocument(options.After)) var item domain.ObjectSyncLeaseRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, false, nil } else if err != nil { return nil, false, err } return &item, true, nil } func (store *MongoStore) GetObjectSyncHead(ctx context.Context, organizationID, syncSpaceID, key string) (*domain.ObjectSyncObjectHeadRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncObjectHeadRecord](ctx, store.objectSyncHeads, bson.M{ "organizationId": normalizedOrganizationID(organizationID), "syncSpaceId": syncSpaceID, "key": key, }) } func (store *MongoStore) UpsertObjectSyncHead(ctx context.Context, item domain.ObjectSyncObjectHeadRecord) error { _, err := store.objectSyncHeads.UpdateOne(ctx, bson.M{ "organizationId": item.OrganizationID, "syncSpaceId": item.SyncSpaceID, "key": item.Key, }, bson.M{"$set": item}, options.Update().SetUpsert(true)) return err } func (store *MongoStore) ListObjectSyncHeads(ctx context.Context, organizationID, syncSpaceID, cursor string, limit int) (domain.ObjectSyncHeadPage, error) { filter := bson.M{ "organizationId": normalizedOrganizationID(organizationID), "syncSpaceId": syncSpaceID, } if decodedCursor := decodeObjectSyncCursor(cursor); decodedCursor != "" { filter["key"] = bson.M{"$gt": decodedCursor} } pageLimit := objectSyncLimit(limit) mongoCursor, err := store.objectSyncHeads.Find(ctx, filter, options.Find().SetSort(bson.D{{Key: "key", Value: 1}}).SetLimit(int64(pageLimit+1))) if err != nil { return domain.ObjectSyncHeadPage{}, err } items, err := decodeMany[domain.ObjectSyncObjectHeadRecord](ctx, mongoCursor) if err != nil { return domain.ObjectSyncHeadPage{}, err } page := domain.ObjectSyncHeadPage{Items: items} if len(items) > pageLimit { page.Items = items[:pageLimit] page.NextCursor = encodeObjectSyncCursor(page.Items[len(page.Items)-1].Key) } return page, nil } func (store *MongoStore) InsertObjectSyncVersion(ctx context.Context, item domain.ObjectSyncVersionRecord) error { _, err := store.objectSyncVersions.InsertOne(ctx, item) if mongo.IsDuplicateKeyError(err) { return nil } return err } func (store *MongoStore) AppendObjectSyncAudit(ctx context.Context, item domain.ObjectSyncAuditEvent) error { _, err := store.objectSyncAuditEvents.InsertOne(ctx, item) if mongo.IsDuplicateKeyError(err) { return nil } return err } func (store *MongoStore) ListObjectSyncAudit(ctx context.Context, query domain.ObjectSyncListQuery) ([]domain.ObjectSyncAuditEvent, error) { filter := bson.M{} if query.OrganizationID != "" { filter["organizationId"] = normalizedOrganizationID(query.OrganizationID) } if query.SessionID != "" { filter["sessionId"] = query.SessionID } cursor, err := store.objectSyncAuditEvents.Find(ctx, filter, options.Find().SetSort(bson.D{{Key: "occurredAt", Value: -1}}).SetLimit(int64(objectSyncLimit(query.Limit)))) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncAuditEvent](ctx, cursor) } func (store *MongoStore) GetLatestObjectSyncAudit(ctx context.Context, organizationID string) (*domain.ObjectSyncAuditEvent, error) { var result domain.ObjectSyncAuditEvent err := store.objectSyncAuditEvents.FindOne( ctx, bson.M{"organizationId": normalizedOrganizationID(organizationID)}, options.FindOne().SetSort(bson.D{{Key: "occurredAt", Value: -1}}), ).Decode(&result) if errors.Is(err, mongo.ErrNoDocuments) { return nil, nil } return &result, err } func (store *MongoStore) ListObjectSyncAuditRange(ctx context.Context, organizationID, start, end, cursor string, limit int) (domain.ObjectSyncAuditPage, error) { filter := bson.M{ "organizationId": normalizedOrganizationID(organizationID), "occurredAt": bson.M{"$gte": start, "$lt": end}, } if decoded := decodeObjectSyncCursor(cursor); decoded != "" { parts := strings.SplitN(decoded, "\x00", 2) if len(parts) == 2 { filter["$or"] = bson.A{ bson.M{"occurredAt": bson.M{"$gt": parts[0]}}, bson.M{"occurredAt": parts[0], "id": bson.M{"$gt": parts[1]}}, } } } pageLimit := objectSyncLimit(limit) mongoCursor, err := store.objectSyncAuditEvents.Find( ctx, filter, options.Find().SetSort(bson.D{{Key: "occurredAt", Value: 1}, {Key: "id", Value: 1}}).SetLimit(int64(pageLimit+1)), ) if err != nil { return domain.ObjectSyncAuditPage{}, err } items, err := decodeMany[domain.ObjectSyncAuditEvent](ctx, mongoCursor) if err != nil { return domain.ObjectSyncAuditPage{}, err } page := domain.ObjectSyncAuditPage{Items: items} if len(items) > pageLimit { page.Items = items[:pageLimit] page.NextCursor = encodeObjectSyncCursor(objectSyncAuditCursor(page.Items[len(page.Items)-1])) } return page, nil } func (store *MongoStore) GetObjectSyncAuditSeal(ctx context.Context, organizationID, dayUTC string) (*domain.ObjectSyncAuditSealRecord, error) { return mongoObjectSyncGet[domain.ObjectSyncAuditSealRecord](ctx, store.objectSyncAuditSeals, bson.M{ "organizationId": normalizedOrganizationID(organizationID), "dayUtc": dayUTC, }) } func (store *MongoStore) InsertObjectSyncAuditSeal(ctx context.Context, item domain.ObjectSyncAuditSealRecord) error { _, err := store.objectSyncAuditSeals.InsertOne(ctx, item) if mongo.IsDuplicateKeyError(err) { return nil } return err } func (store *MongoStore) ListObjectSyncReleases(ctx context.Context, organizationID string) ([]domain.ObjectSyncReleaseRecord, error) { cursor, err := store.objectSyncReleases.Find(ctx, orgCompatibilityFilter(organizationID), options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncReleaseRecord](ctx, cursor) } func (store *MongoStore) UpsertObjectSyncRelease(ctx context.Context, item domain.ObjectSyncReleaseRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncReleases, item.ID, item) } func (store *MongoStore) ClaimObjectSyncRelease(ctx context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncReleaseRecord, error) { now := time.Now().UTC() result := store.objectSyncReleases.FindOneAndUpdate( ctx, bson.M{ "status": "pending", "$or": bson.A{ bson.M{"coordinatorOwner": ""}, bson.M{"coordinatorOwner": bson.M{"$exists": false}}, bson.M{"coordinatorLeaseUntil": bson.M{"$lte": now}}, }, }, bson.M{"$set": bson.M{ "coordinatorOwner": owner, "coordinatorLeaseUntil": now.Add(ttl), }}, options.FindOneAndUpdate().SetSort(bson.D{{Key: "createdAt", Value: 1}}).SetReturnDocument(options.After), ) var item domain.ObjectSyncReleaseRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, nil } else if err != nil { return nil, err } return &item, nil } func (store *MongoStore) ListObjectSyncClientReleases(ctx context.Context) ([]domain.ObjectSyncClientReleaseRecord, error) { cursor, err := store.objectSyncClientReleases.Find(ctx, bson.M{}, options.Find().SetSort(bson.D{{Key: "createdAt", Value: -1}})) if err != nil { return nil, err } return decodeMany[domain.ObjectSyncClientReleaseRecord](ctx, cursor) } func (store *MongoStore) UpsertObjectSyncClientRelease(ctx context.Context, item domain.ObjectSyncClientReleaseRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncClientReleases, item.ID, item) } func (store *MongoStore) UpsertObjectSyncReconcile(ctx context.Context, item domain.ObjectSyncReconcileRecord) error { return mongoObjectSyncUpsert(ctx, store.objectSyncReconciles, item.ID, item) } func (store *MongoStore) ClaimObjectSyncReconcile(ctx context.Context, owner string, ttl time.Duration) (*domain.ObjectSyncReconcileRecord, error) { now := time.Now().UTC() result := store.objectSyncReconciles.FindOneAndUpdate( ctx, bson.M{ "status": "pending", "$or": bson.A{ bson.M{"coordinatorOwner": ""}, bson.M{"coordinatorOwner": bson.M{"$exists": false}}, bson.M{"coordinatorLeaseUntil": bson.M{"$lte": now}}, }, }, bson.M{"$set": bson.M{ "status": "running", "updatedAt": now.Format(time.RFC3339Nano), "coordinatorOwner": owner, "coordinatorLeaseUntil": now.Add(ttl), }}, options.FindOneAndUpdate().SetSort(bson.D{{Key: "createdAt", Value: 1}}).SetReturnDocument(options.After), ) var item domain.ObjectSyncReconcileRecord if err := result.Decode(&item); err == mongo.ErrNoDocuments { return nil, nil } else if err != nil { return nil, err } return &item, nil } func (store *MongoStore) BeginObjectSyncIdempotency(ctx context.Context, requested domain.ObjectSyncIdempotencyRecord) (*domain.ObjectSyncIdempotencyRecord, bool, error) { if _, err := store.objectSyncIdempotency.InsertOne(ctx, requested); err == nil { copy := requested return ©, true, nil } else if !mongo.IsDuplicateKeyError(err) { return nil, false, err } returned, err := mongoObjectSyncGet[domain.ObjectSyncIdempotencyRecord](ctx, store.objectSyncIdempotency, bson.M{"id": requested.ID}) return returned, false, err } func (store *MongoStore) ConsumeObjectSyncRateLimit(ctx context.Context, requested domain.ObjectSyncRateLimitRecord, limit int64) (domain.ObjectSyncRateLimitRecord, bool, error) { var result domain.ObjectSyncRateLimitRecord err := store.objectSyncRateLimits.FindOneAndUpdate( ctx, bson.M{"id": requested.ID}, bson.M{ "$inc": bson.M{"count": 1}, "$setOnInsert": bson.M{ "id": requested.ID, "subject": requested.Subject, "window": requested.Window, "expiresAt": requested.ExpiresAt, }, }, options.FindOneAndUpdate().SetUpsert(true).SetReturnDocument(options.After), ).Decode(&result) if err != nil { return domain.ObjectSyncRateLimitRecord{}, false, err } return result, limit <= 0 || result.Count <= limit, nil } func (store *MongoStore) CompleteObjectSyncIdempotency(ctx context.Context, item domain.ObjectSyncIdempotencyRecord) error { result, err := store.objectSyncIdempotency.ReplaceOne(ctx, bson.M{ "id": item.ID, "requestDigest": item.RequestDigest, }, item) if err != nil { return err } if result.MatchedCount == 0 { return mongo.ErrNoDocuments } return nil } func (store *MongoStore) DeleteObjectSyncIdempotency(ctx context.Context, id, requestDigest string) error { _, err := store.objectSyncIdempotency.DeleteOne(ctx, bson.M{"id": id, "requestDigest": requestDigest}) return err } func objectSyncStringIn(items []string, target string) bool { for _, item := range items { if strings.TrimSpace(item) == target { return true } } return false }