@btst/stack 2.1.0 → 2.2.0

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

@@ -3,6 +3,7 @@ import { z } from 'zod';
 import { blogSchema } from '../db.mjs';
 import { slugify } from '../utils.mjs';
 import { createPostSchema, updatePostSchema } from '../schemas.mjs';
+import { getAllTags, getPostBySlug, getAllPosts } from './getters.mjs';
 
 const PostListQuerySchema = z.object({
   slug: z.string().optional(),
@@ -23,6 +24,11 @@ const NextPreviousPostsQuerySchema = z.object({
 const blogBackendPlugin = (hooks) => defineBackendPlugin({
   name: "blog",
   dbPlugin: blogSchema,
+  api: (adapter) => ({
+    getAllPosts: (params) => getAllPosts(adapter, params),
+    getPostBySlug: (slug) => getPostBySlug(adapter, slug),
+    getAllTags: () => getAllTags(adapter)
+  }),
   routes: (adapter) => {
     const findOrCreateTags = async (tagInputs) => {
       if (tagInputs.length === 0) return [];
@@ -103,111 +109,9 @@ const blogBackendPlugin = (hooks) => defineBackendPlugin({
               });
             }
           }
-          let tagFilterPostIds = null;
-          if (query.tagSlug) {
-            const tag = await adapter.findOne({
-              model: "tag",
-              where: [
-                {
-                  field: "slug",
-                  value: query.tagSlug,
-                  operator: "eq"
-                }
-              ]
-            });
-            if (!tag) {
-              return [];
-            }
-            const postTags = await adapter.findMany({
-              model: "postTag",
-              where: [
-                {
-                  field: "tagId",
-                  value: tag.id,
-                  operator: "eq"
-                }
-              ]
-            });
-            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"
-            },
-            join: {
-              postTag: true
-            }
-          });
-          const tagIds = /* @__PURE__ */ new Set();
-          for (const post of posts) {
-            if (post.postTag) {
-              for (const pt of post.postTag) {
-                tagIds.add(pt.tagId);
-              }
-            }
-          }
-          const tags = tagIds.size > 0 ? await adapter.findMany({
-            model: "tag"
-          }) : [];
-          const tagMap = /* @__PURE__ */ new Map();
-          for (const tag of tags) {
-            if (tagIds.has(tag.id)) {
-              tagMap.set(tag.id, tag);
-            }
-          }
-          let result = posts.map((post) => {
-            const postTags = (post.postTag || []).map((pt) => {
-              const tag = tagMap.get(pt.tagId);
-              return tag ? { ...tag } : void 0;
-            }).filter((tag) => tag !== void 0);
-            const { postTag: _, ...postWithoutJoin } = post;
-            return {
-              ...postWithoutJoin,
-              tags: postTags
-            };
-          });
-          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);
-          }
+          const result = await getAllPosts(adapter, query);
           if (hooks?.onPostsRead) {
-            await hooks.onPostsRead(result, query, context);
+            await hooks.onPostsRead(result.items, query, context);
           }
           return result;
         } catch (error) {
@@ -550,9 +454,7 @@ const blogBackendPlugin = (hooks) => defineBackendPlugin({
         method: "GET"
       },
       async () => {
-        return await adapter.findMany({
-          model: "tag"
-        });
+        return await getAllTags(adapter);
       }
     );
     return {

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

@@ -472,7 +472,7 @@ const blogClientPlugin = (config) => client.defineClientPlugin({
           published: "true"
         }
       });
-      const page = res.data ?? [];
+      const page = res.data?.items ?? [];
       posts.push(...page);
       if (page.length < limit) break;
       offset += limit;

package/dist/packages/stack/src/plugins/blog/client/plugin.mjs

@@ -470,7 +470,7 @@ const blogClientPlugin = (config) => defineClientPlugin({
           published: "true"
         }
       });
-      const page = res.data ?? [];
+      const page = res.data?.items ?? [];
       posts.push(...page);
       if (page.length < limit) break;
       offset += limit;

package/dist/packages/stack/src/plugins/cms/api/getters.cjs

@@ -0,0 +1,146 @@
+'use strict';
+
+function serializeContentType(ct) {
+  const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+  const migratedJsonSchema = needsMigration ? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig) : ct.jsonSchema;
+  return {
+    id: ct.id,
+    name: ct.name,
+    slug: ct.slug,
+    description: ct.description,
+    jsonSchema: migratedJsonSchema,
+    createdAt: ct.createdAt.toISOString(),
+    updatedAt: ct.updatedAt.toISOString()
+  };
+}
+function migrateToUnifiedSchema(jsonSchemaStr, fieldConfigStr) {
+  if (!fieldConfigStr) return jsonSchemaStr;
+  try {
+    const jsonSchema = JSON.parse(jsonSchemaStr);
+    const fieldConfig = JSON.parse(fieldConfigStr);
+    if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+      return jsonSchemaStr;
+    }
+    for (const [key, config] of Object.entries(fieldConfig)) {
+      if (jsonSchema.properties[key] && typeof config === "object" && config !== null && "fieldType" in config) {
+        jsonSchema.properties[key].fieldType = config.fieldType;
+      }
+    }
+    return JSON.stringify(jsonSchema);
+  } catch {
+    return jsonSchemaStr;
+  }
+}
+function serializeContentItem(item) {
+  return {
+    ...item,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString()
+  };
+}
+function serializeContentItemWithType(item) {
+  const parsedData = JSON.parse(item.data);
+  return {
+    ...serializeContentItem(item),
+    parsedData,
+    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
+  };
+}
+async function getAllContentTypes(adapter) {
+  const contentTypes = await adapter.findMany({
+    model: "contentType",
+    sortBy: { field: "name", direction: "asc" }
+  });
+  return contentTypes.map(serializeContentType);
+}
+async function getAllContentItems(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  const whereConditions = [
+    {
+      field: "contentTypeId",
+      value: contentType.id,
+      operator: "eq"
+    }
+  ];
+  if (params?.slug) {
+    whereConditions.push({
+      field: "slug",
+      value: params.slug,
+      operator: "eq"
+    });
+  }
+  const total = await adapter.count({
+    model: "contentItem",
+    where: whereConditions
+  });
+  const items = await adapter.findMany({
+    model: "contentItem",
+    where: whereConditions,
+    limit: params?.limit,
+    offset: params?.offset,
+    sortBy: { field: "createdAt", direction: "desc" },
+    join: { contentType: true }
+  });
+  return {
+    items: items.map(serializeContentItemWithType),
+    total,
+    limit: params?.limit,
+    offset: params?.offset
+  };
+}
+async function getContentItemBySlug(adapter, contentTypeSlug, slug) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return null;
+  }
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [
+      {
+        field: "contentTypeId",
+        value: contentType.id,
+        operator: "eq"
+      },
+      { field: "slug", value: slug, operator: "eq" }
+    ],
+    join: { contentType: true }
+  });
+  if (!item) {
+    return null;
+  }
+  return serializeContentItemWithType(item);
+}
+
+exports.getAllContentItems = getAllContentItems;
+exports.getAllContentTypes = getAllContentTypes;
+exports.getContentItemBySlug = getContentItemBySlug;
+exports.migrateToUnifiedSchema = migrateToUnifiedSchema;
+exports.serializeContentItem = serializeContentItem;
+exports.serializeContentItemWithType = serializeContentItemWithType;
+exports.serializeContentType = serializeContentType;

package/dist/packages/stack/src/plugins/cms/api/getters.mjs

@@ -0,0 +1,138 @@
+function serializeContentType(ct) {
+  const needsMigration = !ct.autoFormVersion || ct.autoFormVersion < 2;
+  const migratedJsonSchema = needsMigration ? migrateToUnifiedSchema(ct.jsonSchema, ct.fieldConfig) : ct.jsonSchema;
+  return {
+    id: ct.id,
+    name: ct.name,
+    slug: ct.slug,
+    description: ct.description,
+    jsonSchema: migratedJsonSchema,
+    createdAt: ct.createdAt.toISOString(),
+    updatedAt: ct.updatedAt.toISOString()
+  };
+}
+function migrateToUnifiedSchema(jsonSchemaStr, fieldConfigStr) {
+  if (!fieldConfigStr) return jsonSchemaStr;
+  try {
+    const jsonSchema = JSON.parse(jsonSchemaStr);
+    const fieldConfig = JSON.parse(fieldConfigStr);
+    if (!jsonSchema.properties || typeof fieldConfig !== "object") {
+      return jsonSchemaStr;
+    }
+    for (const [key, config] of Object.entries(fieldConfig)) {
+      if (jsonSchema.properties[key] && typeof config === "object" && config !== null && "fieldType" in config) {
+        jsonSchema.properties[key].fieldType = config.fieldType;
+      }
+    }
+    return JSON.stringify(jsonSchema);
+  } catch {
+    return jsonSchemaStr;
+  }
+}
+function serializeContentItem(item) {
+  return {
+    ...item,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString()
+  };
+}
+function serializeContentItemWithType(item) {
+  const parsedData = JSON.parse(item.data);
+  return {
+    ...serializeContentItem(item),
+    parsedData,
+    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
+  };
+}
+async function getAllContentTypes(adapter) {
+  const contentTypes = await adapter.findMany({
+    model: "contentType",
+    sortBy: { field: "name", direction: "asc" }
+  });
+  return contentTypes.map(serializeContentType);
+}
+async function getAllContentItems(adapter, contentTypeSlug, params) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return {
+      items: [],
+      total: 0,
+      limit: params?.limit,
+      offset: params?.offset
+    };
+  }
+  const whereConditions = [
+    {
+      field: "contentTypeId",
+      value: contentType.id,
+      operator: "eq"
+    }
+  ];
+  if (params?.slug) {
+    whereConditions.push({
+      field: "slug",
+      value: params.slug,
+      operator: "eq"
+    });
+  }
+  const total = await adapter.count({
+    model: "contentItem",
+    where: whereConditions
+  });
+  const items = await adapter.findMany({
+    model: "contentItem",
+    where: whereConditions,
+    limit: params?.limit,
+    offset: params?.offset,
+    sortBy: { field: "createdAt", direction: "desc" },
+    join: { contentType: true }
+  });
+  return {
+    items: items.map(serializeContentItemWithType),
+    total,
+    limit: params?.limit,
+    offset: params?.offset
+  };
+}
+async function getContentItemBySlug(adapter, contentTypeSlug, slug) {
+  const contentType = await adapter.findOne({
+    model: "contentType",
+    where: [
+      {
+        field: "slug",
+        value: contentTypeSlug,
+        operator: "eq"
+      }
+    ]
+  });
+  if (!contentType) {
+    return null;
+  }
+  const item = await adapter.findOne({
+    model: "contentItem",
+    where: [
+      {
+        field: "contentTypeId",
+        value: contentType.id,
+        operator: "eq"
+      },
+      { field: "slug", value: slug, operator: "eq" }
+    ],
+    join: { contentType: true }
+  });
+  if (!item) {
+    return null;
+  }
+  return serializeContentItemWithType(item);
+}
+
+export { getAllContentItems, getAllContentTypes, getContentItemBySlug, migrateToUnifiedSchema, serializeContentItem, serializeContentItemWithType, serializeContentType };