@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.d.ts

@@ -0,0 +1,65 @@
+import type { Comment } from '../../core/Taskforce.js';
+import { type DurableTaskCreateServiceCore } from './taskCreateMutationService.js';
+import { type TaskLegacyRootAdoptionCore } from './taskLegacyRootAdoptionService.js';
+import { type DurableTaskDeleteServiceCore } from './taskDeleteMutationService.js';
+import { type DurableTaskRestoreServiceCore } from './taskRestoreMutationService.js';
+import { type DurableTaskLifecycleServiceCore } from './taskLifecycleMutationService.js';
+import { type DurableTaskMetadataServiceCore } from './taskMetadataMutationService.js';
+import { type DurableTaskRelationshipServiceCore } from './taskRelationshipMutationService.js';
+import { type TaskRelationshipLegacyAdoptionCore } from './taskRelationshipLegacyAdoptionService.js';
+import { type DurableTaskStatusServiceCore } from './taskStatusMutationService.js';
+import { type DurableTaskWorkflowServiceCore } from './taskWorkflowMutationService.js';
+import { type DurableTaskCommentServiceCore } from './taskCommentMutationService.js';
+import { type DurableTaskChecklistServiceCore } from './taskChecklistMutationService.js';
+import { type DurableWorkstreamTaskOrderCore } from './workstreamTaskOrderMutationService.js';
+import { type DurableTaskAttachmentLinksServiceCore } from './taskAttachmentLinksMutationService.js';
+import { type DurableTaxonomyServiceCore } from './taxonomyMutationService.js';
+import { type DurableTaxonomyCompositeCore } from './taxonomyCompositeMutationService.js';
+import { WorkspaceSyncDurabilityStore } from './syncDurabilityStore.js';
+import { type DurableInitiativeServiceCore } from './initiativeMutationService.js';
+import { type DurableWorkstreamServiceCore } from './workstreamMutationService.js';
+import { type DurableWorkflowRuntimeServiceCore } from './workflowRuntimeMutationService.js';
+import { type EntityEventLegacyAdoptionCore } from './entityEventLegacyAdoptionService.js';
+import type { WorkspaceSyncV3OperationEnvelope, WorkspaceSyncV3TaskCreateEnvelope } from './workspaceSyncV3OperationProtocol.js';
+import type { WorkspaceSyncV3TaskCommentReconcileProvenance } from './taskCommentReconcileProvenance.js';
+export type WorkspaceSyncV3CloudCore = DurableTaskMetadataServiceCore & DurableTaskCreateServiceCore & TaskLegacyRootAdoptionCore & DurableTaskDeleteServiceCore & DurableTaskRestoreServiceCore & DurableTaskLifecycleServiceCore & DurableTaskRelationshipServiceCore & TaskRelationshipLegacyAdoptionCore & DurableTaskWorkflowServiceCore & DurableTaskStatusServiceCore & DurableTaskCommentServiceCore & DurableTaskChecklistServiceCore & DurableWorkstreamTaskOrderCore & DurableTaskAttachmentLinksServiceCore & DurableTaxonomyServiceCore & DurableTaxonomyCompositeCore & DurableInitiativeServiceCore & DurableWorkstreamServiceCore & DurableWorkflowRuntimeServiceCore & EntityEventLegacyAdoptionCore;
+export type WorkspaceSyncV3CloudOperationResult = {
+    state: 'in_progress';
+    retryAt: string;
+} | {
+    state: 'committed';
+    responseJson: string;
+};
+export type WorkspaceSyncV3CloudOperationContext = {
+    store: WorkspaceSyncDurabilityStore;
+    core: WorkspaceSyncV3CloudCore;
+    tenantId: string;
+    workspaceId: string;
+    clientId: string;
+    operationId: string;
+    now: string;
+    leaseExpiresAt: string;
+    /** OAuth/connector authorization identity — not necessarily event authorship. */
+    actorRef: string;
+    resolveOriginActorRef?: (originActor: NonNullable<WorkspaceSyncV3TaskCreateEnvelope['operation']['payload']['originActor']>) => string;
+    resolveTaskCommentReconcileActor?: (comment: Comment, provenance: WorkspaceSyncV3TaskCommentReconcileProvenance) => string;
+    /** @deprecated Prefer resolveOriginActorRef; retained for create callers. */
+    resolveTaskCreateActorRef?: (originActor: NonNullable<WorkspaceSyncV3TaskCreateEnvelope['operation']['payload']['originActor']>) => string;
+    onPostCommitError?: (error: unknown) => void;
+};
+export type WorkspaceSyncV3CloudOperationHandler = {
+    key: string;
+    supports: (envelope: WorkspaceSyncV3OperationEnvelope) => boolean;
+    apply: (envelope: WorkspaceSyncV3OperationEnvelope, context: WorkspaceSyncV3CloudOperationContext) => WorkspaceSyncV3CloudOperationResult;
+};
+export declare class WorkspaceSyncV3CloudOperationUnsupportedError extends Error {
+    readonly code = "WORKSPACE_SYNC_V3_REQUEST_INVALID";
+    readonly statusCode = 400;
+    constructor();
+}
+export declare function createWorkspaceSyncV3CloudOperationHandlers(): WorkspaceSyncV3CloudOperationHandler[];
+export declare function dispatchWorkspaceSyncV3CloudOperation(input: {
+    handlers: readonly WorkspaceSyncV3CloudOperationHandler[];
+    envelope: WorkspaceSyncV3OperationEnvelope;
+    context: WorkspaceSyncV3CloudOperationContext;
+}): WorkspaceSyncV3CloudOperationResult;

package/dist/sync/v3/workspaceSyncV3CloudOperationHandler.js

@@ -0,0 +1,356 @@
+import { runDurableTaskCreate } from './taskCreateMutationService.js';
+import { runDurableTaskLegacyRootAdoption, } from './taskLegacyRootAdoptionService.js';
+import { runDurableTaskDelete } from './taskDeleteMutationService.js';
+import { runDurableTaskRestore } from './taskRestoreMutationService.js';
+import { runDurableTaskLifecycleMutation } from './taskLifecycleMutationService.js';
+import { runDurableTaskMetadataUpdate } from './taskMetadataMutationService.js';
+import { runDurableTaskRelationshipMutation } from './taskRelationshipMutationService.js';
+import { runDurableTaskRelationshipLegacyAdoption, } from './taskRelationshipLegacyAdoptionService.js';
+import { runDurableTaskStatusMutation } from './taskStatusMutationService.js';
+import { runDurableTaskWorkflowMutation } from './taskWorkflowMutationService.js';
+import { runDurableTaskCommentAppend, runDurableTaskCommentReconcile, } from './taskCommentMutationService.js';
+import { runDurableTaskChecklistReplace } from './taskChecklistMutationService.js';
+import { runDurableWorkstreamTaskOrderReplace, } from './workstreamTaskOrderMutationService.js';
+import { runDurableTaskAttachmentLinksReplace, } from './taskAttachmentLinksMutationService.js';
+import { runDurableTaxonomyReplacement } from './taxonomyMutationService.js';
+import { runDurableTaxonomyCompositeReplacement, } from './taxonomyCompositeMutationService.js';
+import { runDurableInitiativeMutation } from './initiativeMutationService.js';
+import { runDurableWorkstreamMutation } from './workstreamMutationService.js';
+import { runDurableWorkflowRuntimeMutation, } from './workflowRuntimeMutationService.js';
+import { runDurableEntityEventLegacyAdoption, } from './entityEventLegacyAdoptionService.js';
+import { resolveEffectiveOperationActorRef, } from './workspaceSyncV3OriginActor.js';
+export class WorkspaceSyncV3CloudOperationUnsupportedError extends Error {
+    code = 'WORKSPACE_SYNC_V3_REQUEST_INVALID';
+    statusCode = 400;
+    constructor() {
+        super('operation domain and mutationKind are not supported.');
+        this.name = 'WorkspaceSyncV3CloudOperationUnsupportedError';
+    }
+}
+function resolveHandlerActorRef(context, originActor) {
+    const resolve = context.resolveOriginActorRef || context.resolveTaskCreateActorRef;
+    return resolveEffectiveOperationActorRef({
+        authorizationActorRef: context.actorRef,
+        originActor,
+        resolveOriginActorRef: resolve,
+    });
+}
+/** Defer origin validation until applyMutation so committed replays skip mutable profile checks. */
+function withDeferredOriginActor(context, originActor) {
+    if (!originActor)
+        return context;
+    return {
+        ...context,
+        originActorRef: originActor.profileId,
+        resolveActorRef: () => resolveHandlerActorRef(context, originActor),
+    };
+}
+function relationshipIdentity(core, operation, workspaceId) {
+    return core.resolveTaskRelationshipIdentity(operation.payload.sourceTaskId, operation.payload.targetTaskId, operation.payload.type, workspaceId);
+}
+export function createWorkspaceSyncV3CloudOperationHandlers() {
+    return [{
+            key: 'entity-event/adopt-legacy-batch',
+            supports: (envelope) => envelope.operation.domain === 'entity-event'
+                && envelope.operation.mutationKind === 'adopt-legacy-batch',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableEntityEventLegacyAdoption({
+                    ...context,
+                    events: operation.payload.events,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task/metadata-update',
+            supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'metadata-update',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskMetadataUpdate({
+                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    taskId: operation.entityId, patch: operation.payload.patch,
+                    saveSource: operation.payload.saveSource,
+                    baseEntityRevision: operation.baseEntityRevision, baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'workflow-execution/runtime',
+            supports: (envelope) => envelope.operation.domain === 'workflow-execution'
+                && (envelope.operation.mutationKind === 'transition'
+                    || envelope.operation.mutationKind === 'complete-step'),
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                const command = operation.payload;
+                if (command.actorType === 'user' && command.actorId !== context.actorRef) {
+                    throw new Error('Workflow runtime command actor does not match the authenticated user.');
+                }
+                if (command.actorType === 'agent' && !context.core.listAssignableActors(context.workspaceId)
+                    .some((actor) => actor.id === command.actorId)) {
+                    throw new Error('Workflow runtime command agent is not assignable in this workspace.');
+                }
+                return runDurableWorkflowRuntimeMutation({
+                    ...context,
+                    command,
+                    baseExecutionEntityRevision: operation.baseEntityRevision,
+                    baseExecutionLifecycleRevision: operation.baseLifecycleRevision,
+                    authenticatedActorId: command.actorId,
+                    authenticatedActorType: command.actorType,
+                });
+            },
+        }, {
+            key: 'task/create',
+            supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'create',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                if ('adoptedRoot' in operation.payload) {
+                    return runDurableTaskLegacyRootAdoption({
+                        ...context,
+                        taskId: operation.entityId,
+                        adoptedRoot: operation.payload.adoptedRoot,
+                        baseEntityRevision: operation.baseEntityRevision,
+                        baseLifecycleRevision: operation.baseLifecycleRevision,
+                    });
+                }
+                // Keep origin resolution deferred via resolveActorRef so committed
+                // creates replay without re-validating an archived origin profile.
+                const originActor = operation.payload.originActor;
+                return runDurableTaskCreate({
+                    ...withDeferredOriginActor(context, originActor),
+                    provisionalTaskId: operation.entityId, task: operation.payload.task,
+                    ...(operation.payload.comments || operation.payload.checklist || operation.payload.attachments ? { carriers: {
+                            attachments: [], checklistItems: operation.payload.checklist || [], comments: operation.payload.comments || [],
+                        } } : {}),
+                    ...(operation.payload.attachments ? { attachmentLinks: operation.payload.attachments } : {}),
+                    baseEntityRevision: operation.baseEntityRevision, baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task/delete',
+            supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'delete',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskDelete({
+                    ...context, taskId: operation.entityId,
+                    baseEntityRevision: operation.baseEntityRevision, baseLifecycleRevision: operation.baseLifecycleRevision,
+                    relationshipBaseRevisions: operation.payload.relationships,
+                });
+            },
+        }, {
+            key: 'task/restore',
+            supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'restore',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskRestore({
+                    ...context,
+                    deletedRecordId: operation.entityId,
+                    taskId: operation.entityId,
+                    restoreDestination: operation.payload.restoreDestination,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task/lifecycle',
+            supports: (envelope) => envelope.operation.domain === 'task'
+                && (envelope.operation.mutationKind === 'archive' || envelope.operation.mutationKind === 'unarchive'),
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                const { originActor, ...payload } = operation.payload;
+                return runDurableTaskLifecycleMutation({
+                    ...withDeferredOriginActor(context, originActor),
+                    taskId: operation.entityId,
+                    mutationKind: operation.mutationKind,
+                    payload: payload,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task/workflow',
+            supports: (envelope) => envelope.operation.domain === 'task'
+                && (envelope.operation.mutationKind === 'complete' || envelope.operation.mutationKind === 'reopen'),
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                const { originActor, ...payload } = operation.payload;
+                return runDurableTaskWorkflowMutation({
+                    ...withDeferredOriginActor(context, originActor),
+                    taskId: operation.entityId,
+                    mutationKind: operation.mutationKind,
+                    payload: payload,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task/set-status',
+            supports: (envelope) => envelope.operation.domain === 'task' && envelope.operation.mutationKind === 'set-status',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                const { originActor, ...payload } = operation.payload;
+                return runDurableTaskStatusMutation({
+                    ...withDeferredOriginActor(context, originActor),
+                    taskId: operation.entityId,
+                    payload,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task-comments/append',
+            supports: (envelope) => envelope.operation.domain === 'task-comments' && envelope.operation.mutationKind === 'append',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskCommentAppend({
+                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    taskId: operation.entityId,
+                    comment: operation.payload.comment,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task-comments/reconcile',
+            supports: (envelope) => envelope.operation.domain === 'task-comments'
+                && envelope.operation.mutationKind === 'reconcile',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskCommentReconcile({
+                    ...context,
+                    taskId: operation.entityId,
+                    comments: operation.payload.comments,
+                    provenance: operation.payload.provenance,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task-checklist/replace',
+            supports: (envelope) => envelope.operation.domain === 'task-checklist' && envelope.operation.mutationKind === 'replace',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskChecklistReplace({
+                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    taskId: operation.entityId,
+                    items: operation.payload.items,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'workstream-task-order/replace',
+            supports: (envelope) => envelope.operation.domain === 'workstream-task-order'
+                && envelope.operation.mutationKind === 'replace',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableWorkstreamTaskOrderReplace({
+                    ...context,
+                    workstreamId: operation.entityId,
+                    taskIds: operation.payload.taskIds,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task-attachment-links/replace',
+            supports: (envelope) => envelope.operation.domain === 'task-attachment-links'
+                && envelope.operation.mutationKind === 'replace',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaskAttachmentLinksReplace({
+                    ...withDeferredOriginActor(context, operation.payload.originActor),
+                    taskId: operation.entityId,
+                    links: operation.payload.links,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'task-relationship/transition',
+            supports: (envelope) => envelope.operation.domain === 'task-relationship',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                const canonical = relationshipIdentity(context.core, operation, context.workspaceId);
+                if (canonical.id !== operation.entityId) {
+                    const error = new Error('operation.entityId does not match the canonical task relationship identity.');
+                    Object.assign(error, { code: 'WORKSPACE_SYNC_V3_REQUEST_INVALID', statusCode: 400 });
+                    throw error;
+                }
+                if (operation.payload.adoptedRelationship) {
+                    return runDurableTaskRelationshipLegacyAdoption({
+                        ...context,
+                        adoptedRelationship: operation.payload.adoptedRelationship,
+                        mutationKind: operation.mutationKind,
+                        baseEntityRevision: operation.baseEntityRevision,
+                        baseLifecycleRevision: operation.baseLifecycleRevision,
+                    });
+                }
+                return runDurableTaskRelationshipMutation({
+                    ...context,
+                    sourceTaskId: operation.payload.sourceTaskId,
+                    targetTaskId: operation.payload.targetTaskId,
+                    type: operation.payload.type,
+                    mutationKind: operation.mutationKind,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'initiative/mutation',
+            supports: (envelope) => envelope.operation.domain === 'initiative',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableInitiativeMutation({
+                    ...(operation.mutationKind === 'append-comment'
+                        ? withDeferredOriginActor(context, operation.payload.originActor)
+                        : context),
+                    operation,
+                });
+            },
+        }, {
+            key: 'workstream/mutation',
+            supports: (envelope) => envelope.operation.domain === 'workstream',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableWorkstreamMutation({
+                    ...(operation.mutationKind === 'append-comment'
+                        ? withDeferredOriginActor(context, operation.payload.originActor)
+                        : context),
+                    operation,
+                });
+            },
+        }, {
+            key: 'taxonomy/replace-state-with-task-remaps',
+            supports: (envelope) => envelope.operation.domain === 'taxonomy'
+                && envelope.operation.mutationKind === 'replace-state-with-task-remaps',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaxonomyCompositeReplacement({
+                    ...context,
+                    taxonomyState: operation.payload.state,
+                    taskPatches: operation.payload.taskPatches,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }, {
+            key: 'taxonomy/replace-state',
+            supports: (envelope) => envelope.operation.domain === 'taxonomy'
+                && envelope.operation.mutationKind === 'replace-state',
+            apply: (envelope, context) => {
+                const operation = envelope.operation;
+                return runDurableTaxonomyReplacement({
+                    ...context,
+                    taxonomyState: operation.payload.state,
+                    baseEntityRevision: operation.baseEntityRevision,
+                    baseLifecycleRevision: operation.baseLifecycleRevision,
+                });
+            },
+        }];
+}
+export function dispatchWorkspaceSyncV3CloudOperation(input) {
+    const handler = input.handlers.find((candidate) => candidate.supports(input.envelope));
+    if (!handler)
+        throw new WorkspaceSyncV3CloudOperationUnsupportedError();
+    return handler.apply(input.envelope, input.context);
+}

package/dist/sync/v3/workspaceSyncV3CombinedCoverage.d.ts

@@ -0,0 +1,51 @@
+import { type WorkspaceSyncV3FeedEntry, type WorkspaceSyncV3FeedCoveragePolicy, type WorkspaceSyncV3FeedOperationProjector } from './workspaceSyncV3Feed.js';
+import { type WorkspaceSyncV3CoverageProfile } from './workspaceSyncV3FeedProfile.js';
+export declare const WORKSPACE_SYNC_V3_COMBINED_PROJECTIONS: readonly [Readonly<{
+    projectionId: "taxonomy/full-v1";
+    domain: "taxonomy";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+    fields: readonly string[];
+    dependencies: readonly [];
+    operationAtomic: true;
+}>, Readonly<{
+    projectionId: "initiative/full-v1";
+    domain: "initiative";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+    fields: readonly string[];
+    dependencies: readonly [];
+    operationAtomic: true;
+}>, Readonly<{
+    projectionId: "workstream/full-v1";
+    domain: "workstream";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+    fields: readonly string[];
+    dependencies: readonly ["initiative/full-v1"];
+    operationAtomic: true;
+}>, Readonly<{
+    projectionId: "task/root-v1";
+    domain: "task";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+    fields: readonly string[];
+    dependencies: readonly ["taxonomy/full-v1", "workstream/full-v1"];
+    operationAtomic: true;
+}>, Readonly<{
+    projectionId: "task-relationship/full-v1";
+    domain: "task-relationship";
+    schemaVersion: 1;
+    mutationKinds: readonly string[];
+    fields: readonly string[];
+    dependencies: readonly ["task/root-v1"];
+    operationAtomic: true;
+}>];
+/**
+ * Frozen combined coverage wire contract. Runtime readiness and durable local
+ * ownership, not this exported descriptor alone, decide whether it is active.
+ */
+export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE: WorkspaceSyncV3CoverageProfile;
+export declare const projectWorkspaceSyncV3CombinedOperation: WorkspaceSyncV3FeedOperationProjector;
+export declare const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_POLICY: WorkspaceSyncV3FeedCoveragePolicy;
+export declare function validateWorkspaceSyncV3CombinedFeedEntry(entry: WorkspaceSyncV3FeedEntry): void;

package/dist/sync/v3/workspaceSyncV3CombinedCoverage.js

@@ -0,0 +1,171 @@
+import { createHash } from 'crypto';
+import { canonicalWorkspaceSyncJson } from './canonicalWorkspaceSyncJson.js';
+import { projectWorkspaceSyncV3InitiativeJournalRow, validateWorkspaceSyncV3FeedEntry, } from './workspaceSyncV3Feed.js';
+import { assertWorkspaceSyncV3OperationBoundary } from './workspaceSyncV3OperationProjection.js';
+import { projectWorkspaceSyncV3TaskRelationshipOperation, validateWorkspaceSyncV3TaskRelationshipFeedEntry } from './workspaceSyncV3TaskRelationshipProjection.js';
+import { projectWorkspaceSyncV3TaskRootOperation, validateWorkspaceSyncV3TaskRootFeedEntry } from './workspaceSyncV3TaskRootProjection.js';
+import { projectWorkspaceSyncV3TaxonomyOperation, validateWorkspaceSyncV3TaxonomyFeedEntry } from './workspaceSyncV3TaxonomyFeedProjection.js';
+import { projectWorkspaceSyncV3WorkstreamJournalRow, validateWorkspaceSyncV3WorkstreamFeedEntry, } from './workspaceSyncV3WorkstreamProjection.js';
+import { projectWorkspaceSyncV3NestedTaskOperation } from './workspaceSyncV3NestedTaskProjection.js';
+export const WORKSPACE_SYNC_V3_COMBINED_PROJECTIONS = Object.freeze([
+    Object.freeze({
+        projectionId: 'taxonomy/full-v1',
+        domain: 'taxonomy',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['replace-state', 'replace-state-with-task-remaps']),
+        fields: Object.freeze(['categories', 'types', 'priorities', 'taxonomies', 'displayLabels']),
+        dependencies: Object.freeze([]),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'initiative/full-v1',
+        domain: 'initiative',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['create', 'metadata-update', 'append-comment', 'archive', 'unarchive']),
+        fields: Object.freeze([
+            'id', 'referenceNumber', 'referenceLabel', 'title', 'description', 'ownerId', 'comments', 'attachments',
+            'order', 'createdAt', 'updatedAt', 'isArchived',
+        ]),
+        dependencies: Object.freeze([]),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'workstream/full-v1',
+        domain: 'workstream',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['create', 'metadata-update', 'append-comment', 'archive', 'unarchive']),
+        fields: Object.freeze([
+            'id', 'referenceNumber', 'referenceLabel', 'initiativeId', 'title', 'description', 'ownerId', 'comments',
+            'attachments', 'order', 'createdAt', 'updatedAt', 'isArchived',
+        ]),
+        dependencies: Object.freeze(['initiative/full-v1']),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'task/root-v1',
+        domain: 'task',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze([
+            'create', 'metadata-update', 'archive', 'unarchive', 'complete', 'reopen', 'set-status', 'taxonomy-remap', 'delete',
+        ]),
+        fields: Object.freeze([
+            // Keep the retired approach field in the frozen v1 coverage signature so existing
+            // journals and repair snapshots remain compatible. Current serializers omit it.
+            'id', 'title', 'description', 'status', 'priority', 'complexity', 'type', 'category', 'approach',
+            'canceledReason', 'createdAt', 'updatedAt', 'completedAt', 'isArchived', 'taxonomies', 'createdBy',
+            'assignee', 'scheduledDate', 'dueDate', 'scheduledWeekKey', 'orderInDay', 'workstreamId', 'referenceNumber',
+        ]),
+        dependencies: Object.freeze(['taxonomy/full-v1', 'workstream/full-v1']),
+        operationAtomic: true,
+    }),
+    Object.freeze({
+        projectionId: 'task-relationship/full-v1',
+        domain: 'task-relationship',
+        schemaVersion: 1,
+        mutationKinds: Object.freeze(['link', 'unlink', 'delete']),
+        fields: Object.freeze([
+            'id', 'workspaceId', 'sourceTaskId', 'targetTaskId', 'kind', 'createdBy', 'createdAt', 'updatedBy',
+            'updatedAt', 'deletedBy', 'deletedAt',
+        ]),
+        dependencies: Object.freeze(['task/root-v1']),
+        operationAtomic: true,
+    }),
+]);
+const identity = Object.freeze({
+    coverageProfileId: 'task-planning-metadata',
+    coverageVersion: 3,
+    projections: WORKSPACE_SYNC_V3_COMBINED_PROJECTIONS,
+});
+/**
+ * Frozen combined coverage wire contract. Runtime readiness and durable local
+ * ownership, not this exported descriptor alone, decide whether it is active.
+ */
+export const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE = Object.freeze({
+    ...identity,
+    coverageDigest: createHash('sha256').update(canonicalWorkspaceSyncJson(identity)).digest('hex'),
+});
+const COVERED_DOMAINS = new Set(['initiative', 'workstream', 'task', 'task-relationship', 'taxonomy']);
+function initiativeOperation(input) {
+    assertWorkspaceSyncV3OperationBoundary(input);
+    if (input.rows[0].domain !== 'initiative'
+        || input.rows.slice(1).some((row) => row.domain !== 'entity-event' || row.mutationKind !== 'append')) {
+        throw new Error('Initiative operation contains an invalid covered projection boundary.');
+    }
+    const projected = projectWorkspaceSyncV3InitiativeJournalRow(input.rows[0]);
+    if (!projected)
+        throw new Error('Initiative operation is not projectable.');
+    return [projected];
+}
+function workstreamOperation(input) {
+    assertWorkspaceSyncV3OperationBoundary(input);
+    if (input.rows[0].domain !== 'workstream'
+        || input.rows.slice(1).some((row) => row.domain !== 'entity-event' || row.mutationKind !== 'append')) {
+        throw new Error('Workstream operation contains an invalid covered projection boundary.');
+    }
+    const projected = projectWorkspaceSyncV3WorkstreamJournalRow(input.rows[0]);
+    if (!projected)
+        throw new Error('Workstream operation is not projectable.');
+    return [projected];
+}
+export const projectWorkspaceSyncV3CombinedOperation = (input) => {
+    const first = input.rows[0];
+    if (!first)
+        throw new Error('Workspace sync journal operation is empty.');
+    if (first.domain === 'initiative')
+        return initiativeOperation(input);
+    if (first.domain === 'workstream')
+        return workstreamOperation(input);
+    if (first.domain === 'taxonomy') {
+        const taxonomy = projectWorkspaceSyncV3TaxonomyOperation(input);
+        const tasks = projectWorkspaceSyncV3TaskRootOperation(input);
+        if (!taxonomy || (taxonomy.length > 1 && (!tasks || tasks.length !== taxonomy.length - 1))) {
+            throw new Error('Combined taxonomy operation is incomplete.');
+        }
+        return [taxonomy[0], ...(tasks || [])];
+    }
+    if (first.domain === 'task') {
+        if (input.rows.some((row) => row.domain === 'task-comments'
+            || row.domain === 'task-checklist' || row.domain === 'task-attachment-links')) {
+            const nested = projectWorkspaceSyncV3NestedTaskOperation(input);
+            if (!nested)
+                throw new Error('Combined nested task operation is incomplete.');
+            return nested.filter((entry) => WORKSPACE_SYNC_V3_COMBINED_PROJECTIONS
+                .some((projection) => projection.projectionId === entry.projection));
+        }
+        const tasks = projectWorkspaceSyncV3TaskRootOperation(input);
+        if (!tasks)
+            throw new Error('Combined task operation is incomplete.');
+        const relationships = projectWorkspaceSyncV3TaskRelationshipOperation(input) || [];
+        return [...tasks, ...relationships];
+    }
+    if (first.domain === 'task-relationship') {
+        const relationships = projectWorkspaceSyncV3TaskRelationshipOperation(input);
+        if (!relationships)
+            throw new Error('Combined task relationship operation is incomplete.');
+        return relationships;
+    }
+    if (input.rows.some((row) => COVERED_DOMAINS.has(row.domain))) {
+        throw new Error('Covered projection is nested under an uncovered operation boundary.');
+    }
+    return [];
+};
+export const WORKSPACE_SYNC_V3_COMBINED_COVERAGE_POLICY = Object.freeze({
+    profile: WORKSPACE_SYNC_V3_COMBINED_COVERAGE_PROFILE,
+    projectOperation: projectWorkspaceSyncV3CombinedOperation,
+});
+export function validateWorkspaceSyncV3CombinedFeedEntry(entry) {
+    if (entry.projection === 'initiative/full-v1')
+        return validateWorkspaceSyncV3FeedEntry(entry);
+    if (entry.projection === 'workstream/full-v1')
+        return validateWorkspaceSyncV3WorkstreamFeedEntry(entry);
+    if (entry.projection === 'task/root-v1') {
+        return validateWorkspaceSyncV3TaskRootFeedEntry(entry);
+    }
+    if (entry.projection === 'task-relationship/full-v1') {
+        return validateWorkspaceSyncV3TaskRelationshipFeedEntry(entry);
+    }
+    if (entry.projection === 'taxonomy/full-v1') {
+        return validateWorkspaceSyncV3TaxonomyFeedEntry(entry);
+    }
+    throw new Error(`Unsupported combined workspace sync projection: ${entry.projection}.`);
+}