@btst/stack 1.0.1 → 1.1.1

package/dist/plugins/blog/api/plugin.mjs

@@ -0,0 +1,565 @@
+import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { blogSchema } from '../db.mjs';
+import { slugify } from '../utils.mjs';
+import { createPostSchema, updatePostSchema } from '../schemas.mjs';
+
+const PostListQuerySchema = z.object({
+  slug: z.string().optional(),
+  tagSlug: z.string().optional(),
+  offset: z.coerce.number().int().min(0).optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional(),
+  query: z.string().optional(),
+  published: 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 NextPreviousPostsQuerySchema = z.object({
+  date: z.coerce.date()
+});
+const blogBackendPlugin = (hooks) => defineBackendPlugin({
+  name: "blog",
+  dbPlugin: blogSchema,
+  routes: (adapter) => {
+    const createTagCache = () => {
+      let cache = null;
+      return {
+        getAllTags: async () => {
+          if (!cache) {
+            cache = await adapter.findMany({
+              model: "tag"
+            });
+          }
+          return cache;
+        },
+        invalidate: () => {
+          cache = null;
+        },
+        addTag: (tag) => {
+          if (cache) {
+            cache.push(tag);
+          }
+        }
+      };
+    };
+    const createPostTagCache = () => {
+      let cache = null;
+      const getAllPostTags = async () => {
+        if (!cache) {
+          cache = await adapter.findMany({
+            model: "postTag"
+          });
+        }
+        return cache;
+      };
+      return {
+        getAllPostTags,
+        invalidate: () => {
+          cache = null;
+        },
+        getByTagId: async (tagId) => {
+          const allPostTags = await getAllPostTags();
+          return allPostTags.filter((pt) => pt.tagId === tagId);
+        },
+        getByPostId: async (postId) => {
+          const allPostTags = await getAllPostTags();
+          return allPostTags.filter((pt) => pt.postId === postId);
+        }
+      };
+    };
+    const findOrCreateTags = async (tagInputs, tagCache) => {
+      if (tagInputs.length === 0) return [];
+      const normalizeTagName = (name) => {
+        return name.trim();
+      };
+      const tagsWithIds = [];
+      const tagsToFindOrCreate = [];
+      for (const tagInput of tagInputs) {
+        if ("id" in tagInput && tagInput.id) {
+          tagsWithIds.push({
+            id: tagInput.id,
+            name: normalizeTagName(tagInput.name),
+            slug: tagInput.slug,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+        } else {
+          tagsToFindOrCreate.push({ name: normalizeTagName(tagInput.name) });
+        }
+      }
+      if (tagsToFindOrCreate.length === 0) {
+        return tagsWithIds;
+      }
+      const allTags = await tagCache.getAllTags();
+      const tagMapBySlug = /* @__PURE__ */ new Map();
+      for (const tag of allTags) {
+        tagMapBySlug.set(tag.slug, tag);
+      }
+      const tagSlugs = tagsToFindOrCreate.map((tag) => slugify(tag.name));
+      const foundTags = [];
+      for (const slug of tagSlugs) {
+        const tag = tagMapBySlug.get(slug);
+        if (tag) {
+          foundTags.push(tag);
+        }
+      }
+      const existingSlugs = /* @__PURE__ */ new Set([
+        ...tagsWithIds.map((tag) => tag.slug),
+        ...foundTags.map((tag) => tag.slug)
+      ]);
+      const tagsToCreate = tagsToFindOrCreate.filter(
+        (tag) => !existingSlugs.has(slugify(tag.name))
+      );
+      const createdTags = [];
+      for (const tag of tagsToCreate) {
+        const normalizedName = normalizeTagName(tag.name);
+        const newTag = await adapter.create({
+          model: "tag",
+          data: {
+            name: normalizedName,
+            slug: slugify(normalizedName),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        createdTags.push(newTag);
+        tagCache.addTag(newTag);
+      }
+      return [...tagsWithIds, ...foundTags, ...createdTags];
+    };
+    const loadTagsForPosts = async (postIds, tagCache, postTagCache) => {
+      if (postIds.length === 0) return /* @__PURE__ */ new Map();
+      const allPostTags = await postTagCache.getAllPostTags();
+      const relevantPostTags = allPostTags.filter(
+        (pt) => postIds.includes(pt.postId)
+      );
+      const tagIds = [...new Set(relevantPostTags.map((pt) => pt.tagId))];
+      if (tagIds.length === 0) return /* @__PURE__ */ new Map();
+      const allTags = await tagCache.getAllTags();
+      const tagMap = /* @__PURE__ */ new Map();
+      for (const tag of allTags) {
+        tagMap.set(tag.id, tag);
+      }
+      const postTagsMap = /* @__PURE__ */ new Map();
+      for (const postTag of relevantPostTags) {
+        const tag = tagMap.get(postTag.tagId);
+        if (tag) {
+          const existing = postTagsMap.get(postTag.postId) || [];
+          postTagsMap.set(postTag.postId, [...existing, { ...tag }]);
+        }
+      }
+      return postTagsMap;
+    };
+    const listPosts = createEndpoint(
+      "/posts",
+      {
+        method: "GET",
+        query: PostListQuerySchema
+      },
+      async (ctx) => {
+        const { query } = ctx;
+        const context = { query };
+        const tagCache = createTagCache();
+        const postTagCache = createPostTagCache();
+        try {
+          if (hooks?.onBeforeListPosts) {
+            const canList = await hooks.onBeforeListPosts(query, context);
+            if (!canList) {
+              throw ctx.error(403, {
+                message: "Unauthorized: Cannot list posts"
+              });
+            }
+          }
+          let tagFilterPostIds = null;
+          if (query.tagSlug) {
+            const allTags = await tagCache.getAllTags();
+            const tag = allTags.find((t) => t.slug === query.tagSlug);
+            if (!tag) {
+              return [];
+            }
+            const postTags = await postTagCache.getByTagId(tag.id);
+            tagFilterPostIds = new Set(postTags.map((pt) => pt.postId));
+            if (tagFilterPostIds.size === 0) {
+              return [];
+            }
+          }
+          const whereConditions = [];
+          if (query.published !== void 0) {
+            whereConditions.push({
+              field: "published",
+              value: query.published,
+              operator: "eq"
+            });
+          }
+          if (query.slug) {
+            whereConditions.push({
+              field: "slug",
+              value: query.slug,
+              operator: "eq"
+            });
+          }
+          const posts = await adapter.findMany({
+            model: "post",
+            limit: query.query || query.tagSlug ? void 0 : query.limit ?? 10,
+            offset: query.query || query.tagSlug ? void 0 : query.offset ?? 0,
+            where: whereConditions,
+            sortBy: {
+              field: "createdAt",
+              direction: "desc"
+            }
+          });
+          const postTagsMap = await loadTagsForPosts(
+            posts.map((post) => post.id),
+            tagCache,
+            postTagCache
+          );
+          let result = posts.map((post) => ({
+            ...post,
+            tags: postTagsMap.get(post.id) || []
+          }));
+          if (tagFilterPostIds) {
+            result = result.filter((post) => tagFilterPostIds.has(post.id));
+          }
+          if (query.query) {
+            const searchLower = query.query.toLowerCase();
+            result = result.filter((post) => {
+              const titleMatch = post.title?.toLowerCase().includes(searchLower);
+              const contentMatch = post.content?.toLowerCase().includes(searchLower);
+              const excerptMatch = post.excerpt?.toLowerCase().includes(searchLower);
+              return titleMatch || contentMatch || excerptMatch;
+            });
+          }
+          if (query.tagSlug || query.query) {
+            const offset = query.offset ?? 0;
+            const limit = query.limit ?? 10;
+            result = result.slice(offset, offset + limit);
+          }
+          if (hooks?.onPostsRead) {
+            await hooks.onPostsRead(result, query, context);
+          }
+          return result;
+        } catch (error) {
+          if (hooks?.onListPostsError) {
+            await hooks.onListPostsError(error, context);
+          }
+          throw error;
+        }
+      }
+    );
+    const createPost = createEndpoint(
+      "/posts",
+      {
+        method: "POST",
+        body: createPostSchema
+      },
+      async (ctx) => {
+        const context = { body: ctx.body };
+        const tagCache = createTagCache();
+        try {
+          if (hooks?.onBeforeCreatePost) {
+            const canCreate = await hooks.onBeforeCreatePost(
+              ctx.body,
+              context
+            );
+            if (!canCreate) {
+              throw ctx.error(403, {
+                message: "Unauthorized: Cannot create post"
+              });
+            }
+          }
+          const { tags, ...postData } = ctx.body;
+          const tagNames = tags || [];
+          const newPost = await adapter.create({
+            model: "post",
+            data: {
+              ...postData,
+              slug: postData.slug ? postData.slug : slugify(postData.title),
+              tags: [],
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date()
+            }
+          });
+          if (tagNames.length > 0) {
+            const createdTags = await findOrCreateTags(tagNames, tagCache);
+            await adapter.transaction(async (tx) => {
+              for (const tag of createdTags) {
+                await tx.create({
+                  model: "postTag",
+                  data: {
+                    postId: newPost.id,
+                    tagId: tag.id
+                  }
+                });
+              }
+            });
+            newPost.tags = createdTags.map((tag) => ({ ...tag }));
+          } else {
+            newPost.tags = [];
+          }
+          if (hooks?.onPostCreated) {
+            await hooks.onPostCreated(newPost, context);
+          }
+          return newPost;
+        } catch (error) {
+          if (hooks?.onCreatePostError) {
+            await hooks.onCreatePostError(error, context);
+          }
+          throw error;
+        }
+      }
+    );
+    const updatePost = createEndpoint(
+      "/posts/:id",
+      {
+        method: "PUT",
+        body: updatePostSchema
+      },
+      async (ctx) => {
+        const context = {
+          body: ctx.body,
+          params: ctx.params
+        };
+        const tagCache = createTagCache();
+        try {
+          if (hooks?.onBeforeUpdatePost) {
+            const canUpdate = await hooks.onBeforeUpdatePost(
+              ctx.params.id,
+              ctx.body,
+              context
+            );
+            if (!canUpdate) {
+              throw ctx.error(403, {
+                message: "Unauthorized: Cannot update post"
+              });
+            }
+          }
+          const { tags, ...postData } = ctx.body;
+          const tagNames = tags || [];
+          const updated = await adapter.transaction(async (tx) => {
+            const existingPostTags = await tx.findMany({
+              model: "postTag",
+              where: [
+                {
+                  field: "postId",
+                  value: ctx.params.id,
+                  operator: "eq"
+                }
+              ]
+            });
+            const updatedPost = await tx.update({
+              model: "post",
+              where: [{ field: "id", value: ctx.params.id }],
+              update: {
+                ...postData,
+                updatedAt: /* @__PURE__ */ new Date()
+              }
+            });
+            if (!updatedPost) {
+              throw ctx.error(404, {
+                message: "Post not found"
+              });
+            }
+            for (const postTag of existingPostTags) {
+              await tx.delete({
+                model: "postTag",
+                where: [
+                  {
+                    field: "postId",
+                    value: postTag.postId,
+                    operator: "eq"
+                  },
+                  {
+                    field: "tagId",
+                    value: postTag.tagId,
+                    operator: "eq"
+                  }
+                ]
+              });
+            }
+            if (tagNames.length > 0) {
+              const createdTags = await findOrCreateTags(tagNames, tagCache);
+              for (const tag of createdTags) {
+                await tx.create({
+                  model: "postTag",
+                  data: {
+                    postId: ctx.params.id,
+                    tagId: tag.id
+                  }
+                });
+              }
+              updatedPost.tags = createdTags.map((tag) => ({ ...tag }));
+            } else {
+              updatedPost.tags = [];
+            }
+            return updatedPost;
+          });
+          if (hooks?.onPostUpdated) {
+            await hooks.onPostUpdated(updated, context);
+          }
+          return updated;
+        } catch (error) {
+          if (hooks?.onUpdatePostError) {
+            await hooks.onUpdatePostError(error, context);
+          }
+          throw error;
+        }
+      }
+    );
+    const deletePost = createEndpoint(
+      "/posts/:id",
+      {
+        method: "DELETE"
+      },
+      async (ctx) => {
+        const context = { params: ctx.params };
+        try {
+          if (hooks?.onBeforeDeletePost) {
+            const canDelete = await hooks.onBeforeDeletePost(
+              ctx.params.id,
+              context
+            );
+            if (!canDelete) {
+              throw ctx.error(403, {
+                message: "Unauthorized: Cannot delete post"
+              });
+            }
+          }
+          await adapter.transaction(async (tx) => {
+            await tx.delete({
+              model: "postTag",
+              where: [{ field: "postId", value: ctx.params.id }]
+            });
+            await tx.delete({
+              model: "post",
+              where: [{ field: "id", value: ctx.params.id }]
+            });
+          });
+          if (hooks?.onPostDeleted) {
+            await hooks.onPostDeleted(ctx.params.id, context);
+          }
+          return { success: true };
+        } catch (error) {
+          if (hooks?.onDeletePostError) {
+            await hooks.onDeletePostError(error, context);
+          }
+          throw error;
+        }
+      }
+    );
+    const getNextPreviousPosts = createEndpoint(
+      "/posts/next-previous",
+      {
+        method: "GET",
+        query: NextPreviousPostsQuerySchema
+      },
+      async (ctx) => {
+        const { query } = ctx;
+        const context = { query };
+        const tagCache = createTagCache();
+        const postTagCache = createPostTagCache();
+        try {
+          if (hooks?.onBeforeListPosts) {
+            const canList = await hooks.onBeforeListPosts(
+              { published: true },
+              context
+            );
+            if (!canList) {
+              throw ctx.error(403, {
+                message: "Unauthorized: Cannot list posts"
+              });
+            }
+          }
+          const date = query.date;
+          const previousPost = await adapter.findMany({
+            model: "post",
+            limit: 1,
+            where: [
+              {
+                field: "createdAt",
+                value: date,
+                operator: "lt"
+              },
+              {
+                field: "published",
+                value: true,
+                operator: "eq"
+              }
+            ],
+            sortBy: {
+              field: "createdAt",
+              direction: "desc"
+            }
+          });
+          const nextPost = await adapter.findMany({
+            model: "post",
+            limit: 1,
+            where: [
+              {
+                field: "createdAt",
+                value: date,
+                operator: "gt"
+              },
+              {
+                field: "published",
+                value: true,
+                operator: "eq"
+              }
+            ],
+            sortBy: {
+              field: "createdAt",
+              direction: "asc"
+            }
+          });
+          const postIds = [
+            ...previousPost?.[0] ? [previousPost[0].id] : [],
+            ...nextPost?.[0] ? [nextPost[0].id] : []
+          ];
+          const postTagsMap = await loadTagsForPosts(
+            postIds,
+            tagCache,
+            postTagCache
+          );
+          return {
+            previous: previousPost?.[0] ? {
+              ...previousPost[0],
+              tags: postTagsMap.get(previousPost[0].id) || []
+            } : null,
+            next: nextPost?.[0] ? {
+              ...nextPost[0],
+              tags: postTagsMap.get(nextPost[0].id) || []
+            } : null
+          };
+        } catch (error) {
+          if (hooks?.onListPostsError) {
+            await hooks.onListPostsError(error, context);
+          }
+          throw error;
+        }
+      }
+    );
+    const listTags = createEndpoint(
+      "/tags",
+      {
+        method: "GET"
+      },
+      async () => {
+        return await adapter.findMany({
+          model: "tag"
+        });
+      }
+    );
+    return {
+      listPosts,
+      createPost,
+      updatePost,
+      deletePost,
+      getNextPreviousPosts,
+      listTags
+    };
+  }
+});
+
+export { NextPreviousPostsQuerySchema, PostListQuerySchema, blogBackendPlugin };

package/dist/plugins/blog/client/components/forms/image-field.cjs

@@ -0,0 +1,133 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const button = require('@workspace/ui/components/button');
+const form = require('@workspace/ui/components/form');
+const input = require('@workspace/ui/components/input');
+const context = require('@btst/stack/context');
+const lucideReact = require('lucide-react');
+const React = require('react');
+const sonner = require('sonner');
+const index = require('../../localization/index.cjs');
+
+function FeaturedImageField({
+  isRequired,
+  value,
+  onChange,
+  setFeaturedImageUploading
+}) {
+  const fileInputRef = React.useRef(null);
+  const [isUploading, setIsUploading] = React.useState(false);
+  const { uploadImage, Image, localization } = context.usePluginOverrides("blog", { localization: index.BLOG_LOCALIZATION });
+  const ImageComponent = Image ? Image : DefaultImage;
+  const handleImageUpload = async (event) => {
+    const file = event.target.files?.[0];
+    if (!file) return;
+    if (!file.type.startsWith("image/")) {
+      sonner.toast.error(localization.BLOG_FORMS_FEATURED_IMAGE_ERROR_NOT_IMAGE);
+      return;
+    }
+    if (file.size > 4 * 1024 * 1024) {
+      sonner.toast.error(localization.BLOG_FORMS_FEATURED_IMAGE_ERROR_TOO_LARGE);
+      return;
+    }
+    try {
+      setIsUploading(true);
+      setFeaturedImageUploading(true);
+      const url = await uploadImage(file);
+      onChange(url);
+      sonner.toast.success(localization.BLOG_FORMS_FEATURED_IMAGE_TOAST_SUCCESS);
+    } catch (error) {
+      sonner.toast.error(localization.BLOG_FORMS_FEATURED_IMAGE_TOAST_FAILURE);
+      console.error("Failed to upload image:", error);
+      sonner.toast.error(localization.BLOG_FORMS_FEATURED_IMAGE_TOAST_FAILURE);
+    } finally {
+      setIsUploading(false);
+      setFeaturedImageUploading(false);
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(form.FormItem, { className: "flex flex-col", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(form.FormLabel, { children: [
+      localization.BLOG_FORMS_FEATURED_IMAGE_LABEL,
+      isRequired && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "text-destructive", children: [
+        " ",
+        localization.BLOG_FORMS_FEATURED_IMAGE_REQUIRED_ASTERISK
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(form.FormControl, { children: /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex gap-2", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          input.Input,
+          {
+            placeholder: localization.BLOG_FORMS_FEATURED_IMAGE_INPUT_PLACEHOLDER,
+            value: value || "",
+            onChange: (e) => onChange(e.target.value),
+            disabled: isUploading
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          button.Button,
+          {
+            type: "button",
+            variant: "outline",
+            onClick: () => fileInputRef.current?.click(),
+            disabled: isUploading,
+            children: isUploading ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "mr-2 h-4 w-4 animate-spin" }),
+              localization.BLOG_FORMS_FEATURED_IMAGE_UPLOADING_BUTTON
+            ] }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+              /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Upload, { className: "mr-2 h-4 w-4" }),
+              localization.BLOG_FORMS_FEATURED_IMAGE_UPLOAD_BUTTON
+            ] })
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          accept: "image/*",
+          onChange: handleImageUpload,
+          className: "hidden"
+        }
+      ),
+      isUploading && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2 text-muted-foreground text-sm", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(lucideReact.Loader2, { className: "h-4 w-4 animate-spin" }),
+        localization.BLOG_FORMS_FEATURED_IMAGE_UPLOADING_TEXT
+      ] }),
+      value && !isUploading && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative", children: /* @__PURE__ */ jsxRuntime.jsx(
+        ImageComponent,
+        {
+          src: value,
+          alt: localization.BLOG_FORMS_FEATURED_IMAGE_PREVIEW_ALT,
+          className: "h-auto w-full max-w-xs rounded-md border",
+          width: 400,
+          height: 400
+        }
+      ) })
+    ] }) }),
+    /* @__PURE__ */ jsxRuntime.jsx(form.FormDescription, {}),
+    /* @__PURE__ */ jsxRuntime.jsx(form.FormMessage, {})
+  ] });
+}
+function DefaultImage({
+  src,
+  alt,
+  className,
+  width,
+  height
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "img",
+    {
+      src,
+      alt,
+      className,
+      width,
+      height
+    }
+  );
+}
+
+exports.FeaturedImageField = FeaturedImageField;