@plandesk/api 0.3.0 → 0.4.1

package/dist/services/sync.js

@@ -0,0 +1,297 @@
+import { randomUUID } from 'node:crypto';
+import { getPullCursor, getShare, getSubmission as dbGetSubmission, getSyncRemote, listSubmissions, parseSharePermissions, setPullCursor, setSubmissionStatus, setSyncRemote, upsertSubmission, } from '@plandesk/db';
+export class SyncUnavailableError extends Error {
+    constructor(message = 'sync server unavailable') {
+        super(message);
+        this.name = 'SyncUnavailableError';
+    }
+}
+export class SyncUnauthorizedError extends Error {
+    constructor(message = 'sync token unauthorized') {
+        super(message);
+        this.name = 'SyncUnauthorizedError';
+    }
+}
+export class InvalidTriageError extends Error {
+    constructor(message = 'submission not found') {
+        super(message);
+        this.name = 'InvalidTriageError';
+    }
+}
+export function serializeSubmission(row) {
+    return {
+        id: row.id,
+        project_id: row.projectId,
+        hosted_share_id: row.hostedShareId,
+        participant_name: row.participantName,
+        title: row.title,
+        body: row.body,
+        severity: row.severity,
+        task_ref: row.taskRef,
+        status: row.status,
+        linked_task_id: row.linkedTaskId,
+        created_at: row.createdAt.toISOString(),
+        pulled_at: row.pulledAt.toISOString(),
+    };
+}
+function parseInvitedEmails(raw) {
+    if (raw === null || raw === '') {
+        return [];
+    }
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed.filter((value) => typeof value === 'string');
+}
+function buildDesc(submission) {
+    const footer = `Reported by ${submission.participantName} (client) via Plan Desk`;
+    if (submission.body === null || submission.body === '') {
+        return footer;
+    }
+    return `${submission.body}\n\n${footer}`;
+}
+async function ackSubmission(remote, submissionId, status) {
+    const base = remote.serverUrl.replace(/\/$/, '');
+    const url = `${base}/api/sync/v1/projects/${encodeURIComponent(remote.globalProjectId)}/submissions/${encodeURIComponent(submissionId)}/ack`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${remote.syncToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ status }),
+        });
+    }
+    catch {
+        throw new SyncUnavailableError();
+    }
+    if (!response.ok) {
+        throw new SyncUnavailableError(`sync server returned ${String(response.status)}`);
+    }
+}
+async function pushProjection(remote, share, view) {
+    const base = remote.serverUrl.replace(/\/$/, '');
+    const url = `${base}/api/sync/v1/projects/${encodeURIComponent(remote.globalProjectId)}/projection`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'PUT',
+            headers: {
+                Authorization: `Bearer ${remote.syncToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                share: {
+                    token_hash: share.tokenHash,
+                    audience_name: share.audienceName,
+                    permissions: parseSharePermissions(share),
+                    mode: share.mode,
+                    invited_emails: parseInvitedEmails(share.invitedEmails),
+                    expires_at: share.expiresAt?.toISOString() ?? null,
+                },
+                version: Date.now(),
+                view,
+            }),
+        });
+    }
+    catch {
+        throw new SyncUnavailableError();
+    }
+    if (response.status === 401) {
+        throw new SyncUnauthorizedError();
+    }
+    if (!response.ok) {
+        throw new SyncUnavailableError(`sync server returned ${String(response.status)}`);
+    }
+}
+function createWatchPush(push, projectId, remote, opts) {
+    const debounceMs = opts?.debounceMs ?? 1500;
+    const onPushError = opts?.onPushError ??
+        ((err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error(`sync watch push failed: ${message}`);
+        });
+    let timer;
+    let disposed = false;
+    const runPush = () => {
+        timer = undefined;
+        void push(projectId, remote).catch(onPushError);
+    };
+    return {
+        onChange() {
+            if (disposed) {
+                return;
+            }
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+            timer = setTimeout(runPush, debounceMs);
+        },
+        dispose() {
+            disposed = true;
+            if (timer !== undefined) {
+                clearTimeout(timer);
+                timer = undefined;
+            }
+        },
+    };
+}
+export function createSyncService(deps) {
+    const { db, eventBus, taskService, shareService } = deps;
+    return {
+        async push(projectId, remote) {
+            const shares = shareService.listShares(projectId);
+            if (shares === undefined) {
+                throw new SyncUnavailableError('project not found');
+            }
+            const active = shares.filter((share) => share.revoked_at === null);
+            let pushed = 0;
+            for (const serialized of active) {
+                const shareRow = getShare(db, serialized.id);
+                if (shareRow === undefined) {
+                    continue;
+                }
+                const view = shareService.buildClientView(projectId, serialized.id);
+                if (view === undefined) {
+                    continue;
+                }
+                await pushProjection(remote, shareRow, view);
+                pushed += 1;
+            }
+            return { pushed };
+        },
+        async publishProject(projectId, input) {
+            const globalProjectId = randomUUID();
+            const { pushed } = await this.push(projectId, {
+                serverUrl: input.serverUrl,
+                globalProjectId,
+                syncToken: input.syncToken,
+            });
+            return { globalProjectId, pushed };
+        },
+        async pull(projectId, remote) {
+            const cursor = getPullCursor(db, projectId);
+            const base = remote.serverUrl.replace(/\/$/, '');
+            const url = new URL(`${base}/api/sync/v1/projects/${encodeURIComponent(remote.globalProjectId)}/submissions`);
+            if (cursor !== undefined) {
+                url.searchParams.set('since', cursor);
+            }
+            let response;
+            try {
+                response = await fetch(url, {
+                    headers: { Authorization: `Bearer ${remote.syncToken}` },
+                });
+            }
+            catch {
+                throw new SyncUnavailableError();
+            }
+            if (response.status === 401) {
+                throw new SyncUnauthorizedError();
+            }
+            if (!response.ok) {
+                throw new SyncUnavailableError(`sync server returned ${String(response.status)}`);
+            }
+            const remoteSubmissions = (await response.json());
+            const now = new Date();
+            let pulled = 0;
+            let maxCreatedAt = cursor;
+            for (const submission of remoteSubmissions) {
+                const inserted = upsertSubmission(db, {
+                    id: submission.id,
+                    projectId,
+                    hostedShareId: submission.share_id,
+                    participantName: submission.participant.name,
+                    title: submission.title,
+                    body: submission.body,
+                    severity: submission.severity,
+                    taskRef: submission.task_ref,
+                    status: 'pending',
+                    createdAt: new Date(submission.created_at),
+                    pulledAt: now,
+                });
+                if (inserted) {
+                    pulled += 1;
+                }
+                if (maxCreatedAt === undefined || submission.created_at > maxCreatedAt) {
+                    maxCreatedAt = submission.created_at;
+                }
+            }
+            if (maxCreatedAt !== undefined && maxCreatedAt !== cursor) {
+                setPullCursor(db, projectId, maxCreatedAt);
+            }
+            if (pulled > 0) {
+                eventBus.emit({ type: 'submissions_pulled', projectId });
+            }
+            return { pulled };
+        },
+        listTriage(projectId, status) {
+            return listSubmissions(db, projectId, status).map(serializeSubmission);
+        },
+        getSubmission(submissionId) {
+            const submission = dbGetSubmission(db, submissionId);
+            return submission === undefined ? undefined : serializeSubmission(submission);
+        },
+        setRemote(projectId, remote) {
+            setSyncRemote(db, projectId, {
+                serverUrl: remote.serverUrl,
+                globalProjectId: remote.globalProjectId,
+                syncToken: remote.syncToken,
+            });
+        },
+        getRemote(projectId) {
+            const row = getSyncRemote(db, projectId);
+            if (row === undefined) {
+                return undefined;
+            }
+            return {
+                serverUrl: row.serverUrl,
+                globalProjectId: row.globalProjectId,
+                syncToken: row.syncToken,
+            };
+        },
+        async triage(submissionId, action, remote, asTask) {
+            const submission = dbGetSubmission(db, submissionId);
+            if (submission === undefined) {
+                throw new InvalidTriageError();
+            }
+            if (submission.status !== 'pending') {
+                return serializeSubmission(submission);
+            }
+            const projectId = submission.projectId;
+            if (action === 'accept') {
+                const task = taskService.create(projectId, {
+                    label: asTask?.label ?? submission.title,
+                    status: asTask?.status ?? 'todo',
+                    description: asTask?.description ?? buildDesc(submission),
+                });
+                if (task === undefined) {
+                    throw new InvalidTriageError('project not found');
+                }
+                const updated = setSubmissionStatus(db, submissionId, {
+                    status: 'accepted',
+                    linkedTaskId: task.id,
+                });
+                if (updated === undefined) {
+                    throw new InvalidTriageError();
+                }
+                eventBus.emit({ type: 'submissions_pulled', projectId });
+                await ackSubmission(remote, submissionId, 'accepted');
+                return serializeSubmission(updated);
+            }
+            const updated = setSubmissionStatus(db, submissionId, { status: 'rejected' });
+            if (updated === undefined) {
+                throw new InvalidTriageError();
+            }
+            eventBus.emit({ type: 'submissions_pulled', projectId });
+            await ackSubmission(remote, submissionId, 'rejected');
+            return serializeSubmission(updated);
+        },
+        watchPush(projectId, remote, opts) {
+            return createWatchPush((id, rem) => this.push(id, rem), projectId, remote, opts);
+        },
+    };
+}
+//# sourceMappingURL=sync.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plandesk/api",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "type": "module",
   "exports": {
     ".": {
@@ -12,14 +12,14 @@
     "dist",
     "web",
     "!dist/**/*.test.js",
-    "!dist/**/*.test.js.map",
     "!dist/**/*.test.d.ts",
-    "!dist/**/*.test.d.ts.map"
+    "!dist/**/*.map"
   ],
   "devDependencies": {
     "typescript": "^6.0.3",
     "vitest": "^3.2.6",
-    "@plandesk/db": "0.3.0"
+    "@plandesk/db": "0.4.1",
+    "@plandesk/sync-server": "0.4.1"
   },
   "dependencies": {
     "@hono/node-server": "^2.0.4",
@@ -28,7 +28,7 @@
   "description": "Plan Desk REST + SSE API and service layer (local-first planning workspace).",
   "license": "MIT",
   "author": "asyncdotengineering",
-  "homepage": "https://plandesk-docs.pages.dev",
+  "homepage": "https://plandesk.asyncdot.com",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/asyncdotengineering/plandesk.git",

package/web/_redirects

@@ -0,0 +1 @@
+/*    /index.html   200