Kanban Plugin

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

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

export { handler, dbSchema }

import { createClientStack } from "@btst/stack/client"
import { kanbanClientPlugin } from "@btst/stack/plugins/kanban/client"
import type { StackIdentity } from "@btst/stack/context"
import { QueryClient } from "@tanstack/react-query"

function getBaseURL(serverOrigin?: string) {
  if (typeof window !== "undefined") return window.location.origin
  return (
    serverOrigin ||
    process.env.BTST_SITE_URL ||
    process.env.BASE_URL ||
    "http://localhost:3000"
  )
}

export const getStackClient = (
  queryClient: QueryClient,
  request?: { headers?: Headers; identity?: StackIdentity; origin?: string },
) => {
  const baseURL = getBaseURL(request?.origin)
  return createClientStack({
    api: {
      baseURL,
      basePath: "/api/data",
      headers: request?.headers,
    },
    site: { baseURL, basePath: "/pages" },
    queryClient,
    plugins: {
      kanban: kanbanClientPlugin({
        // Use the same validated identity that hydrates StackProvider so
        // protected SSR and browser query keys match.
        identityPartition: request?.identity,
        // 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

import { defineAuthorization } from "@btst/stack/authorization"
import { kanbanPermissions } from "@btst/stack/plugins/kanban/permissions"
import { z } from "zod"

const identitySchema = z.object({
  id: z.string(),
  role: z.enum(["user", "admin"]),
  organizationIds: z.array(z.string()).default([]),
})

type Identity = z.output<typeof identitySchema>
type BoardFacts = { ownerId?: string; organizationId?: string }

function canManageBoard(identity: Identity | null, facts: BoardFacts) {
  return identity !== null && (
    identity.role === "admin" ||
    identity.id === facts.ownerId ||
    (facts.organizationId !== undefined &&
      identity.organizationIds.includes(facts.organizationId))
  )
}

export const authorization = defineAuthorization({
  identity: identitySchema,
  permissions: [kanbanPermissions] as const,
  rules: ({ kanban }) => [
    // A collection check is deliberately coarse. It does not filter rows.
    kanban.board.read.when(({ identity, facts }) =>
      facts.scope === "collection"
        ? identity?.role === "admin"
        : canManageBoard(identity, facts),
    ),
    kanban.board.create.when(({ identity }) => identity !== null),
    kanban.board.update.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.board.delete.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.column.create.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.column.update.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.column.delete.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.column.reorder.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.task.create.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.task.update.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.task.move.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.task.delete.when(({ identity, facts }) => canManageBoard(identity, facts)),
    kanban.task.reorder.when(({ identity, facts }) => canManageBoard(identity, facts)),
  ],
})

import "server-only"
import { createServerAuth } from "@btst/stack/authorization/server"
import { authorization } from "./authorization"

export const serverAuth = createServerAuth({
  authorization,
  getIdentityFromHeaders: async ({ headers }) => {
    const session = await getSession(headers)
    return session?.user ?? null
  },
})

import { headers } from "next/headers"
import { getServerClientOriginsFromHeaders } from "@/lib/stack-client.server"

const requestHeaders = await headers()
const initialIdentity = await serverAuth.getIdentityFromHeaders({
  headers: requestHeaders,
})
const clientOrigins = getServerClientOriginsFromHeaders(requestHeaders)

<PagesClientLayout
  clientOrigins={clientOrigins}
  initialIdentity={initialIdentity}
>
  {children}
</PagesClientLayout>

kanbanClientPlugin({
  // ... other config
  pageComponents: {
    // Replace the boards list page
    boards: MyCustomBoardsPage,
    // Replace the board detail page — receives the route context as props
    board: ({ params }) => <MyCustomBoardPage boardId={params.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
    },
  }
}}

<StackProvider
  stack={clientStack}
  i18n={{
    translate: (key, defaultValue, params) =>
      i18next.t(key, { defaultValue, ...params }),
  }}
/>

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

const hooks: KanbanBackendHooks = {
  // Add canonical lifecycle callbacks here.
}

const app = createBackendStack({
  auth: serverAuth,
  plugins: {
    kanban: kanbanBackendPlugin({ hooks })
  },
  // ...
})

await app.forRequest(request).operations.kanban.updateTask({
  id: taskId,
  data: { title: "Ready for review" },
})

await app.trusted.kanban.moveTask({
  taskId,
  targetColumnId,
  targetOrder: 0,
})

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

const kanbanHooks: KanbanBackendHooks = {
  onBeforeUpdateTask: async (taskId, data, context) => {
    if (context.facts.isArchived) {
      throw new Error("Archived tasks are immutable")
    }
    await auditDomainAttempt({
      taskId,
      actorId: context.identity?.id,
      input: context.input,
    })
  },
  onAfterCreateTask: async (task, context) => {
    await sendTaskNotification(task, context.facts.boardId)
  },
}

kanban: kanbanClientPlugin({
  // Optional SEO configuration
  seo: {
    siteName: "My Kanban App",
    description: "Project management",
  },
  // Optional hooks
  hooks: {
    beforeLoadBoards: async (context) => {
      performance.mark("kanban-boards-load-start")
    },
    beforeLoadBoard: async (boardId, context) => {
      analytics.track("kanban-board-load", { boardId })
    },
  },
})

overrides={{
  kanban: {
    // Required: User resolution for assignees
    resolveUser: (userId) => findUserById(userId),
    searchUsers: (query) => searchAllUsers(query),
    
    // Optional lifecycle hooks
    onRouteRender: async (routeName, context) => {
      console.log("Rendering route:", routeName)
    },
  }
}}

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

overrides={{
  kanban: {
    // ...
    taskDetailBottomSlot: (task) => (
      <CommentThread
        resourceId={task.id}
        resourceType="kanban-task"
      />
    ),
  }
}}

import { 
  useBoards,
  useBoard,
  useBoardForm,
  useBoardMutations,
  useColumnForm,
  useColumnMutations,
  useTaskForm,
  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()

// Resource form lifecycles choose create/update, await cache invalidation,
// and expose normalized server validation issues through fieldErrors.
const boardForm = useBoardForm({
  action: board ? "edit" : "create",
  record: board ?? null,
  toCreateVars: (values) => values,
  toUpdateVars: (values) => ({ id: board.id, data: values }),
})

const columnForm = useColumnForm({
  action: column ? "edit" : "create",
  record: column ?? null,
  toCreateVars: (values) => ({ ...values, boardId }),
  toUpdateVars: (values) => ({ id: column.id, data: values }),
})

const taskForm = useTaskForm({
  action: task ? "edit" : "create",
  record: task ?? null,
  toCreateVars: (values) => values,
  toUpdateVars: (values) => ({ id: task.id, data: values }),
})

// 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 { 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.raw.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.raw.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 = {
  onAfterCreateBoard: async (board) => {
    revalidatePath("/kanban")
  },
  onAfterUpdateBoard: async (board) => {
    revalidatePath("/kanban")
  },
  onAfterDeleteBoard: async (boardId) => {
    revalidatePath("/kanban")
  },
}

const board = await app.trusted.kanban.createBoard({ name: "Review Queue" })
await app.trusted.kanban.createTask({ title: "Review", columnId })

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({
  pageComponents: {
    boards: BoardsPageComponent, // replaces the boards list page
    // Param routes receive the route context ({ params }) as props
    board: ({ params }) => <BoardPageComponent boardId={params.boardId} />,
    // newBoard — omit to keep built-in default
  },
})