@btst/stack 1.11.0 → 2.0.0

package/src/plugins/kanban/client.css

@@ -0,0 +1,68 @@
+/* Kanban Plugin Client Styles */
+
+/* Kanban board container */
+[data-slot="kanban-board"] {
+	min-height: 400px;
+}
+
+/* Column styling */
+[data-slot="kanban-column"] {
+	min-width: 0;
+}
+
+/* Item dragging state */
+[data-slot="kanban-item"][data-dragging] {
+	opacity: 0.5;
+}
+
+/* Column dragging state */
+[data-slot="kanban-column"][data-dragging] {
+	opacity: 0.5;
+}
+
+/* Handle cursor */
+[data-slot="kanban-column-handle"],
+[data-slot="kanban-item-handle"] {
+	cursor: grab;
+}
+
+[data-slot="kanban-column-handle"]:active,
+[data-slot="kanban-item-handle"]:active {
+	cursor: grabbing;
+}
+
+/* Task card hover effect */
+.kanban-task-card {
+	transition: box-shadow 0.2s ease;
+}
+
+.kanban-task-card:hover {
+	box-shadow:
+		0 4px 6px -1px rgba(0, 0, 0, 0.1),
+		0 2px 4px -1px rgba(0, 0, 0, 0.06);
+}
+
+/* Priority badge colors */
+.kanban-priority-urgent {
+	background-color: var(--destructive) !important;
+	color: var(--destructive-foreground) !important;
+	border-color: var(--destructive) !important;
+}
+
+.kanban-priority-high {
+	background-color: rgb(249, 115, 22) !important;
+	color: white !important;
+	border-color: rgb(249, 115, 22) !important;
+}
+
+.kanban-priority-medium {
+	background-color: var(--primary) !important;
+	color: var(--primary-foreground) !important;
+	border-color: var(--primary) !important;
+}
+
+.kanban-priority-low {
+	background-color: var(--secondary) !important;
+	color: var(--secondary-foreground) !important;
+	border-color: var(--secondary) !important;
+}

package/src/plugins/kanban/db.ts

@@ -0,0 +1,125 @@
+import { createDbPlugin } from "@btst/db";
+
+/**
+ * Kanban plugin schema
+ * Defines the database tables for kanban boards, columns, and tasks
+ */
+export const kanbanSchema = createDbPlugin("kanban", {
+	board: {
+		modelName: "kanbanBoard",
+		fields: {
+			name: {
+				type: "string",
+				required: true,
+			},
+			slug: {
+				type: "string",
+				required: true,
+				unique: true,
+			},
+			description: {
+				type: "string",
+				required: false,
+			},
+			ownerId: {
+				type: "string",
+				required: false,
+			},
+			organizationId: {
+				type: "string",
+				required: false,
+			},
+			createdAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+			updatedAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+	column: {
+		modelName: "kanbanColumn",
+		fields: {
+			title: {
+				type: "string",
+				required: true,
+			},
+			order: {
+				type: "number",
+				required: true,
+				defaultValue: 0,
+			},
+			boardId: {
+				type: "string",
+				required: true,
+				references: {
+					model: "kanbanBoard",
+					field: "id",
+					onDelete: "cascade",
+				},
+			},
+			createdAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+			updatedAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+	task: {
+		modelName: "kanbanTask",
+		fields: {
+			title: {
+				type: "string",
+				required: true,
+			},
+			description: {
+				type: "string",
+				required: false,
+			},
+			priority: {
+				type: "string",
+				required: true,
+				defaultValue: "MEDIUM",
+			},
+			order: {
+				type: "number",
+				required: true,
+				defaultValue: 0,
+			},
+			columnId: {
+				type: "string",
+				required: true,
+				references: {
+					model: "kanbanColumn",
+					field: "id",
+					onDelete: "cascade",
+				},
+			},
+			assigneeId: {
+				type: "string",
+				required: false,
+			},
+			completedAt: {
+				type: "date",
+				required: false,
+			},
+			isArchived: {
+				type: "boolean",
+				defaultValue: false,
+			},
+			createdAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+			updatedAt: {
+				type: "date",
+				defaultValue: () => new Date(),
+			},
+		},
+	},
+});

package/src/plugins/kanban/query-keys.ts

@@ -0,0 +1,154 @@
+import {
+	mergeQueryKeys,
+	createQueryKeys,
+} from "@lukemorales/query-key-factory";
+import type { KanbanApiRouter } from "./api";
+import { createApiClient } from "@btst/stack/plugins/client";
+import type { SerializedBoardWithColumns } from "./types";
+
+interface BoardsListParams {
+	slug?: string;
+	ownerId?: string;
+	organizationId?: string;
+	limit?: number;
+	offset?: number;
+}
+
+// Type guard for better-call error responses
+function isErrorResponse(
+	response: unknown,
+): response is { error: unknown; data?: never } {
+	return (
+		typeof response === "object" &&
+		response !== null &&
+		"error" in response &&
+		response.error !== null &&
+		response.error !== undefined
+	);
+}
+
+// Helper to convert error to a proper Error object with meaningful message
+function toError(error: unknown): Error {
+	if (error instanceof Error) {
+		return error;
+	}
+
+	if (typeof error === "object" && error !== null) {
+		const errorObj = error as Record<string, unknown>;
+		const message =
+			(typeof errorObj.message === "string" ? errorObj.message : null) ||
+			(typeof errorObj.error === "string" ? errorObj.error : null) ||
+			JSON.stringify(error);
+
+		const err = new Error(message);
+		Object.assign(err, error);
+		return err;
+	}
+
+	return new Error(String(error));
+}
+
+export function createKanbanQueryKeys(
+	client: ReturnType<typeof createApiClient<KanbanApiRouter>>,
+	headers?: HeadersInit,
+) {
+	const boards = createBoardsQueries(client, headers);
+
+	return mergeQueryKeys(boards);
+}
+
+function createBoardsQueries(
+	client: ReturnType<typeof createApiClient<KanbanApiRouter>>,
+	headers?: HeadersInit,
+) {
+	return createQueryKeys("boards", {
+		list: (params?: BoardsListParams) => ({
+			queryKey: [
+				{
+					slug: params?.slug,
+					ownerId: params?.ownerId,
+					organizationId: params?.organizationId,
+					limit: params?.limit ?? 50,
+					offset: params?.offset ?? 0,
+				},
+			],
+			queryFn: async () => {
+				try {
+					const response = await client("/boards", {
+						method: "GET",
+						query: {
+							slug: params?.slug,
+							ownerId: params?.ownerId,
+							organizationId: params?.organizationId,
+							limit: params?.limit ?? 50,
+							offset: params?.offset ?? 0,
+						},
+						headers,
+					});
+
+					if (isErrorResponse(response)) {
+						const errorResponse = response as { error: unknown };
+						throw toError(errorResponse.error);
+					}
+
+					return ((response as { data?: unknown }).data ??
+						[]) as unknown as SerializedBoardWithColumns[];
+				} catch (error) {
+					throw error;
+				}
+			},
+		}),
+
+		detail: (boardId: string) => ({
+			queryKey: [boardId],
+			queryFn: async () => {
+				if (!boardId) return null;
+
+				try {
+					const response = await client("/boards/:id", {
+						method: "GET",
+						params: { id: boardId },
+						headers,
+					});
+
+					if (isErrorResponse(response)) {
+						const errorResponse = response as { error: unknown };
+						throw toError(errorResponse.error);
+					}
+
+					return ((response as { data?: unknown }).data ??
+						null) as unknown as SerializedBoardWithColumns | null;
+				} catch (error) {
+					throw error;
+				}
+			},
+		}),
+
+		// Get board by slug
+		bySlug: (slug: string) => ({
+			queryKey: ["slug", slug],
+			queryFn: async () => {
+				if (!slug) return null;
+
+				try {
+					const response = await client("/boards", {
+						method: "GET",
+						query: { slug, limit: 1 },
+						headers,
+					});
+
+					if (isErrorResponse(response)) {
+						const errorResponse = response as { error: unknown };
+						throw toError(errorResponse.error);
+					}
+
+					const boards = ((response as { data?: unknown }).data ??
+						[]) as unknown as SerializedBoardWithColumns[];
+					return boards[0] ?? null;
+				} catch (error) {
+					throw error;
+				}
+			},
+		}),
+	});
+}

package/src/plugins/kanban/schemas.ts

@@ -0,0 +1,143 @@
+import { z } from "zod";
+
+/**
+ * Priority enum schema
+ */
+export const PrioritySchema = z.enum(["LOW", "MEDIUM", "HIGH", "URGENT"]);
+
+// ============ Board Schemas ============
+
+const boardDateFields = {
+	createdAt: z.coerce.date().optional(),
+	updatedAt: z.coerce.date().optional(),
+};
+
+const boardCoreFields = {
+	name: z.string().min(1, "Name is required"),
+	slug: z.string().min(1, "Slug is required"),
+	description: z.string().optional(),
+	ownerId: z.string().optional(),
+	organizationId: z.string().optional(),
+};
+
+export const BoardDomainSchema = z.object({
+	id: z.string().optional(),
+	...boardCoreFields,
+	...boardDateFields,
+});
+
+export const createBoardSchema = BoardDomainSchema.extend({
+	slug: BoardDomainSchema.shape.slug.optional(),
+}).omit({ id: true });
+
+export const updateBoardSchema = BoardDomainSchema.extend({
+	id: z.string(),
+})
+	.partial()
+	.required({ id: true });
+
+// ============ Column Schemas ============
+
+const columnDateFields = {
+	createdAt: z.coerce.date().optional(),
+	updatedAt: z.coerce.date().optional(),
+};
+
+const columnCoreFields = {
+	title: z.string().min(1, "Title is required"),
+	order: z.number().int().min(0).optional().default(0),
+	boardId: z.string().min(1, "Board ID is required"),
+};
+
+export const ColumnDomainSchema = z.object({
+	id: z.string().optional(),
+	...columnCoreFields,
+	...columnDateFields,
+});
+
+export const createColumnSchema = ColumnDomainSchema.omit({ id: true });
+
+export const updateColumnSchema = ColumnDomainSchema.extend({
+	id: z.string(),
+})
+	.partial()
+	.required({ id: true });
+
+// ============ Task Schemas ============
+
+const taskDateFields = {
+	completedAt: z.coerce.date().optional(),
+	createdAt: z.coerce.date().optional(),
+	updatedAt: z.coerce.date().optional(),
+};
+
+const taskCoreFields = {
+	title: z.string().min(1, "Title is required"),
+	description: z.string().optional(),
+	priority: PrioritySchema.optional().default("MEDIUM"),
+	order: z.number().int().min(0).optional().default(0),
+	columnId: z.string().min(1, "Column ID is required"),
+	assigneeId: z.string().optional().nullable(),
+	isArchived: z.boolean().optional().default(false),
+};
+
+export const TaskDomainSchema = z.object({
+	id: z.string().optional(),
+	...taskCoreFields,
+	...taskDateFields,
+});
+
+export const createTaskSchema = TaskDomainSchema.omit({ id: true });
+
+export const updateTaskSchema = TaskDomainSchema.extend({
+	id: z.string(),
+})
+	.partial()
+	.required({ id: true });
+
+// ============ Query Schemas ============
+
+export const BoardListQuerySchema = z.object({
+	slug: z.string().optional(),
+	ownerId: z.string().optional(),
+	organizationId: z.string().optional(),
+	offset: z.coerce.number().int().min(0).optional(),
+	limit: z.coerce.number().int().min(1).max(100).optional(),
+});
+
+export const ColumnListQuerySchema = z.object({
+	boardId: z.string().optional(),
+});
+
+export const TaskListQuerySchema = z.object({
+	columnId: z.string().optional(),
+	assigneeId: z.string().optional(),
+	priority: PrioritySchema.optional(),
+	isArchived: z
+		.string()
+		.optional()
+		.transform((val) => {
+			if (val === undefined) return undefined;
+			if (val === "true") return true;
+			if (val === "false") return false;
+			return undefined;
+		}),
+});
+
+// ============ Batch Update Schemas ============
+
+export const reorderColumnsSchema = z.object({
+	boardId: z.string().min(1, "Board ID is required"),
+	columnIds: z.array(z.string()).min(1, "Column IDs are required"),
+});
+
+export const reorderTasksSchema = z.object({
+	columnId: z.string().min(1, "Column ID is required"),
+	taskIds: z.array(z.string()).min(1, "Task IDs are required"),
+});
+
+export const moveTaskSchema = z.object({
+	taskId: z.string().min(1, "Task ID is required"),
+	targetColumnId: z.string().min(1, "Target column ID is required"),
+	targetOrder: z.number().int().min(0),
+});

package/src/plugins/kanban/style.css

@@ -0,0 +1,7 @@
+/* Kanban Plugin Full Styles */
+/* This file includes Tailwind directives for consumers who need the full stylesheet */
+
+@import "./client.css";
+
+/* Import minimal-tiptap styles for rich text editor in task forms */
+@import "@workspace/ui/components/minimal-tiptap/styles.css";

package/src/plugins/kanban/types.ts

@@ -0,0 +1,106 @@
+/**
+ * Priority levels for tasks
+ */
+export type Priority = "LOW" | "MEDIUM" | "HIGH" | "URGENT";
+
+/**
+ * Kanban Board
+ */
+export type Board = {
+	id: string;
+	name: string;
+	slug: string;
+	description?: string;
+	ownerId?: string;
+	organizationId?: string;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+/**
+ * Kanban Column
+ */
+export type Column = {
+	id: string;
+	title: string;
+	order: number;
+	boardId: string;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+/**
+ * Kanban Task
+ */
+export type Task = {
+	id: string;
+	title: string;
+	description?: string;
+	priority: Priority;
+	order: number;
+	columnId: string;
+	assigneeId?: string;
+	completedAt?: Date;
+	isArchived: boolean;
+	createdAt: Date;
+	updatedAt: Date;
+};
+
+/**
+ * Column with its tasks
+ */
+export type ColumnWithTasks = Column & {
+	tasks: Task[];
+};
+
+/**
+ * Board with columns and tasks
+ */
+export type BoardWithColumns = Board & {
+	columns: ColumnWithTasks[];
+};
+
+/**
+ * Board with joined column relationships from the database
+ * Note: The adapter returns joined data under the schema key name ("column"),
+ * not the model name ("kanbanColumn")
+ */
+export type BoardWithKanbanColumn = Board & {
+	column?: Column[];
+};
+
+/**
+ * Column with joined task relationships from the database
+ * Note: The adapter returns joined data under the schema key name ("task"),
+ * not the model name ("kanbanTask")
+ */
+export type ColumnWithKanbanTask = Column & {
+	task?: Task[];
+};
+
+// Serialized types for API responses (dates as strings)
+
+export interface SerializedTask
+	extends Omit<Task, "createdAt" | "updatedAt" | "completedAt"> {
+	completedAt?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface SerializedColumn
+	extends Omit<Column, "createdAt" | "updatedAt"> {
+	createdAt: string;
+	updatedAt: string;
+	tasks?: SerializedTask[];
+}
+
+export interface SerializedBoard
+	extends Omit<Board, "createdAt" | "updatedAt"> {
+	createdAt: string;
+	updatedAt: string;
+	columns?: SerializedColumn[];
+}
+
+export interface SerializedBoardWithColumns extends SerializedBoard {
+	columns: SerializedColumn[];
+}

package/src/plugins/kanban/utils.ts

@@ -0,0 +1,107 @@
+/**
+ * Slugify a string for use in URLs
+ * @param text - The text to slugify
+ * @returns A URL-safe slug
+ */
+export function slugify(text: string): string {
+	return text
+		.toLowerCase()
+		.trim()
+		.replace(/[^\w\s-]/g, "") // Remove non-word characters
+		.replace(/[\s_-]+/g, "-") // Replace spaces and underscores with hyphens
+		.replace(/^-+|-+$/g, ""); // Remove leading/trailing hyphens
+}
+
+/**
+ * Generate a unique slug by appending a random suffix
+ * @param baseSlug - The base slug
+ * @returns A unique slug with random suffix
+ */
+export function generateUniqueSlug(baseSlug: string): string {
+	const randomSuffix = Math.random().toString(36).substring(2, 8);
+	return `${baseSlug}-${randomSuffix}`;
+}
+
+/**
+ * Calculate the next order value for a list of items
+ * @param items - Array of items with order property
+ * @returns The next order value
+ */
+export function getNextOrder(items: { order: number }[]): number {
+	if (items.length === 0) return 0;
+	return Math.max(...items.map((item) => item.order)) + 1;
+}
+
+/**
+ * Reorder items by swapping positions
+ * @param items - Array of items to reorder
+ * @param fromIndex - Original index
+ * @param toIndex - Target index
+ * @returns Reordered array with updated order values
+ */
+export function reorderItems<T extends { id: string; order: number }>(
+	items: T[],
+	fromIndex: number,
+	toIndex: number,
+): T[] {
+	const result = [...items];
+	const [removed] = result.splice(fromIndex, 1);
+	if (removed) {
+		result.splice(toIndex, 0, removed);
+	}
+	return result.map((item, index) => ({ ...item, order: index }));
+}
+
+/**
+ * Get priority display configuration
+ * @param priority - Priority level
+ * @returns Display configuration for the priority
+ */
+export function getPriorityConfig(priority: string): {
+	label: string;
+	variant: "default" | "secondary" | "destructive" | "outline";
+	className: string;
+} {
+	switch (priority) {
+		case "URGENT":
+			return {
+				label: "Urgent",
+				variant: "destructive",
+				className: "kanban-priority-urgent",
+			};
+		case "HIGH":
+			return {
+				label: "High",
+				variant: "outline",
+				className: "kanban-priority-high",
+			};
+		case "MEDIUM":
+			return {
+				label: "Medium",
+				variant: "default",
+				className: "kanban-priority-medium",
+			};
+		case "LOW":
+			return {
+				label: "Low",
+				variant: "secondary",
+				className: "kanban-priority-low",
+			};
+		default:
+			return {
+				label: "Medium",
+				variant: "default",
+				className: "kanban-priority-medium",
+			};
+	}
+}
+
+/**
+ * Priority options for forms
+ */
+export const PRIORITY_OPTIONS = [
+	{ value: "LOW", label: "Low" },
+	{ value: "MEDIUM", label: "Medium" },
+	{ value: "HIGH", label: "High" },
+	{ value: "URGENT", label: "Urgent" },
+] as const;