@btst/stack 2.11.0 → 2.11.2

package/dist/packages/stack/src/plugins/blog/api/mutations.cjs

@@ -0,0 +1,170 @@
+'use strict';
+
+const utils = require('../utils.cjs');
+
+async function findOrCreateTags(adapter, tagInputs) {
+  if (tagInputs.length === 0) return [];
+  const normalizeTagName = (name) => 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 adapter.findMany({ model: "tag" });
+  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);
+  }
+  return [...tagsWithIds, ...foundTags, ...createdTags];
+}
+async function createPost(adapter, input) {
+  const { tags: tagInputs, ...postData } = input;
+  const tagList = tagInputs ?? [];
+  const newPost = await adapter.create({
+    model: "post",
+    data: {
+      ...postData,
+      published: postData.published ?? false,
+      tags: [],
+      createdAt: postData.createdAt ?? /* @__PURE__ */ new Date(),
+      updatedAt: postData.updatedAt ?? /* @__PURE__ */ new Date()
+    }
+  });
+  if (tagList.length > 0) {
+    const resolvedTags = await findOrCreateTags(adapter, tagList);
+    await adapter.transaction(async (tx) => {
+      for (const tag of resolvedTags) {
+        await tx.create({
+          model: "postTag",
+          data: {
+            postId: newPost.id,
+            tagId: tag.id
+          }
+        });
+      }
+    });
+    newPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+  } else {
+    newPost.tags = [];
+  }
+  return newPost;
+}
+async function updatePost(adapter, id, input) {
+  const { tags: tagInputs, ...postData } = input;
+  return adapter.transaction(async (tx) => {
+    const updatedPost = await tx.update({
+      model: "post",
+      where: [{ field: "id", value: id }],
+      update: {
+        ...postData,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (!updatedPost) return null;
+    if (tagInputs !== void 0) {
+      const existingPostTags = await tx.findMany({
+        model: "postTag",
+        where: [{ field: "postId", value: id, operator: "eq" }]
+      });
+      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 (tagInputs.length > 0) {
+        const resolvedTags = await findOrCreateTags(adapter, tagInputs);
+        for (const tag of resolvedTags) {
+          await tx.create({
+            model: "postTag",
+            data: {
+              postId: id,
+              tagId: tag.id
+            }
+          });
+        }
+        updatedPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+      } else {
+        updatedPost.tags = [];
+      }
+    } else {
+      const existingPostTags = await tx.findMany({
+        model: "postTag",
+        where: [{ field: "postId", value: id, operator: "eq" }]
+      });
+      if (existingPostTags.length > 0) {
+        const tagIds = existingPostTags.map((pt) => pt.tagId);
+        const tags = await tx.findMany({
+          model: "tag"
+        });
+        updatedPost.tags = tags.filter((tag) => tagIds.includes(tag.id)).map((tag) => ({ ...tag }));
+      } else {
+        updatedPost.tags = [];
+      }
+    }
+    return updatedPost;
+  });
+}
+async function deletePost(adapter, id) {
+  await adapter.delete({
+    model: "post",
+    where: [{ field: "id", value: id }]
+  });
+}
+
+exports.createPost = createPost;
+exports.deletePost = deletePost;
+exports.updatePost = updatePost;

package/dist/packages/stack/src/plugins/blog/api/mutations.mjs

@@ -0,0 +1,166 @@
+import { slugify } from '../utils.mjs';
+
+async function findOrCreateTags(adapter, tagInputs) {
+  if (tagInputs.length === 0) return [];
+  const normalizeTagName = (name) => 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 adapter.findMany({ model: "tag" });
+  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);
+  }
+  return [...tagsWithIds, ...foundTags, ...createdTags];
+}
+async function createPost(adapter, input) {
+  const { tags: tagInputs, ...postData } = input;
+  const tagList = tagInputs ?? [];
+  const newPost = await adapter.create({
+    model: "post",
+    data: {
+      ...postData,
+      published: postData.published ?? false,
+      tags: [],
+      createdAt: postData.createdAt ?? /* @__PURE__ */ new Date(),
+      updatedAt: postData.updatedAt ?? /* @__PURE__ */ new Date()
+    }
+  });
+  if (tagList.length > 0) {
+    const resolvedTags = await findOrCreateTags(adapter, tagList);
+    await adapter.transaction(async (tx) => {
+      for (const tag of resolvedTags) {
+        await tx.create({
+          model: "postTag",
+          data: {
+            postId: newPost.id,
+            tagId: tag.id
+          }
+        });
+      }
+    });
+    newPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+  } else {
+    newPost.tags = [];
+  }
+  return newPost;
+}
+async function updatePost(adapter, id, input) {
+  const { tags: tagInputs, ...postData } = input;
+  return adapter.transaction(async (tx) => {
+    const updatedPost = await tx.update({
+      model: "post",
+      where: [{ field: "id", value: id }],
+      update: {
+        ...postData,
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (!updatedPost) return null;
+    if (tagInputs !== void 0) {
+      const existingPostTags = await tx.findMany({
+        model: "postTag",
+        where: [{ field: "postId", value: id, operator: "eq" }]
+      });
+      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 (tagInputs.length > 0) {
+        const resolvedTags = await findOrCreateTags(adapter, tagInputs);
+        for (const tag of resolvedTags) {
+          await tx.create({
+            model: "postTag",
+            data: {
+              postId: id,
+              tagId: tag.id
+            }
+          });
+        }
+        updatedPost.tags = resolvedTags.map((tag) => ({ ...tag }));
+      } else {
+        updatedPost.tags = [];
+      }
+    } else {
+      const existingPostTags = await tx.findMany({
+        model: "postTag",
+        where: [{ field: "postId", value: id, operator: "eq" }]
+      });
+      if (existingPostTags.length > 0) {
+        const tagIds = existingPostTags.map((pt) => pt.tagId);
+        const tags = await tx.findMany({
+          model: "tag"
+        });
+        updatedPost.tags = tags.filter((tag) => tagIds.includes(tag.id)).map((tag) => ({ ...tag }));
+      } else {
+        updatedPost.tags = [];
+      }
+    }
+    return updatedPost;
+  });
+}
+async function deletePost(adapter, id) {
+  await adapter.delete({
+    model: "post",
+    where: [{ field: "id", value: id }]
+  });
+}
+
+export { createPost, deletePost, updatePost };

package/dist/packages/stack/src/plugins/blog/api/plugin.cjs

@@ -6,6 +6,7 @@ const db = require('../db.cjs');
 const utils$1 = require('../utils.cjs');
 const schemas = require('../schemas.cjs');
 const getters = require('./getters.cjs');
+const mutations = require('./mutations.cjs');
 const queryKeyDefs = require('./query-key-defs.cjs');
 const serializers = require('./serializers.cjs');
 const utils = require('../../utils.cjs');
@@ -81,70 +82,13 @@ const blogBackendPlugin = (hooks) => api.defineBackendPlugin({
     getAllPosts: (params) => getters.getAllPosts(adapter, params),
     getPostBySlug: (slug) => getters.getPostBySlug(adapter, slug),
     getAllTags: () => getters.getAllTags(adapter),
-    prefetchForRoute: createBlogPrefetchForRoute(adapter)
+    prefetchForRoute: createBlogPrefetchForRoute(adapter),
+    // Mutations
+    createPost: (input) => mutations.createPost(adapter, input),
+    updatePost: (id, input) => mutations.updatePost(adapter, id, input),
+    deletePost: (id) => mutations.deletePost(adapter, id)
   }),
   routes: (adapter) => {
-    const findOrCreateTags = async (tagInputs) => {
-      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 adapter.findMany({
-        model: "tag"
-      });
-      const tagMapBySlug = /* @__PURE__ */ new Map();
-      for (const tag of allTags) {
-        tagMapBySlug.set(tag.slug, tag);
-      }
-      const tagSlugs = tagsToFindOrCreate.map((tag) => utils$1.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$1.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$1.slugify(normalizedName),
-            createdAt: /* @__PURE__ */ new Date(),
-            updatedAt: /* @__PURE__ */ new Date()
-          }
-        });
-        createdTags.push(newTag);
-      }
-      return [...tagsWithIds, ...foundTags, ...createdTags];
-    };
     const listPosts = api.createEndpoint(
       "/posts",
       {
@@ -194,41 +138,26 @@ const blogBackendPlugin = (hooks) => api.defineBackendPlugin({
               "Unauthorized: Cannot create post"
             );
           }
-          const { tags, ...postData } = ctx.body;
-          const tagNames = tags || [];
-          const slug = utils$1.slugify(postData.slug || postData.title);
+          const {
+            tags,
+            slug: rawSlug,
+            createdAt: _ca,
+            updatedAt: _ua,
+            ...postData
+          } = ctx.body;
+          const slug = utils$1.slugify(rawSlug || postData.title);
           if (!slug) {
             throw ctx.error(400, {
               message: "Invalid slug: must contain at least one alphanumeric character"
             });
           }
-          const newPost = await adapter.create({
-            model: "post",
-            data: {
-              ...postData,
-              slug,
-              tags: [],
-              createdAt: /* @__PURE__ */ new Date(),
-              updatedAt: /* @__PURE__ */ new Date()
-            }
+          const newPost = await mutations.createPost(adapter, {
+            ...postData,
+            slug,
+            tags: tags ?? [],
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
           });
-          if (tagNames.length > 0) {
-            const createdTags = await findOrCreateTags(tagNames);
-            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);
           }
@@ -261,76 +190,27 @@ const blogBackendPlugin = (hooks) => api.defineBackendPlugin({
               "Unauthorized: Cannot update post"
             );
           }
-          const { tags, slug: rawSlug, ...restPostData } = ctx.body;
-          const tagNames = tags || [];
+          const {
+            tags,
+            slug: rawSlug,
+            createdAt: _ca,
+            updatedAt: _ua,
+            ...restPostData
+          } = ctx.body;
           const slugified = rawSlug ? utils$1.slugify(rawSlug) : void 0;
           if (rawSlug && !slugified) {
             throw ctx.error(400, {
               message: "Invalid slug: must contain at least one alphanumeric character"
             });
           }
-          const postData = {
+          const updated = await mutations.updatePost(adapter, ctx.params.id, {
             ...restPostData,
-            ...slugified ? { slug: slugified } : {}
-          };
-          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);
-              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;
+            ...slugified ? { slug: slugified } : {},
+            tags: tags ?? []
           });
+          if (!updated) {
+            throw ctx.error(404, { message: "Post not found" });
+          }
           if (hooks?.onPostUpdated) {
             await hooks.onPostUpdated(updated, context);
           }
@@ -361,10 +241,7 @@ const blogBackendPlugin = (hooks) => api.defineBackendPlugin({
               "Unauthorized: Cannot delete post"
             );
           }
-          await adapter.delete({
-            model: "post",
-            where: [{ field: "id", value: ctx.params.id }]
-          });
+          await mutations.deletePost(adapter, ctx.params.id);
           if (hooks?.onPostDeleted) {
             await hooks.onPostDeleted(ctx.params.id, context);
           }