@taskforcehq/taskforce 0.3.170 → 0.3.300

package/dist/core/SyncReconciliationService.js

@@ -0,0 +1,406 @@
+import { DEFAULT_TYPE_VALUE } from '../shared/taxonomyDefaults.js';
+export function listTasksForSyncService(deps, workspaceId, cursor, limit) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
+    let rows;
+    if (cursor) {
+        rows = deps.db.prepare(`
+            SELECT *, COALESCE(updated_at, created_at) AS sync_watermark
+            FROM tasks
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND (
+                  COALESCE(updated_at, created_at) > ?
+                  OR (COALESCE(updated_at, created_at) = ? AND id > ?)
+              )
+            ORDER BY COALESCE(updated_at, created_at) ASC, id ASC
+            LIMIT ?
+        `).all(deps.tenantId, normalizedWorkspaceId, cursor.watermark, cursor.watermark, cursor.id, safeLimit);
+    }
+    else {
+        rows = deps.db.prepare(`
+            SELECT *, COALESCE(updated_at, created_at) AS sync_watermark
+            FROM tasks
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+            ORDER BY COALESCE(updated_at, created_at) ASC, id ASC
+            LIMIT ?
+        `).all(deps.tenantId, normalizedWorkspaceId, safeLimit);
+    }
+    return rows.map((row) => ({
+        task: deps.rowToTask(row),
+        archived: Boolean(row.is_archived)
+    }));
+}
+export function listWorkspaceSyncDeletesSinceService(deps, workspaceId, cursor, limit) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const safeLimit = Math.max(1, Math.min(10000, Math.floor(limit)));
+    let rows;
+    if (cursor) {
+        rows = deps.db.prepare(`
+            SELECT task_id, deleted_at
+            FROM workspace_sync_deletes
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+              AND (
+                  deleted_at > ?
+                  OR (deleted_at = ? AND task_id > ?)
+              )
+            ORDER BY deleted_at ASC, task_id ASC
+            LIMIT ?
+        `).all(deps.tenantId, normalizedWorkspaceId, cursor.watermark, cursor.watermark, cursor.id, safeLimit);
+    }
+    else {
+        rows = deps.db.prepare(`
+            SELECT task_id, deleted_at
+            FROM workspace_sync_deletes
+            WHERE tenant_id = ?
+              AND workspace_id = ?
+            ORDER BY deleted_at ASC, task_id ASC
+            LIMIT ?
+        `).all(deps.tenantId, normalizedWorkspaceId, safeLimit);
+    }
+    return rows
+        .map((row) => ({
+        taskId: String(row.task_id || '').trim(),
+        deletedAt: String(row.deleted_at || '').trim()
+    }))
+        .filter((row) => row.taskId.length > 0 && Number.isFinite(Date.parse(row.deletedAt)));
+}
+function normalizeConflictTaxonomies(value) {
+    if (!value || typeof value !== 'object')
+        return {};
+    const source = value;
+    return Object.keys(source).sort().reduce((acc, key) => {
+        const raw = source[key];
+        if (Array.isArray(raw)) {
+            acc[key] = raw.map((entry) => String(entry ?? '')).sort();
+        }
+        else if (raw === null || raw === undefined) {
+            acc[key] = '';
+        }
+        else {
+            acc[key] = String(raw);
+        }
+        return acc;
+    }, {});
+}
+function normalizeConflictChecklistItems(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .map((item) => {
+        const entry = item && typeof item === 'object' ? item : {};
+        return {
+            id: String(entry.id || '').trim(),
+            title: String(entry.title || '').trim(),
+            isCompleted: Boolean(entry.isCompleted),
+            order: entry.order === undefined || entry.order === null ? '' : String(entry.order),
+        };
+    })
+        .sort((left, right) => {
+        const leftOrder = Number.parseInt(left.order, 10);
+        const rightOrder = Number.parseInt(right.order, 10);
+        if (Number.isFinite(leftOrder) && Number.isFinite(rightOrder) && leftOrder !== rightOrder) {
+            return leftOrder - rightOrder;
+        }
+        if (left.title !== right.title)
+            return left.title.localeCompare(right.title);
+        return left.id.localeCompare(right.id);
+    });
+}
+function buildSyncConflictKey(task, archivedValue) {
+    const source = task || {};
+    return JSON.stringify({
+        id: String(source.id || ''),
+        title: String(source.title || ''),
+        description: source.description === null || source.description === undefined ? '' : String(source.description),
+        category: String(source.category || ''),
+        type: String(source.type || ''),
+        priority: source.priority === undefined || source.priority === null ? '' : String(source.priority),
+        complexity: source.complexity === undefined || source.complexity === null ? '' : String(source.complexity),
+        status: String(source.status || ''),
+        approach: source.approach === undefined || source.approach === null ? '' : String(source.approach),
+        canceledReason: source.canceledReason === undefined || source.canceledReason === null ? '' : String(source.canceledReason),
+        scheduledDate: source.scheduledDate === undefined || source.scheduledDate === null ? '' : String(source.scheduledDate),
+        dueDate: source.dueDate === undefined || source.dueDate === null ? '' : String(source.dueDate),
+        scheduledWeekKey: source.scheduledWeekKey === undefined || source.scheduledWeekKey === null ? '' : String(source.scheduledWeekKey),
+        orderInDay: source.orderInDay === undefined || source.orderInDay === null ? '' : String(source.orderInDay),
+        workstreamId: source.workstreamId === undefined || source.workstreamId === null ? '' : String(source.workstreamId),
+        referenceNumber: source.referenceNumber === undefined || source.referenceNumber === null ? '' : String(source.referenceNumber),
+        assignee: source.assignee === undefined || source.assignee === null ? '' : String(source.assignee),
+        taxonomies: normalizeConflictTaxonomies(source.taxonomies),
+        checklistItems: normalizeConflictChecklistItems(source.checklistItems),
+        isArchived: archivedValue ? '1' : '0'
+    });
+}
+export function applyWorkspaceSyncSnapshotService(deps, input, workspaceId) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const activeTasks = Array.isArray(input?.tasks) ? input.tasks : [];
+    const archivedTasks = Array.isArray(input?.archived) ? input.archived : [];
+    const combined = [
+        ...activeTasks.map((task) => ({ task, archivedDefault: false })),
+        ...archivedTasks.map((task) => ({ task, archivedDefault: true }))
+    ];
+    const incomingTaskById = new Map();
+    for (const item of combined) {
+        const sourceTask = (item.task && typeof item.task === 'object') ? item.task : {};
+        const taskId = String(sourceTask.id || '').trim();
+        if (taskId)
+            incomingTaskById.set(taskId, sourceTask);
+    }
+    combined.sort((left, right) => {
+        const leftId = String((left.task && typeof left.task === 'object' ? left.task.id : '') || '').trim();
+        const rightId = String((right.task && typeof right.task === 'object' ? right.task.id : '') || '').trim();
+        return leftId.localeCompare(rightId);
+    });
+    let created = 0;
+    let updated = 0;
+    let archived = 0;
+    let unarchived = 0;
+    let skipped = 0;
+    for (const item of combined) {
+        const sourceTask = (item.task && typeof item.task === 'object') ? item.task : {};
+        const taskId = String(sourceTask.id || '').trim();
+        if (!taskId) {
+            skipped++;
+            continue;
+        }
+        const incomingUpdatedAt = String(sourceTask.updatedAt || sourceTask.createdAt || '').trim();
+        const incomingMs = Date.parse(incomingUpdatedAt);
+        const existing = deps.getTask(taskId, normalizedWorkspaceId);
+        const existingUpdatedAt = String(existing?.updatedAt || existing?.createdAt || '').trim();
+        const existingMs = Date.parse(existingUpdatedAt);
+        const desiredArchived = typeof sourceTask.isArchived === 'boolean'
+            ? sourceTask.isArchived
+            : item.archivedDefault;
+        const incomingStatus = sourceTask.status === undefined ? existing?.status : sourceTask.status;
+        const normalizedIncomingStatus = incomingStatus === undefined
+            ? undefined
+            : deps.normalizeStatusValue(incomingStatus);
+        const taskPatch = {
+            id: taskId,
+            title: String(sourceTask.title || existing?.title || 'Untitled Task'),
+            description: sourceTask.description === undefined ? existing?.description || null : (sourceTask.description || null),
+            category: String(sourceTask.category || existing?.category || deps.defaultCategoryValue),
+            type: String(sourceTask.type || existing?.type || DEFAULT_TYPE_VALUE),
+            priority: sourceTask.priority === undefined ? existing?.priority : sourceTask.priority,
+            complexity: sourceTask.complexity === undefined ? existing?.complexity : sourceTask.complexity,
+            status: normalizedIncomingStatus || existing?.status || 'task',
+            approach: sourceTask.approach === undefined ? existing?.approach : sourceTask.approach,
+            canceledReason: sourceTask.canceledReason === undefined ? existing?.canceledReason : sourceTask.canceledReason,
+            createdAt: String(sourceTask.createdAt || existing?.createdAt || new Date().toISOString()),
+            updatedAt: incomingUpdatedAt || existing?.updatedAt || undefined,
+            workstreamId: sourceTask.workstreamId === undefined ? existing?.workstreamId : sourceTask.workstreamId,
+            taxonomies: sourceTask.taxonomies && typeof sourceTask.taxonomies === 'object'
+                ? sourceTask.taxonomies
+                : (existing?.taxonomies || {}),
+            createdBy: sourceTask.createdBy === undefined ? existing?.createdBy : sourceTask.createdBy,
+            assignee: sourceTask.assignee === undefined ? existing?.assignee : sourceTask.assignee,
+            referenceNumber: sourceTask.referenceNumber === undefined ? existing?.referenceNumber : sourceTask.referenceNumber,
+            scheduledDate: sourceTask.scheduledDate === undefined ? existing?.scheduledDate : sourceTask.scheduledDate,
+            dueDate: sourceTask.dueDate === undefined ? existing?.dueDate : sourceTask.dueDate,
+            scheduledWeekKey: sourceTask.scheduledWeekKey === undefined ? existing?.scheduledWeekKey : sourceTask.scheduledWeekKey,
+            orderInDay: sourceTask.orderInDay === undefined ? existing?.orderInDay : sourceTask.orderInDay,
+            comments: sourceTask.comments === undefined ? undefined : sourceTask.comments,
+            attachments: sourceTask.attachments === undefined ? undefined : sourceTask.attachments,
+            checklistItems: sourceTask.checklistItems === undefined ? undefined : sourceTask.checklistItems
+        };
+        if (existing
+            && Number.isFinite(incomingMs)
+            && Number.isFinite(existingMs)) {
+            if (incomingMs < existingMs) {
+                skipped++;
+                continue;
+            }
+            if (incomingMs === existingMs) {
+                const incomingConflictKey = buildSyncConflictKey(taskPatch, desiredArchived);
+                const existingConflictKey = buildSyncConflictKey(existing, Boolean(existing?.isArchived));
+                if (incomingConflictKey.localeCompare(existingConflictKey) <= 0) {
+                    skipped++;
+                    continue;
+                }
+            }
+        }
+        if (!existing) {
+            try {
+                deps.createTask(taskPatch, {
+                    persistBackup: false,
+                    workspaceId: normalizedWorkspaceId,
+                    allowClientProvidedId: true,
+                    skipRecompute: true,
+                    syncUpdatedAt: incomingUpdatedAt,
+                    skipTaskEvents: true
+                });
+                created++;
+            }
+            catch {
+                skipped++;
+                continue;
+            }
+        }
+        else {
+            let updatedTask;
+            try {
+                updatedTask = deps.updateTask(taskId, taskPatch, normalizedWorkspaceId, {
+                    persistBackup: false,
+                    skipRecompute: true,
+                    syncUpdatedAt: incomingUpdatedAt,
+                    skipTaskEvents: true
+                });
+            }
+            catch {
+                skipped++;
+                continue;
+            }
+            if (!updatedTask) {
+                skipped++;
+                continue;
+            }
+            updated++;
+        }
+        const next = deps.getTask(taskId, normalizedWorkspaceId);
+        if (desiredArchived && next && !next.isArchived) {
+            const cancel = String(sourceTask.status || '').trim() === 'cancelled';
+            try {
+                const archivedTask = deps.archiveTask(taskId, cancel, sourceTask.canceledReason, normalizedWorkspaceId, {
+                    persistBackup: false,
+                    skipRecompute: true,
+                    syncUpdatedAt: incomingUpdatedAt,
+                    skipHierarchyCheck: true,
+                    skipTaskEvents: true
+                });
+                if (archivedTask)
+                    archived++;
+            }
+            catch {
+                skipped++;
+            }
+        }
+        else if (!desiredArchived && next && next.isArchived) {
+            try {
+                const restored = deps.unarchiveTask(taskId, normalizedWorkspaceId, {
+                    persistBackup: false,
+                    skipRecompute: true,
+                    syncUpdatedAt: incomingUpdatedAt,
+                    skipTaskEvents: true
+                });
+                if (restored)
+                    unarchived++;
+            }
+            catch {
+                skipped++;
+            }
+        }
+    }
+    deps.persistBackup();
+    return {
+        total: combined.length,
+        created,
+        updated,
+        archived,
+        unarchived,
+        skipped
+    };
+}
+export function readPushIdempotencyService(deps, workspaceId, idempotencyKey) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const now = Date.now();
+    try {
+        deps.db.prepare(`DELETE FROM sync_idempotency WHERE expires_at <= ?`).run(now);
+    }
+    catch { /* ignore */ }
+    const row = deps.db.prepare(`
+        SELECT payload
+        FROM sync_idempotency
+        WHERE tenant_id = ? AND workspace_id = ? AND idempotency_key = ? AND expires_at > ?
+        LIMIT 1
+    `).get(deps.tenantId, normalizedWorkspaceId, idempotencyKey, now);
+    return typeof row?.payload === 'string' ? row.payload : null;
+}
+export function writePushIdempotencyService(deps, workspaceId, idempotencyKey, payload) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const expiresAt = Date.now() + 10 * 60_000;
+    deps.db.prepare(`
+        INSERT INTO sync_idempotency (tenant_id, workspace_id, idempotency_key, payload, expires_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT (tenant_id, workspace_id, idempotency_key) DO UPDATE SET
+            payload = excluded.payload,
+            expires_at = excluded.expires_at
+    `).run(deps.tenantId, normalizedWorkspaceId, idempotencyKey, payload, expiresAt);
+}
+export function recordSyncEventService(deps, workspaceId, event) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    try {
+        deps.db.prepare(`
+            INSERT INTO sync_events
+                (tenant_id, workspace_id, event_type, status, status_code, error_message, change_count, request_ms, details_json, occurred_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `).run(deps.tenantId, normalizedWorkspaceId, event.eventType, event.status, event.statusCode ?? null, event.errorMessage ?? null, event.changeCount ?? null, event.requestMs ?? null, event.details ? JSON.stringify(event.details) : null, new Date().toISOString());
+        deps.db.prepare(`
+            DELETE FROM sync_events
+            WHERE tenant_id = ? AND workspace_id = ? AND id NOT IN (
+                SELECT id FROM sync_events
+                WHERE tenant_id = ? AND workspace_id = ?
+                ORDER BY id DESC
+                LIMIT 1000
+            )
+        `).run(deps.tenantId, normalizedWorkspaceId, deps.tenantId, normalizedWorkspaceId);
+    }
+    catch {
+        // best-effort
+    }
+}
+export function getDocumentWatermarkService(deps, workspaceId, docPath) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    const row = deps.db.prepare(`
+        SELECT updated_at, content_hash
+        FROM workspace_documents
+        WHERE tenant_id = ? AND workspace_id = ? AND path = ?
+    `).get(deps.tenantId, normalizedWorkspaceId, docPath);
+    return row ? { updatedAt: row.updated_at, contentHash: row.content_hash } : null;
+}
+export function upsertDocumentWatermarkService(deps, workspaceId, docPath, contentHash, updatedAt) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    try {
+        const existing = getDocumentWatermarkService(deps, normalizedWorkspaceId, docPath);
+        if (existing && existing.contentHash === contentHash)
+            return;
+        deps.db.prepare(`
+            INSERT INTO workspace_documents (tenant_id, workspace_id, path, content_hash, updated_at)
+            VALUES (?, ?, ?, ?, ?)
+            ON CONFLICT (tenant_id, workspace_id, path) DO UPDATE SET
+                content_hash = excluded.content_hash,
+                updated_at   = excluded.updated_at
+        `).run(deps.tenantId, normalizedWorkspaceId, docPath, contentHash, updatedAt);
+        deps.emitRealtimeMutation({
+            workspaceId: normalizedWorkspaceId,
+            entityType: 'document-metadata',
+            changeType: 'upsert',
+            entityIds: [docPath]
+        });
+    }
+    catch {
+        // best-effort
+    }
+}
+export function deleteDocumentWatermarkService(deps, workspaceId, docPath) {
+    const normalizedWorkspaceId = deps.normalizeWorkspaceId(workspaceId);
+    try {
+        const result = deps.db.prepare(`
+            DELETE FROM workspace_documents
+            WHERE tenant_id = ? AND workspace_id = ? AND path = ?
+        `).run(deps.tenantId, normalizedWorkspaceId, docPath);
+        if (Number(result?.changes || 0) > 0) {
+            deps.emitRealtimeMutation({
+                workspaceId: normalizedWorkspaceId,
+                entityType: 'document-metadata',
+                changeType: 'delete',
+                entityIds: [docPath]
+            });
+        }
+    }
+    catch {
+        // best-effort
+    }
+}