@btst/plugin-cms 0.0.0-stage → 1.0.0

package/dist/api/plugin.cjs

@@ -0,0 +1,337 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const z = require('zod');
+const schemaConverter = require('../ui/src/lib/schema-converter.cjs');
+const db = require('../db.cjs');
+const schemas = require('../schemas.cjs');
+const getters = require('./getters.cjs');
+const operations = require('./operations.cjs');
+const queryKeyDefs = require('./query-key-defs.cjs');
+
+function schemasEqual(stored, configured) {
+  const normalize = (key, value) => key !== "properties" && value && typeof value === "object" && !Array.isArray(value) ? Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a.localeCompare(b))
+  ) : value;
+  try {
+    return JSON.stringify(JSON.parse(stored), normalize) === JSON.stringify(JSON.parse(configured), normalize);
+  } catch {
+    return false;
+  }
+}
+async function syncContentTypes(adapter, config) {
+  for (const definition of config.contentTypes) {
+    const jsonSchema = JSON.stringify(schemaConverter.zodToFormSchema(definition.schema));
+    const existing = await adapter.findOne({
+      model: "contentType",
+      where: [
+        { field: "slug", value: definition.slug, operator: "eq" }
+      ]
+    });
+    if (existing) {
+      if (existing.name === definition.name && (existing.description ?? null) === (definition.description ?? null) && schemasEqual(existing.jsonSchema, jsonSchema) && existing.fieldConfig == null && existing.autoFormVersion === 2)
+        continue;
+      await adapter.update({
+        model: "contentType",
+        where: [{ field: "id", value: existing.id, operator: "eq" }],
+        update: {
+          name: definition.name,
+          description: definition.description ?? null,
+          jsonSchema,
+          fieldConfig: null,
+          autoFormVersion: 2,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      continue;
+    }
+    try {
+      await adapter.create({
+        model: "contentType",
+        data: {
+          name: definition.name,
+          slug: definition.slug,
+          description: definition.description ?? null,
+          jsonSchema,
+          fieldConfig: null,
+          autoFormVersion: 2,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } catch (error) {
+      const nowExists = await adapter.findOne({
+        model: "contentType",
+        where: [
+          { field: "slug", value: definition.slug, operator: "eq" }
+        ]
+      });
+      if (nowExists) continue;
+      throw new Error(
+        `Failed to create content type "${definition.slug}": ${error instanceof Error ? error.message : "Unknown database error"}`
+      );
+    }
+  }
+}
+const cmsBackendPlugin = (config) => {
+  let syncPromise = null;
+  const ensureSynced = (adapter) => {
+    if (!syncPromise) {
+      syncPromise = syncContentTypes(adapter, config).catch((error) => {
+        syncPromise = null;
+        throw error;
+      });
+    }
+    return syncPromise;
+  };
+  const getContentTypesWithCounts = async (adapter) => {
+    const contentTypes = await getters.getAllContentTypes(adapter);
+    return Promise.all(
+      contentTypes.map(async (contentType) => ({
+        ...contentType,
+        itemCount: await adapter.count({
+          model: "contentItem",
+          where: [
+            {
+              field: "contentTypeId",
+              value: contentType.id,
+              operator: "eq"
+            }
+          ]
+        })
+      }))
+    );
+  };
+  const createCMSPrefetchForRoute = (adapter) => async function prefetchForRoute(key, queryClient, params) {
+    await ensureSynced(adapter);
+    switch (key) {
+      case "dashboard":
+      case "newContent":
+        queryClient.setQueryData(
+          queryKeyDefs.CMS_QUERY_KEYS.typesList(),
+          await getContentTypesWithCounts(adapter)
+        );
+        break;
+      case "contentList": {
+        const typeSlug = params?.typeSlug ?? "";
+        const options = schemas.createListContentQuerySchema(
+          config.maxPageSize
+        ).parse({
+          limit: params?.limit,
+          search: params?.search,
+          view: params?.view,
+          fields: params?.fields
+        });
+        const [contentTypes, contentItems] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          getters.getAllContentItems(adapter, typeSlug, options)
+        ]);
+        queryClient.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.typesList(), contentTypes);
+        queryClient.setQueryData(
+          queryKeyDefs.CMS_QUERY_KEYS.contentList({ typeSlug, ...options }),
+          {
+            pages: [
+              {
+                items: contentItems.items,
+                total: contentItems.total,
+                limit: contentItems.limit ?? 20,
+                offset: contentItems.offset ?? 0
+              }
+            ],
+            pageParams: [0]
+          }
+        );
+        break;
+      }
+      case "editContent": {
+        const typeSlug = params?.typeSlug ?? "";
+        const id = params?.id ?? "";
+        const options = schemas.contentReadOptionsSchema.parse({
+          view: params?.view,
+          fields: params?.fields
+        });
+        const [contentTypes, item] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          id ? getters.getContentItemById(adapter, id, options) : Promise.resolve(null)
+        ]);
+        queryClient.setQueryData(queryKeyDefs.CMS_QUERY_KEYS.typesList(), contentTypes);
+        if (id) {
+          queryClient.setQueryData(
+            queryKeyDefs.CMS_QUERY_KEYS.contentDetail(typeSlug, id, options),
+            item
+          );
+        }
+        break;
+      }
+    }
+  };
+  return api.defineBackendPlugin({
+    id: "cms",
+    dbPlugin: db.cmsSchema,
+    operations: (adapter) => operations.createCMSOperations(adapter, {
+      ensureSynced: () => ensureSynced(adapter),
+      getContentTypesWithCounts: () => getContentTypesWithCounts(adapter),
+      ...config.maxPageSize !== void 0 ? { maxPageSize: config.maxPageSize } : {},
+      ...config.hooks ? { hooks: config.hooks } : {}
+    }),
+    /** Lower-level SSG helper that intentionally bypasses auth and hooks. */
+    raw: (adapter) => ({
+      prefetchForRoute: createCMSPrefetchForRoute(adapter)
+    }),
+    routes: (_adapter, _context, operations$1) => {
+      const listQuerySchema = schemas.createListContentQuerySchema(
+        config.maxPageSize
+      ).extend(schemas.contentReadQuerySchema.shape);
+      const paginationSchema = z.z.object({
+        limit: z.z.coerce.number().min(1).max(config.maxPageSize ?? schemas.DEFAULT_MAX_PAGE_SIZE).optional().default(20),
+        offset: z.z.coerce.number().min(0).optional().default(0)
+      });
+      const listContentTypes = api.createEndpoint(
+        "/content-types",
+        { method: "GET", requireRequest: true },
+        operations$1.listContentTypes.route(() => ({}))
+      );
+      const getContentTypeBySlug = api.createEndpoint(
+        "/content-types/:slug",
+        {
+          method: "GET",
+          params: operations.CMSContentTypeParamsSchema,
+          requireRequest: true
+        },
+        operations$1.getContentTypeBySlug.route((ctx) => ctx.params)
+      );
+      const listContentItems = api.createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string().min(1) }),
+          query: listQuerySchema,
+          requireRequest: true
+        },
+        operations$1.listContentItems.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
+      );
+      const getContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "GET",
+          params: operations.CMSContentItemParamsSchema,
+          query: schemas.contentReadQuerySchema,
+          requireRequest: true
+        },
+        operations$1.getContentItem.route((ctx) => ({
+          ...ctx.params,
+          ...ctx.query
+        }))
+      );
+      const createContentItem = api.createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "POST",
+          params: z.z.object({ typeSlug: z.z.string().min(1) }),
+          body: operations.CMSCreateContentItemBodySchema,
+          requireRequest: true
+        },
+        operations$1.createContentItem.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          body: ctx.body
+        }))
+      );
+      const updateContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "PUT",
+          params: operations.CMSContentItemParamsSchema,
+          body: operations.CMSUpdateContentItemBodySchema,
+          requireRequest: true
+        },
+        operations$1.updateContentItem.route((ctx) => ({
+          ...ctx.params,
+          body: ctx.body
+        }))
+      );
+      const deleteContentItem = api.createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "DELETE",
+          params: operations.CMSContentItemParamsSchema,
+          requireRequest: true
+        },
+        operations$1.deleteContentItem.route((ctx) => ctx.params)
+      );
+      const getContentItemPopulated = api.createEndpoint(
+        "/content/:typeSlug/:id/populated",
+        {
+          method: "GET",
+          params: operations.CMSContentItemParamsSchema,
+          requireRequest: true
+        },
+        operations$1.getContentItemPopulated.route((ctx) => ctx.params)
+      );
+      const listContentByRelation = api.createEndpoint(
+        "/content/:typeSlug/by-relation",
+        {
+          method: "GET",
+          params: z.z.object({ typeSlug: z.z.string().min(1) }),
+          query: z.z.object({ field: z.z.string(), targetId: z.z.string() }).merge(paginationSchema).merge(schemas.contentReadQuerySchema),
+          requireRequest: true
+        },
+        operations$1.listContentByRelation.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
+      );
+      const getInverseRelations = api.createEndpoint(
+        "/content-types/:slug/inverse-relations",
+        {
+          method: "GET",
+          params: operations.CMSContentTypeParamsSchema,
+          query: z.z.object({ itemId: z.z.string().optional() }),
+          requireRequest: true
+        },
+        operations$1.getInverseRelations.route((ctx) => ({
+          slug: ctx.params.slug,
+          query: ctx.query
+        }))
+      );
+      const listInverseRelationItems = api.createEndpoint(
+        "/content-types/:slug/inverse-relations/:sourceType",
+        {
+          method: "GET",
+          params: z.z.object({
+            slug: z.z.string().min(1),
+            sourceType: z.z.string().min(1)
+          }),
+          query: z.z.object({ itemId: z.z.string(), fieldName: z.z.string() }).merge(paginationSchema).merge(schemas.contentReadQuerySchema),
+          requireRequest: true
+        },
+        operations$1.listInverseRelationItems.route((ctx) => ({
+          slug: ctx.params.slug,
+          sourceType: ctx.params.sourceType,
+          query: ctx.query
+        }))
+      );
+      return {
+        listContentTypes,
+        getContentTypeBySlug,
+        listContentItems,
+        getContentItem,
+        createContentItem,
+        updateContentItem,
+        deleteContentItem,
+        getContentItemPopulated,
+        listContentByRelation,
+        getInverseRelations,
+        listInverseRelationItems
+      };
+    }
+  });
+};
+
+exports.CMSContentItemParamsSchema = operations.CMSContentItemParamsSchema;
+exports.CMSContentTypeParamsSchema = operations.CMSContentTypeParamsSchema;
+exports.CMSCreateContentItemBodySchema = operations.CMSCreateContentItemBodySchema;
+exports.CMSUpdateContentItemBodySchema = operations.CMSUpdateContentItemBodySchema;
+exports.cmsBackendPlugin = cmsBackendPlugin;

package/dist/api/plugin.mjs

@@ -0,0 +1,331 @@
+import { defineBackendPlugin, createEndpoint } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { zodToFormSchema } from '../ui/src/lib/schema-converter.mjs';
+import { cmsSchema } from '../db.mjs';
+import { createListContentQuerySchema, contentReadQuerySchema, DEFAULT_MAX_PAGE_SIZE, contentReadOptionsSchema } from '../schemas.mjs';
+import { getContentItemById, getAllContentItems, getAllContentTypes } from './getters.mjs';
+import { CMSContentTypeParamsSchema, CMSContentItemParamsSchema, CMSCreateContentItemBodySchema, CMSUpdateContentItemBodySchema, createCMSOperations } from './operations.mjs';
+import { CMS_QUERY_KEYS } from './query-key-defs.mjs';
+
+function schemasEqual(stored, configured) {
+  const normalize = (key, value) => key !== "properties" && value && typeof value === "object" && !Array.isArray(value) ? Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a.localeCompare(b))
+  ) : value;
+  try {
+    return JSON.stringify(JSON.parse(stored), normalize) === JSON.stringify(JSON.parse(configured), normalize);
+  } catch {
+    return false;
+  }
+}
+async function syncContentTypes(adapter, config) {
+  for (const definition of config.contentTypes) {
+    const jsonSchema = JSON.stringify(zodToFormSchema(definition.schema));
+    const existing = await adapter.findOne({
+      model: "contentType",
+      where: [
+        { field: "slug", value: definition.slug, operator: "eq" }
+      ]
+    });
+    if (existing) {
+      if (existing.name === definition.name && (existing.description ?? null) === (definition.description ?? null) && schemasEqual(existing.jsonSchema, jsonSchema) && existing.fieldConfig == null && existing.autoFormVersion === 2)
+        continue;
+      await adapter.update({
+        model: "contentType",
+        where: [{ field: "id", value: existing.id, operator: "eq" }],
+        update: {
+          name: definition.name,
+          description: definition.description ?? null,
+          jsonSchema,
+          fieldConfig: null,
+          autoFormVersion: 2,
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+      continue;
+    }
+    try {
+      await adapter.create({
+        model: "contentType",
+        data: {
+          name: definition.name,
+          slug: definition.slug,
+          description: definition.description ?? null,
+          jsonSchema,
+          fieldConfig: null,
+          autoFormVersion: 2,
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        }
+      });
+    } catch (error) {
+      const nowExists = await adapter.findOne({
+        model: "contentType",
+        where: [
+          { field: "slug", value: definition.slug, operator: "eq" }
+        ]
+      });
+      if (nowExists) continue;
+      throw new Error(
+        `Failed to create content type "${definition.slug}": ${error instanceof Error ? error.message : "Unknown database error"}`
+      );
+    }
+  }
+}
+const cmsBackendPlugin = (config) => {
+  let syncPromise = null;
+  const ensureSynced = (adapter) => {
+    if (!syncPromise) {
+      syncPromise = syncContentTypes(adapter, config).catch((error) => {
+        syncPromise = null;
+        throw error;
+      });
+    }
+    return syncPromise;
+  };
+  const getContentTypesWithCounts = async (adapter) => {
+    const contentTypes = await getAllContentTypes(adapter);
+    return Promise.all(
+      contentTypes.map(async (contentType) => ({
+        ...contentType,
+        itemCount: await adapter.count({
+          model: "contentItem",
+          where: [
+            {
+              field: "contentTypeId",
+              value: contentType.id,
+              operator: "eq"
+            }
+          ]
+        })
+      }))
+    );
+  };
+  const createCMSPrefetchForRoute = (adapter) => async function prefetchForRoute(key, queryClient, params) {
+    await ensureSynced(adapter);
+    switch (key) {
+      case "dashboard":
+      case "newContent":
+        queryClient.setQueryData(
+          CMS_QUERY_KEYS.typesList(),
+          await getContentTypesWithCounts(adapter)
+        );
+        break;
+      case "contentList": {
+        const typeSlug = params?.typeSlug ?? "";
+        const options = createListContentQuerySchema(
+          config.maxPageSize
+        ).parse({
+          limit: params?.limit,
+          search: params?.search,
+          view: params?.view,
+          fields: params?.fields
+        });
+        const [contentTypes, contentItems] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          getAllContentItems(adapter, typeSlug, options)
+        ]);
+        queryClient.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
+        queryClient.setQueryData(
+          CMS_QUERY_KEYS.contentList({ typeSlug, ...options }),
+          {
+            pages: [
+              {
+                items: contentItems.items,
+                total: contentItems.total,
+                limit: contentItems.limit ?? 20,
+                offset: contentItems.offset ?? 0
+              }
+            ],
+            pageParams: [0]
+          }
+        );
+        break;
+      }
+      case "editContent": {
+        const typeSlug = params?.typeSlug ?? "";
+        const id = params?.id ?? "";
+        const options = contentReadOptionsSchema.parse({
+          view: params?.view,
+          fields: params?.fields
+        });
+        const [contentTypes, item] = await Promise.all([
+          getContentTypesWithCounts(adapter),
+          id ? getContentItemById(adapter, id, options) : Promise.resolve(null)
+        ]);
+        queryClient.setQueryData(CMS_QUERY_KEYS.typesList(), contentTypes);
+        if (id) {
+          queryClient.setQueryData(
+            CMS_QUERY_KEYS.contentDetail(typeSlug, id, options),
+            item
+          );
+        }
+        break;
+      }
+    }
+  };
+  return defineBackendPlugin({
+    id: "cms",
+    dbPlugin: cmsSchema,
+    operations: (adapter) => createCMSOperations(adapter, {
+      ensureSynced: () => ensureSynced(adapter),
+      getContentTypesWithCounts: () => getContentTypesWithCounts(adapter),
+      ...config.maxPageSize !== void 0 ? { maxPageSize: config.maxPageSize } : {},
+      ...config.hooks ? { hooks: config.hooks } : {}
+    }),
+    /** Lower-level SSG helper that intentionally bypasses auth and hooks. */
+    raw: (adapter) => ({
+      prefetchForRoute: createCMSPrefetchForRoute(adapter)
+    }),
+    routes: (_adapter, _context, operations) => {
+      const listQuerySchema = createListContentQuerySchema(
+        config.maxPageSize
+      ).extend(contentReadQuerySchema.shape);
+      const paginationSchema = z.object({
+        limit: z.coerce.number().min(1).max(config.maxPageSize ?? DEFAULT_MAX_PAGE_SIZE).optional().default(20),
+        offset: z.coerce.number().min(0).optional().default(0)
+      });
+      const listContentTypes = createEndpoint(
+        "/content-types",
+        { method: "GET", requireRequest: true },
+        operations.listContentTypes.route(() => ({}))
+      );
+      const getContentTypeBySlug = createEndpoint(
+        "/content-types/:slug",
+        {
+          method: "GET",
+          params: CMSContentTypeParamsSchema,
+          requireRequest: true
+        },
+        operations.getContentTypeBySlug.route((ctx) => ctx.params)
+      );
+      const listContentItems = createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "GET",
+          params: z.object({ typeSlug: z.string().min(1) }),
+          query: listQuerySchema,
+          requireRequest: true
+        },
+        operations.listContentItems.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
+      );
+      const getContentItem = createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "GET",
+          params: CMSContentItemParamsSchema,
+          query: contentReadQuerySchema,
+          requireRequest: true
+        },
+        operations.getContentItem.route((ctx) => ({
+          ...ctx.params,
+          ...ctx.query
+        }))
+      );
+      const createContentItem = createEndpoint(
+        "/content/:typeSlug",
+        {
+          method: "POST",
+          params: z.object({ typeSlug: z.string().min(1) }),
+          body: CMSCreateContentItemBodySchema,
+          requireRequest: true
+        },
+        operations.createContentItem.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          body: ctx.body
+        }))
+      );
+      const updateContentItem = createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "PUT",
+          params: CMSContentItemParamsSchema,
+          body: CMSUpdateContentItemBodySchema,
+          requireRequest: true
+        },
+        operations.updateContentItem.route((ctx) => ({
+          ...ctx.params,
+          body: ctx.body
+        }))
+      );
+      const deleteContentItem = createEndpoint(
+        "/content/:typeSlug/:id",
+        {
+          method: "DELETE",
+          params: CMSContentItemParamsSchema,
+          requireRequest: true
+        },
+        operations.deleteContentItem.route((ctx) => ctx.params)
+      );
+      const getContentItemPopulated = createEndpoint(
+        "/content/:typeSlug/:id/populated",
+        {
+          method: "GET",
+          params: CMSContentItemParamsSchema,
+          requireRequest: true
+        },
+        operations.getContentItemPopulated.route((ctx) => ctx.params)
+      );
+      const listContentByRelation = createEndpoint(
+        "/content/:typeSlug/by-relation",
+        {
+          method: "GET",
+          params: z.object({ typeSlug: z.string().min(1) }),
+          query: z.object({ field: z.string(), targetId: z.string() }).merge(paginationSchema).merge(contentReadQuerySchema),
+          requireRequest: true
+        },
+        operations.listContentByRelation.route((ctx) => ({
+          typeSlug: ctx.params.typeSlug,
+          query: ctx.query
+        }))
+      );
+      const getInverseRelations = createEndpoint(
+        "/content-types/:slug/inverse-relations",
+        {
+          method: "GET",
+          params: CMSContentTypeParamsSchema,
+          query: z.object({ itemId: z.string().optional() }),
+          requireRequest: true
+        },
+        operations.getInverseRelations.route((ctx) => ({
+          slug: ctx.params.slug,
+          query: ctx.query
+        }))
+      );
+      const listInverseRelationItems = createEndpoint(
+        "/content-types/:slug/inverse-relations/:sourceType",
+        {
+          method: "GET",
+          params: z.object({
+            slug: z.string().min(1),
+            sourceType: z.string().min(1)
+          }),
+          query: z.object({ itemId: z.string(), fieldName: z.string() }).merge(paginationSchema).merge(contentReadQuerySchema),
+          requireRequest: true
+        },
+        operations.listInverseRelationItems.route((ctx) => ({
+          slug: ctx.params.slug,
+          sourceType: ctx.params.sourceType,
+          query: ctx.query
+        }))
+      );
+      return {
+        listContentTypes,
+        getContentTypeBySlug,
+        listContentItems,
+        getContentItem,
+        createContentItem,
+        updateContentItem,
+        deleteContentItem,
+        getContentItemPopulated,
+        listContentByRelation,
+        getInverseRelations,
+        listInverseRelationItems
+      };
+    }
+  });
+};
+
+export { CMSContentItemParamsSchema, CMSContentTypeParamsSchema, CMSCreateContentItemBodySchema, CMSUpdateContentItemBodySchema, cmsBackendPlugin };