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

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
  onBeforeListBoards: async (filter, context) => {
    // Return false to deny access
    return isAuthenticated(context.headers)
  },
  onBeforeCreateBoard: async (data, context) => {
    return isAuthenticated(context.headers)
  },
  onBeforeUpdateBoard: async (boardId, data, context) => {
    return isBoardOwner(boardId, context.headers)
  },
  onBeforeDeleteBoard: async (boardId, context) => {
    return isBoardOwner(boardId, context.headers)
  },
  
  // Column hooks
  onBeforeCreateColumn: async (data, context) => {
    return canEditBoard(data.boardId, context.headers)
  },
  onBeforeUpdateColumn: async (columnId, data, context) => {
    return canEditColumn(columnId, context.headers)
  },
  onBeforeDeleteColumn: async (columnId, context) => {
    return canEditColumn(columnId, context.headers)
  },
  
  // Task hooks
  onBeforeCreateTask: async (data, context) => {
    return canEditColumn(data.columnId, context.headers)
  },
  onBeforeUpdateTask: async (taskId, data, context) => {
    return canEditTask(taskId, context.headers)
  },
  onBeforeDeleteTask: async (taskId, context) => {
    return canEditTask(taskId, context.headers)
  },
  
  // 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) => {
      return isAuthenticated(context.headers)
    },
    beforeLoadBoard: async (boardId, context) => {
      return canViewBoard(boardId, context.headers)
    },
  },
})

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 { 
  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")
  },
}