@btst/stack 1.0.1 → 1.1.1

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

@@ -0,0 +1,530 @@
+import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
+import * as better_call from 'better-call';
+import { z } from 'zod';
+import { c as createPostSchema, u as updatePostSchema, P as Post, T as Tag, S as SerializedPost, a as SerializedTag } from '../../shared/stack.CoPoHVfV.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+
+declare const PostListQuerySchema: z.ZodObject<{
+    slug: z.ZodOptional<z.ZodString>;
+    tagSlug: z.ZodOptional<z.ZodString>;
+    offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    query: z.ZodOptional<z.ZodString>;
+    published: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean | undefined, string | undefined>>;
+}, z.core.$strip>;
+declare const NextPreviousPostsQuerySchema: z.ZodObject<{
+    date: z.ZodCoercedDate<unknown>;
+}, z.core.$strip>;
+/**
+ * Context passed to blog API hooks
+ */
+interface BlogApiContext<TBody = any, TParams = any, TQuery = any> {
+    body?: TBody;
+    params?: TParams;
+    query?: TQuery;
+    request?: Request;
+    [key: string]: any;
+}
+/**
+ * Configuration hooks for blog backend plugin
+ * All hooks are optional and allow consumers to customize behavior
+ */
+interface BlogBackendHooks {
+    onBeforeListPosts?: (filter: z.infer<typeof PostListQuerySchema>, context: BlogApiContext) => Promise<boolean> | boolean;
+    onBeforeCreatePost?: (data: z.infer<typeof createPostSchema>, context: BlogApiContext) => Promise<boolean> | boolean;
+    onBeforeUpdatePost?: (postId: string, data: z.infer<typeof updatePostSchema>, context: BlogApiContext) => Promise<boolean> | boolean;
+    onBeforeDeletePost?: (postId: string, context: BlogApiContext) => Promise<boolean> | boolean;
+    onPostsRead?: (posts: Post[], filter: z.infer<typeof PostListQuerySchema>, context: BlogApiContext) => Promise<void> | void;
+    onPostCreated?: (post: Post, context: BlogApiContext) => Promise<void> | void;
+    onPostUpdated?: (post: Post, context: BlogApiContext) => Promise<void> | void;
+    onPostDeleted?: (postId: string, context: BlogApiContext) => Promise<void> | void;
+    onListPostsError?: (error: Error, context: BlogApiContext) => Promise<void> | void;
+    onCreatePostError?: (error: Error, context: BlogApiContext) => Promise<void> | void;
+    onUpdatePostError?: (error: Error, context: BlogApiContext) => Promise<void> | void;
+    onDeletePostError?: (error: Error, context: BlogApiContext) => Promise<void> | void;
+}
+/**
+ * Blog backend plugin
+ * Provides API endpoints for managing blog posts
+ * Uses better-db adapter for database operations
+ *
+ * @param hooks - Optional configuration hooks for customizing plugin behavior
+ */
+declare const blogBackendPlugin: (hooks?: BlogBackendHooks) => _btst_stack_plugins_api.BackendPlugin<{
+    readonly listPosts: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+        } & {
+            method?: "GET" | undefined;
+        } & {
+            query: {
+                slug?: string | undefined;
+                tagSlug?: string | undefined;
+                offset?: unknown;
+                limit?: unknown;
+                query?: string | undefined;
+                published?: string | undefined;
+            };
+        } & {
+            params?: Record<string, any>;
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: {
+                tags: Tag[];
+                id: string;
+                authorId?: string;
+                defaultLocale?: string;
+                slug: string;
+                title: string;
+                content: string;
+                excerpt: string;
+                image?: string;
+                published: boolean;
+                status?: "DRAFT" | "PUBLISHED";
+                publishedAt?: Date;
+                createdAt: Date;
+                updatedAt: Date;
+            }[];
+        } : {
+            tags: Tag[];
+            id: string;
+            authorId?: string;
+            defaultLocale?: string;
+            slug: string;
+            title: string;
+            content: string;
+            excerpt: string;
+            image?: string;
+            published: boolean;
+            status?: "DRAFT" | "PUBLISHED";
+            publishedAt?: Date;
+            createdAt: Date;
+            updatedAt: Date;
+        }[]>;
+        options: {
+            method: "GET";
+            query: z.ZodObject<{
+                slug: z.ZodOptional<z.ZodString>;
+                tagSlug: z.ZodOptional<z.ZodString>;
+                offset: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+                query: z.ZodOptional<z.ZodString>;
+                published: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<boolean | undefined, string | undefined>>;
+            }, z.core.$strip>;
+        };
+        path: "/posts";
+    };
+    readonly createPost: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body: {
+                title: string;
+                content: string;
+                excerpt: string;
+                slug?: string | undefined;
+                published?: boolean | undefined;
+                createdAt?: unknown;
+                publishedAt?: unknown;
+                updatedAt?: unknown;
+                image?: string | undefined;
+                tags?: ({
+                    name: string;
+                } | {
+                    id: string;
+                    name: string;
+                    slug: string;
+                })[] | undefined;
+            };
+        } & {
+            method?: "POST" | undefined;
+        } & {
+            query?: Record<string, any> | undefined;
+        } & {
+            params?: Record<string, any>;
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: Post;
+        } : Post>;
+        options: {
+            method: "POST";
+            body: z.ZodObject<{
+                slug: z.ZodOptional<z.ZodString>;
+                published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                title: z.ZodString;
+                content: z.ZodString;
+                excerpt: z.ZodString;
+                image: z.ZodOptional<z.ZodString>;
+                tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    slug: z.ZodString;
+                }, z.core.$strip>]>>>>;
+            }, z.core.$strip>;
+        };
+        path: "/posts";
+    };
+    readonly updatePost: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body: {
+                title: string;
+                content: string;
+                excerpt: string;
+                slug: string;
+                id: string;
+                publishedAt?: unknown;
+                createdAt?: unknown;
+                updatedAt?: unknown;
+                image?: string | undefined;
+                published?: boolean | undefined;
+                tags?: ({
+                    name: string;
+                } | {
+                    id: string;
+                    name: string;
+                    slug: string;
+                })[] | undefined;
+            };
+        } & {
+            method?: "PUT" | undefined;
+        } & {
+            query?: Record<string, any> | undefined;
+        } & {
+            params: {
+                id: string;
+            };
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: Post;
+        } : Post>;
+        options: {
+            method: "PUT";
+            body: z.ZodObject<{
+                publishedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                createdAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                updatedAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
+                title: z.ZodString;
+                content: z.ZodString;
+                excerpt: z.ZodString;
+                image: z.ZodOptional<z.ZodString>;
+                published: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                slug: z.ZodString;
+                tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>, z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    slug: z.ZodString;
+                }, z.core.$strip>]>>>>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+        };
+        path: "/posts/:id";
+    };
+    readonly deletePost: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+        } & {
+            method?: "DELETE" | undefined;
+        } & {
+            query?: Record<string, any> | undefined;
+        } & {
+            params: {
+                id: string;
+            };
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: {
+                success: boolean;
+            };
+        } : {
+            success: boolean;
+        }>;
+        options: {
+            method: "DELETE";
+        };
+        path: "/posts/:id";
+    };
+    readonly getNextPreviousPosts: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+            body?: undefined;
+        } & {
+            method?: "GET" | undefined;
+        } & {
+            query: {
+                date: unknown;
+            };
+        } & {
+            params?: Record<string, any>;
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: {
+                previous: {
+                    tags: Tag[];
+                    id: string;
+                    authorId?: string;
+                    defaultLocale?: string;
+                    slug: string;
+                    title: string;
+                    content: string;
+                    excerpt: string;
+                    image?: string;
+                    published: boolean;
+                    status?: "DRAFT" | "PUBLISHED";
+                    publishedAt?: Date;
+                    createdAt: Date;
+                    updatedAt: Date;
+                } | null;
+                next: {
+                    tags: Tag[];
+                    id: string;
+                    authorId?: string;
+                    defaultLocale?: string;
+                    slug: string;
+                    title: string;
+                    content: string;
+                    excerpt: string;
+                    image?: string;
+                    published: boolean;
+                    status?: "DRAFT" | "PUBLISHED";
+                    publishedAt?: Date;
+                    createdAt: Date;
+                    updatedAt: Date;
+                } | null;
+            };
+        } : {
+            previous: {
+                tags: Tag[];
+                id: string;
+                authorId?: string;
+                defaultLocale?: string;
+                slug: string;
+                title: string;
+                content: string;
+                excerpt: string;
+                image?: string;
+                published: boolean;
+                status?: "DRAFT" | "PUBLISHED";
+                publishedAt?: Date;
+                createdAt: Date;
+                updatedAt: Date;
+            } | null;
+            next: {
+                tags: Tag[];
+                id: string;
+                authorId?: string;
+                defaultLocale?: string;
+                slug: string;
+                title: string;
+                content: string;
+                excerpt: string;
+                image?: string;
+                published: boolean;
+                status?: "DRAFT" | "PUBLISHED";
+                publishedAt?: Date;
+                createdAt: Date;
+                updatedAt: Date;
+            } | null;
+        }>;
+        options: {
+            method: "GET";
+            query: z.ZodObject<{
+                date: z.ZodCoercedDate<unknown>;
+            }, z.core.$strip>;
+        };
+        path: "/posts/next-previous";
+    };
+    readonly listTags: {
+        <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+            body?: undefined;
+        } & {
+            method?: "GET" | undefined;
+        } & {
+            query?: Record<string, any> | undefined;
+        } & {
+            params?: Record<string, any>;
+        } & {
+            request?: Request;
+        } & {
+            headers?: HeadersInit;
+        } & {
+            asResponse?: boolean;
+            returnHeaders?: boolean;
+            use?: better_call.Middleware[];
+            path?: string;
+        } & {
+            asResponse?: AsResponse | undefined;
+            returnHeaders?: ReturnHeaders | undefined;
+        }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+            headers: Headers;
+            response: Tag[];
+        } : Tag[]>;
+        options: {
+            method: "GET";
+        };
+        path: "/tags";
+    };
+}>;
+type BlogApiRouter = ReturnType<ReturnType<typeof blogBackendPlugin>["routes"]>;
+
+interface PostsListParams {
+    query?: string;
+    limit?: number;
+    published?: boolean;
+    tagSlug?: string;
+}
+declare function createBlogQueryKeys(client: ReturnType<typeof createApiClient<BlogApiRouter>>): {
+    posts: {
+        _def: readonly ["posts"];
+    } & {
+        list: ((params?: PostsListParams | undefined) => Omit<Omit<{
+            queryKey: readonly ["posts", "list", {
+                query: string | undefined;
+                limit: number;
+                published: boolean;
+                tagSlug: string | undefined;
+            }];
+            queryFn: _tanstack_react_query.QueryFunction<unknown, readonly ["posts", "list", {
+                query: string | undefined;
+                limit: number;
+                published: boolean;
+                tagSlug: string | undefined;
+            }]>;
+        }, "queryFn"> & {
+            _def: readonly ["posts", "list"];
+        }, "_def">) & {
+            _def: readonly ["posts", "list"];
+        };
+        detail: ((slug: string) => Omit<{
+            queryKey: readonly ["posts", "detail", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedPost | null, readonly ["posts", "detail", string]>;
+        } & {
+            _def: readonly ["posts", "detail"];
+        }, "_def">) & {
+            _def: readonly ["posts", "detail"];
+        };
+        nextPrevious: ((date: string | Date) => Omit<{
+            queryKey: readonly ["posts", "nextPrevious", string, string | Date];
+            queryFn: _tanstack_react_query.QueryFunction<{
+                previous: SerializedPost | null;
+                next: SerializedPost | null;
+            }, readonly ["posts", "nextPrevious", string, string | Date]>;
+        } & {
+            _def: readonly ["posts", "nextPrevious"];
+        }, "_def">) & {
+            _def: readonly ["posts", "nextPrevious"];
+        };
+        recent: ((params?: {
+            limit?: number;
+            excludeSlug?: string;
+        } | undefined) => Omit<{
+            queryKey: readonly ["posts", "recent", string, {
+                limit?: number;
+                excludeSlug?: string;
+            } | undefined];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedPost[], readonly ["posts", "recent", string, {
+                limit?: number;
+                excludeSlug?: string;
+            } | undefined]>;
+        } & {
+            _def: readonly ["posts", "recent"];
+        }, "_def">) & {
+            _def: readonly ["posts", "recent"];
+        };
+    };
+    drafts: {
+        _def: readonly ["drafts"];
+    } & {
+        list: ((params?: PostsListParams | undefined) => Omit<Omit<{
+            queryKey: readonly ["drafts", "list", {
+                limit?: number | undefined;
+            }];
+            queryFn: _tanstack_react_query.QueryFunction<unknown, readonly ["drafts", "list", {
+                limit?: number | undefined;
+            }]>;
+        }, "queryFn"> & {
+            _def: readonly ["drafts", "list"];
+        }, "_def">) & {
+            _def: readonly ["drafts", "list"];
+        };
+    };
+    tags: {
+        _def: readonly ["tags"];
+    } & {
+        list: (() => Omit<{
+            queryKey: readonly ["tags", "list", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedTag[], readonly ["tags", "list", string]>;
+        } & {
+            _def: readonly ["tags", "list"];
+        }, "_def">) & {
+            _def: readonly ["tags", "list"];
+        };
+    };
+};
+
+export { NextPreviousPostsQuerySchema as N, PostListQuerySchema as P, blogBackendPlugin as b, createBlogQueryKeys };
+export type { BlogApiContext as B, BlogBackendHooks as a, BlogApiRouter as c };

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

@@ -0,0 +1,179 @@
+import { mergeQueryKeys, createQueryKeys } from '@lukemorales/query-key-factory';
+
+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 createBlogQueryKeys(client) {
+  const posts = createPostsQueries(client);
+  const drafts = createDraftsQueries(client);
+  const tags = createTagsQueries(client);
+  return mergeQueryKeys(posts, drafts, tags);
+}
+function createPostsQueries(client) {
+  return createQueryKeys("posts", {
+    list: (params) => ({
+      queryKey: [
+        {
+          query: params?.query !== void 0 && params?.query?.trim() === "" ? void 0 : params?.query,
+          limit: params?.limit ?? 10,
+          published: params?.published ?? true,
+          tagSlug: params?.tagSlug
+        }
+      ],
+      queryFn: async ({ pageParam }) => {
+        try {
+          const response = await client("/posts", {
+            method: "GET",
+            query: {
+              query: params?.query,
+              offset: pageParam ?? 0,
+              limit: params?.limit ?? 10,
+              published: params?.published !== void 0 ? params.published ? "true" : "false" : void 0,
+              tagSlug: params?.tagSlug
+            }
+          });
+          if (isErrorResponse(response)) {
+            const errorResponse = response;
+            throw toError(errorResponse.error);
+          }
+          return response.data ?? [];
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    // Simplified detail query
+    detail: (slug) => ({
+      queryKey: [slug],
+      queryFn: async () => {
+        if (!slug) return null;
+        try {
+          const response = await client("/posts", {
+            method: "GET",
+            query: { slug, limit: 1 }
+          });
+          if (isErrorResponse(response)) {
+            const errorResponse = response;
+            throw toError(errorResponse.error);
+          }
+          const dataResponse = response;
+          return dataResponse.data?.[0] ?? null;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    // Next/previous posts query
+    nextPrevious: (date) => ({
+      queryKey: ["nextPrevious", date],
+      queryFn: async () => {
+        const dateValue = typeof date === "string" ? new Date(date) : date;
+        const response = await client("/posts/next-previous", {
+          method: "GET",
+          query: {
+            date: dateValue.toISOString()
+          }
+        });
+        if (isErrorResponse(response)) {
+          const errorResponse = response;
+          throw toError(errorResponse.error);
+        }
+        const dataResponse = response;
+        return dataResponse.data;
+      }
+    }),
+    // Recent posts query (separate from main list to avoid cache conflicts)
+    recent: (params) => ({
+      queryKey: ["recent", params],
+      queryFn: async () => {
+        try {
+          const response = await client("/posts", {
+            method: "GET",
+            query: {
+              limit: params?.limit ?? 5,
+              published: "true"
+            }
+          });
+          if (isErrorResponse(response)) {
+            const errorResponse = response;
+            throw toError(errorResponse.error);
+          }
+          let posts = response.data ?? [];
+          if (params?.excludeSlug) {
+            posts = posts.filter((post) => post.slug !== params.excludeSlug);
+          }
+          return posts;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+function createDraftsQueries(client) {
+  return createQueryKeys("drafts", {
+    list: (params) => ({
+      queryKey: [
+        {
+          ...params?.limit && { limit: params.limit }
+        }
+      ],
+      queryFn: async ({ pageParam }) => {
+        try {
+          const response = await client("/posts", {
+            method: "GET",
+            query: {
+              query: params?.query,
+              offset: pageParam ?? 0,
+              limit: params?.limit ?? 10,
+              published: "false"
+            }
+          });
+          if (isErrorResponse(response)) {
+            const errorResponse = response;
+            throw toError(errorResponse.error);
+          }
+          return response.data ?? [];
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+function createTagsQueries(client) {
+  return createQueryKeys("tags", {
+    list: () => ({
+      queryKey: ["tags"],
+      queryFn: async () => {
+        try {
+          const response = await client("/tags", {
+            method: "GET"
+          });
+          if (isErrorResponse(response)) {
+            const errorResponse = response;
+            throw toError(errorResponse.error);
+          }
+          return response.data ?? [];
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+
+export { createBlogQueryKeys };