@btst/stack 2.12.2 → 3.0.0-rc.1

package/dist/plugins/kanban/query-keys.d.ts

@@ -1,11 +1,12 @@
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { K as KanbanApiRouter, j as BoardsListDiscriminator } from '../../shared/stack.D4Cea8II.js';
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { S as SerializedBoardWithColumns } from '../../shared/stack.DJaKVY7v.js';
+import { j as BoardsListDiscriminator, K as KanbanApiRouter } from '../../shared/stack.CMbX8Q5C.js';
+import { P as Priority, S as SerializedBoardWithColumns, c as SerializedBoard, a as SerializedColumn, b as SerializedTask } from '../../shared/stack.DJaKVY7v.js';
 import '@btst/stack/plugins/api';
 import '@btst/db';
 import 'zod';
 import 'better-call';
+import '@tanstack/react-query';
 
 interface BoardsListParams {
     slug?: string;
@@ -14,35 +15,369 @@ interface BoardsListParams {
     limit?: number;
     offset?: number;
 }
-declare function createKanbanQueryKeys(client: ReturnType<typeof createApiClient<KanbanApiRouter>>, headers?: HeadersInit): {
+interface CreateBoardInput {
+    name: string;
+    description?: string;
+    ownerId?: string;
+    organizationId?: string;
+}
+interface UpdateBoardInput {
+    id: string;
+    data: Partial<{
+        name: string;
+        description: string;
+        slug: string;
+    }>;
+}
+interface CreateColumnInput {
+    title: string;
+    boardId: string;
+    order?: number;
+}
+interface UpdateColumnInput {
+    id: string;
+    data: Partial<{
+        title: string;
+        order: number;
+    }>;
+}
+interface ReorderColumnsInput {
+    boardId: string;
+    columnIds: string[];
+}
+interface CreateTaskInput {
+    title: string;
+    description?: string;
+    priority?: Priority;
+    columnId: string;
+    assigneeId?: string;
+    order?: number;
+}
+interface UpdateTaskInput {
+    id: string;
+    data: Partial<{
+        title: string;
+        description: string;
+        priority: Priority;
+        columnId: string;
+        assigneeId: string | null;
+        order: number;
+        isArchived: boolean;
+    }>;
+}
+interface MoveTaskInput {
+    taskId: string;
+    targetColumnId: string;
+    targetOrder: number;
+}
+interface ReorderTasksInput {
+    columnId: string;
+    taskIds: string[];
+}
+/**
+ * Kanban resource declaration — the single source of truth for query keys,
+ * HTTP mappings, cache invalidation, and generated client hooks.
+ *
+ * Board key shapes intentionally match `KANBAN_QUERY_KEYS` so SSR loaders and
+ * `prefetchForRoute` hydrate the same cache entries as client hooks.
+ */
+declare const kanbanResources: {
     boards: {
-        _def: readonly ["boards"];
-    } & {
-        list: ((params?: BoardsListParams | undefined) => Omit<{
-            queryKey: readonly ["boards", "list", BoardsListDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedBoardWithColumns[], readonly ["boards", "list", BoardsListDiscriminator]>;
-        } & {
-            _def: readonly ["boards", "list"];
-        }, "_def">) & {
-            _def: readonly ["boards", "list"];
+        queries: {
+            list: {
+                path: string;
+                query: (params?: BoardsListParams) => {
+                    slug: string | undefined;
+                    ownerId: string | undefined;
+                    organizationId: string | undefined;
+                    limit: number;
+                    offset: number;
+                };
+                key: (params?: BoardsListParams) => BoardsListDiscriminator[];
+                select: (data: any, _params?: BoardsListParams) => SerializedBoardWithColumns[];
+            };
+            detail: {
+                path: string;
+                params: (boardId: string) => {
+                    id: string;
+                };
+                key: (boardId: string) => string[];
+                select: (data: any, _boardId: string) => SerializedBoardWithColumns | null;
+                skip: (boardId: string) => boolean;
+            };
+            bySlug: {
+                path: string;
+                query: (slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedBoardWithColumns | null;
+                skip: (slug: string) => boolean;
+            };
         };
-        detail: ((boardId: string) => Omit<{
-            queryKey: readonly ["boards", "detail", string];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedBoardWithColumns | null, readonly ["boards", "detail", string]>;
-        } & {
-            _def: readonly ["boards", "detail"];
-        }, "_def">) & {
-            _def: readonly ["boards", "detail"];
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (data: CreateBoardInput) => {
+                    body: CreateBoardInput;
+                };
+                select: (data: any) => SerializedBoardWithColumns;
+                setData: {
+                    query: string;
+                    args: (board: SerializedBoardWithColumns) => string[];
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: UpdateBoardInput) => {
+                    params: {
+                        id: string;
+                    };
+                    body: Partial<{
+                        name: string;
+                        description: string;
+                        slug: string;
+                    }>;
+                };
+                select: (data: any) => SerializedBoard;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
         };
-        bySlug: ((slug: string) => Omit<{
-            queryKey: readonly ["boards", "bySlug", string, string];
-            queryFn: _tanstack_react_query.QueryFunction<SerializedBoardWithColumns | null, readonly ["boards", "bySlug", string, string]>;
-        } & {
-            _def: readonly ["boards", "bySlug"];
-        }, "_def">) & {
-            _def: readonly ["boards", "bySlug"];
+    };
+    columns: {
+        queries: {};
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (data: CreateColumnInput) => {
+                    body: CreateColumnInput;
+                };
+                select: (data: any) => SerializedColumn;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: UpdateColumnInput) => {
+                    params: {
+                        id: string;
+                    };
+                    body: Partial<{
+                        title: string;
+                        order: number;
+                    }>;
+                };
+                select: (data: any) => SerializedColumn;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+            reorder: {
+                path: string;
+                method: "POST";
+                input: (data: ReorderColumnsInput) => {
+                    body: ReorderColumnsInput;
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+    tasks: {
+        queries: {};
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (data: CreateTaskInput) => {
+                    body: CreateTaskInput;
+                };
+                select: (data: any) => SerializedTask;
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: UpdateTaskInput) => {
+                    params: {
+                        id: string;
+                    };
+                    body: Partial<{
+                        title: string;
+                        description: string;
+                        priority: Priority;
+                        columnId: string;
+                        assigneeId: string | null;
+                        order: number;
+                        isArchived: boolean;
+                    }>;
+                };
+                select: (data: any) => SerializedTask;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+            move: {
+                path: string;
+                method: "POST";
+                input: (data: MoveTaskInput) => {
+                    body: MoveTaskInput;
+                };
+                select: (data: any) => SerializedTask;
+                invalidates: string[];
+                refresh: false;
+            };
+            reorder: {
+                path: string;
+                method: "POST";
+                input: (data: ReorderTasksInput) => {
+                    body: ReorderTasksInput;
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
         };
     };
 };
+declare function createKanbanQueryKeys(client: ReturnType<typeof createApiClient<KanbanApiRouter>>, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
+    boards: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: BoardsListParams) => {
+                    slug: string | undefined;
+                    ownerId: string | undefined;
+                    organizationId: string | undefined;
+                    limit: number;
+                    offset: number;
+                };
+                key: (params?: BoardsListParams) => BoardsListDiscriminator[];
+                select: (data: any, _params?: BoardsListParams) => SerializedBoardWithColumns[];
+            };
+            detail: {
+                path: string;
+                params: (boardId: string) => {
+                    id: string;
+                };
+                key: (boardId: string) => string[];
+                select: (data: any, _boardId: string) => SerializedBoardWithColumns | null;
+                skip: (boardId: string) => boolean;
+            };
+            bySlug: {
+                path: string;
+                query: (slug: string) => {
+                    slug: string;
+                    limit: number;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedBoardWithColumns | null;
+                skip: (slug: string) => boolean;
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (data: CreateBoardInput) => {
+                    body: CreateBoardInput;
+                };
+                select: (data: any) => SerializedBoardWithColumns;
+                setData: {
+                    query: string;
+                    args: (board: SerializedBoardWithColumns) => string[];
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: ({ id, data }: UpdateBoardInput) => {
+                    params: {
+                        id: string;
+                    };
+                    body: Partial<{
+                        name: string;
+                        description: string;
+                        slug: string;
+                    }>;
+                };
+                select: (data: any) => SerializedBoard;
+                invalidates: string[];
+                refresh: false;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+                refresh: false;
+            };
+        };
+    };
+}>;
 
-export { createKanbanQueryKeys };
+export { createKanbanQueryKeys, kanbanResources };
+export type { BoardsListParams, CreateBoardInput, CreateColumnInput, CreateTaskInput, MoveTaskInput, ReorderColumnsInput, ReorderTasksInput, UpdateBoardInput, UpdateColumnInput, UpdateTaskInput };

package/dist/plugins/kanban/query-keys.mjs

@@ -1,97 +1,164 @@
-import { mergeQueryKeys, createQueryKeys } from '@lukemorales/query-key-factory';
+import { createResourceQueryKeys } from '@btst/stack/plugins/client';
 import { boardsListDiscriminator } from '../../packages/stack/src/plugins/kanban/api/query-key-defs.mjs';
 
-function isErrorResponse(response) {
-  return typeof response === "object" && response !== null && "error" in response && response.error !== null && response.error !== void 0;
-}
-function toError(error) {
-  if (error instanceof Error) {
-    return error;
-  }
-  if (typeof error === "object" && error !== null) {
-    const errorObj = error;
-    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));
-}
-function createKanbanQueryKeys(client, headers) {
-  const boards = createBoardsQueries(client, headers);
-  return mergeQueryKeys(boards);
-}
-function createBoardsQueries(client, headers) {
-  return createQueryKeys("boards", {
-    list: (params) => ({
-      queryKey: [boardsListDiscriminator(params)],
-      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;
-            throw toError(errorResponse.error);
-          }
-          const envelope = response.data;
-          return envelope?.items ?? [];
-        } catch (error) {
-          throw error;
-        }
+const kanbanResources = {
+  boards: {
+    queries: {
+      list: {
+        path: "/boards",
+        query: (params) => ({
+          slug: params?.slug,
+          ownerId: params?.ownerId,
+          organizationId: params?.organizationId,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        }),
+        key: (params) => [boardsListDiscriminator(params)],
+        select: (data, _params) => data?.items ?? []
+      },
+      detail: {
+        path: "/boards/:id",
+        params: (boardId) => ({ id: boardId }),
+        key: (boardId) => [boardId],
+        select: (data, _boardId) => data ?? null,
+        skip: (boardId) => !boardId
+      },
+      bySlug: {
+        path: "/boards",
+        query: (slug) => ({ slug, limit: 1 }),
+        key: (slug) => ["slug", slug],
+        select: (data, _slug) => data?.items?.[0] ?? null,
+        skip: (slug) => !slug
+      }
+    },
+    mutations: {
+      create: {
+        path: "@post/boards",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        setData: {
+          query: "detail",
+          args: (board) => [board.id]
+        },
+        invalidates: ["boards.list"],
+        refresh: false
+      },
+      update: {
+        path: "@put/boards/:id",
+        method: "PUT",
+        input: ({ id, data }) => ({
+          params: { id },
+          body: data
+        }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      delete: {
+        path: "@delete/boards/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        select: (data) => data,
+        invalidates: ["boards.list"],
+        refresh: false
       }
-    }),
-    detail: (boardId) => ({
-      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;
-            throw toError(errorResponse.error);
-          }
-          return response.data ?? null;
-        } catch (error) {
-          throw error;
-        }
+    }
+  },
+  columns: {
+    queries: {},
+    mutations: {
+      create: {
+        path: "@post/columns",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      update: {
+        path: "@put/columns/:id",
+        method: "PUT",
+        input: ({ id, data }) => ({
+          params: { id },
+          body: data
+        }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      delete: {
+        path: "@delete/columns/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      reorder: {
+        path: "@post/columns/reorder",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
       }
-    }),
-    // Get board by slug
-    bySlug: (slug) => ({
-      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;
-            throw toError(errorResponse.error);
-          }
-          const envelope = response.data;
-          return envelope?.items?.[0] ?? null;
-        } catch (error) {
-          throw error;
-        }
+    }
+  },
+  tasks: {
+    queries: {},
+    mutations: {
+      create: {
+        path: "@post/tasks",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      update: {
+        path: "@put/tasks/:id",
+        method: "PUT",
+        input: ({ id, data }) => ({
+          params: { id },
+          body: data
+        }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      delete: {
+        path: "@delete/tasks/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      move: {
+        path: "@post/tasks/move",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
+      },
+      reorder: {
+        path: "@post/tasks/reorder",
+        method: "POST",
+        input: (data) => ({ body: data }),
+        select: (data) => data,
+        invalidates: ["boards"],
+        refresh: false
       }
-    })
-  });
+    }
+  }
+};
+const kanbanQueryResources = {
+  boards: kanbanResources.boards
+};
+function createKanbanQueryKeys(client, headers) {
+  return createResourceQueryKeys(client, kanbanQueryResources, headers);
 }
 
-export { createKanbanQueryKeys };
+export { createKanbanQueryKeys, kanbanResources };

package/dist/plugins/media/api/index.cjs

@@ -23,3 +23,4 @@ exports.serializeAsset = serializers.serializeAsset;
 exports.serializeFolder = serializers.serializeFolder;
 exports.MEDIA_QUERY_KEYS = queryKeyDefs.MEDIA_QUERY_KEYS;
 exports.assetListDiscriminator = queryKeyDefs.assetListDiscriminator;
+exports.folderListDiscriminator = queryKeyDefs.folderListDiscriminator;

package/dist/plugins/media/api/index.d.cts

@@ -1,5 +1,4 @@
-export { C as CreateAssetInput, e as CreateFolderInput, M as MEDIA_QUERY_KEYS, g as MediaApiContext, j as MediaApiRouter, i as MediaBackendConfig, h as MediaBackendHooks, U as UpdateAssetInput, f as assetListDiscriminator, c as createAsset, a as createFolder, d as deleteAsset, b as deleteFolder, m as mediaBackendPlugin, u as updateAsset } from '../../../shared/stack.BrNVff5Q.cjs';
-export { A as AssetListParams, d as AssetListResult, F as FolderListParams, g as getAssetById, b as getFolderById, c as getFolderByName, l as listAssets, a as listFolders } from '../../../shared/stack.jU2iG86n.cjs';
+export { A as AssetListParams, d as AssetListResult, C as CreateAssetInput, j as CreateFolderInput, F as FolderListParams, M as MEDIA_QUERY_KEYS, n as MediaApiContext, r as MediaApiRouter, p as MediaBackendConfig, o as MediaBackendHooks, U as UpdateAssetInput, k as assetListDiscriminator, e as createAsset, h as createFolder, f as deleteAsset, i as deleteFolder, m as folderListDiscriminator, g as getAssetById, b as getFolderById, c as getFolderByName, l as listAssets, a as listFolders, q as mediaBackendPlugin, u as updateAsset } from '../../../shared/stack.C5Y5lViI.cjs';
 import { A as Asset, S as SerializedAsset, F as Folder, a as SerializedFolder } from '../../../shared/stack.BMlLOMED.cjs';
 export { D as DirectStorageAdapter, a as S3StorageAdapter, b as S3UploadToken, S as StorageAdapter, U as UploadOptions, c as VercelBlobHandlerCallbacks, V as VercelBlobStorageAdapter } from '../../../shared/stack.lkebw2nj.cjs';
 import '@btst/stack/plugins/api';