@btst/stack 1.11.0 → 2.0.0

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

@@ -0,0 +1,288 @@
+import { jsx } from 'react/jsx-runtime';
+import { defineClientPlugin, createApiClient } from '@btst/stack/plugins/client';
+import { createRoute } from '@btst/yar';
+import { createKanbanQueryKeys } from '../../../../../../plugins/kanban/query-keys.mjs';
+import { BoardsListPageComponent } from './components/pages/boards-list-page.mjs';
+import { NewBoardPageComponent } from './components/pages/new-board-page.mjs';
+import { BoardPageComponent } from './components/pages/board-page.mjs';
+
+function createBoardsLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/kanban",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadBoards) {
+          const canLoad = await hooks.beforeLoadBoards(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadBoards hook");
+          }
+        }
+        const client = createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = createKanbanQueryKeys(client, headers);
+        const listQuery = queries.boards.list({});
+        await queryClient.prefetchQuery(listQuery);
+        if (hooks?.afterLoadBoards) {
+          const boards = queryClient.getQueryData(
+            listQuery.queryKey
+          );
+          const canContinue = await hooks.afterLoadBoards(
+            boards || null,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadBoards hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(listQuery.queryKey);
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createBoardLoader(boardId, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: `/kanban/${boardId}`,
+        params: { boardId },
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadBoard) {
+          const canLoad = await hooks.beforeLoadBoard(boardId, context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadBoard hook");
+          }
+        }
+        const client = createApiClient({
+          baseURL: apiBaseURL,
+          basePath: apiBasePath
+        });
+        const queries = createKanbanQueryKeys(client, headers);
+        const boardQuery = queries.boards.detail(boardId);
+        await queryClient.prefetchQuery(boardQuery);
+        if (hooks?.afterLoadBoard) {
+          const board = queryClient.getQueryData(
+            boardQuery.queryKey
+          );
+          const canContinue = await hooks.afterLoadBoard(
+            board || null,
+            boardId,
+            context
+          );
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadBoard hook");
+          }
+        }
+        const queryState = queryClient.getQueryState(boardQuery.queryKey);
+        if (queryState?.error && hooks?.onLoadError) {
+          const error = queryState.error instanceof Error ? queryState.error : new Error(String(queryState.error));
+          await hooks.onLoadError(error, context);
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createNewBoardLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { apiBasePath, apiBaseURL, hooks, headers } = config;
+      const context = {
+        path: "/kanban/new",
+        isSSR: true,
+        apiBaseURL,
+        apiBasePath,
+        headers
+      };
+      try {
+        if (hooks?.beforeLoadNewBoard) {
+          const canLoad = await hooks.beforeLoadNewBoard(context);
+          if (!canLoad) {
+            throw new Error("Load prevented by beforeLoadNewBoard hook");
+          }
+        }
+        if (hooks?.afterLoadNewBoard) {
+          const canContinue = await hooks.afterLoadNewBoard(context);
+          if (canContinue === false) {
+            throw new Error("Load prevented by afterLoadNewBoard hook");
+          }
+        }
+      } catch (error) {
+        if (hooks?.onLoadError) {
+          await hooks.onLoadError(error, context);
+        }
+      }
+    }
+  };
+}
+function createBoardsListMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath, seo } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban`;
+    const title = "Kanban Boards";
+    const description = seo?.description || "Manage your projects with kanban boards";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "index, follow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.locale ? [{ property: "og:locale", content: seo.locale }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title },
+      { name: "twitter:description", content: description }
+    ];
+  };
+}
+function createBoardMeta(boardId, config) {
+  return () => {
+    const {
+      queryClient,
+      apiBaseURL,
+      apiBasePath,
+      siteBaseURL,
+      siteBasePath,
+      seo
+    } = config;
+    const queries = createKanbanQueryKeys(
+      createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      })
+    );
+    const board = queryClient.getQueryData(
+      queries.boards.detail(boardId).queryKey
+    );
+    if (!board) {
+      return [
+        { title: "Board Not Found" },
+        { name: "robots", content: "noindex" }
+      ];
+    }
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/${board.id}`;
+    const title = board.name;
+    const description = board.description || `Kanban board: ${board.name}`;
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: description },
+      { name: "robots", content: "index, follow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:url", content: fullUrl },
+      ...seo?.siteName ? [{ property: "og:site_name", content: seo.siteName }] : [],
+      ...seo?.defaultImage ? [{ property: "og:image", content: seo.defaultImage }] : [],
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+function createNewBoardMeta(config) {
+  return () => {
+    const { siteBaseURL, siteBasePath } = config;
+    const fullUrl = `${siteBaseURL}${siteBasePath}/kanban/new`;
+    const title = "Create New Board";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "description", content: "Create a new kanban board" },
+      { name: "robots", content: "noindex, nofollow" },
+      { property: "og:type", content: "website" },
+      { property: "og:title", content: title },
+      { property: "og:url", content: fullUrl },
+      { name: "twitter:card", content: "summary" },
+      { name: "twitter:title", content: title }
+    ];
+  };
+}
+const kanbanClientPlugin = (config) => defineClientPlugin({
+  name: "kanban",
+  routes: () => ({
+    boards: createRoute("/kanban", () => {
+      return {
+        PageComponent: () => /* @__PURE__ */ jsx(BoardsListPageComponent, {}),
+        loader: createBoardsLoader(config),
+        meta: createBoardsListMeta(config)
+      };
+    }),
+    newBoard: createRoute("/kanban/new", () => {
+      return {
+        PageComponent: NewBoardPageComponent,
+        loader: createNewBoardLoader(config),
+        meta: createNewBoardMeta(config)
+      };
+    }),
+    board: createRoute("/kanban/:boardId", ({ params: { boardId } }) => {
+      return {
+        PageComponent: () => /* @__PURE__ */ jsx(BoardPageComponent, { boardId }),
+        loader: createBoardLoader(boardId, config),
+        meta: createBoardMeta(boardId, config)
+      };
+    })
+  }),
+  sitemap: async () => {
+    const origin = `${config.siteBaseURL}${config.siteBasePath}`;
+    const indexUrl = `${origin}/kanban`;
+    const client = createApiClient({
+      baseURL: config.apiBaseURL,
+      basePath: config.apiBasePath
+    });
+    let boards = [];
+    try {
+      const res = await client("/boards", {
+        method: "GET",
+        query: { limit: 100 }
+      });
+      boards = res.data ?? [];
+    } catch {
+    }
+    const entries = [
+      {
+        url: indexUrl,
+        lastModified: /* @__PURE__ */ new Date(),
+        changeFrequency: "daily",
+        priority: 0.7
+      },
+      ...boards.map((b) => ({
+        url: `${origin}/kanban/${b.id}`,
+        lastModified: b.updatedAt ? new Date(b.updatedAt) : void 0,
+        changeFrequency: "weekly",
+        priority: 0.6
+      }))
+    ];
+    return entries;
+  }
+});
+
+export { kanbanClientPlugin };

package/dist/packages/stack/src/plugins/kanban/db.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const kanbanSchema = db.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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ 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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ 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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+exports.kanbanSchema = kanbanSchema;

package/dist/packages/stack/src/plugins/kanban/db.mjs

@@ -0,0 +1,123 @@
+import { createDbPlugin } from '@btst/db';
+
+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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ 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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ 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: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+export { kanbanSchema };

package/dist/packages/stack/src/plugins/kanban/schemas.cjs

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