@plandesk/api 0.7.0 → 0.8.0

package/dist/events.d.ts

@@ -24,6 +24,20 @@ export type CommentUpdatedEvent = {
     documentId: string;
     projectId: string;
 };
+export type FolderCreatedEvent = {
+    type: 'folder_created';
+    folderId: string;
+    projectId: string;
+};
+export type FolderUpdatedEvent = {
+    type: 'folder_updated';
+    folderId: string;
+    projectId: string;
+};
+export type TagUpdatedEvent = {
+    type: 'tag_updated';
+    projectId: string;
+};
 export type NoteCreatedEvent = {
     type: 'note_created';
     noteId: string;
@@ -53,7 +67,7 @@ export type SubmissionsPulledEvent = {
     type: 'submissions_pulled';
     projectId: string;
 };
-export type PlankDeskEvent = TaskUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | NoteCreatedEvent | NoteUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent | SubmissionsPulledEvent;
+export type PlankDeskEvent = TaskUpdatedEvent | TagUpdatedEvent | CanvasUpdatedEvent | DocumentCreatedEvent | CommentCreatedEvent | CommentUpdatedEvent | FolderCreatedEvent | FolderUpdatedEvent | NoteCreatedEvent | NoteUpdatedEvent | AgentRunStartedEvent | AgentRunProgressEvent | AgentRunCompletedEvent | SubmissionsPulledEvent;
 export type EventListener = (event: PlankDeskEvent) => void;
 export type EventBus = {
     subscribe(listener: EventListener): () => void;

package/dist/index.d.ts

@@ -6,13 +6,17 @@ export { createServices, type Services, type ServicesDeps } from './services/ind
 export { createEventBus, type EventBus, type PlankDeskEvent } from './events.js';
 export type { ProjectService } from './services/projects.js';
 export type { TaskService } from './services/tasks.js';
+export type { TagService } from './services/tags.js';
 export type { CanvasService } from './services/canvas.js';
 export type { DocumentService } from './services/documents.js';
+export type { FolderService } from './services/folders.js';
 export type { NoteService } from './services/notes.js';
 export type { CommentService } from './services/comments.js';
 export type { AgentRunService } from './services/agent-runs.js';
 export { InvalidDocumentError } from './services/documents.js';
+export { InvalidFolderError } from './services/folders.js';
 export { InvalidNoteError } from './services/notes.js';
+export { InvalidTagError } from './services/tags.js';
 export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';

package/dist/index.js

@@ -5,7 +5,9 @@ export { mountStatic } from './static.js';
 export { createServices } from './services/index.js';
 export { createEventBus } from './events.js';
 export { InvalidDocumentError } from './services/documents.js';
+export { InvalidFolderError } from './services/folders.js';
 export { InvalidNoteError } from './services/notes.js';
+export { InvalidTagError } from './services/tags.js';
 export { InvalidCommentError } from './services/comments.js';
 export { InvalidCanvasError } from './services/canvas.js';
 export { InvalidAgentRunError } from './services/agent-runs.js';

package/dist/routes/documents.js

@@ -37,6 +37,7 @@ export function createDocumentsRouter(documentService) {
                 body: body.body,
                 statusLine: body.status_line,
                 parentId: body.parent_id,
+                folderId: body.folder_id,
                 linkedTaskId: resolveLinkedTaskId(body),
             });
             if (!document) {
@@ -67,6 +68,7 @@ export function createDocumentsRouter(documentService) {
                 ...(body.body !== undefined ? { body: body.body } : {}),
                 ...(body.status_line !== undefined ? { statusLine: body.status_line } : {}),
                 ...(body.parent_id !== undefined ? { parentId: body.parent_id } : {}),
+                ...(body.folder_id !== undefined ? { folderId: body.folder_id } : {}),
                 ...(linkedTaskId !== undefined ? { linkedTaskId } : {}),
             });
             if (!document) {

package/dist/routes/folders.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { type FolderService } from '../services/folders.js';
+export declare function createFoldersRouter(folderService: FolderService): Hono;
+//# sourceMappingURL=folders.d.ts.map

package/dist/routes/folders.js

@@ -0,0 +1,69 @@
+import { Hono } from 'hono';
+import { InvalidFolderError } from '../services/folders.js';
+export function createFoldersRouter(folderService) {
+    const router = new Hono();
+    router.get('/projects/:id/folders', (c) => {
+        const folders = folderService.list(c.req.param('id'));
+        if (!folders) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(folders);
+    });
+    router.post('/projects/:id/folders', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.name !== 'string' || body.name.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const folder = folderService.create(c.req.param('id'), {
+                name: body.name,
+                parentFolderId: body.parent_folder_id,
+            });
+            if (!folder) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(folder, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidFolderError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.get('/folders/:id', (c) => {
+        const folder = folderService.get(c.req.param('id'));
+        if (!folder) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(folder);
+    });
+    router.patch('/folders/:id', async (c) => {
+        const body = await c.req.json();
+        try {
+            const folder = folderService.update(c.req.param('id'), {
+                ...(body.name !== undefined ? { name: body.name } : {}),
+                ...(body.parent_folder_id !== undefined ? { parentFolderId: body.parent_folder_id } : {}),
+            });
+            if (!folder) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(folder);
+        }
+        catch (error) {
+            if (error instanceof InvalidFolderError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.delete('/folders/:id', (c) => {
+        const deleted = folderService.delete(c.req.param('id'));
+        if (!deleted) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.body(null, 204);
+    });
+    return router;
+}
+//# sourceMappingURL=folders.js.map

package/dist/routes/projects.js

@@ -1,5 +1,7 @@
 import { Hono } from 'hono';
 import { InvalidTaskStatusError, isTaskStatus } from '@plandesk/db';
+import { InvalidTagError } from '../services/tags.js';
+import { isStringArray } from './tasks.js';
 import { parsePaginationParams } from '../serialize.js';
 export function createProjectsRouter(projectService, taskService) {
     const router = new Hono();
@@ -57,6 +59,9 @@ export function createProjectsRouter(projectService, taskService) {
         if (body.status !== undefined && !isTaskStatus(body.status)) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
+        if (body.tags !== undefined && !isStringArray(body.tags)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
         let dueDate;
         if (body.due_date !== undefined && body.due_date !== null) {
             dueDate = new Date(body.due_date);
@@ -76,6 +81,7 @@ export function createProjectsRouter(projectService, taskService) {
                 ...(body.y !== undefined ? { y: body.y } : {}),
                 ...(body.assignee !== undefined ? { assignee: body.assignee } : {}),
                 ...(dueDate !== undefined ? { dueDate } : {}),
+                ...(body.tags !== undefined ? { tags: body.tags } : {}),
             });
             if (!task) {
                 return c.json({ error: 'not_found' }, 404);
@@ -83,7 +89,7 @@ export function createProjectsRouter(projectService, taskService) {
             return c.json(task, 201);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError || error instanceof InvalidTagError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;
@@ -96,14 +102,17 @@ export function createProjectsRouter(projectService, taskService) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             const status = c.req.query('status');
-            const tasks = taskService.listByProject(c.req.param('id'), { status }, pagination);
+            // Repeated ?tag= params filter with OR semantics (task matches if it has
+            // ANY of the given tags).
+            const tags = c.req.queries('tag');
+            const tasks = taskService.listByProject(c.req.param('id'), { status, ...(tags !== undefined && tags.length > 0 ? { tags } : {}) }, pagination);
             if (!tasks) {
                 return c.json({ error: 'not_found' }, 404);
             }
             return c.json(tasks);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError || error instanceof InvalidTagError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;

package/dist/routes/tags.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from 'hono';
+import { type TagService } from '../services/tags.js';
+export declare function createTagsRouter(tagService: TagService): Hono;
+//# sourceMappingURL=tags.d.ts.map

package/dist/routes/tags.js

@@ -0,0 +1,62 @@
+import { Hono } from 'hono';
+import { InvalidTagError } from '../services/tags.js';
+export function createTagsRouter(tagService) {
+    const router = new Hono();
+    router.get('/projects/:id/tags', (c) => {
+        const tags = tagService.list(c.req.param('id'));
+        if (!tags) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.json(tags);
+    });
+    router.post('/projects/:id/tags', async (c) => {
+        const body = await c.req.json();
+        if (typeof body.name !== 'string' || body.name.trim() === '') {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
+        try {
+            const tag = tagService.create(c.req.param('id'), {
+                name: body.name,
+                color: body.color,
+            });
+            if (!tag) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(tag, 201);
+        }
+        catch (error) {
+            if (error instanceof InvalidTagError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.patch('/tags/:id', async (c) => {
+        const body = await c.req.json();
+        try {
+            const tag = tagService.update(c.req.param('id'), {
+                ...(body.name !== undefined ? { name: body.name } : {}),
+                ...(body.color !== undefined ? { color: body.color } : {}),
+            });
+            if (!tag) {
+                return c.json({ error: 'not_found' }, 404);
+            }
+            return c.json(tag);
+        }
+        catch (error) {
+            if (error instanceof InvalidTagError) {
+                return c.json({ error: 'invalid_argument' }, 400);
+            }
+            throw error;
+        }
+    });
+    router.delete('/tags/:id', (c) => {
+        const deleted = tagService.delete(c.req.param('id'));
+        if (!deleted) {
+            return c.json({ error: 'not_found' }, 404);
+        }
+        return c.body(null, 204);
+    });
+    return router;
+}
+//# sourceMappingURL=tags.js.map

package/dist/routes/tasks.d.ts

@@ -1,4 +1,5 @@
 import { Hono } from 'hono';
 import type { TaskService } from '../services/tasks.js';
+export declare function isStringArray(value: unknown): value is string[];
 export declare function createTasksRouter(taskService: TaskService): Hono;
 //# sourceMappingURL=tasks.d.ts.map

package/dist/routes/tasks.js

@@ -1,5 +1,9 @@
 import { Hono } from 'hono';
 import { InvalidTaskStatusError, isTaskStatus } from '@plandesk/db';
+import { InvalidTagError } from '../services/tags.js';
+export function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
 export function createTasksRouter(taskService) {
     const router = new Hono();
     router.patch('/tasks/:id', async (c) => {
@@ -7,6 +11,9 @@ export function createTasksRouter(taskService) {
         if (body.status !== undefined && !isTaskStatus(body.status)) {
             return c.json({ error: 'invalid_argument' }, 400);
         }
+        if (body.tags !== undefined && !isStringArray(body.tags)) {
+            return c.json({ error: 'invalid_argument' }, 400);
+        }
         try {
             const task = taskService.update(c.req.param('id'), {
                 ...(body.label !== undefined ? { label: body.label } : {}),
@@ -14,6 +21,7 @@ export function createTasksRouter(taskService) {
                 ...(body.description !== undefined ? { description: body.description } : {}),
                 ...(body.x !== undefined ? { x: body.x } : {}),
                 ...(body.y !== undefined ? { y: body.y } : {}),
+                ...(body.tags !== undefined ? { tags: body.tags } : {}),
             });
             if (!task) {
                 return c.json({ error: 'not_found' }, 404);
@@ -21,7 +29,7 @@ export function createTasksRouter(taskService) {
             return c.json(task);
         }
         catch (error) {
-            if (error instanceof InvalidTaskStatusError) {
+            if (error instanceof InvalidTaskStatusError || error instanceof InvalidTagError) {
                 return c.json({ error: 'invalid_argument' }, 400);
             }
             throw error;

package/dist/serialize.d.ts

@@ -1,4 +1,4 @@
-import type { AgentRun, AgentRunEvent, Document, DocumentComment, Edge, Note, Project, Task, TaskStatus } from '@plandesk/db';
+import type { AgentRun, AgentRunEvent, Document, DocumentComment, Edge, Folder, Note, Project, Tag, Task, TaskStatus } from '@plandesk/db';
 export type PaginationParams = {
     limit?: number;
     offset?: number;
@@ -21,7 +21,16 @@ export declare function serializeProjectDetail(project: Project, summary: TaskSt
     created_at: string;
     updated_at: string;
 };
-export declare function serializeTask(task: Task): {
+export type SerializedTag = {
+    id: string;
+    project_id: string;
+    name: string;
+    color: string | null;
+    created_at: string;
+};
+export declare function serializeTag(tag: Tag): SerializedTag;
+export declare function serializeTask(task: Task, tags?: Tag[]): {
+    tags?: SerializedTag[] | undefined;
     id: string;
     project_id: string;
     label: string;
@@ -41,6 +50,7 @@ export type SerializedDocument = {
     body: string | null;
     status_line: string | null;
     parent_id: string | null;
+    folder_id: string | null;
     linked_task_id: string | null;
     created_at: string;
     updated_at: string;
@@ -68,6 +78,24 @@ export type SerializedComment = {
 };
 export declare function serializeComment(comment: DocumentComment): SerializedComment;
 export declare function buildDocumentTree(documents: Document[]): SerializedDocumentTree[];
+export type SerializedFolder = {
+    id: string;
+    project_id: string;
+    name: string;
+    parent_folder_id: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function serializeFolder(folder: Folder): SerializedFolder;
+export type SerializedFolderTree = SerializedFolder & {
+    folders: SerializedFolderTree[];
+    documents: SerializedDocumentTree[];
+};
+export type SerializedDocumentFolderTree = {
+    folders: SerializedFolderTree[];
+    documents: SerializedDocumentTree[];
+};
+export declare function buildFolderTree(folders: Folder[], documents: Document[]): SerializedDocumentFolderTree;
 export declare function serializeEdge(edge: Edge): {
     id: string;
     project_id: string;

package/dist/serialize.js

@@ -36,7 +36,16 @@ export function serializeProjectDetail(project, summary) {
         summary,
     };
 }
-export function serializeTask(task) {
+export function serializeTag(tag) {
+    return {
+        id: tag.id,
+        project_id: tag.projectId,
+        name: tag.name,
+        color: tag.color,
+        created_at: tag.createdAt.toISOString(),
+    };
+}
+export function serializeTask(task, tags) {
     return {
         id: task.id,
         project_id: task.projectId,
@@ -49,6 +58,7 @@ export function serializeTask(task) {
         due_date: task.dueDate?.toISOString() ?? null,
         created_at: task.createdAt.toISOString(),
         updated_at: task.updatedAt.toISOString(),
+        ...(tags !== undefined ? { tags: tags.map(serializeTag) } : {}),
     };
 }
 export function serializeDocument(document) {
@@ -59,6 +69,7 @@ export function serializeDocument(document) {
         body: document.body,
         status_line: document.statusLine,
         parent_id: document.parentId,
+        folder_id: document.folderId,
         linked_task_id: document.linkedTaskId,
         created_at: document.createdAt.toISOString(),
         updated_at: document.updatedAt.toISOString(),
@@ -109,6 +120,60 @@ export function buildDocumentTree(documents) {
     }
     return roots;
 }
+export function serializeFolder(folder) {
+    return {
+        id: folder.id,
+        project_id: folder.projectId,
+        name: folder.name,
+        parent_folder_id: folder.parentFolderId,
+        created_at: folder.createdAt.toISOString(),
+        updated_at: folder.updatedAt.toISOString(),
+    };
+}
+export function buildFolderTree(folders, documents) {
+    const folderNodes = new Map();
+    for (const folder of folders) {
+        folderNodes.set(folder.id, { ...serializeFolder(folder), folders: [], documents: [] });
+    }
+    const rootFolders = [];
+    for (const folder of folders) {
+        const node = folderNodes.get(folder.id);
+        if (!node) {
+            continue;
+        }
+        const parent = folder.parentFolderId === null ? undefined : folderNodes.get(folder.parentFolderId);
+        if (parent) {
+            parent.folders.push(node);
+        }
+        else {
+            rootFolders.push(node);
+        }
+    }
+    const documentsByFolder = new Map();
+    for (const document of documents) {
+        const key = document.folderId !== null && folderNodes.has(document.folderId) ? document.folderId : null;
+        const group = documentsByFolder.get(key);
+        if (group) {
+            group.push(document);
+        }
+        else {
+            documentsByFolder.set(key, [document]);
+        }
+    }
+    for (const [folderId, group] of documentsByFolder) {
+        if (folderId === null) {
+            continue;
+        }
+        const node = folderNodes.get(folderId);
+        if (node) {
+            node.documents = buildDocumentTree(group);
+        }
+    }
+    return {
+        folders: rootFolders,
+        documents: buildDocumentTree(documentsByFolder.get(null) ?? []),
+    };
+}
 export function serializeEdge(edge) {
     return {
         id: edge.id,

package/dist/server.js

@@ -3,9 +3,11 @@ import { createAuthMiddleware } from './auth.js';
 import { healthRouter } from './routes/health.js';
 import { createProjectsRouter } from './routes/projects.js';
 import { createTasksRouter } from './routes/tasks.js';
+import { createTagsRouter } from './routes/tags.js';
 import { createCanvasRouter } from './routes/canvas.js';
 import { createCommentsRouter } from './routes/comments.js';
 import { createDocumentsRouter } from './routes/documents.js';
+import { createFoldersRouter } from './routes/folders.js';
 import { createNotesRouter } from './routes/notes.js';
 import { createEventsRouter } from './routes/events.js';
 import { createTokensRouter } from './routes/tokens.js';
@@ -14,7 +16,7 @@ import { mountStatic } from './static.js';
 import { createServices } from './services/index.js';
 export function createApp(deps) {
     const services = deps.services ?? createServices({ db: deps.db, eventBus: deps.eventBus });
-    const { eventBus, projectService, taskService, canvasService, documentService, noteService, commentService, agentRunService, tokenService, } = services;
+    const { eventBus, projectService, taskService, tagService, canvasService, documentService, folderService, noteService, commentService, agentRunService, tokenService, } = services;
     const app = new Hono();
     if (deps.authPassword !== undefined && deps.authPassword.length > 0) {
         app.use('*', createAuthMiddleware(deps.authPassword));
@@ -22,8 +24,10 @@ export function createApp(deps) {
     app.route('/api/v1', healthRouter);
     app.route('/api/v1', createProjectsRouter(projectService, taskService));
     app.route('/api/v1', createTasksRouter(taskService));
+    app.route('/api/v1', createTagsRouter(tagService));
     app.route('/api/v1', createCanvasRouter(canvasService));
     app.route('/api/v1', createDocumentsRouter(documentService));
+    app.route('/api/v1', createFoldersRouter(folderService));
     app.route('/api/v1', createNotesRouter(noteService));
     app.route('/api/v1', createCommentsRouter(commentService));
     app.route('/api/v1', createTokensRouter(tokenService));

package/dist/services/canvas.d.ts

@@ -30,6 +30,7 @@ export declare class InvalidCanvasError extends Error {
 export declare function createCanvasService(deps: CanvasServiceDeps): {
     get(projectId: string): {
         nodes: {
+            tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
             label: string;
@@ -71,6 +72,7 @@ export declare function createCanvasService(deps: CanvasServiceDeps): {
     } | undefined;
     putLayout(projectId: string, payload: PutCanvasLayoutInput): {
         nodes: {
+            tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
             label: string;

package/dist/services/canvas.js

@@ -21,7 +21,7 @@ export function createCanvasService(deps) {
         const tasks = listTasks(db, projectId);
         const edgeRows = listEdges(db, projectId);
         return {
-            nodes: tasks.map(serializeTask),
+            nodes: tasks.map((task) => serializeTask(task)),
             edges: edgeRows.map(serializeEdge),
             layout: serializeLayout(project.canvasLayout),
         };

package/dist/services/documents.d.ts

@@ -1,5 +1,5 @@
 import { type Db } from '@plandesk/db';
-import { type PaginationParams, type SerializedDocument, type SerializedDocumentTree } from '../serialize.js';
+import { type PaginationParams, type SerializedDocument, type SerializedDocumentFolderTree, type SerializedDocumentTree } from '../serialize.js';
 import type { EventBus } from '../events.js';
 export type DocumentServiceDeps = {
     db: Db;
@@ -10,6 +10,7 @@ export type CreateDocumentInput = {
     body?: string | null;
     statusLine?: string | null;
     parentId?: string | null;
+    folderId?: string | null;
     linkedTaskId?: string | null;
 };
 export type UpdateDocumentInput = {
@@ -17,6 +18,7 @@ export type UpdateDocumentInput = {
     body?: string | null;
     statusLine?: string | null;
     parentId?: string | null;
+    folderId?: string | null;
     linkedTaskId?: string | null;
 };
 export declare class InvalidDocumentError extends Error {
@@ -24,6 +26,8 @@ export declare class InvalidDocumentError extends Error {
 }
 export declare function createDocumentService(deps: DocumentServiceDeps): {
     listTree(projectId: string, pagination?: PaginationParams): SerializedDocumentTree[] | undefined;
+    listFolderTree(projectId: string): SerializedDocumentFolderTree | undefined;
+    listByFolder(projectId: string, folderId: string): SerializedDocumentTree[] | undefined;
     create(projectId: string, input: CreateDocumentInput): SerializedDocument | undefined;
     get(id: string): SerializedDocument | undefined;
     update(id: string, input: UpdateDocumentInput): SerializedDocument | undefined;

package/dist/services/documents.js

@@ -1,5 +1,5 @@
-import { createDocument as dbCreateDocument, deleteCommentsByDocumentId, deleteDocument as dbDeleteDocument, detachDocumentChildren, getDocument as dbGetDocument, getDocumentByTask as dbGetDocumentByTask, getProject, getTask, listDocuments as dbListDocuments, updateDocument as dbUpdateDocument, } from '@plandesk/db';
-import { buildDocumentTree, serializeDocument, } from '../serialize.js';
+import { createDocument as dbCreateDocument, deleteCommentsByDocumentId, deleteDocument as dbDeleteDocument, detachDocumentChildren, getDocument as dbGetDocument, getDocumentByTask as dbGetDocumentByTask, getFolderByProjectAndId, getProject, getTask, listDocuments as dbListDocuments, listFolders as dbListFolders, updateDocument as dbUpdateDocument, } from '@plandesk/db';
+import { buildDocumentTree, buildFolderTree, serializeDocument, } from '../serialize.js';
 export class InvalidDocumentError extends Error {
     constructor(message) {
         super(message);
@@ -18,6 +18,11 @@ function assertParentInProject(db, projectId, parentId) {
         throw new InvalidDocumentError('Parent document does not belong to project');
     }
 }
+function assertFolderInProject(db, projectId, folderId) {
+    if (!getFolderByProjectAndId(db, projectId, folderId)) {
+        throw new InvalidDocumentError('Folder does not belong to project');
+    }
+}
 export function createDocumentService(deps) {
     const { db, eventBus } = deps;
     return {
@@ -28,6 +33,23 @@ export function createDocumentService(deps) {
             }
             return buildDocumentTree(dbListDocuments(db, projectId, pagination));
         },
+        listFolderTree(projectId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            return buildFolderTree(dbListFolders(db, projectId), dbListDocuments(db, projectId));
+        },
+        listByFolder(projectId, folderId) {
+            const project = getProject(db, projectId);
+            if (!project) {
+                return undefined;
+            }
+            if (!getFolderByProjectAndId(db, projectId, folderId)) {
+                return undefined;
+            }
+            return buildDocumentTree(dbListDocuments(db, projectId, { folderId }));
+        },
         create(projectId, input) {
             const project = getProject(db, projectId);
             if (!project) {
@@ -39,12 +61,16 @@ export function createDocumentService(deps) {
             if (input.parentId !== undefined && input.parentId !== null) {
                 assertParentInProject(db, projectId, input.parentId);
             }
+            if (input.folderId !== undefined && input.folderId !== null) {
+                assertFolderInProject(db, projectId, input.folderId);
+            }
             const document = dbCreateDocument(db, {
                 projectId,
                 title: input.title,
                 body: input.body,
                 statusLine: input.statusLine,
                 parentId: input.parentId,
+                folderId: input.folderId,
                 linkedTaskId: input.linkedTaskId,
             });
             eventBus.emit({
@@ -75,6 +101,9 @@ export function createDocumentService(deps) {
                 }
                 assertParentInProject(db, existing.projectId, input.parentId);
             }
+            if (input.folderId !== undefined && input.folderId !== null) {
+                assertFolderInProject(db, existing.projectId, input.folderId);
+            }
             const document = dbUpdateDocument(db, id, input);
             if (!document) {
                 return undefined;

package/dist/services/folders.d.ts

@@ -0,0 +1,27 @@
+import { type Db } from '@plandesk/db';
+import { type SerializedFolder } from '../serialize.js';
+import type { EventBus } from '../events.js';
+export type FolderServiceDeps = {
+    db: Db;
+    eventBus: EventBus;
+};
+export type CreateFolderInput = {
+    name: string;
+    parentFolderId?: string | null;
+};
+export type UpdateFolderInput = {
+    name?: string;
+    parentFolderId?: string | null;
+};
+export declare class InvalidFolderError extends Error {
+    constructor(message: string);
+}
+export declare function createFolderService(deps: FolderServiceDeps): {
+    list(projectId: string): SerializedFolder[] | undefined;
+    create(projectId: string, input: CreateFolderInput): SerializedFolder | undefined;
+    get(id: string): SerializedFolder | undefined;
+    update(id: string, input: UpdateFolderInput): SerializedFolder | undefined;
+    delete(id: string): boolean;
+};
+export type FolderService = ReturnType<typeof createFolderService>;
+//# sourceMappingURL=folders.d.ts.map