@plandesk/api 0.3.0 → 0.4.1

package/dist/events.d.ts

@@ -39,7 +39,11 @@ export type AgentRunCompletedEvent = {
     runId: string;
     projectId: string;
 };
-export type PlankDeskEvent = TaskUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent;
+export type SubmissionsPulledEvent = {
+    type: 'submissions_pulled';
+    projectId: string;
+};
+export type PlankDeskEvent = TaskUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent | SubmissionsPulledEvent;
 export type EventListener = (event: PlankDeskEvent) => void;
 export type EventBus = {
     subscribe(listener: EventListener): () => void;

package/dist/index.d.ts

@@ -15,5 +15,7 @@ export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';
 export { InvalidScaffoldError } from './services/projects.js';
+export { InvalidShareError } from './services/share.js';
+export { InvalidTriageError, SyncUnavailableError, SyncUnauthorizedError, type SyncRemote, type SyncService, } from './services/sync.js';
 export declare const version: () => string;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -9,6 +9,8 @@ export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';
 export { InvalidScaffoldError } from './services/projects.js';
+export { InvalidShareError } from './services/share.js';
+export { InvalidTriageError, SyncUnavailableError, SyncUnauthorizedError, } from './services/sync.js';
 import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';

package/dist/projection.d.ts

@@ -0,0 +1,51 @@
+import { type Db, type Share } from '@plandesk/db';
+export type SharePolicy = {
+    tasks: 'all' | string[];
+    documentIds: string[];
+    fields: {
+        assignee?: boolean;
+        description?: boolean;
+    };
+};
+export type ClientViewTask = {
+    id: string;
+    label: string;
+    status: string;
+    due_date: string | null;
+    x: number;
+    y: number;
+    description?: string | null;
+    assignee?: string | null;
+};
+export type ClientView = {
+    project: {
+        id: string;
+        name: string;
+        description: string | null;
+        updated_at: string;
+    };
+    tasks: ClientViewTask[];
+    edges: Array<{
+        id: string;
+        from: string;
+        to: string;
+        label: string | null;
+    }>;
+    documents: Array<{
+        id: string;
+        title: string;
+        body_html: string | null;
+        updated_at: string;
+    }>;
+    progress: Record<string, number>;
+    share: {
+        audience_name: string;
+        permissions: {
+            read: boolean;
+            submit: boolean;
+        };
+        expires_at: string | null;
+    };
+};
+export declare function buildClientView(db: Db, projectId: string, share: Share): ClientView | undefined;
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.js

@@ -0,0 +1,75 @@
+import { getProject, listDocuments, listEdges, listTasks, parseSharePermissions, parseSharePolicy, } from '@plandesk/db';
+function buildProgress(tasks) {
+    const progress = {};
+    for (const task of tasks) {
+        progress[task.status] = (progress[task.status] ?? 0) + 1;
+    }
+    return progress;
+}
+export function buildClientView(db, projectId, share) {
+    const project = getProject(db, projectId);
+    if (!project) {
+        return undefined;
+    }
+    const policy = parseSharePolicy(share);
+    const permissions = parseSharePermissions(share);
+    const allTasks = listTasks(db, projectId);
+    const sharedTasks = [];
+    for (const task of allTasks) {
+        const included = policy.tasks === 'all' || (Array.isArray(policy.tasks) && policy.tasks.includes(task.id));
+        if (!included) {
+            continue;
+        }
+        const viewTask = {
+            id: task.id,
+            label: task.label,
+            status: task.status,
+            due_date: task.dueDate?.toISOString() ?? null,
+            x: task.x,
+            y: task.y,
+        };
+        if (policy.fields.description) {
+            viewTask.description = task.description;
+        }
+        if (policy.fields.assignee) {
+            viewTask.assignee = task.assignee;
+        }
+        sharedTasks.push(viewTask);
+    }
+    const sharedTaskIds = new Set(sharedTasks.map((task) => task.id));
+    const sharedEdges = listEdges(db, projectId)
+        .filter((edge) => sharedTaskIds.has(edge.fromTaskId) && sharedTaskIds.has(edge.toTaskId))
+        .map((edge) => ({
+        id: edge.id,
+        from: edge.fromTaskId,
+        to: edge.toTaskId,
+        label: edge.label,
+    }));
+    const documentIdSet = new Set(policy.documentIds);
+    const sharedDocuments = listDocuments(db, projectId)
+        .filter((doc) => documentIdSet.has(doc.id))
+        .map((doc) => ({
+        id: doc.id,
+        title: doc.title,
+        body_html: doc.body,
+        updated_at: doc.updatedAt.toISOString(),
+    }));
+    return {
+        project: {
+            id: project.id,
+            name: project.name,
+            description: project.description,
+            updated_at: project.updatedAt.toISOString(),
+        },
+        tasks: sharedTasks,
+        edges: sharedEdges,
+        documents: sharedDocuments,
+        progress: buildProgress(sharedTasks),
+        share: {
+            audience_name: share.audienceName,
+            permissions,
+            expires_at: share.expiresAt?.toISOString() ?? null,
+        },
+    };
+}
+//# sourceMappingURL=projection.js.map

package/dist/services/index.d.ts

@@ -7,6 +7,8 @@ import { type ProjectService } from './projects.js';
 import { type AgentRunService } from './agent-runs.js';
 import { type TaskService } from './tasks.js';
 import { type TokenService } from './tokens.js';
+import { type ShareService } from './share.js';
+import { type SyncService } from './sync.js';
 export type ServicesDeps = {
     db: Db;
     eventBus?: EventBus;
@@ -20,6 +22,8 @@ export type Services = {
     commentService: CommentService;
     agentRunService: AgentRunService;
     tokenService: TokenService;
+    shareService: ShareService;
+    syncService: SyncService;
 };
 export declare function createServices(deps: ServicesDeps): Services;
 //# sourceMappingURL=index.d.ts.map

package/dist/services/index.js

@@ -6,6 +6,8 @@ import { createProjectService } from './projects.js';
 import { createAgentRunService } from './agent-runs.js';
 import { createTaskService } from './tasks.js';
 import { createTokenService } from './tokens.js';
+import { createShareService } from './share.js';
+import { createSyncService } from './sync.js';
 export function createServices(deps) {
     const eventBus = deps.eventBus ?? createEventBus();
     const projectService = createProjectService({ db: deps.db, eventBus });
@@ -15,6 +17,8 @@ export function createServices(deps) {
     const commentService = createCommentService({ db: deps.db, eventBus });
     const agentRunService = createAgentRunService({ db: deps.db, eventBus });
     const tokenService = createTokenService({ db: deps.db });
+    const shareService = createShareService({ db: deps.db, eventBus });
+    const syncService = createSyncService({ db: deps.db, eventBus, taskService, shareService });
     return {
         eventBus,
         projectService,
@@ -24,6 +28,8 @@ export function createServices(deps) {
         commentService,
         agentRunService,
         tokenService,
+        shareService,
+        syncService,
     };
 }
 //# sourceMappingURL=index.js.map

package/dist/services/projects.js

@@ -1,4 +1,4 @@
-import { clearDocumentParentRefsByProject, createDocument, createEdge, createProject as dbCreateProject, createTask, deleteAgentRun, deleteAgentRunEventsByRunId, deleteCommentsByProjectId, deleteDocumentsByProjectId, deleteEdgesByProjectId, deleteProject as dbDeleteProject, deleteTasksByProjectId, getProject as dbGetProject, InvalidTaskStatusError, isTaskStatus, listAgentRuns, listProjects as dbListProjects, listTasks, updateProject as dbUpdateProject, } from '@plandesk/db';
+import { clearDocumentParentRefsByProject, createDocument, createEdge, createProject as dbCreateProject, createTask, deleteAgentRun, deleteAgentRunEventsByRunId, deleteCommentsByProjectId, deleteDocumentsByProjectId, deleteEdgesByProjectId, deleteShareSubmissionsByProjectId, deleteSharesByProjectId, deleteSyncRemoteByProjectId, deleteSyncStateByProjectId, deleteProject as dbDeleteProject, deleteTasksByProjectId, getProject as dbGetProject, InvalidTaskStatusError, isTaskStatus, listAgentRuns, listProjects as dbListProjects, listTasks, updateProject as dbUpdateProject, } from '@plandesk/db';
 import { emptyTaskStatusSummary, serializeDocument, serializeEdge, serializeProject, serializeProjectDetail, serializeTask, } from '../serialize.js';
 export class InvalidScaffoldError extends Error {
     constructor(message) {
@@ -90,6 +90,10 @@ export function createProjectService(deps) {
                 deleteCommentsByProjectId(tx, id);
                 deleteDocumentsByProjectId(tx, id);
                 deleteTasksByProjectId(tx, id);
+                deleteShareSubmissionsByProjectId(tx, id);
+                deleteSyncStateByProjectId(tx, id);
+                deleteSyncRemoteByProjectId(tx, id);
+                deleteSharesByProjectId(tx, id);
                 dbDeleteProject(tx, id);
             });
             eventBus.emit({ type: 'canvas_updated', projectId: id });

package/dist/services/share.d.ts

@@ -0,0 +1,41 @@
+import { type Db, type Share, type ShareMode, type SharePermissions } from '@plandesk/db';
+import type { EventBus } from '../events.js';
+import { type ClientView, type SharePolicy } from '../projection.js';
+export declare class InvalidShareError extends Error {
+    constructor(message: string);
+}
+export type ShareServiceDeps = {
+    db: Db;
+    eventBus: EventBus;
+};
+export type SerializedShare = {
+    id: string;
+    project_id: string;
+    audience_name: string;
+    mode: ShareMode;
+    permissions: SharePermissions;
+    policy: SharePolicy;
+    expires_at: string | null;
+    revoked_at: string | null;
+    created_at: string;
+};
+export declare function serializeShare(share: Share): SerializedShare;
+export type CreateShareInput = {
+    audienceName: string;
+    mode: ShareMode;
+    permissions?: SharePermissions;
+    policy?: SharePolicy;
+    invitedEmails?: string[];
+    expiresAt?: Date;
+};
+export declare function createShareService(deps: ShareServiceDeps): {
+    createShare(projectId: string, input: CreateShareInput): {
+        share: SerializedShare;
+        token: string;
+    } | undefined;
+    listShares(projectId: string): SerializedShare[] | undefined;
+    revokeShare(id: string): boolean;
+    buildClientView(projectId: string, shareId: string): ClientView | undefined;
+};
+export type ShareService = ReturnType<typeof createShareService>;
+//# sourceMappingURL=share.d.ts.map

package/dist/services/share.js

@@ -0,0 +1,65 @@
+import { createShare as dbCreateShare, getProject, getShare as dbGetShare, listShares as dbListShares, parseSharePermissions, parseSharePolicy, revokeShare as dbRevokeShare, } from '@plandesk/db';
+import { buildClientView } from '../projection.js';
+export class InvalidShareError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidShareError';
+    }
+}
+const DEFAULT_POLICY = { tasks: 'all', documentIds: [], fields: {} };
+const DEFAULT_PERMISSIONS = { read: true, submit: false };
+export function serializeShare(share) {
+    return {
+        id: share.id,
+        project_id: share.projectId,
+        audience_name: share.audienceName,
+        mode: share.mode,
+        permissions: parseSharePermissions(share),
+        policy: parseSharePolicy(share),
+        expires_at: share.expiresAt?.toISOString() ?? null,
+        revoked_at: share.revokedAt?.toISOString() ?? null,
+        created_at: share.createdAt.toISOString(),
+    };
+}
+export function createShareService(deps) {
+    const { db } = deps;
+    return {
+        createShare(projectId, input) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            if (input.audienceName.trim() === '') {
+                throw new InvalidShareError('Share audience name must not be empty');
+            }
+            const { share, token } = dbCreateShare(db, {
+                projectId,
+                audienceName: input.audienceName,
+                mode: input.mode,
+                permissions: input.permissions ?? DEFAULT_PERMISSIONS,
+                policy: input.policy ?? DEFAULT_POLICY,
+                invitedEmails: input.invitedEmails,
+                expiresAt: input.expiresAt,
+            });
+            return { share: serializeShare(share), token };
+        },
+        listShares(projectId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            return dbListShares(db, projectId).map(serializeShare);
+        },
+        revokeShare(id) {
+            return dbRevokeShare(db, id) !== undefined;
+        },
+        buildClientView(projectId, shareId) {
+            const share = dbGetShare(db, shareId);
+            if (!share || share.projectId !== projectId) {
+                return undefined;
+            }
+            return buildClientView(db, projectId, share);
+        },
+    };
+}
+//# sourceMappingURL=share.js.map

package/dist/services/sync.d.ts

@@ -0,0 +1,74 @@
+import { type Db, type ShareSubmission, type ShareSubmissionStatus, type TaskStatus } from '@plandesk/db';
+import type { EventBus } from '../events.js';
+import type { ShareService } from './share.js';
+import type { TaskService } from './tasks.js';
+export declare class SyncUnavailableError extends Error {
+    constructor(message?: string);
+}
+export declare class SyncUnauthorizedError extends Error {
+    constructor(message?: string);
+}
+export declare class InvalidTriageError extends Error {
+    constructor(message?: string);
+}
+export type SyncRemote = {
+    serverUrl: string;
+    globalProjectId: string;
+    syncToken: string;
+};
+export type SerializedSubmission = {
+    id: string;
+    project_id: string;
+    hosted_share_id: string;
+    participant_name: string;
+    title: string;
+    body: string | null;
+    severity: string | null;
+    task_ref: string | null;
+    status: ShareSubmissionStatus;
+    linked_task_id: string | null;
+    created_at: string;
+    pulled_at: string;
+};
+export declare function serializeSubmission(row: ShareSubmission): SerializedSubmission;
+export type SyncServiceDeps = {
+    db: Db;
+    eventBus: EventBus;
+    taskService: TaskService;
+    shareService: ShareService;
+};
+export type WatchPushController = {
+    onChange(): void;
+    dispose(): void;
+};
+export type WatchPushOptions = {
+    debounceMs?: number;
+    onPushError?: (err: unknown) => void;
+};
+export declare function createSyncService(deps: SyncServiceDeps): {
+    push(projectId: string, remote: SyncRemote): Promise<{
+        pushed: number;
+    }>;
+    publishProject(projectId: string, input: {
+        serverUrl: string;
+        syncToken: string;
+    }): Promise<{
+        globalProjectId: string;
+        pushed: number;
+    }>;
+    pull(projectId: string, remote: SyncRemote): Promise<{
+        pulled: number;
+    }>;
+    listTriage(projectId: string, status?: ShareSubmissionStatus): SerializedSubmission[];
+    getSubmission(submissionId: string): SerializedSubmission | undefined;
+    setRemote(projectId: string, remote: SyncRemote): void;
+    getRemote(projectId: string): SyncRemote | undefined;
+    triage(submissionId: string, action: "accept" | "reject", remote: SyncRemote, asTask?: {
+        label?: string;
+        status?: TaskStatus;
+        description?: string;
+    }): Promise<SerializedSubmission>;
+    watchPush(projectId: string, remote: SyncRemote, opts?: WatchPushOptions): WatchPushController;
+};
+export type SyncService = ReturnType<typeof createSyncService>;
+//# sourceMappingURL=sync.d.ts.map