@bosun-sh/logbook 1.0.0 → 2.0.0

package/dist/sync/linear/push.js

@@ -0,0 +1,681 @@
+import { nowIso } from "../../shared/time.js";
+import { createSyncConflict } from "../../sync/conflicts.js";
+import { appendSyncEvent } from "../../sync/events.js";
+import { findExternalLink, upsertExternalLink } from "../../sync/external-links.js";
+import { readLinearApiToken, readLinearWorkspaceConfig } from "../../sync/linear/config.js";
+import { mapTaskToLinearIssueInput } from "../../sync/linear/mapping.js";
+import { Context, Effect } from "effect";
+const LINEAR_PROVIDER_ID = "linear";
+const DEFAULT_COMMENT_PAGE_SIZE = 100;
+const MAX_COMMENT_PAGE_SIZE = 100;
+const LINEAR_CREATE_ISSUE_OPERATION = "LinearCreateIssue";
+const LINEAR_UPDATE_ISSUE_OPERATION = "LinearUpdateIssue";
+const LINEAR_CREATE_COMMENT_OPERATION = "LinearCreateComment";
+const TaskRepository = Context.GenericTag("TaskRepository");
+const SyncEventRepository = Context.GenericTag("SyncEventRepository");
+const LinearGraphQLClientTag = Context.GenericTag("LinearGraphQLClient");
+export const pushLinearSync = (input) => Effect.gen(function* () {
+    const configResult = yield* Effect.promise(() => readLinearWorkspaceConfig());
+    if (!configResult.ok) {
+        return configResult;
+    }
+    const config = configResult.data;
+    const taskRepo = (yield* TaskRepository);
+    const eventRepo = (yield* SyncEventRepository);
+    const client = (yield* LinearGraphQLClientTag);
+    const defaultTeamId = config?.defaultTeamId;
+    const defaultProjectId = config?.defaultProjectId;
+    const statusMapping = config?.statusMapping;
+    const labelMapping = config?.labelMapping;
+    if (readLinearApiToken(config) === undefined) {
+        return providerError("auth_failed", "Linear API token is required.", {
+            provider: LINEAR_PROVIDER_ID,
+            reason: "missing_token",
+        });
+    }
+    const tasksResult = yield* loadTasks(taskRepo, input.taskIds);
+    if (!tasksResult.ok) {
+        return tasksResult;
+    }
+    const tasks = tasksResult.data;
+    let created = 0;
+    let updated = 0;
+    let skipped = 0;
+    let conflicts = 0;
+    const events = [];
+    for (const task of tasks) {
+        const linkResult = yield* findExternalLink({
+            provider: LINEAR_PROVIDER_ID,
+            localRecord: { kind: "task", id: task.id },
+            limit: 2,
+        });
+        if (!linkResult.ok) {
+            return linkResult;
+        }
+        const link = linkResult.data.externalLinks[0];
+        if (link === undefined) {
+            if (defaultTeamId === undefined || defaultTeamId.length === 0) {
+                const event = yield* appendAndCollect(events, eventRepo, {
+                    direction: "push",
+                    data: {
+                        result: "skipped",
+                        providerId: LINEAR_PROVIDER_ID,
+                        entityType: "task",
+                        entityId: task.id,
+                        reason: "missing_mapping",
+                    },
+                });
+                if (!event.ok) {
+                    return event;
+                }
+                skipped += 1;
+                continue;
+            }
+            if (input.dryRun) {
+                const event = yield* appendAndCollect(events, eventRepo, {
+                    direction: "push",
+                    data: {
+                        result: "skipped",
+                        providerId: LINEAR_PROVIDER_ID,
+                        entityType: "task",
+                        entityId: task.id,
+                        reason: "dry_run",
+                    },
+                });
+                if (!event.ok) {
+                    return event;
+                }
+                skipped += 1;
+                continue;
+            }
+            const createProjectId = input.projectId ?? defaultProjectId;
+            const mapped = mapTaskToLinearIssueInput(task, {
+                ...(defaultTeamId === undefined ? {} : { defaultTeamId }),
+                ...(createProjectId === undefined ? {} : { defaultProjectId: createProjectId }),
+                ...(statusMapping === undefined ? {} : { statusMapping }),
+                ...(labelMapping === undefined ? {} : { labelMapping }),
+            });
+            if (!mapped.ok) {
+                return mapped;
+            }
+            const createdIssue = yield* Effect.either(client.request({
+                operationName: LINEAR_CREATE_ISSUE_OPERATION,
+                query: LINEAR_CREATE_ISSUE_QUERY,
+                variables: mapped.data.input,
+            }));
+            if (createdIssue._tag === "Left") {
+                const failure = yield* appendFailedEvent(events, eventRepo, {
+                    entityType: "task",
+                    entityId: task.id,
+                    error: createdIssue.left,
+                });
+                if (!failure.ok) {
+                    return failure;
+                }
+                return providerError("unknown", "Linear issue creation failed.", {
+                    provider: LINEAR_PROVIDER_ID,
+                    error: createdIssue.left,
+                });
+            }
+            const createdRecord = createdIssue.right.issueCreate?.issue;
+            if (createdRecord === undefined || createdRecord === null) {
+                const failure = yield* appendFailedEvent(events, eventRepo, {
+                    entityType: "task",
+                    entityId: task.id,
+                    error: {
+                        providerId: LINEAR_PROVIDER_ID,
+                        code: "not_found",
+                        retryable: false,
+                        message: "Linear issue creation returned no issue.",
+                    },
+                });
+                if (!failure.ok) {
+                    return failure;
+                }
+                return providerError("unknown", "Linear issue creation returned no issue.", {
+                    provider: LINEAR_PROVIDER_ID,
+                });
+            }
+            const commentResult = yield* pushTaskComments({
+                task,
+                issueId: createdRecord.id,
+                lastPushedLocalVersion: undefined,
+                client,
+                events,
+                eventRepo,
+            });
+            if (!commentResult.ok) {
+                return commentResult;
+            }
+            const now = yield* nowIso();
+            const linked = yield* upsertExternalLink({
+                provider: LINEAR_PROVIDER_ID,
+                localRecord: { kind: "task", id: task.id },
+                remoteRecord: {
+                    id: createdRecord.id,
+                    ...(createdRecord.url === undefined || createdRecord.url === null
+                        ? {}
+                        : { url: createdRecord.url }),
+                    type: "issue",
+                },
+                lastSyncedAt: now,
+                lastSeenRemoteVersion: createdRecord.updatedAt,
+                lastPushedLocalVersion: task.updatedAt,
+            });
+            if (!linked.ok) {
+                return linked;
+            }
+            const event = yield* appendAndCollect(events, eventRepo, {
+                direction: "push",
+                data: {
+                    result: "created",
+                    providerId: LINEAR_PROVIDER_ID,
+                    entityType: "task",
+                    entityId: task.id,
+                    remoteId: createdRecord.id,
+                    fields: commentResult.data.pushedComments > 0
+                        ? ["title", "description", "status", "priority", "comments"]
+                        : ["title", "description", "status", "priority"],
+                },
+            });
+            if (!event.ok) {
+                return event;
+            }
+            created += 1;
+            continue;
+        }
+        const issueResult = yield* Effect.either(client.request({
+            operationName: "LinearGetIssue",
+            query: LINEAR_GET_ISSUE_QUERY,
+            variables: {
+                id: link.remoteRecord.id,
+            },
+        }));
+        if (issueResult._tag === "Left") {
+            const failure = yield* appendFailedEvent(events, eventRepo, {
+                entityType: "task",
+                entityId: task.id,
+                remoteId: link.remoteRecord.id,
+                error: issueResult.left,
+            });
+            if (!failure.ok) {
+                return failure;
+            }
+            return providerError("unknown", "Linear issue lookup failed.", {
+                provider: LINEAR_PROVIDER_ID,
+                error: issueResult.left,
+            });
+        }
+        const remoteIssue = issueResult.right.issue;
+        if (remoteIssue === undefined || remoteIssue === null) {
+            const failure = yield* appendFailedEvent(events, eventRepo, {
+                entityType: "task",
+                entityId: task.id,
+                remoteId: link.remoteRecord.id,
+                error: {
+                    providerId: LINEAR_PROVIDER_ID,
+                    code: "not_found",
+                    retryable: false,
+                    message: "Linear issue was not found.",
+                },
+            });
+            if (!failure.ok) {
+                return failure;
+            }
+            return providerError("not_found", "Linear issue was not found.", {
+                provider: LINEAR_PROVIDER_ID,
+                remoteId: link.remoteRecord.id,
+            });
+        }
+        const localChanged = link.lastPushedLocalVersion !== task.updatedAt;
+        const remoteChanged = link.lastSeenRemoteVersion !== remoteIssue.updatedAt;
+        if (localChanged && remoteChanged) {
+            const conflict = yield* createSyncConflict({
+                provider: LINEAR_PROVIDER_ID,
+                localRecord: { kind: "task", id: task.id },
+                remoteRecord: {
+                    id: remoteIssue.id,
+                    ...(remoteIssue.url === undefined || remoteIssue.url === null
+                        ? {}
+                        : { url: remoteIssue.url }),
+                },
+                fields: pushConflictFields(task, remoteIssue),
+            });
+            if (!conflict.ok) {
+                return conflict;
+            }
+            if (conflict.data.conflict !== undefined) {
+                const event = yield* appendAndCollect(events, eventRepo, {
+                    direction: "push",
+                    data: {
+                        result: "conflict",
+                        providerId: LINEAR_PROVIDER_ID,
+                        conflictId: conflict.data.conflict.id,
+                        entityType: "task",
+                        entityId: task.id,
+                        fields: [...conflict.data.decision.fields],
+                    },
+                });
+                if (!event.ok) {
+                    return event;
+                }
+                conflicts += 1;
+            }
+            continue;
+        }
+        if (!localChanged) {
+            const event = yield* appendAndCollect(events, eventRepo, {
+                direction: "push",
+                data: {
+                    result: "skipped",
+                    providerId: LINEAR_PROVIDER_ID,
+                    entityType: "task",
+                    entityId: task.id,
+                    remoteId: remoteIssue.id,
+                    reason: "unchanged",
+                },
+            });
+            if (!event.ok) {
+                return event;
+            }
+            skipped += 1;
+            continue;
+        }
+        if (input.dryRun) {
+            const event = yield* appendAndCollect(events, eventRepo, {
+                direction: "push",
+                data: {
+                    result: "skipped",
+                    providerId: LINEAR_PROVIDER_ID,
+                    entityType: "task",
+                    entityId: task.id,
+                    remoteId: remoteIssue.id,
+                    reason: "dry_run",
+                },
+            });
+            if (!event.ok) {
+                return event;
+            }
+            skipped += 1;
+            continue;
+        }
+        const updateTeamId = remoteIssue.team?.id ?? defaultTeamId;
+        const updateProjectId = input.projectId ?? defaultProjectId ?? remoteIssue.project?.id;
+        const mapped = mapTaskToLinearIssueInput(task, {
+            ...(updateTeamId === undefined ? {} : { defaultTeamId: updateTeamId }),
+            ...(updateProjectId === undefined ? {} : { defaultProjectId: updateProjectId }),
+            ...(statusMapping === undefined ? {} : { statusMapping }),
+            ...(labelMapping === undefined ? {} : { labelMapping }),
+        });
+        if (!mapped.ok) {
+            return mapped;
+        }
+        const updateInput = {
+            input: {
+                id: remoteIssue.id,
+                title: mapped.data.input.title,
+                description: mapped.data.input.description,
+                teamId: remoteIssue.team?.id ?? mapped.data.input.teamId,
+                ...(mapped.data.input.projectId === undefined
+                    ? {}
+                    : { projectId: mapped.data.input.projectId }),
+                ...(mapped.data.input.stateId === undefined
+                    ? {}
+                    : { stateId: mapped.data.input.stateId }),
+                priority: mapped.data.input.priority,
+            },
+        };
+        const issueUpdateResult = yield* Effect.either(client.request({
+            operationName: LINEAR_UPDATE_ISSUE_OPERATION,
+            query: LINEAR_UPDATE_ISSUE_QUERY,
+            variables: updateInput,
+        }));
+        if (issueUpdateResult._tag === "Left") {
+            const failure = yield* appendFailedEvent(events, eventRepo, {
+                entityType: "task",
+                entityId: task.id,
+                remoteId: remoteIssue.id,
+                error: issueUpdateResult.left,
+            });
+            if (!failure.ok) {
+                return failure;
+            }
+            return providerError("unknown", "Linear issue update failed.", {
+                provider: LINEAR_PROVIDER_ID,
+                error: issueUpdateResult.left,
+            });
+        }
+        const updatedRecord = issueUpdateResult.right.issueUpdate?.issue;
+        if (updatedRecord === undefined || updatedRecord === null) {
+            const failure = yield* appendFailedEvent(events, eventRepo, {
+                entityType: "task",
+                entityId: task.id,
+                remoteId: remoteIssue.id,
+                error: {
+                    providerId: LINEAR_PROVIDER_ID,
+                    code: "not_found",
+                    retryable: false,
+                    message: "Linear issue update returned no issue.",
+                },
+            });
+            if (!failure.ok) {
+                return failure;
+            }
+            return providerError("unknown", "Linear issue update returned no issue.", {
+                provider: LINEAR_PROVIDER_ID,
+            });
+        }
+        const commentResult = yield* pushTaskComments({
+            task,
+            issueId: updatedRecord.id,
+            lastPushedLocalVersion: link.lastPushedLocalVersion,
+            client,
+            events,
+            eventRepo,
+        });
+        if (!commentResult.ok) {
+            return commentResult;
+        }
+        const now = yield* nowIso();
+        const linked = yield* upsertExternalLink({
+            provider: LINEAR_PROVIDER_ID,
+            localRecord: { kind: "task", id: task.id },
+            remoteRecord: {
+                id: updatedRecord.id,
+                ...(updatedRecord.url === undefined || updatedRecord.url === null
+                    ? {}
+                    : { url: updatedRecord.url }),
+                type: "issue",
+            },
+            lastSyncedAt: now,
+            lastSeenRemoteVersion: updatedRecord.updatedAt,
+            lastPushedLocalVersion: task.updatedAt,
+        });
+        if (!linked.ok) {
+            return linked;
+        }
+        const fields = ["title", "description", "status", "priority"];
+        const event = yield* appendAndCollect(events, eventRepo, {
+            direction: "push",
+            data: {
+                result: "updated",
+                providerId: LINEAR_PROVIDER_ID,
+                entityType: "task",
+                entityId: task.id,
+                remoteId: updatedRecord.id,
+                fields: commentResult.data.pushedComments > 0 ? [...fields, "comments"] : fields,
+            },
+        });
+        if (!event.ok) {
+            return event;
+        }
+        updated += 1;
+    }
+    return {
+        ok: true,
+        data: {
+            created,
+            updated,
+            skipped,
+            conflicts,
+            events,
+        },
+    };
+});
+const loadTasks = (taskRepo, taskIds) => Effect.gen(function* () {
+    if (taskIds === undefined || taskIds.length === 0) {
+        const tasks = yield* Effect.either(taskRepo.findByStatus("*"));
+        if (tasks._tag === "Left") {
+            return repositoryError(tasks.left);
+        }
+        return { ok: true, data: tasks.right };
+    }
+    const tasks = [];
+    for (const taskId of taskIds) {
+        const task = yield* Effect.either(taskRepo.findById(taskId));
+        if (task._tag === "Left") {
+            return repositoryError(task.left);
+        }
+        tasks.push(task.right);
+    }
+    return { ok: true, data: tasks };
+});
+const pushTaskComments = (input) => Effect.gen(function* () {
+    const comments = input.task.comments
+        .filter((comment) => comment.kind !== "sync")
+        .filter((comment) => input.lastPushedLocalVersion === undefined
+        ? true
+        : comment.createdAt > input.lastPushedLocalVersion)
+        .sort((left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id));
+    if (comments.length === 0) {
+        return {
+            ok: true,
+            data: { pushedComments: 0 },
+        };
+    }
+    const page = comments.slice(0, MAX_COMMENT_PAGE_SIZE);
+    if (comments.length > MAX_COMMENT_PAGE_SIZE) {
+        const event = yield* appendAndCollect(input.events, input.eventRepo, {
+            direction: "push",
+            data: {
+                result: "skipped",
+                providerId: LINEAR_PROVIDER_ID,
+                entityType: "task",
+                entityId: input.task.id,
+                remoteId: input.issueId,
+                reason: "filtered",
+            },
+        });
+        if (!event.ok) {
+            return event;
+        }
+    }
+    for (const comment of page) {
+        const created = yield* Effect.either(input.client.request({
+            operationName: LINEAR_CREATE_COMMENT_OPERATION,
+            query: LINEAR_CREATE_COMMENT_QUERY,
+            variables: {
+                issueId: input.issueId,
+                body: comment.content,
+            },
+        }));
+        if (created._tag === "Left") {
+            return providerError("unknown", "Linear comment creation failed.", {
+                provider: LINEAR_PROVIDER_ID,
+                error: created.left,
+            });
+        }
+        if (created.right.commentCreate?.comment === undefined ||
+            created.right.commentCreate.comment === null) {
+            return providerError("unknown", "Linear comment creation returned no comment.", {
+                provider: LINEAR_PROVIDER_ID,
+            });
+        }
+    }
+    if (comments.length > MAX_COMMENT_PAGE_SIZE) {
+        return {
+            ok: true,
+            data: {
+                pushedComments: page.length,
+            },
+            warnings: [
+                {
+                    code: "has_more",
+                    message: "Linear comments exceeded the 100 item limit.",
+                    details: {
+                        providerId: LINEAR_PROVIDER_ID,
+                        issueId: input.issueId,
+                        hasMore: true,
+                        limit: MAX_COMMENT_PAGE_SIZE,
+                        cursor: {
+                            providerId: LINEAR_PROVIDER_ID,
+                            cursor: page[page.length - 1]?.id,
+                            pageSize: DEFAULT_COMMENT_PAGE_SIZE,
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    return {
+        ok: true,
+        data: {
+            pushedComments: page.length,
+        },
+    };
+});
+const appendAndCollect = (events, eventRepo, input) => Effect.gen(function* () {
+    const result = yield* appendSyncEvent(input);
+    if (!result.ok) {
+        return result;
+    }
+    events.push(result.data.syncEvent);
+    const saved = yield* Effect.either(eventRepo.create(result.data.syncEvent));
+    if (saved._tag === "Left") {
+        return repositoryError(saved.left);
+    }
+    return {
+        ok: true,
+        data: undefined,
+    };
+});
+const appendFailedEvent = (events, eventRepo, input) => appendAndCollect(events, eventRepo, {
+    direction: "push",
+    data: {
+        result: "failed",
+        providerId: LINEAR_PROVIDER_ID,
+        ...(input.entityType === undefined ? {} : { entityType: input.entityType }),
+        ...(input.entityId === undefined ? {} : { entityId: input.entityId }),
+        ...(input.remoteId === undefined ? {} : { remoteId: input.remoteId }),
+        error: normalizeProviderError(input.error),
+    },
+});
+const normalizeProviderError = (error) => isProviderError(error)
+    ? error
+    : {
+        providerId: LINEAR_PROVIDER_ID,
+        code: "unknown",
+        retryable: false,
+        message: "Linear provider request failed.",
+        details: { error: String(error) },
+    };
+const isProviderError = (value) => isRecord(value) &&
+    typeof value.providerId === "string" &&
+    typeof value.code === "string" &&
+    typeof value.retryable === "boolean" &&
+    typeof value.message === "string";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const repositoryError = (cause) => ({
+    ok: false,
+    error: {
+        code: "storage_error",
+        message: "Repository operation failed.",
+        ...(cause === undefined ? {} : { details: { cause } }),
+    },
+});
+const providerError = (code, message, details) => ({
+    ok: false,
+    error: {
+        code,
+        message,
+        ...(details === undefined ? {} : { details }),
+    },
+});
+const pushConflictFields = (task, issue) => [
+    ["title", task.title, issue.title],
+    ["description", task.description, issue.description ?? ""],
+    ["status", task.status, mapLinearStateToTaskStatus(issue)],
+    ["priority", task.priority, issue.priority ?? 0],
+].map(([path, localValue, remoteValue]) => ({
+    path,
+    localValue,
+    remoteValue,
+}));
+const mapLinearStateToTaskStatus = (issue) => {
+    switch (issue.state?.type ?? "unstarted") {
+        case "backlog":
+            return "backlog";
+        case "unstarted":
+            return "todo";
+        case "started":
+            return "in_progress";
+        case "completed":
+            return "done";
+        case "canceled":
+            return "canceled";
+        default:
+            return "todo";
+    }
+};
+const LINEAR_CREATE_ISSUE_QUERY = `
+mutation LinearCreateIssue($input: IssueCreateInput!) {
+  issueCreate(input: $input) {
+    issue {
+      id
+      identifier
+      url
+      title
+      description
+      priority
+      updatedAt
+      archivedAt
+      team { id key name }
+      project { id name }
+      state { id name type }
+      assignee { id name }
+      labels { nodes { id name } }
+    }
+  }
+}
+`;
+const LINEAR_UPDATE_ISSUE_QUERY = `
+mutation LinearUpdateIssue($input: IssueUpdateInput!) {
+  issueUpdate(input: $input) {
+    issue {
+      id
+      identifier
+      url
+      title
+      description
+      priority
+      updatedAt
+      archivedAt
+      team { id key name }
+      project { id name }
+      state { id name type }
+      assignee { id name }
+      labels { nodes { id name } }
+    }
+  }
+}
+`;
+const LINEAR_CREATE_COMMENT_QUERY = `
+mutation LinearCreateComment($issueId: String!, $body: String!) {
+  commentCreate(issueId: $issueId, body: $body) {
+    comment {
+      id
+      createdAt
+    }
+  }
+}
+`;
+const LINEAR_GET_ISSUE_QUERY = `
+query LinearGetIssue($id: String!) {
+  issue(id: $id) {
+    id
+    identifier
+    url
+    title
+    description
+    priority
+    updatedAt
+    archivedAt
+    team { id key name }
+    project { id name }
+    state { id name type }
+    assignee { id name }
+    labels { nodes { id name } }
+  }
+}
+`;
+//# sourceMappingURL=push.js.map