@btst/stack 1.4.1 → 1.5.1

package/dist/packages/better-stack/src/plugins/cms/api/plugin.cjs

@@ -0,0 +1,457 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const z = require('zod');
+const db = require('../db.cjs');
+const schemas = require('../schemas.cjs');
+const utils = require('../utils.cjs');
+
+function serializeContentType(ct) {
+  return {
+    ...ct,
+    createdAt: ct.createdAt.toISOString(),
+    updatedAt: ct.updatedAt.toISOString()
+  };
+}
+function serializeContentItem(item) {
+  return {
+    ...item,
+    createdAt: item.createdAt.toISOString(),
+    updatedAt: item.updatedAt.toISOString()
+  };
+}
+function serializeContentItemWithType(item) {
+  return {
+    ...serializeContentItem(item),
+    parsedData: JSON.parse(item.data),
+    contentType: item.contentType ? serializeContentType(item.contentType) : void 0
+  };
+}
+async function syncContentTypes(adapter, config) {
+  for (const ct of config.contentTypes) {
+    const jsonSchema = JSON.stringify(z.z.toJSONSchema(ct.schema));
+    const fieldConfig = ct.fieldConfig ? JSON.stringify(ct.fieldConfig) : null;
+    const existing = await adapter.findOne({
+      model: "contentType",
+      where: [{ field: "slug", value: ct.slug, operator: "eq" }]
+    });
+    if (existing) {
+      await adapter.update({
+        model: "contentType",
+        where: [{ field: "id", value: existing.id, operator: "eq" }],
+        update: {
+          name: ct.name,
+          description: ct.description ?? null,
+          jsonSchema,
+          fieldConfig,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } else {
+      try {
+        await adapter.create({
+          model: "contentType",
+          data: {
+            name: ct.name,
+            slug: ct.slug,
+            description: ct.description ?? null,
+            jsonSchema,
+            fieldConfig,
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+      } catch (err) {
+        const nowExists = await adapter.findOne({
+          model: "contentType",
+          where: [{ field: "slug", value: ct.slug, operator: "eq" }]
+        });
+        if (nowExists) {
+          continue;
+        }
+        const message = err instanceof Error ? err.message : "Unknown database error";
+        throw new Error(
+          `Failed to create content type "${ct.slug}": ${message}`
+        );
+      }
+    }
+  }
+}
+function getContentTypeZodSchema(contentType) {
+  const jsonSchema = JSON.parse(contentType.jsonSchema);
+  return z.z.fromJSONSchema(jsonSchema);
+}
+const cmsBackendPlugin = (config) => api.defineBackendPlugin({
+  name: "cms",
+  dbPlugin: db.cmsSchema,
+  routes: (adapter) => {
+    let syncPromise = null;
+    const ensureSynced = async () => {
+      if (!syncPromise) {
+        syncPromise = syncContentTypes(adapter, config).catch((err) => {
+          syncPromise = null;
+          throw err;
+        });
+      }
+      await syncPromise;
+    };
+    const getContentType = async (slug) => {
+      await ensureSynced();
+      return adapter.findOne({
+        model: "contentType",
+        where: [{ field: "slug", value: slug, operator: "eq" }]
+      });
+    };
+    const createContext = (typeSlug, headers) => ({
+      typeSlug,
+      headers
+    });
+    const listContentTypes = api.createEndpoint(
+      "/content-types",
+      { method: "GET" },
+      async (ctx) => {
+        await ensureSynced();
+        const contentTypes = await adapter.findMany({
+          model: "contentType",
+          sortBy: { field: "name", direction: "asc" }
+        });
+        const typesWithCounts = await Promise.all(
+          contentTypes.map(async (ct) => {
+            const items = await adapter.findMany({
+              model: "contentItem",
+              where: [
+                {
+                  field: "contentTypeId",
+                  value: ct.id,
+                  operator: "eq"
+                }
+              ]
+            });
+            return {
+              ...serializeContentType(ct),
+              itemCount: items.length
+            };
+          })
+        );
+        return typesWithCounts;
+      }
+    );
+    const getContentTypeBySlug = api.createEndpoint(
+      "/content-types/:slug",
+      {
+        method: "GET",
+        params: z.z.object({ slug: z.z.string() })
+      },
+      async (ctx) => {
+        const { slug } = ctx.params;
+        const contentType = await getContentType(slug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        return serializeContentType(contentType);
+      }
+    );
+    const listContentItems = api.createEndpoint(
+      "/content/:typeSlug",
+      {
+        method: "GET",
+        params: z.z.object({ typeSlug: z.z.string() }),
+        query: schemas.listContentQuerySchema
+      },
+      async (ctx) => {
+        const { typeSlug } = ctx.params;
+        const { slug, limit, offset } = ctx.query;
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const whereConditions = [
+          {
+            field: "contentTypeId",
+            value: contentType.id,
+            operator: "eq"
+          }
+        ];
+        if (slug) {
+          whereConditions.push({
+            field: "slug",
+            value: slug,
+            operator: "eq"
+          });
+        }
+        const allItems = await adapter.findMany({
+          model: "contentItem",
+          where: whereConditions
+        });
+        const total = allItems.length;
+        const items = await adapter.findMany({
+          model: "contentItem",
+          where: whereConditions,
+          limit,
+          offset,
+          sortBy: { field: "createdAt", direction: "desc" },
+          join: { contentType: true }
+        });
+        return {
+          items: items.map(serializeContentItemWithType),
+          total,
+          limit,
+          offset
+        };
+      }
+    );
+    const getContentItem = api.createEndpoint(
+      "/content/:typeSlug/:id",
+      {
+        method: "GET",
+        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+      },
+      async (ctx) => {
+        const { typeSlug, id } = ctx.params;
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const item = await adapter.findOne({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }],
+          join: { contentType: true }
+        });
+        if (!item || item.contentTypeId !== contentType.id) {
+          throw ctx.error(404, { message: "Content item not found" });
+        }
+        return serializeContentItemWithType(item);
+      }
+    );
+    const createContentItem = api.createEndpoint(
+      "/content/:typeSlug",
+      {
+        method: "POST",
+        params: z.z.object({ typeSlug: z.z.string() }),
+        body: z.z.object({
+          slug: z.z.string().min(1),
+          // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+          data: z.z.object({}).passthrough()
+        })
+      },
+      async (ctx) => {
+        const { typeSlug } = ctx.params;
+        const { slug: rawSlug, data } = ctx.body;
+        const context = createContext(typeSlug, ctx.headers);
+        const slug = utils.slugify(rawSlug);
+        if (!slug) {
+          throw ctx.error(400, {
+            message: "Invalid slug: must contain at least one alphanumeric character"
+          });
+        }
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const zodSchema = getContentTypeZodSchema(contentType);
+        const validation = zodSchema.safeParse(data);
+        if (!validation.success) {
+          throw ctx.error(400, {
+            message: "Validation failed",
+            errors: validation.error.issues
+          });
+        }
+        const existing = await adapter.findOne({
+          model: "contentItem",
+          where: [
+            {
+              field: "contentTypeId",
+              value: contentType.id,
+              operator: "eq"
+            },
+            { field: "slug", value: slug, operator: "eq" }
+          ]
+        });
+        if (existing) {
+          throw ctx.error(409, {
+            message: "Content item with this slug already exists"
+          });
+        }
+        let finalData = validation.data;
+        if (config.hooks?.onBeforeCreate) {
+          const result = await config.hooks.onBeforeCreate(
+            validation.data,
+            context
+          );
+          if (result === false) {
+            throw ctx.error(403, { message: "Create operation denied" });
+          }
+          if (result && typeof result === "object") {
+            finalData = result;
+          }
+        }
+        const item = await adapter.create({
+          model: "contentItem",
+          data: {
+            contentTypeId: contentType.id,
+            slug,
+            data: JSON.stringify(finalData),
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date()
+          }
+        });
+        const serialized = serializeContentItem(item);
+        if (config.hooks?.onAfterCreate) {
+          await config.hooks.onAfterCreate(serialized, context);
+        }
+        return {
+          ...serialized,
+          parsedData: finalData
+        };
+      }
+    );
+    const updateContentItem = api.createEndpoint(
+      "/content/:typeSlug/:id",
+      {
+        method: "PUT",
+        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() }),
+        body: z.z.object({
+          slug: z.z.string().min(1).optional(),
+          // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+          data: z.z.object({}).passthrough().optional()
+        })
+      },
+      async (ctx) => {
+        const { typeSlug, id } = ctx.params;
+        const { slug: rawSlug, data } = ctx.body;
+        const context = createContext(typeSlug, ctx.headers);
+        const slug = rawSlug ? utils.slugify(rawSlug) : void 0;
+        if (rawSlug && !slug) {
+          throw ctx.error(400, {
+            message: "Invalid slug: must contain at least one alphanumeric character"
+          });
+        }
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const existing = await adapter.findOne({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }]
+        });
+        if (!existing || existing.contentTypeId !== contentType.id) {
+          throw ctx.error(404, { message: "Content item not found" });
+        }
+        if (slug && slug !== existing.slug) {
+          const duplicate = await adapter.findOne({
+            model: "contentItem",
+            where: [
+              {
+                field: "contentTypeId",
+                value: contentType.id,
+                operator: "eq"
+              },
+              { field: "slug", value: slug, operator: "eq" }
+            ]
+          });
+          if (duplicate) {
+            throw ctx.error(409, {
+              message: "Content item with this slug already exists"
+            });
+          }
+        }
+        let validatedData = data;
+        if (data) {
+          const zodSchema = getContentTypeZodSchema(contentType);
+          const validation = zodSchema.safeParse(data);
+          if (!validation.success) {
+            throw ctx.error(400, {
+              message: "Validation failed",
+              errors: validation.error.issues
+            });
+          }
+          validatedData = validation.data;
+        }
+        let finalData = validatedData;
+        if (config.hooks?.onBeforeUpdate && validatedData) {
+          const result = await config.hooks.onBeforeUpdate(
+            id,
+            validatedData,
+            context
+          );
+          if (result === false) {
+            throw ctx.error(403, { message: "Update operation denied" });
+          }
+          if (result && typeof result === "object") {
+            finalData = result;
+          }
+        }
+        const updateData = {
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        if (slug) updateData.slug = slug;
+        if (finalData) updateData.data = JSON.stringify(finalData);
+        await adapter.update({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }],
+          update: updateData
+        });
+        const updated = await adapter.findOne({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }],
+          join: { contentType: true }
+        });
+        if (!updated) {
+          throw ctx.error(500, { message: "Failed to fetch updated item" });
+        }
+        const serialized = serializeContentItem(updated);
+        if (config.hooks?.onAfterUpdate) {
+          await config.hooks.onAfterUpdate(serialized, context);
+        }
+        return serializeContentItemWithType(updated);
+      }
+    );
+    const deleteContentItem = api.createEndpoint(
+      "/content/:typeSlug/:id",
+      {
+        method: "DELETE",
+        params: z.z.object({ typeSlug: z.z.string(), id: z.z.string() })
+      },
+      async (ctx) => {
+        const { typeSlug, id } = ctx.params;
+        const context = createContext(typeSlug, ctx.headers);
+        const contentType = await getContentType(typeSlug);
+        if (!contentType) {
+          throw ctx.error(404, { message: "Content type not found" });
+        }
+        const existing = await adapter.findOne({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }]
+        });
+        if (!existing || existing.contentTypeId !== contentType.id) {
+          throw ctx.error(404, { message: "Content item not found" });
+        }
+        if (config.hooks?.onBeforeDelete) {
+          const canDelete = await config.hooks.onBeforeDelete(id, context);
+          if (!canDelete) {
+            throw ctx.error(403, { message: "Delete operation denied" });
+          }
+        }
+        await adapter.delete({
+          model: "contentItem",
+          where: [{ field: "id", value: id, operator: "eq" }]
+        });
+        if (config.hooks?.onAfterDelete) {
+          await config.hooks.onAfterDelete(id, context);
+        }
+        return { success: true };
+      }
+    );
+    return {
+      listContentTypes,
+      getContentTypeBySlug,
+      listContentItems,
+      getContentItem,
+      createContentItem,
+      updateContentItem,
+      deleteContentItem
+    };
+  }
+});
+
+exports.cmsBackendPlugin = cmsBackendPlugin;