@plandesk/api 0.19.0 → 1.0.0-beta.1

package/dist/services/documents.d.ts

@@ -1,9 +1,8 @@
 import { type Db } from '@plandesk/db';
 import { type PaginationParams, type SerializedDocument, type SerializedDocumentFolderTree, type SerializedDocumentTree } from '../serialize.js';
-import type { EventBus } from '../events.js';
-export type DocumentServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type DocumentServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CreateDocumentInput = {
     title: string;
@@ -25,14 +24,14 @@ export declare class InvalidDocumentError extends Error {
     constructor(message: string);
 }
 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;
-    getByTask(taskId: string): SerializedDocument | undefined;
-    delete(id: string): boolean;
+    listTree(projectId: string, pagination?: PaginationParams): Promise<SerializedDocumentTree[] | undefined>;
+    listFolderTree(projectId: string): Promise<SerializedDocumentFolderTree | undefined>;
+    listByFolder(projectId: string, folderId: string): Promise<SerializedDocumentTree[] | undefined>;
+    create(projectId: string, input: CreateDocumentInput): Promise<SerializedDocument | undefined>;
+    get(id: string): Promise<SerializedDocument | undefined>;
+    update(id: string, input: UpdateDocumentInput): Promise<SerializedDocument | undefined>;
+    getByTask(taskId: string): Promise<SerializedDocument | undefined>;
+    delete(id: string): Promise<boolean>;
 };
 export type DocumentService = ReturnType<typeof createDocumentService>;
 //# sourceMappingURL=documents.d.ts.map

package/dist/services/documents.js

@@ -1,70 +1,93 @@
-import { createDocument as dbCreateDocument, deleteCommentsByTarget, 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 { withTransaction, createDocument as dbCreateDocument, deleteCommentsByTarget, 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';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidDocumentError extends Error {
     constructor(message) {
         super(message);
         this.name = 'InvalidDocumentError';
     }
 }
-function assertTaskInProject(db, projectId, taskId) {
-    const task = getTask(db, taskId);
+async function assertTaskInProject(db, projectId, taskId) {
+    const task = await getTask(db, taskId);
     if (!task || task.projectId !== projectId) {
         throw new InvalidDocumentError('Task does not belong to project');
     }
 }
-function assertParentInProject(db, projectId, parentId) {
-    const parent = dbGetDocument(db, parentId);
+async function assertParentInProject(db, projectId, parentId) {
+    const parent = await dbGetDocument(db, parentId);
     if (!parent || parent.projectId !== projectId) {
         throw new InvalidDocumentError('Parent document does not belong to project');
     }
 }
-function assertFolderInProject(db, projectId, folderId) {
-    if (!getFolderByProjectAndId(db, projectId, folderId)) {
+async function assertFolderInProject(db, projectId, folderId) {
+    if (!(await getFolderByProjectAndId(db, projectId, folderId))) {
         throw new InvalidDocumentError('Folder does not belong to project');
     }
 }
 export function createDocumentService(deps) {
-    const { db, eventBus } = deps;
+    const { db } = deps;
     return {
-        listTree(projectId, pagination = {}) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listTree(projectId, pagination = {}) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
-            return buildDocumentTree(dbListDocuments(db, projectId, pagination));
+            return buildDocumentTree(await dbListDocuments(db, projectId, pagination));
         },
-        listFolderTree(projectId) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listFolderTree(projectId) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
             }
-            return buildFolderTree(dbListFolders(db, projectId), dbListDocuments(db, projectId));
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
+            }
+            return buildFolderTree(await dbListFolders(db, projectId), await dbListDocuments(db, projectId));
         },
-        listByFolder(projectId, folderId) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async listByFolder(projectId, folderId) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
             }
-            if (!getFolderByProjectAndId(db, projectId, folderId)) {
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
+            }
+            if (!(await getFolderByProjectAndId(db, projectId, folderId))) {
                 return undefined;
             }
-            return buildDocumentTree(dbListDocuments(db, projectId, { folderId }));
+            return buildDocumentTree(await dbListDocuments(db, projectId, { folderId }));
         },
-        create(projectId, input) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async create(projectId, input) {
+            assertPermission(deps, 'document', 'create');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
             if (input.linkedTaskId !== undefined && input.linkedTaskId !== null) {
-                assertTaskInProject(db, projectId, input.linkedTaskId);
+                await assertTaskInProject(db, projectId, input.linkedTaskId);
             }
             if (input.parentId !== undefined && input.parentId !== null) {
-                assertParentInProject(db, projectId, input.parentId);
+                await assertParentInProject(db, projectId, input.parentId);
             }
             if (input.folderId !== undefined && input.folderId !== null) {
-                assertFolderInProject(db, projectId, input.folderId);
+                await assertFolderInProject(db, projectId, input.folderId);
             }
-            const document = dbCreateDocument(db, {
+            const document = await dbCreateDocument(db, {
                 projectId,
                 title: input.title,
                 body: input.body,
@@ -73,65 +96,61 @@ export function createDocumentService(deps) {
                 folderId: input.folderId,
                 linkedTaskId: input.linkedTaskId,
             });
-            eventBus.emit({
-                type: 'document_created',
-                documentId: document.id,
-                projectId,
-            });
             return serializeDocument(document);
         },
-        get(id) {
-            const document = dbGetDocument(db, id);
+        async get(id) {
+            const document = await dbGetDocument(db, id);
             if (!document) {
                 return undefined;
             }
             return serializeDocument(document);
         },
-        update(id, input) {
-            const existing = dbGetDocument(db, id);
+        async update(id, input) {
+            assertPermission(deps, 'document', 'update');
+            const existing = await dbGetDocument(db, id);
             if (!existing) {
                 return undefined;
             }
             if (input.linkedTaskId !== undefined && input.linkedTaskId !== null) {
-                assertTaskInProject(db, existing.projectId, input.linkedTaskId);
+                await assertTaskInProject(db, existing.projectId, input.linkedTaskId);
             }
             if (input.parentId !== undefined && input.parentId !== null) {
                 if (input.parentId === id) {
                     throw new InvalidDocumentError('Document cannot be its own parent');
                 }
-                assertParentInProject(db, existing.projectId, input.parentId);
+                await assertParentInProject(db, existing.projectId, input.parentId);
             }
             if (input.folderId !== undefined && input.folderId !== null) {
-                assertFolderInProject(db, existing.projectId, input.folderId);
+                await assertFolderInProject(db, existing.projectId, input.folderId);
             }
-            const document = dbUpdateDocument(db, id, input);
+            const document = await dbUpdateDocument(db, id, input);
             if (!document) {
                 return undefined;
             }
             return serializeDocument(document);
         },
-        getByTask(taskId) {
-            const task = getTask(db, taskId);
+        async getByTask(taskId) {
+            const task = await getTask(db, taskId);
             if (!task) {
                 return undefined;
             }
-            const document = dbGetDocumentByTask(db, taskId);
+            const document = await dbGetDocumentByTask(db, taskId);
             if (!document) {
                 return undefined;
             }
             return serializeDocument(document);
         },
-        delete(id) {
-            const existing = dbGetDocument(db, id);
+        async delete(id) {
+            assertPermission(deps, 'document', 'delete');
+            const existing = await dbGetDocument(db, id);
             if (!existing) {
                 return false;
             }
-            db.transaction((tx) => {
-                detachDocumentChildren(tx, id);
-                deleteCommentsByTarget(tx, 'document', id);
-                dbDeleteDocument(tx, id);
+            await withTransaction(db, async (tx) => {
+                await detachDocumentChildren(tx, id);
+                await deleteCommentsByTarget(tx, 'document', id);
+                await dbDeleteDocument(tx, id);
             });
-            eventBus.emit({ type: 'canvas_updated', projectId: existing.projectId });
             return true;
         },
     };

package/dist/services/files.d.ts

@@ -1,6 +1,7 @@
 import { type Db } from '@plandesk/db';
 import type { StorageAdapter, StorageResolveResult } from '../storage/adapter.js';
-export type FileServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type FileServiceDeps = OrgScopedDeps & {
     db: Db;
     storage: StorageAdapter;
 };

package/dist/services/files.js

@@ -1,11 +1,19 @@
-import { getFile, getProject } from '@plandesk/db';
+import { getFile } from '@plandesk/db';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export function createFileService(deps) {
     const { db, storage } = deps;
     return {
         async create(input) {
-            const project = getProject(db, input.projectId);
-            if (!project) {
-                return undefined;
+            assertPermission(deps, 'document', 'create');
+            try {
+                await assertProjectInOrg(db, input.projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
             const { id, url } = await storage.put({
                 projectId: input.projectId,
@@ -16,7 +24,7 @@ export function createFileService(deps) {
             // Content-addressed dedup means the persisted row may reflect an
             // earlier upload of the same bytes — read it back rather than echoing
             // this call's input, so the response always matches what is stored.
-            const file = getFile(db, id);
+            const file = await getFile(db, input.projectId, id);
             if (!file) {
                 throw new Error(`Storage adapter did not persist file metadata for ${id}`);
             }

package/dist/services/folders.d.ts

@@ -1,9 +1,8 @@
 import { type Db } from '@plandesk/db';
 import { type SerializedFolder } from '../serialize.js';
-import type { EventBus } from '../events.js';
-export type FolderServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type FolderServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export type CreateFolderInput = {
     name: string;
@@ -17,11 +16,11 @@ 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;
+    list(projectId: string): Promise<SerializedFolder[] | undefined>;
+    create(projectId: string, input: CreateFolderInput): Promise<SerializedFolder | undefined>;
+    get(id: string): Promise<SerializedFolder | undefined>;
+    update(id: string, input: UpdateFolderInput): Promise<SerializedFolder | undefined>;
+    delete(id: string): Promise<boolean>;
 };
 export type FolderService = ReturnType<typeof createFolderService>;
 //# sourceMappingURL=folders.d.ts.map

package/dist/services/folders.js

@@ -1,5 +1,7 @@
-import { createFolder as dbCreateFolder, deleteFolder as dbDeleteFolder, getFolder as dbGetFolder, getProject, listFolders as dbListFolders, moveDocumentsToFolder, reparentChildFolders, updateFolder as dbUpdateFolder, } from '@plandesk/db';
+import { withTransaction, createFolder as dbCreateFolder, deleteFolder as dbDeleteFolder, getFolder as dbGetFolder, getProject, listFolders as dbListFolders, moveDocumentsToFolder, reparentChildFolders, updateFolder as dbUpdateFolder, } from '@plandesk/db';
 import { serializeFolder } from '../serialize.js';
+import { assertPermission, resolveOrgId } from './org-scope.js';
+import { assertProjectInOrg, ProjectNotInOrgError } from './scope.js';
 export class InvalidFolderError extends Error {
     constructor(message) {
         super(message);
@@ -11,13 +13,13 @@ function assertNonEmptyName(name) {
         throw new InvalidFolderError('Folder name must not be empty');
     }
 }
-function assertParentInProject(db, projectId, parentFolderId) {
-    const parent = dbGetFolder(db, parentFolderId);
+async function assertParentInProject(db, projectId, parentFolderId) {
+    const parent = await dbGetFolder(db, parentFolderId);
     if (!parent || parent.projectId !== projectId) {
         throw new InvalidFolderError('Parent folder does not belong to project');
     }
 }
-function assertNoCycle(db, folderId, newParentFolderId) {
+async function assertNoCycle(db, folderId, newParentFolderId) {
     const visited = new Set();
     let current = newParentFolderId;
     while (current !== null) {
@@ -28,45 +30,56 @@ function assertNoCycle(db, folderId, newParentFolderId) {
             return;
         }
         visited.add(current);
-        current = dbGetFolder(db, current)?.parentFolderId ?? null;
+        current = (await dbGetFolder(db, current))?.parentFolderId ?? null;
     }
 }
 export function createFolderService(deps) {
-    const { db, eventBus } = deps;
+    const { db } = deps;
     return {
-        list(projectId) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async list(projectId) {
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
-            return dbListFolders(db, projectId).map(serializeFolder);
+            return (await dbListFolders(db, projectId)).map(serializeFolder);
         },
-        create(projectId, input) {
-            const project = getProject(db, projectId);
-            if (!project) {
-                return undefined;
+        async create(projectId, input) {
+            assertPermission(deps, 'document', 'create');
+            try {
+                await assertProjectInOrg(db, projectId, resolveOrgId(deps));
+            }
+            catch (error) {
+                if (error instanceof ProjectNotInOrgError) {
+                    return undefined;
+                }
+                throw error;
             }
             assertNonEmptyName(input.name);
             if (input.parentFolderId !== undefined && input.parentFolderId !== null) {
-                assertParentInProject(db, projectId, input.parentFolderId);
+                await assertParentInProject(db, projectId, input.parentFolderId);
             }
-            const folder = dbCreateFolder(db, {
+            const folder = await dbCreateFolder(db, {
                 projectId,
                 name: input.name,
                 parentFolderId: input.parentFolderId,
             });
-            eventBus.emit({ type: 'folder_created', folderId: folder.id, projectId });
             return serializeFolder(folder);
         },
-        get(id) {
-            const folder = dbGetFolder(db, id);
+        async get(id) {
+            const folder = await dbGetFolder(db, id);
             if (!folder) {
                 return undefined;
             }
             return serializeFolder(folder);
         },
-        update(id, input) {
-            const existing = dbGetFolder(db, id);
+        async update(id, input) {
+            assertPermission(deps, 'document', 'update');
+            const existing = await dbGetFolder(db, id);
             if (!existing) {
                 return undefined;
             }
@@ -77,29 +90,28 @@ export function createFolderService(deps) {
                 if (input.parentFolderId === id) {
                     throw new InvalidFolderError('Folder cannot be its own parent');
                 }
-                assertParentInProject(db, existing.projectId, input.parentFolderId);
-                assertNoCycle(db, id, input.parentFolderId);
+                await assertParentInProject(db, existing.projectId, input.parentFolderId);
+                await assertNoCycle(db, id, input.parentFolderId);
             }
-            const folder = dbUpdateFolder(db, id, input);
+            const folder = await dbUpdateFolder(db, id, input);
             if (!folder) {
                 return undefined;
             }
-            eventBus.emit({ type: 'folder_updated', folderId: folder.id, projectId: folder.projectId });
             return serializeFolder(folder);
         },
-        delete(id) {
-            const existing = dbGetFolder(db, id);
+        async delete(id) {
+            assertPermission(deps, 'document', 'delete');
+            const existing = await dbGetFolder(db, id);
             if (!existing) {
                 return false;
             }
             // Never orphan: children folders and contained documents move to the
             // deleted folder's parent (or root when the folder was at root).
-            db.transaction((tx) => {
-                reparentChildFolders(tx, id, existing.parentFolderId);
-                moveDocumentsToFolder(tx, id, existing.parentFolderId);
-                dbDeleteFolder(tx, id);
+            await withTransaction(db, async (tx) => {
+                await reparentChildFolders(tx, id, existing.parentFolderId);
+                await moveDocumentsToFolder(tx, id, existing.parentFolderId);
+                await dbDeleteFolder(tx, id);
             });
-            eventBus.emit({ type: 'folder_updated', folderId: id, projectId: existing.projectId });
             return true;
         },
     };

package/dist/services/goals.d.ts

@@ -1,8 +1,7 @@
 import { type Db, type GoalStatus } from '@plandesk/db';
-import type { EventBus } from '../events.js';
-export type GoalServiceDeps = {
+import { type OrgScopedDeps } from './org-scope.js';
+export type GoalServiceDeps = OrgScopedDeps & {
     db: Db;
-    eventBus: EventBus;
 };
 export declare class InvalidGoalTransitionError extends Error {
     constructor(message: string);
@@ -79,11 +78,11 @@ export declare function evaluateEvidence(surface: VerificationSurface, evidence:
     detail?: string;
 };
 export declare function createGoalService(deps: GoalServiceDeps): {
-    create(projectId: string, input: CreateGoalInput): {
+    create(projectId: string, input: CreateGoalInput): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -98,15 +97,15 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
-    get(goalId: string): {
+    } | undefined>;
+    get(goalId: string): Promise<{
         cycle_tasks: {
             tags?: import("../serialize.js").SerializedTag[] | undefined;
             id: string;
             project_id: string;
             goal_id: string;
             label: string;
-            status: "scope" | "todo" | "in_progress" | "done" | "backlog";
+            status: "in_progress" | "done" | "todo" | "scope" | "backlog";
             description: string | null;
             x: number;
             y: number;
@@ -118,7 +117,7 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -133,12 +132,12 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
-    listByProject(projectId: string): {
+    } | undefined>;
+    listByProject(projectId: string): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -153,12 +152,12 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    }[] | undefined;
-    update(goalId: string, input: UpdateGoalInput): {
+    }[] | undefined>;
+    update(goalId: string, input: UpdateGoalInput): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -173,12 +172,12 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
-    pause(goalId: string): {
+    } | undefined>;
+    pause(goalId: string): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -193,12 +192,12 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
-    resume(goalId: string): {
+    } | undefined>;
+    resume(goalId: string): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -213,12 +212,12 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
-    complete(goalId: string, evidence?: VerificationEvidence): {
+    } | undefined>;
+    complete(goalId: string, evidence?: VerificationEvidence): Promise<{
         id: string;
         project_id: string;
         objective: string;
-        status: "active" | "paused" | "complete" | "blocked";
+        status: "paused" | "active" | "complete" | "blocked";
         verification_surface: string | null;
         constraints: string | null;
         boundaries: string | null;
@@ -233,7 +232,7 @@ export declare function createGoalService(deps: GoalServiceDeps): {
         } | null;
         created_at: string;
         updated_at: string;
-    } | undefined;
+    } | undefined>;
 };
 export type GoalService = ReturnType<typeof createGoalService>;
 //# sourceMappingURL=goals.d.ts.map