@btst/stack 1.0.0 → 1.1.0

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

@@ -0,0 +1,569 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const zod = require('zod');
+const db = require('../db.cjs');
+const utils = require('../utils.cjs');
+const schemas = require('../schemas.cjs');
+
+const PostListQuerySchema = zod.z.object({
+  slug: zod.z.string().optional(),
+  tagSlug: zod.z.string().optional(),
+  offset: zod.z.coerce.number().int().min(0).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(100).optional(),
+  query: zod.z.string().optional(),
+  published: zod.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 = zod.z.object({
+  date: zod.z.coerce.date()
+});
+const blogBackendPlugin = (hooks) => api.defineBackendPlugin({
+  name: "blog",
+  dbPlugin: db.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) => utils.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(utils.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: utils.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 = api.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 = api.createEndpoint(
+      "/posts",
+      {
+        method: "POST",
+        body: schemas.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 : utils.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 = api.createEndpoint(
+      "/posts/:id",
+      {
+        method: "PUT",
+        body: schemas.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 = api.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 = api.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 = api.createEndpoint(
+      "/tags",
+      {
+        method: "GET"
+      },
+      async () => {
+        return await adapter.findMany({
+          model: "tag"
+        });
+      }
+    );
+    return {
+      listPosts,
+      createPost,
+      updatePost,
+      deletePost,
+      getNextPreviousPosts,
+      listTags
+    };
+  }
+});
+
+exports.NextPreviousPostsQuerySchema = NextPreviousPostsQuerySchema;
+exports.PostListQuerySchema = PostListQuerySchema;
+exports.blogBackendPlugin = blogBackendPlugin;