@btst/stack 3.0.0-rc.1 → 3.0.0-rc.3

package/dist/packages/stack/src/plugins/kanban/api/plugin.mjs

@@ -1,21 +1,23 @@
 import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
 import { kanbanSchema } from '../db.mjs';
-import { slugify } from '../utils.mjs';
 import { BoardListQuerySchema, createBoardSchema, updateBoardSchema, createColumnSchema, updateColumnSchema, reorderColumnsSchema, createTaskSchema, updateTaskSchema, moveTaskSchema, reorderTasksSchema } from '../schemas.mjs';
-import { getBoardById, getAllBoards } from './getters.mjs';
-import { getKanbanColumnsByBoardId, findOrCreateKanbanBoard, createKanbanTask } from './mutations.mjs';
+import { getBoardById, getBoardSummaries } from './getters.mjs';
+import { createKanbanOperations, BoardIdOperationInputSchema } from './operations.mjs';
+export { ColumnIdOperationInputSchema, TaskIdOperationInputSchema, UpdateBoardOperationInputSchema, UpdateColumnOperationInputSchema, UpdateTaskOperationInputSchema } from './operations.mjs';
 import { KANBAN_QUERY_KEYS } from './query-key-defs.mjs';
-import { runHook } from '../../utils.mjs';
-import { serializeBoard } from './serializers.mjs';
+import { serializeBoard, serializeBoardSummary } from './serializers.mjs';
 
 function createKanbanPrefetchForRoute(adapter) {
-  return async function prefetchForRoute(key, qc, params) {
+  return async function prefetchForRoute(key, queryClient, params) {
     switch (key) {
       case "boards": {
-        const result = await getAllBoards(adapter, { limit: 50, offset: 0 });
-        qc.setQueryData(
+        const result = await getBoardSummaries(adapter, {
+          limit: 50,
+          offset: 0
+        });
+        queryClient.setQueryData(
           KANBAN_QUERY_KEYS.boardsList({}),
-          result.items.map(serializeBoard)
+          result.items.map(serializeBoardSummary)
         );
         break;
       }
@@ -23,7 +25,7 @@ function createKanbanPrefetchForRoute(adapter) {
         const boardId = params?.boardId ?? "";
         if (boardId) {
           const board = await getBoardById(adapter, boardId);
-          qc.setQueryData(
+          queryClient.setQueryData(
             KANBAN_QUERY_KEYS.boardDetail(boardId),
             board ? serializeBoard(board) : null
           );
@@ -33,683 +35,109 @@ function createKanbanPrefetchForRoute(adapter) {
     }
   };
 }
-const kanbanBackendPlugin = (hooks) => defineBackendPlugin({
-  name: "kanban",
+const kanbanBackendPlugin = (options = {}) => defineBackendPlugin({
+  id: "kanban",
   dbPlugin: kanbanSchema,
-  api: (adapter) => ({
-    getAllBoards: (params) => getAllBoards(adapter, params),
-    getBoardById: (id) => getBoardById(adapter, id),
-    prefetchForRoute: createKanbanPrefetchForRoute(adapter),
-    // Mutations
-    createTask: (input) => createKanbanTask(adapter, input),
-    findOrCreateBoard: (slug, name, columnTitles) => findOrCreateKanbanBoard(adapter, slug, name, columnTitles),
-    getColumnsByBoardId: (boardId) => getKanbanColumnsByBoardId(adapter, boardId)
+  operations: (adapter) => createKanbanOperations(adapter, options.hooks),
+  /** Lower-level SSG helper that intentionally bypasses auth and hooks. */
+  raw: (adapter) => ({
+    prefetchForRoute: createKanbanPrefetchForRoute(adapter)
   }),
-  routes: (adapter) => {
+  routes: (_adapter, _context, operations) => {
     const listBoards = createEndpoint(
       "/boards",
-      {
-        method: "GET",
-        query: BoardListQuerySchema
-      },
-      async (ctx) => {
-        const { query, headers } = ctx;
-        const context = { query, headers };
-        try {
-          if (hooks?.onBeforeListBoards) {
-            await runHook(
-              () => hooks.onBeforeListBoards(query, context),
-              ctx.error,
-              "Unauthorized: Cannot list boards"
-            );
-          }
-          const result = await getAllBoards(adapter, query);
-          if (hooks?.onBoardsRead) {
-            await hooks.onBoardsRead(result.items, query, context);
-          }
-          return result;
-        } catch (error) {
-          if (hooks?.onListBoardsError) {
-            await hooks.onListBoardsError(error, context);
-          }
-          throw error;
-        }
-      }
+      { method: "GET", query: BoardListQuerySchema, requireRequest: true },
+      operations.listBoards.route((ctx) => ctx.query)
     );
     const getBoard = createEndpoint(
       "/boards/:id",
       {
-        method: "GET"
+        method: "GET",
+        params: BoardIdOperationInputSchema,
+        requireRequest: true
       },
-      async (ctx) => {
-        const { params, headers } = ctx;
-        const context = { params, headers };
-        try {
-          if (hooks?.onBeforeReadBoard) {
-            await runHook(
-              () => hooks.onBeforeReadBoard(params.id, context),
-              ctx.error,
-              "Unauthorized: Cannot read board"
-            );
-          }
-          const result = await getBoardById(adapter, params.id);
-          if (!result) {
-            throw ctx.error(404, { message: "Board not found" });
-          }
-          if (hooks?.onBoardRead) {
-            await hooks.onBoardRead(result, context);
-          }
-          return result;
-        } catch (error) {
-          if (hooks?.onReadBoardError) {
-            await hooks.onReadBoardError(error, context);
-          }
-          throw error;
-        }
-      }
+      operations.getBoard.route((ctx) => ctx.params)
     );
     const createBoard = createEndpoint(
       "/boards",
-      {
-        method: "POST",
-        body: createBoardSchema
-      },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeCreateBoard) {
-            await runHook(
-              () => hooks.onBeforeCreateBoard(ctx.body, context),
-              ctx.error,
-              "Unauthorized: Cannot create board"
-            );
-          }
-          const { ...boardData } = ctx.body;
-          const slug = slugify(boardData.slug || boardData.name);
-          if (!slug) {
-            throw ctx.error(400, {
-              message: "Invalid slug: must contain at least one alphanumeric character"
-            });
-          }
-          let newBoard;
-          const createdColumns = [];
-          await adapter.transaction(async (tx) => {
-            const createdBoard = await tx.create({
-              model: "kanbanBoard",
-              data: {
-                ...boardData,
-                slug,
-                createdAt: /* @__PURE__ */ new Date(),
-                updatedAt: /* @__PURE__ */ new Date()
-              }
-            });
-            newBoard = createdBoard;
-            const defaultColumns = [
-              { title: "To Do", order: 0, boardId: createdBoard.id },
-              { title: "In Progress", order: 1, boardId: createdBoard.id },
-              { title: "Done", order: 2, boardId: createdBoard.id }
-            ];
-            for (const colData of defaultColumns) {
-              const col = await tx.create({
-                model: "kanbanColumn",
-                data: {
-                  ...colData,
-                  createdAt: /* @__PURE__ */ new Date(),
-                  updatedAt: /* @__PURE__ */ new Date()
-                }
-              });
-              createdColumns.push({ ...col, tasks: [] });
-            }
-          });
-          if (!newBoard) {
-            throw ctx.error(500, {
-              message: "Failed to create board"
-            });
-          }
-          const result = { ...newBoard, columns: createdColumns };
-          if (hooks?.onBoardCreated) {
-            await hooks.onBoardCreated(result, context);
-          }
-          return result;
-        } catch (error) {
-          if (hooks?.onCreateBoardError) {
-            await hooks.onCreateBoardError(error, context);
-          }
-          throw error;
-        }
-      }
+      { method: "POST", body: createBoardSchema, requireRequest: true },
+      operations.createBoard.route((ctx) => ctx.body)
     );
     const updateBoard = createEndpoint(
       "/boards/:id",
       {
         method: "PUT",
-        body: updateBoardSchema.omit({ id: true })
+        body: updateBoardSchema.omit({ id: true }),
+        requireRequest: true
       },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeUpdateBoard) {
-            await runHook(
-              () => hooks.onBeforeUpdateBoard(
-                ctx.params.id,
-                { ...ctx.body, id: ctx.params.id },
-                context
-              ),
-              ctx.error,
-              "Unauthorized: Cannot update board"
-            );
-          }
-          const { slug: rawSlug, ...restBoardData } = ctx.body;
-          const slugified = rawSlug ? slugify(rawSlug) : void 0;
-          if (rawSlug && !slugified) {
-            throw ctx.error(400, {
-              message: "Invalid slug: must contain at least one alphanumeric character"
-            });
-          }
-          const boardData = {
-            ...restBoardData,
-            ...slugified ? { slug: slugified } : {}
-          };
-          const updated = await adapter.update({
-            model: "kanbanBoard",
-            where: [{ field: "id", value: ctx.params.id }],
-            update: {
-              ...boardData,
-              updatedAt: /* @__PURE__ */ new Date()
-            }
-          });
-          if (!updated) {
-            throw ctx.error(404, { message: "Board not found" });
-          }
-          if (hooks?.onBoardUpdated) {
-            await hooks.onBoardUpdated(updated, context);
-          }
-          return updated;
-        } catch (error) {
-          if (hooks?.onUpdateBoardError) {
-            await hooks.onUpdateBoardError(error, context);
-          }
-          throw error;
-        }
-      }
+      operations.updateBoard.route((ctx) => ({
+        id: ctx.params.id,
+        data: ctx.body
+      }))
     );
     const deleteBoard = createEndpoint(
       "/boards/:id",
-      {
-        method: "DELETE"
-      },
-      async (ctx) => {
-        const context = {
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          const existingBoard = await adapter.findOne({
-            model: "kanbanBoard",
-            where: [
-              { field: "id", value: ctx.params.id, operator: "eq" }
-            ]
-          });
-          if (!existingBoard) {
-            throw ctx.error(404, { message: "Board not found" });
-          }
-          if (hooks?.onBeforeDeleteBoard) {
-            await runHook(
-              () => hooks.onBeforeDeleteBoard(ctx.params.id, context),
-              ctx.error,
-              "Unauthorized: Cannot delete board"
-            );
-          }
-          await adapter.delete({
-            model: "kanbanBoard",
-            where: [{ field: "id", value: ctx.params.id }]
-          });
-          if (hooks?.onBoardDeleted) {
-            await hooks.onBoardDeleted(ctx.params.id, context);
-          }
-          return { success: true };
-        } catch (error) {
-          if (hooks?.onDeleteBoardError) {
-            await hooks.onDeleteBoardError(error, context);
-          }
-          throw error;
-        }
-      }
+      { method: "DELETE", requireRequest: true },
+      operations.deleteBoard.route((ctx) => ({ id: ctx.params.id }))
     );
     const createColumn = createEndpoint(
       "/columns",
-      {
-        method: "POST",
-        body: createColumnSchema
-      },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeCreateColumn) {
-            await runHook(
-              () => hooks.onBeforeCreateColumn(ctx.body, context),
-              ctx.error,
-              "Unauthorized: Cannot create column"
-            );
-          }
-          const existingColumns = await adapter.findMany({
-            model: "kanbanColumn",
-            where: [
-              {
-                field: "boardId",
-                value: ctx.body.boardId,
-                operator: "eq"
-              }
-            ]
-          });
-          const nextOrder = existingColumns.length > 0 ? Math.max(...existingColumns.map((c) => c.order)) + 1 : 0;
-          const newColumn = await adapter.create({
-            model: "kanbanColumn",
-            data: {
-              ...ctx.body,
-              order: ctx.body.order ?? nextOrder,
-              createdAt: /* @__PURE__ */ new Date(),
-              updatedAt: /* @__PURE__ */ new Date()
-            }
-          });
-          if (hooks?.onColumnCreated) {
-            await hooks.onColumnCreated(newColumn, context);
-          }
-          return newColumn;
-        } catch (error) {
-          throw error;
-        }
-      }
+      { method: "POST", body: createColumnSchema, requireRequest: true },
+      operations.createColumn.route((ctx) => ctx.body)
     );
     const updateColumn = createEndpoint(
       "/columns/:id",
       {
         method: "PUT",
-        body: updateColumnSchema.omit({ id: true })
+        body: updateColumnSchema.omit({ id: true }),
+        requireRequest: true
       },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeUpdateColumn) {
-            await runHook(
-              () => hooks.onBeforeUpdateColumn(
-                ctx.params.id,
-                { ...ctx.body, id: ctx.params.id },
-                context
-              ),
-              ctx.error,
-              "Unauthorized: Cannot update column"
-            );
-          }
-          const updated = await adapter.update({
-            model: "kanbanColumn",
-            where: [{ field: "id", value: ctx.params.id }],
-            update: {
-              ...ctx.body,
-              updatedAt: /* @__PURE__ */ new Date()
-            }
-          });
-          if (!updated) {
-            throw ctx.error(404, { message: "Column not found" });
-          }
-          if (hooks?.onColumnUpdated) {
-            await hooks.onColumnUpdated(updated, context);
-          }
-          return updated;
-        } catch (error) {
-          throw error;
-        }
-      }
+      operations.updateColumn.route((ctx) => ({
+        id: ctx.params.id,
+        data: ctx.body
+      }))
     );
     const deleteColumn = createEndpoint(
       "/columns/:id",
-      {
-        method: "DELETE"
-      },
-      async (ctx) => {
-        const context = {
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          const existingColumn = await adapter.findOne({
-            model: "kanbanColumn",
-            where: [
-              { field: "id", value: ctx.params.id, operator: "eq" }
-            ]
-          });
-          if (!existingColumn) {
-            throw ctx.error(404, { message: "Column not found" });
-          }
-          if (hooks?.onBeforeDeleteColumn) {
-            await runHook(
-              () => hooks.onBeforeDeleteColumn(ctx.params.id, context),
-              ctx.error,
-              "Unauthorized: Cannot delete column"
-            );
-          }
-          await adapter.delete({
-            model: "kanbanColumn",
-            where: [{ field: "id", value: ctx.params.id }]
-          });
-          if (hooks?.onColumnDeleted) {
-            await hooks.onColumnDeleted(ctx.params.id, context);
-          }
-          return { success: true };
-        } catch (error) {
-          throw error;
-        }
-      }
+      { method: "DELETE", requireRequest: true },
+      operations.deleteColumn.route((ctx) => ({ id: ctx.params.id }))
     );
     const reorderColumns = createEndpoint(
       "/columns/reorder",
-      {
-        method: "POST",
-        body: reorderColumnsSchema
-      },
-      async (ctx) => {
-        const { boardId, columnIds } = ctx.body;
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        if (hooks?.onBeforeUpdateColumn) {
-          for (let i = 0; i < columnIds.length; i++) {
-            const columnId = columnIds[i];
-            if (!columnId) continue;
-            await runHook(
-              () => hooks.onBeforeUpdateColumn(
-                columnId,
-                { id: columnId, order: i },
-                context
-              ),
-              ctx.error,
-              "Unauthorized: Cannot reorder columns"
-            );
-          }
-        }
-        const updatedColumns = [];
-        await adapter.transaction(async (tx) => {
-          for (let i = 0; i < columnIds.length; i++) {
-            const columnId = columnIds[i];
-            if (!columnId) continue;
-            const updated = await tx.update({
-              model: "kanbanColumn",
-              where: [
-                { field: "id", value: columnId },
-                { field: "boardId", value: boardId, operator: "eq" }
-              ],
-              update: { order: i, updatedAt: /* @__PURE__ */ new Date() }
-            });
-            if (updated) {
-              updatedColumns.push(updated);
-            }
-          }
-        });
-        if (hooks?.onColumnUpdated) {
-          for (const column of updatedColumns) {
-            await hooks.onColumnUpdated(column, context);
-          }
-        }
-        return { success: true };
-      }
+      { method: "POST", body: reorderColumnsSchema, requireRequest: true },
+      operations.reorderColumns.route((ctx) => ctx.body)
     );
     const createTask = createEndpoint(
       "/tasks",
-      {
-        method: "POST",
-        body: createTaskSchema
-      },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeCreateTask) {
-            await runHook(
-              () => hooks.onBeforeCreateTask(ctx.body, context),
-              ctx.error,
-              "Unauthorized: Cannot create task"
-            );
-          }
-          const existingTasks = await adapter.findMany({
-            model: "kanbanTask",
-            where: [
-              {
-                field: "columnId",
-                value: ctx.body.columnId,
-                operator: "eq"
-              }
-            ]
-          });
-          const nextOrder = existingTasks.length > 0 ? Math.max(...existingTasks.map((t) => t.order)) + 1 : 0;
-          const taskData = {
-            title: ctx.body.title,
-            columnId: ctx.body.columnId,
-            description: ctx.body.description,
-            priority: ctx.body.priority || "MEDIUM",
-            order: ctx.body.order ?? nextOrder,
-            assigneeId: ctx.body.assigneeId ?? void 0,
-            isArchived: ctx.body.isArchived ?? false,
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
-          };
-          const newTask = await adapter.create({
-            model: "kanbanTask",
-            data: taskData
-          });
-          if (hooks?.onTaskCreated) {
-            await hooks.onTaskCreated(newTask, context);
-          }
-          return newTask;
-        } catch (error) {
-          throw error;
-        }
-      }
+      { method: "POST", body: createTaskSchema, requireRequest: true },
+      operations.createTask.route((ctx) => ctx.body)
     );
     const updateTask = createEndpoint(
       "/tasks/:id",
       {
         method: "PUT",
-        body: updateTaskSchema.omit({ id: true })
+        body: updateTaskSchema.omit({ id: true }),
+        requireRequest: true
       },
-      async (ctx) => {
-        const context = {
-          body: ctx.body,
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          if (hooks?.onBeforeUpdateTask) {
-            await runHook(
-              () => hooks.onBeforeUpdateTask(
-                ctx.params.id,
-                { ...ctx.body, id: ctx.params.id },
-                context
-              ),
-              ctx.error,
-              "Unauthorized: Cannot update task"
-            );
-          }
-          const updated = await adapter.update({
-            model: "kanbanTask",
-            where: [{ field: "id", value: ctx.params.id }],
-            update: {
-              ...ctx.body,
-              updatedAt: /* @__PURE__ */ new Date()
-            }
-          });
-          if (!updated) {
-            throw ctx.error(404, { message: "Task not found" });
-          }
-          if (hooks?.onTaskUpdated) {
-            await hooks.onTaskUpdated(updated, context);
-          }
-          return updated;
-        } catch (error) {
-          throw error;
-        }
-      }
+      operations.updateTask.route((ctx) => ({
+        id: ctx.params.id,
+        data: ctx.body
+      }))
     );
     const deleteTask = createEndpoint(
       "/tasks/:id",
-      {
-        method: "DELETE"
-      },
-      async (ctx) => {
-        const context = {
-          params: ctx.params,
-          headers: ctx.headers
-        };
-        try {
-          const existingTask = await adapter.findOne({
-            model: "kanbanTask",
-            where: [
-              { field: "id", value: ctx.params.id, operator: "eq" }
-            ]
-          });
-          if (!existingTask) {
-            throw ctx.error(404, { message: "Task not found" });
-          }
-          if (hooks?.onBeforeDeleteTask) {
-            await runHook(
-              () => hooks.onBeforeDeleteTask(ctx.params.id, context),
-              ctx.error,
-              "Unauthorized: Cannot delete task"
-            );
-          }
-          await adapter.delete({
-            model: "kanbanTask",
-            where: [{ field: "id", value: ctx.params.id }]
-          });
-          if (hooks?.onTaskDeleted) {
-            await hooks.onTaskDeleted(ctx.params.id, context);
-          }
-          return { success: true };
-        } catch (error) {
-          throw error;
-        }
-      }
+      { method: "DELETE", requireRequest: true },
+      operations.deleteTask.route((ctx) => ({ id: ctx.params.id }))
     );
     const moveTask = createEndpoint(
       "/tasks/move",
-      {
-        method: "POST",
-        body: moveTaskSchema
-      },
-      async (ctx) => {
-        const { taskId, targetColumnId, targetOrder } = ctx.body;
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        const task = await adapter.findOne({
-          model: "kanbanTask",
-          where: [{ field: "id", value: taskId, operator: "eq" }]
-        });
-        if (!task) {
-          throw ctx.error(404, { message: "Task not found" });
-        }
-        if (hooks?.onBeforeUpdateTask) {
-          await runHook(
-            () => hooks.onBeforeUpdateTask(
-              taskId,
-              { id: taskId, columnId: targetColumnId, order: targetOrder },
-              context
-            ),
-            ctx.error,
-            "Unauthorized: Cannot move task"
-          );
-        }
-        const updated = await adapter.update({
-          model: "kanbanTask",
-          where: [{ field: "id", value: taskId }],
-          update: {
-            columnId: targetColumnId,
-            order: targetOrder,
-            updatedAt: /* @__PURE__ */ new Date()
-          }
-        });
-        if (!updated) {
-          throw ctx.error(404, { message: "Task not found" });
-        }
-        if (hooks?.onTaskUpdated) {
-          await hooks.onTaskUpdated(updated, context);
-        }
-        return updated;
-      }
+      { method: "POST", body: moveTaskSchema, requireRequest: true },
+      operations.moveTask.route((ctx) => ctx.body)
     );
     const reorderTasks = createEndpoint(
       "/tasks/reorder",
-      {
-        method: "POST",
-        body: reorderTasksSchema
-      },
-      async (ctx) => {
-        const { columnId, taskIds } = ctx.body;
-        const context = {
-          body: ctx.body,
-          headers: ctx.headers
-        };
-        if (hooks?.onBeforeUpdateTask) {
-          for (let i = 0; i < taskIds.length; i++) {
-            const taskId = taskIds[i];
-            if (!taskId) continue;
-            await runHook(
-              () => hooks.onBeforeUpdateTask(
-                taskId,
-                { id: taskId, order: i },
-                context
-              ),
-              ctx.error,
-              "Unauthorized: Cannot reorder tasks"
-            );
-          }
-        }
-        const updatedTasks = [];
-        await adapter.transaction(async (tx) => {
-          for (let i = 0; i < taskIds.length; i++) {
-            const taskId = taskIds[i];
-            if (!taskId) continue;
-            const updated = await tx.update({
-              model: "kanbanTask",
-              where: [
-                { field: "id", value: taskId },
-                {
-                  field: "columnId",
-                  value: columnId,
-                  operator: "eq"
-                }
-              ],
-              update: { order: i, updatedAt: /* @__PURE__ */ new Date() }
-            });
-            if (updated) {
-              updatedTasks.push(updated);
-            }
-          }
-        });
-        if (hooks?.onTaskUpdated) {
-          for (const task of updatedTasks) {
-            await hooks.onTaskUpdated(task, context);
-          }
-        }
-        return { success: true };
-      }
+      { method: "POST", body: reorderTasksSchema, requireRequest: true },
+      operations.reorderTasks.route((ctx) => ctx.body)
     );
     return {
       listBoards,
@@ -730,4 +158,4 @@ const kanbanBackendPlugin = (hooks) => defineBackendPlugin({
   }
 });
 
-export { kanbanBackendPlugin };
+export { BoardIdOperationInputSchema, kanbanBackendPlugin };