@btst/stack 2.12.2 → 3.0.0-rc.1

package/dist/plugins/comments/query-keys.cjs

@@ -1,114 +1,125 @@
 'use strict';
 
-const queryKeyFactory = require('@lukemorales/query-key-factory');
+const client = require('@btst/stack/plugins/client');
 const queryKeyDefs = require('../../packages/stack/src/plugins/comments/api/query-key-defs.cjs');
-const errorUtils = require('../../packages/stack/src/plugins/comments/error-utils.cjs');
 
-function isErrorResponse(response) {
-  return typeof response === "object" && response !== null && "error" in response && response.error !== null && response.error !== void 0;
-}
-function createCommentsQueryKeys(client, headers) {
-  return queryKeyFactory.mergeQueryKeys(
-    createCommentsQueries(client, headers),
-    createCommentCountQueries(client, headers),
-    createCommentsThreadQueries(client, headers)
-  );
-}
-function createCommentsQueries(client, headers) {
-  return queryKeyFactory.createQueryKeys("comments", {
-    list: (params) => ({
-      queryKey: [queryKeyDefs.commentsListDiscriminator(params)],
-      queryFn: async () => {
-        const response = await client("/comments", {
-          method: "GET",
-          query: {
-            resourceId: params?.resourceId,
-            resourceType: params?.resourceType,
-            parentId: params?.parentId === null ? "null" : params?.parentId,
-            status: params?.status,
-            // currentUserId is intentionally NOT sent to the server.
-            // The server resolves the caller's identity server-side via the
-            // resolveCurrentUserId hook. Sending it would allow any caller to
-            // impersonate another user and read their pending comments.
-            // It is still included in the queryKey above for client-side
-            // cache segregation (different users get different cache entries).
-            authorId: params?.authorId,
-            sort: params?.sort,
-            limit: params?.limit ?? 20,
-            offset: params?.offset ?? 0
-          },
-          headers
-        });
-        if (isErrorResponse(response)) {
-          throw errorUtils.toError(response.error);
-        }
-        const data = response.data;
-        return data ?? { items: [], total: 0, limit: 20, offset: 0 };
+const commentsResources = {
+  comments: {
+    queries: {
+      list: {
+        path: "/comments",
+        query: (params) => ({
+          resourceId: params?.resourceId,
+          resourceType: params?.resourceType,
+          parentId: params?.parentId === null ? "null" : params?.parentId,
+          status: params?.status,
+          authorId: params?.authorId,
+          sort: params?.sort,
+          limit: params?.limit ?? 20,
+          offset: params?.offset ?? 0
+        }),
+        key: (params) => [
+          queryKeyDefs.commentsListDiscriminator(params)
+        ],
+        select: (data, _params) => data ?? { items: [], total: 0, limit: 20, offset: 0 }
       }
-    })
-  });
-}
-function createCommentCountQueries(client, headers) {
-  return queryKeyFactory.createQueryKeys("commentCount", {
-    byResource: (params) => ({
-      queryKey: [queryKeyDefs.commentCountDiscriminator(params)],
-      queryFn: async () => {
-        const response = await client("/comments/count", {
-          method: "GET",
-          query: {
-            resourceId: params.resourceId,
-            resourceType: params.resourceType,
-            status: params.status
-          },
-          headers
-        });
-        if (isErrorResponse(response)) {
-          throw errorUtils.toError(response.error);
-        }
-        const data = response.data;
-        return data?.count ?? 0;
+    },
+    mutations: {
+      create: {
+        path: "@post/comments",
+        method: "POST",
+        input: (vars) => ({
+          body: {
+            resourceId: vars.resourceId,
+            resourceType: vars.resourceType,
+            parentId: vars.parentId ?? null,
+            body: vars.body
+          }
+        }),
+        select: (data) => data
+      },
+      update: {
+        path: "@patch/comments/:id",
+        method: "PATCH",
+        input: (vars) => ({
+          params: { id: vars.id },
+          body: { body: vars.body }
+        }),
+        select: (data) => data
+      },
+      updateStatus: {
+        path: "@patch/comments/:id/status",
+        method: "PATCH",
+        input: (vars) => ({
+          params: { id: vars.id },
+          body: { status: vars.status }
+        }),
+        select: (data) => data
+      },
+      delete: {
+        path: "@delete/comments/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        select: (data) => data
+      },
+      like: {
+        path: "@post/comments/:id/like",
+        method: "POST",
+        input: (vars) => ({
+          params: { id: vars.commentId },
+          body: { authorId: vars.authorId }
+        }),
+        select: (data) => data
       }
-    })
-  });
-}
-function createCommentsThreadQueries(client, headers) {
-  return queryKeyFactory.createQueryKeys("commentsThread", {
-    list: (params) => ({
-      // Offset is excluded from the key — it is driven by pageParam.
-      queryKey: [queryKeyDefs.commentsThreadDiscriminator(params)],
-      queryFn: async ({
-        pageParam
-      } = {}) => {
-        const response = await client("/comments", {
-          method: "GET",
-          query: {
-            resourceId: params?.resourceId,
-            resourceType: params?.resourceType,
-            parentId: params?.parentId === null ? "null" : params?.parentId,
-            status: params?.status,
-            // currentUserId is intentionally NOT sent to the server.
-            // The server resolves the caller's identity server-side via the
-            // resolveCurrentUserId hook. It is still included in the queryKey
-            // above for client-side cache segregation.
-            sort: params?.sort,
-            limit: params?.limit ?? 20,
-            offset: pageParam ?? 0
-          },
-          headers
-        });
-        if (isErrorResponse(response)) {
-          throw errorUtils.toError(response.error);
-        }
-        const data = response.data;
-        return data ?? {
+    }
+  },
+  commentCount: {
+    queries: {
+      byResource: {
+        path: "/comments/count",
+        query: (params) => ({
+          resourceId: params.resourceId,
+          resourceType: params.resourceType,
+          status: params.status
+        }),
+        key: (params) => [
+          queryKeyDefs.commentCountDiscriminator(params)
+        ],
+        select: (data, _params) => data?.count ?? 0
+      }
+    }
+  },
+  commentsThread: {
+    queries: {
+      // Offset is excluded from the key — it is driven by `pageParam`
+      // (injected per page by the infinite queryFn).
+      list: {
+        path: "/comments",
+        query: (params) => ({
+          resourceId: params?.resourceId,
+          resourceType: params?.resourceType,
+          parentId: params?.parentId === null ? "null" : params?.parentId,
+          status: params?.status,
+          sort: params?.sort,
+          limit: params?.limit ?? 20
+        }),
+        key: (params) => [
+          queryKeyDefs.commentsThreadDiscriminator(params)
+        ],
+        select: (data, params) => data ?? {
           items: [],
           total: 0,
           limit: params?.limit ?? 20,
-          offset: pageParam ?? 0
-        };
+          offset: 0
+        },
+        infinite: true
       }
-    })
-  });
+    }
+  }
+};
+function createCommentsQueryKeys(client$1, headers) {
+  return client.createResourceQueryKeys(client$1, commentsResources, headers);
 }
 
+exports.commentsResources = commentsResources;
 exports.createCommentsQueryKeys = createCommentsQueryKeys;

package/dist/plugins/comments/query-keys.d.cts

@@ -1,7 +1,7 @@
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { b as CommentsListDiscriminator, C as CommentListResult, c as CommentCountDiscriminator, a as CommentsThreadDiscriminator } from '../../shared/stack.C7KNNiJm.cjs';
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { C as CommentsApiRouter } from '../../shared/stack.CCncwK6g.cjs';
+import { C as CommentsListDiscriminator, a as CommentCountDiscriminator, b as CommentsThreadDiscriminator, c as CommentsApiRouter } from '../../shared/stack.DKZMaVr6.cjs';
+import { C as CommentListResult, S as SerializedComment } from '../../shared/stack.C3GBG8in.cjs';
 import '@btst/stack/plugins/api';
 import 'better-call';
 import 'zod';
@@ -22,51 +22,306 @@ interface CommentCountParams {
     resourceType: string;
     status?: "pending" | "approved" | "spam";
 }
-declare function createCommentsQueryKeys(client: ReturnType<typeof createApiClient<CommentsApiRouter>>, headers?: HeadersInit): {
+/** Params for the infinite thread query (offset is driven by `pageParam`). */
+interface CommentsThreadParams {
+    resourceId?: string;
+    resourceType?: string;
+    parentId?: string | null;
+    status?: "pending" | "approved" | "spam";
+    currentUserId?: string;
+    sort?: "asc" | "desc";
+    limit?: number;
+}
+/** Input for the create-comment mutation (`authorId` is resolved server-side). */
+interface CreateCommentInput {
+    resourceId: string;
+    resourceType: string;
+    parentId?: string | null;
+    body: string;
+}
+/**
+ * Comments resource declaration — the single source of truth for query keys
+ * and HTTP mappings. Feeds `createCommentsQueryKeys` (SSR loaders and the
+ * client hooks in `client/hooks/use-comments.tsx`).
+ *
+ * Key shapes intentionally match the discriminators in
+ * `api/query-key-defs.ts` so SSG/loader prefetch hydration keeps working.
+ *
+ * `currentUserId` is intentionally NOT sent to the server in any query.
+ * The server resolves the caller's identity server-side via the
+ * `resolveCurrentUserId` hook. Sending it would allow any caller to
+ * impersonate another user and read their pending comments. It is still
+ * included in the query keys for client-side cache segregation (different
+ * users get different cache entries).
+ *
+ * Mutations declare only the HTTP mapping (path/method/input/select).
+ * Cache behavior (optimistic updates, invalidation) lives in the wrapper
+ * hooks in `use-comments.tsx`: the public comments hooks take an explicit
+ * client config — required by the embeddable `CommentThread` — so they
+ * cannot use the overrides-bound `createResource` mutation hooks.
+ */
+declare const commentsResources: {
     comments: {
-        _def: readonly ["comments"];
-    } & {
-        list: ((params?: CommentsListParams | undefined) => Omit<{
-            queryKey: readonly ["comments", "list", CommentsListDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<CommentListResult, readonly ["comments", "list", CommentsListDiscriminator]>;
-        } & {
-            _def: readonly ["comments", "list"];
-        }, "_def">) & {
-            _def: readonly ["comments", "list"];
+        queries: {
+            list: {
+                path: string;
+                query: (params?: CommentsListParams) => {
+                    resourceId: string | undefined;
+                    resourceType: string | undefined;
+                    parentId: string | undefined;
+                    status: "pending" | "approved" | "spam" | undefined;
+                    authorId: string | undefined;
+                    sort: "asc" | "desc" | undefined;
+                    limit: number;
+                    offset: number;
+                };
+                key: (params?: CommentsListParams) => CommentsListDiscriminator[];
+                select: (data: any, _params?: CommentsListParams) => CommentListResult;
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: CreateCommentInput) => {
+                    body: {
+                        resourceId: string;
+                        resourceType: string;
+                        parentId: string | null;
+                        body: string;
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            update: {
+                path: string;
+                method: "PATCH";
+                input: (vars: {
+                    id: string;
+                    body: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        body: string;
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            updateStatus: {
+                path: string;
+                method: "PATCH";
+                input: (vars: {
+                    id: string;
+                    status: "pending" | "approved" | "spam";
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "pending" | "approved" | "spam";
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+            };
+            like: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    commentId: string;
+                    authorId: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        authorId: string;
+                    };
+                };
+                select: (data: any) => {
+                    likes: number;
+                    isLiked: boolean;
+                };
+            };
         };
     };
     commentCount: {
-        _def: readonly ["commentCount"];
-    } & {
-        byResource: ((params: CommentCountParams) => Omit<{
-            queryKey: readonly ["commentCount", "byResource", CommentCountDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<number, readonly ["commentCount", "byResource", CommentCountDiscriminator]>;
-        } & {
-            _def: readonly ["commentCount", "byResource"];
-        }, "_def">) & {
-            _def: readonly ["commentCount", "byResource"];
+        queries: {
+            byResource: {
+                path: string;
+                query: (params: CommentCountParams) => {
+                    resourceId: string;
+                    resourceType: string;
+                    status: "pending" | "approved" | "spam" | undefined;
+                };
+                key: (params: CommentCountParams) => CommentCountDiscriminator[];
+                select: (data: any, _params: CommentCountParams) => number;
+            };
         };
     };
     commentsThread: {
-        _def: readonly ["commentsThread"];
-    } & {
-        list: ((params?: {
-            resourceId?: string;
-            resourceType?: string;
-            parentId?: string | null;
-            status?: "pending" | "approved" | "spam";
-            currentUserId?: string;
-            sort?: "asc" | "desc";
-            limit?: number;
-        } | undefined) => Omit<Omit<{
-            queryKey: readonly ["commentsThread", "list", CommentsThreadDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<unknown, readonly ["commentsThread", "list", CommentsThreadDiscriminator]>;
-        }, "queryFn"> & {
-            _def: readonly ["commentsThread", "list"];
-        }, "_def">) & {
-            _def: readonly ["commentsThread", "list"];
+        queries: {
+            list: {
+                path: string;
+                query: (params?: CommentsThreadParams) => {
+                    resourceId: string | undefined;
+                    resourceType: string | undefined;
+                    parentId: string | undefined;
+                    status: "pending" | "approved" | "spam" | undefined;
+                    sort: "asc" | "desc" | undefined;
+                    limit: number;
+                };
+                key: (params?: CommentsThreadParams) => CommentsThreadDiscriminator[];
+                select: (data: any, params?: CommentsThreadParams) => CommentListResult;
+                infinite: true;
+            };
         };
     };
 };
+declare function createCommentsQueryKeys(client: ReturnType<typeof createApiClient<CommentsApiRouter>>, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
+    comments: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: CommentsListParams) => {
+                    resourceId: string | undefined;
+                    resourceType: string | undefined;
+                    parentId: string | undefined;
+                    status: "pending" | "approved" | "spam" | undefined;
+                    authorId: string | undefined;
+                    sort: "asc" | "desc" | undefined;
+                    limit: number;
+                    offset: number;
+                };
+                key: (params?: CommentsListParams) => CommentsListDiscriminator[];
+                select: (data: any, _params?: CommentsListParams) => CommentListResult;
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: CreateCommentInput) => {
+                    body: {
+                        resourceId: string;
+                        resourceType: string;
+                        parentId: string | null;
+                        body: string;
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            update: {
+                path: string;
+                method: "PATCH";
+                input: (vars: {
+                    id: string;
+                    body: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        body: string;
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            updateStatus: {
+                path: string;
+                method: "PATCH";
+                input: (vars: {
+                    id: string;
+                    status: "pending" | "approved" | "spam";
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        status: "pending" | "approved" | "spam";
+                    };
+                };
+                select: (data: any) => SerializedComment;
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+            };
+            like: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    commentId: string;
+                    authorId: string;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: {
+                        authorId: string;
+                    };
+                };
+                select: (data: any) => {
+                    likes: number;
+                    isLiked: boolean;
+                };
+            };
+        };
+    };
+    commentCount: {
+        queries: {
+            byResource: {
+                path: string;
+                query: (params: CommentCountParams) => {
+                    resourceId: string;
+                    resourceType: string;
+                    status: "pending" | "approved" | "spam" | undefined;
+                };
+                key: (params: CommentCountParams) => CommentCountDiscriminator[];
+                select: (data: any, _params: CommentCountParams) => number;
+            };
+        };
+    };
+    commentsThread: {
+        queries: {
+            list: {
+                path: string;
+                query: (params?: CommentsThreadParams) => {
+                    resourceId: string | undefined;
+                    resourceType: string | undefined;
+                    parentId: string | undefined;
+                    status: "pending" | "approved" | "spam" | undefined;
+                    sort: "asc" | "desc" | undefined;
+                    limit: number;
+                };
+                key: (params?: CommentsThreadParams) => CommentsThreadDiscriminator[];
+                select: (data: any, params?: CommentsThreadParams) => CommentListResult;
+                infinite: true;
+            };
+        };
+    };
+}>;
 
-export { createCommentsQueryKeys };
+export { commentsResources, createCommentsQueryKeys };
+export type { CommentCountParams, CommentsListParams, CommentsThreadParams, CreateCommentInput };