Kanban Plugin

import { stack } from "@btst/stack"
import { kanbanBackendPlugin } from "@btst/stack/plugins/kanban/api"
// ... your adapter imports

const { handler, dbSchema } = stack({
  basePath: "/api/data",
  plugins: {
    kanban: kanbanBackendPlugin()
  },
  adapter: (db) => createPrismaAdapter(prisma, db, { 
    provider: "postgresql" 
  })
})

export { handler, dbSchema }

import { createStackClient } from "@btst/stack/client"
import { kanbanClientPlugin } from "@btst/stack/plugins/kanban/client"
import { QueryClient } from "@tanstack/react-query"

const getBaseURL = () => 
   (process.env.BASE_URL || "http://localhost:3000")

export const getStackClient = (queryClient: QueryClient) => {
  const baseURL = getBaseURL()
  return createStackClient({
    plugins: {
      kanban: kanbanClientPlugin({
        // Required configuration
        apiBaseURL: baseURL,
        apiBasePath: "/api/data",
        siteBaseURL: baseURL,
        siteBasePath: "/pages",
        queryClient: queryClient,
        // Optional: SEO configuration
        seo: {
          siteName: "My Kanban App",
          description: "Manage your projects with kanban boards",
        },
      })
    }
  })
}

@import "@btst/stack/plugins/kanban/css";

npx @btst/cli generate --orm prisma --config lib/stack.ts  --output prisma/schema.prisma

kanbanClientPlugin({
  // ... other config
  pageComponents: {
    // Replace the boards list page
    boards: MyCustomBoardsPage,
    // Replace the board detail page — receives boardId as a prop
    board: ({ boardId }) => <MyCustomBoardPage boardId={boardId} />,
    // Replace the new board page
    newBoard: MyCustomNewBoardPage,
  },
})

interface KanbanUser {
  id: string;       // Unique user identifier
  name: string;     // Display name
  avatarUrl?: string; // Optional avatar image URL
  email?: string;   // Optional email address
}

overrides={{
  kanban: {
    // ... other overrides
    
    // Resolve user info from an ID (for displaying assignee on task cards)
    resolveUser: (userId: string) => {
      // Return KanbanUser or null if not found
    },
    
    // Search/list users (for the assignee picker dropdown)
    searchUsers: (query: string, boardId?: string) => {
      // Return array of KanbanUser matching the query
      // Return all users if query is empty
    },
  }
}}

import { kanbanBackendPlugin } from "@btst/stack/plugins/kanban/api"

const { handler, dbSchema } = stack({
  plugins: {
    kanban: kanbanBackendPlugin(hooks)
  },
  // ...
})

import { kanbanBackendPlugin, type KanbanBackendHooks } from "@btst/stack/plugins/kanban/api"

const kanbanHooks: KanbanBackendHooks = {
  // Board hooks — throw to deny access
  onBeforeListBoards: async (filter, context) => {
    if (!await isAuthenticated(context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeCreateBoard: async (data, context) => {
    if (!await isAuthenticated(context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeUpdateBoard: async (boardId, data, context) => {
    if (!await isBoardOwner(boardId, context.headers))
      throw new Error("You do not own this board")
  },
  onBeforeDeleteBoard: async (boardId, context) => {
    if (!await isBoardOwner(boardId, context.headers))
      throw new Error("You do not own this board")
  },
  
  // Column hooks
  onBeforeCreateColumn: async (data, context) => {
    if (!await canEditBoard(data.boardId, context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeUpdateColumn: async (columnId, data, context) => {
    if (!await canEditColumn(columnId, context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeDeleteColumn: async (columnId, context) => {
    if (!await canEditColumn(columnId, context.headers))
      throw new Error("Unauthorized")
  },
  
  // Task hooks
  onBeforeCreateTask: async (data, context) => {
    if (!await canEditColumn(data.columnId, context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeUpdateTask: async (taskId, data, context) => {
    if (!await canEditTask(taskId, context.headers))
      throw new Error("Unauthorized")
  },
  onBeforeDeleteTask: async (taskId, context) => {
    if (!await canEditTask(taskId, context.headers))
      throw new Error("Unauthorized")
  },
  
  // Lifecycle hooks
  onBoardCreated: async (board, context) => {
    console.log("Board created:", board.name)
  },
  onTaskCreated: async (task, context) => {
    console.log("Task created:", task.title)
  },
}

const { handler, dbSchema } = stack({
  plugins: {
    kanban: kanbanBackendPlugin(kanbanHooks)
  },
  // ...
})

kanban: kanbanClientPlugin({
  // Required configuration
  apiBaseURL: baseURL,
  apiBasePath: "/api/data",
  siteBaseURL: baseURL,
  siteBasePath: "/pages",
  queryClient: queryClient,
  // Optional SEO configuration
  seo: {
    siteName: "My Kanban App",
    description: "Project management",
  },
  // Optional hooks
  hooks: {
    beforeLoadBoards: async (context) => {
      if (!await isAuthenticated(context.headers))
        throw new Error("Unauthorized")
    },
    beforeLoadBoard: async (boardId, context) => {
      if (!await canViewBoard(boardId, context.headers))
        throw new Error("Unauthorized")
    },
  },
})

overrides={{
  kanban: {
    // Required overrides
    apiBaseURL: baseURL,
    apiBasePath: "/api/data",
    navigate: (path) => router.push(path),
    
    // Required: User resolution for assignees
    resolveUser: (userId) => findUserById(userId),
    searchUsers: (query) => searchAllUsers(query),
    
    // Optional overrides
    Link: (props) => <Link {...props} />,
    refresh: () => router.refresh(),
    
    // Optional lifecycle hooks
    onRouteRender: async (routeName, context) => {
      console.log("Rendering route:", routeName)
    },
    onBeforeBoardsPageRendered: (context) => {
      return isAuthenticated()
    },
    onBeforeBoardPageRendered: (boardId, context) => {
      return canViewBoard(boardId)
    },
    onBeforeNewBoardPageRendered: (context) => {
      return canCreateBoard()
    },
  }
}}

import { CommentThread } from "@btst/stack/plugins/comments/client/components"

overrides={{
  kanban: {
    // ...
    taskDetailBottomSlot: (task) => (
      <CommentThread
        resourceId={task.id}
        resourceType="kanban-task"
        apiBaseURL={baseURL}
        apiBasePath="/api/data"
        currentUserId={session?.user?.id}
        loginHref="/login"
      />
    ),
  }
}}

import { 
  useBoards,
  useBoard,
  useBoardMutations,
  useColumnMutations,
  useTaskMutations,
  useResolveUser,
  useSearchUsers,
} from "@btst/stack/plugins/kanban/client/hooks"

// List all boards
const { data: boards, isLoading, error } = useBoards()

// Get a single board with columns and tasks
const { data: board, isLoading, error } = useBoard(boardId)

// Board mutations
const { createBoard, updateBoard, deleteBoard, isCreating, isUpdating, isDeleting } = useBoardMutations()

// Column mutations
const { createColumn, updateColumn, deleteColumn } = useColumnMutations()

// Task mutations (includes assigneeId support)
const { createTask, updateTask, deleteTask, moveTask } = useTaskMutations()

// Resolve user info (with caching)
const { data: user, isLoading } = useResolveUser(assigneeId)

// Search users for picker
const { data: users, isLoading } = useSearchUsers(searchQuery, boardId)

// API types
import type { 
  Board, 
  Column, 
  Task, 
  Priority,
  BoardWithColumns,
  ColumnWithTasks,
  SerializedBoard,
  SerializedColumn,
  SerializedTask,
} from "@btst/stack/plugins/kanban/api"

// Client types (for user resolution)
import type { 
  KanbanUser,
  KanbanPluginOverrides,
} from "@btst/stack/plugins/kanban/client"

import { myStack } from "./stack";

// List all boards (with columns and tasks)
const result = await myStack.api.kanban.getAllBoards({ ownerId: "user-123" });
// result.items  — BoardWithColumns[]
// result.total  — total count before pagination
// result.limit  — applied limit
// result.offset — applied offset

// Get a single board with full column/task tree
const board = await myStack.api.kanban.getBoardById("board-456");
if (board) {
  board.columns.forEach((col) => {
    console.log(col.title, col.tasks.length, "tasks");
  });
}

import {
  getAllBoards,
  getBoardById,
} from "@btst/stack/plugins/kanban/api";

// In Next.js generateStaticParams
export async function generateStaticParams() {
  const { items } = await getAllBoards(myAdapter);
  return items.map((b) => ({ slug: b.slug }));
}

import { dehydrate, HydrationBoundary } from "@tanstack/react-query"
import { getOrCreateQueryClient } from "@/lib/query-client"
import { getStackClient } from "@/lib/stack-client"
import { myStack } from "@/lib/stack"
import { metaElementsToObject, normalizePath } from "@btst/stack/client"
import type { Metadata } from "next"

export async function generateStaticParams() {
  return [{}]
}

// export const revalidate = 3600 // uncomment for ISR

export async function generateMetadata(): Promise<Metadata> {
  const queryClient = getOrCreateQueryClient()
  const stackClient = getStackClient(queryClient)
  const route = stackClient.router.getRoute(normalizePath(["kanban"]))
  if (!route) return { title: "Kanban Boards" }
  await myStack.api.kanban.prefetchForRoute("boards", queryClient)
  return metaElementsToObject(route.meta?.() ?? []) satisfies Metadata
}

export default async function KanbanBoardsPage() {
  const queryClient = getOrCreateQueryClient()
  const stackClient = getStackClient(queryClient)
  const route = stackClient.router.getRoute(normalizePath(["kanban"]))
  if (!route) return null
  // Reads directly from DB — works at build time, no HTTP server required
  await myStack.api.kanban.prefetchForRoute("boards", queryClient)
  return (
    <HydrationBoundary state={dehydrate(queryClient)}>
      <route.PageComponent />
    </HydrationBoundary>
  )
}

import { revalidatePath } from "next/cache"
import type { KanbanBackendHooks } from "@btst/stack/plugins/kanban/api"

const kanbanHooks: KanbanBackendHooks = {
  onBoardCreated: async (board) => {
    revalidatePath("/kanban")
  },
  onBoardUpdated: async (board) => {
    revalidatePath("/kanban")
  },
  onBoardDeleted: async (boardId) => {
    revalidatePath("/kanban")
  },
}

import { createKanbanTask } from "@btst/stack/plugins/kanban/api"

await createKanbanTask(myStack.adapter, {
  title: "Review Q1 financials",
  columnId: "col-abc",
  description: "See attached report",
  priority: "HIGH",         // "LOW" | "MEDIUM" | "HIGH" | "URGENT"
})

import { findOrCreateKanbanBoard, getKanbanColumnsByBoardId } from "@btst/stack/plugins/kanban/api"

const board = await findOrCreateKanbanBoard(
  myStack.adapter,
  "advisor-review-queue",           // slug (URL-safe, unique)
  "Advisor Review Queue",           // display name (used only on creation)
  ["New Intakes", "Under Review", "Escalated"], // column titles (used only on creation)
)

const columns = await getKanbanColumnsByBoardId(myStack.adapter, board.id)
const target = columns.find((c) => c.title === "New Intakes")

const board = await myStack.api.kanban.findOrCreateBoard(
  "advisor-review-queue",
  "Advisor Review Queue",
  ["New Intakes", "Under Review", "Escalated"],
)
const columns = await myStack.api.kanban.getColumnsByBoardId(board.id)
await myStack.api.kanban.createTask({
  title: "Sarah Chen — Ready for Review",
  columnId: columns[0]!.id,
  priority: "MEDIUM",
})

import { tool } from "ai"
import { z } from "zod"
import { createKanbanTask, findOrCreateKanbanBoard, getKanbanColumnsByBoardId } from "@btst/stack/plugins/kanban/api"

// Adapter captured after stack() returns — safe for tool execute closures
let adapter: any

const myTool = tool({
  description: "Create a review card",
  inputSchema: z.object({ title: z.string(), urgent: z.boolean() }),
  execute: async ({ title, urgent }) => {
    const board = await findOrCreateKanbanBoard(adapter, "review", "Review Queue", ["To Do", "Urgent"])
    const columns = await getKanbanColumnsByBoardId(adapter, board.id)
    const col = urgent ? columns.find((c) => c.title === "Urgent") : columns[0]
    await createKanbanTask(adapter, { title, columnId: col!.id, priority: urgent ? "URGENT" : "MEDIUM" })
    return { success: true }
  },
})

export const myStack = stack({ plugins: { aiChat: aiChatBackendPlugin({ tools: { myTool } }), kanban: kanbanBackendPlugin() } })
adapter = myStack.adapter

import { kanbanClientPlugin } from "@btst/stack/plugins/kanban/client"
// Import your ejected (and customized) page components
import { BoardsPageComponent } from "@/components/btst/kanban/client/components/pages/boards-page"
import { BoardPageComponent } from "@/components/btst/kanban/client/components/pages/board-page"

kanbanClientPlugin({
  apiBaseURL: "...",
  apiBasePath: "/api/data",
  queryClient,
  pageComponents: {
    boards: BoardsPageComponent,   // replaces the boards list page
    board: BoardPageComponent,     // replaces the board detail page
    // newBoard — omit to keep built-in default
  },
})