@btst/stack 1.4.1 → 1.5.0

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

@@ -0,0 +1,185 @@
+'use strict';
+
+const jsxRuntime = require('react/jsx-runtime');
+const React = require('react');
+const client = require('@btst/stack/plugins/client');
+const yar = require('@btst/yar');
+const plugins_cms_queryKeys = require('../../../../../../plugins/cms/query-keys.cjs');
+
+const DashboardPageComponent = React.lazy(
+  () => import('./components/pages/dashboard-page.cjs').then((m) => ({
+    default: m.DashboardPageComponent
+  }))
+);
+const ContentListPageComponent = React.lazy(
+  () => import('./components/pages/content-list-page.cjs').then((m) => ({
+    default: m.ContentListPageComponent
+  }))
+);
+const ContentEditorPageComponent = React.lazy(
+  () => import('./components/pages/content-editor-page.cjs').then((m) => ({
+    default: m.ContentEditorPageComponent
+  }))
+);
+function createDashboardLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client$1 = client.createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = plugins_cms_queryKeys.createCMSQueryKeys(client$1, headers);
+      try {
+        await queryClient.prefetchQuery(queries.cmsTypes.list());
+      } catch {
+      }
+    }
+  };
+}
+function createContentListLoader(typeSlug, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client$1 = client.createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = plugins_cms_queryKeys.createCMSQueryKeys(client$1, headers);
+      const limit = 20;
+      try {
+        await queryClient.prefetchQuery(queries.cmsTypes.list());
+        const listQuery = queries.cmsContent.list({
+          typeSlug,
+          limit,
+          offset: 0
+        });
+        await queryClient.prefetchInfiniteQuery({
+          queryKey: listQuery.queryKey,
+          queryFn: async ({ pageParam = 0 }) => {
+            const response = await client$1("/content/:typeSlug", {
+              method: "GET",
+              params: { typeSlug },
+              query: { limit, offset: pageParam },
+              headers
+            });
+            if (typeof response === "object" && response !== null && "error" in response && response.error) {
+              throw new Error(String(response.error));
+            }
+            return response.data;
+          },
+          initialPageParam: 0
+        });
+      } catch {
+      }
+    }
+  };
+}
+function createContentEditorLoader(typeSlug, id, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client$1 = client.createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = plugins_cms_queryKeys.createCMSQueryKeys(client$1, headers);
+      try {
+        const promises = [queryClient.prefetchQuery(queries.cmsTypes.list())];
+        if (id) {
+          promises.push(
+            queryClient.prefetchQuery(queries.cmsContent.detail(typeSlug, id))
+          );
+        }
+        await Promise.all(promises);
+      } catch {
+      }
+    }
+  };
+}
+function createDashboardMeta() {
+  return () => {
+    const title = "CMS Dashboard";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+function createContentListMeta(typeSlug, config) {
+  return () => {
+    const { queryClient, apiBasePath, apiBaseURL } = config;
+    const client$1 = client.createApiClient({
+      baseURL: apiBaseURL,
+      basePath: apiBasePath
+    });
+    const queries = plugins_cms_queryKeys.createCMSQueryKeys(client$1);
+    const contentTypes = queryClient.getQueryData(
+      queries.cmsTypes.list().queryKey
+    );
+    const contentType = contentTypes?.find((ct) => ct.slug === typeSlug);
+    const title = contentType?.name ? `${contentType.name} | CMS` : "Content | CMS";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+function createContentEditorMeta(typeSlug, id, config) {
+  return () => {
+    const { queryClient, apiBasePath, apiBaseURL } = config;
+    const client$1 = client.createApiClient({
+      baseURL: apiBaseURL,
+      basePath: apiBasePath
+    });
+    const queries = plugins_cms_queryKeys.createCMSQueryKeys(client$1);
+    const contentTypes = queryClient.getQueryData(
+      queries.cmsTypes.list().queryKey
+    );
+    const contentType = contentTypes?.find((ct) => ct.slug === typeSlug);
+    const title = id ? `Edit ${contentType?.name || "Content"} | CMS` : `New ${contentType?.name || "Content"} | CMS`;
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+const cmsClientPlugin = (config) => client.defineClientPlugin({
+  name: "cms",
+  routes: () => ({
+    dashboard: yar.createRoute("/cms", () => ({
+      PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(DashboardPageComponent, {}),
+      loader: createDashboardLoader(config),
+      meta: createDashboardMeta()
+    })),
+    contentList: yar.createRoute("/cms/:typeSlug", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(ContentListPageComponent, { typeSlug: params.typeSlug }),
+      loader: createContentListLoader(params.typeSlug, config),
+      meta: createContentListMeta(params.typeSlug, config)
+    })),
+    newContent: yar.createRoute("/cms/:typeSlug/new", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(ContentEditorPageComponent, { typeSlug: params.typeSlug }),
+      loader: createContentEditorLoader(params.typeSlug, void 0, config),
+      meta: createContentEditorMeta(params.typeSlug, void 0, config)
+    })),
+    editContent: yar.createRoute("/cms/:typeSlug/:id", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsxRuntime.jsx(
+        ContentEditorPageComponent,
+        {
+          typeSlug: params.typeSlug,
+          id: params.id
+        }
+      ),
+      loader: createContentEditorLoader(params.typeSlug, params.id, config),
+      meta: createContentEditorMeta(params.typeSlug, params.id, config)
+    }))
+  }),
+  sitemap: async () => {
+    return [];
+  }
+});
+
+exports.cmsClientPlugin = cmsClientPlugin;

package/dist/packages/better-stack/src/plugins/cms/client/plugin.mjs

@@ -0,0 +1,183 @@
+import { jsx } from 'react/jsx-runtime';
+import { lazy } from 'react';
+import { defineClientPlugin, createApiClient } from '@btst/stack/plugins/client';
+import { createRoute } from '@btst/yar';
+import { createCMSQueryKeys } from '../../../../../../plugins/cms/query-keys.mjs';
+
+const DashboardPageComponent = lazy(
+  () => import('./components/pages/dashboard-page.mjs').then((m) => ({
+    default: m.DashboardPageComponent
+  }))
+);
+const ContentListPageComponent = lazy(
+  () => import('./components/pages/content-list-page.mjs').then((m) => ({
+    default: m.ContentListPageComponent
+  }))
+);
+const ContentEditorPageComponent = lazy(
+  () => import('./components/pages/content-editor-page.mjs').then((m) => ({
+    default: m.ContentEditorPageComponent
+  }))
+);
+function createDashboardLoader(config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client = createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = createCMSQueryKeys(client, headers);
+      try {
+        await queryClient.prefetchQuery(queries.cmsTypes.list());
+      } catch {
+      }
+    }
+  };
+}
+function createContentListLoader(typeSlug, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client = createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = createCMSQueryKeys(client, headers);
+      const limit = 20;
+      try {
+        await queryClient.prefetchQuery(queries.cmsTypes.list());
+        const listQuery = queries.cmsContent.list({
+          typeSlug,
+          limit,
+          offset: 0
+        });
+        await queryClient.prefetchInfiniteQuery({
+          queryKey: listQuery.queryKey,
+          queryFn: async ({ pageParam = 0 }) => {
+            const response = await client("/content/:typeSlug", {
+              method: "GET",
+              params: { typeSlug },
+              query: { limit, offset: pageParam },
+              headers
+            });
+            if (typeof response === "object" && response !== null && "error" in response && response.error) {
+              throw new Error(String(response.error));
+            }
+            return response.data;
+          },
+          initialPageParam: 0
+        });
+      } catch {
+      }
+    }
+  };
+}
+function createContentEditorLoader(typeSlug, id, config) {
+  return async () => {
+    if (typeof window === "undefined") {
+      const { queryClient, apiBasePath, apiBaseURL, headers } = config;
+      const client = createApiClient({
+        baseURL: apiBaseURL,
+        basePath: apiBasePath
+      });
+      const queries = createCMSQueryKeys(client, headers);
+      try {
+        const promises = [queryClient.prefetchQuery(queries.cmsTypes.list())];
+        if (id) {
+          promises.push(
+            queryClient.prefetchQuery(queries.cmsContent.detail(typeSlug, id))
+          );
+        }
+        await Promise.all(promises);
+      } catch {
+      }
+    }
+  };
+}
+function createDashboardMeta() {
+  return () => {
+    const title = "CMS Dashboard";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+function createContentListMeta(typeSlug, config) {
+  return () => {
+    const { queryClient, apiBasePath, apiBaseURL } = config;
+    const client = createApiClient({
+      baseURL: apiBaseURL,
+      basePath: apiBasePath
+    });
+    const queries = createCMSQueryKeys(client);
+    const contentTypes = queryClient.getQueryData(
+      queries.cmsTypes.list().queryKey
+    );
+    const contentType = contentTypes?.find((ct) => ct.slug === typeSlug);
+    const title = contentType?.name ? `${contentType.name} | CMS` : "Content | CMS";
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+function createContentEditorMeta(typeSlug, id, config) {
+  return () => {
+    const { queryClient, apiBasePath, apiBaseURL } = config;
+    const client = createApiClient({
+      baseURL: apiBaseURL,
+      basePath: apiBasePath
+    });
+    const queries = createCMSQueryKeys(client);
+    const contentTypes = queryClient.getQueryData(
+      queries.cmsTypes.list().queryKey
+    );
+    const contentType = contentTypes?.find((ct) => ct.slug === typeSlug);
+    const title = id ? `Edit ${contentType?.name || "Content"} | CMS` : `New ${contentType?.name || "Content"} | CMS`;
+    return [
+      { title },
+      { name: "title", content: title },
+      { name: "robots", content: "noindex" }
+    ];
+  };
+}
+const cmsClientPlugin = (config) => defineClientPlugin({
+  name: "cms",
+  routes: () => ({
+    dashboard: createRoute("/cms", () => ({
+      PageComponent: () => /* @__PURE__ */ jsx(DashboardPageComponent, {}),
+      loader: createDashboardLoader(config),
+      meta: createDashboardMeta()
+    })),
+    contentList: createRoute("/cms/:typeSlug", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsx(ContentListPageComponent, { typeSlug: params.typeSlug }),
+      loader: createContentListLoader(params.typeSlug, config),
+      meta: createContentListMeta(params.typeSlug, config)
+    })),
+    newContent: createRoute("/cms/:typeSlug/new", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsx(ContentEditorPageComponent, { typeSlug: params.typeSlug }),
+      loader: createContentEditorLoader(params.typeSlug, void 0, config),
+      meta: createContentEditorMeta(params.typeSlug, void 0, config)
+    })),
+    editContent: createRoute("/cms/:typeSlug/:id", ({ params }) => ({
+      PageComponent: () => /* @__PURE__ */ jsx(
+        ContentEditorPageComponent,
+        {
+          typeSlug: params.typeSlug,
+          id: params.id
+        }
+      ),
+      loader: createContentEditorLoader(params.typeSlug, params.id, config),
+      meta: createContentEditorMeta(params.typeSlug, params.id, config)
+    }))
+  }),
+  sitemap: async () => {
+    return [];
+  }
+});
+
+export { cmsClientPlugin };

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

@@ -0,0 +1,76 @@
+'use strict';
+
+const db = require('@btst/db');
+
+const cmsSchema = db.createDbPlugin("cms", {
+  contentType: {
+    modelName: "contentType",
+    fields: {
+      name: {
+        type: "string",
+        required: true
+      },
+      slug: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      description: {
+        type: "string",
+        required: false
+      },
+      jsonSchema: {
+        type: "string",
+        required: true
+      },
+      fieldConfig: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  contentItem: {
+    modelName: "contentItem",
+    fields: {
+      contentTypeId: {
+        type: "string",
+        required: true,
+        references: {
+          model: "contentType",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      slug: {
+        type: "string",
+        required: true
+      },
+      data: {
+        type: "string",
+        required: true
+      },
+      authorId: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+exports.cmsSchema = cmsSchema;

package/dist/packages/better-stack/src/plugins/cms/db.mjs

@@ -0,0 +1,74 @@
+import { createDbPlugin } from '@btst/db';
+
+const cmsSchema = createDbPlugin("cms", {
+  contentType: {
+    modelName: "contentType",
+    fields: {
+      name: {
+        type: "string",
+        required: true
+      },
+      slug: {
+        type: "string",
+        required: true,
+        unique: true
+      },
+      description: {
+        type: "string",
+        required: false
+      },
+      jsonSchema: {
+        type: "string",
+        required: true
+      },
+      fieldConfig: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  },
+  contentItem: {
+    modelName: "contentItem",
+    fields: {
+      contentTypeId: {
+        type: "string",
+        required: true,
+        references: {
+          model: "contentType",
+          field: "id",
+          onDelete: "cascade"
+        }
+      },
+      slug: {
+        type: "string",
+        required: true
+      },
+      data: {
+        type: "string",
+        required: true
+      },
+      authorId: {
+        type: "string",
+        required: false
+      },
+      createdAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      },
+      updatedAt: {
+        type: "date",
+        defaultValue: () => /* @__PURE__ */ new Date()
+      }
+    }
+  }
+});
+
+export { cmsSchema };

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

@@ -0,0 +1,54 @@
+'use strict';
+
+const z = require('zod');
+
+const listContentQuerySchema = z.z.object({
+  slug: z.z.string().optional(),
+  limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.z.coerce.number().min(0).optional().default(0)
+});
+z.z.object({
+  slug: z.z.string().min(1, "Slug is required"),
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  data: z.z.object({}).passthrough()
+});
+z.z.object({
+  slug: z.z.string().min(1, "Slug is required").optional(),
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  data: z.z.object({}).passthrough().optional()
+});
+const contentTypeResponseSchema = z.z.object({
+  id: z.z.string(),
+  name: z.z.string(),
+  slug: z.z.string(),
+  description: z.z.string().nullable().optional(),
+  jsonSchema: z.z.string(),
+  fieldConfig: z.z.string().nullable().optional(),
+  createdAt: z.z.string(),
+  updatedAt: z.z.string()
+});
+const contentItemResponseSchema = z.z.object({
+  id: z.z.string(),
+  contentTypeId: z.z.string(),
+  slug: z.z.string(),
+  data: z.z.string(),
+  authorId: z.z.string().nullable().optional(),
+  createdAt: z.z.string(),
+  updatedAt: z.z.string()
+});
+const contentItemWithDataResponseSchema = contentItemResponseSchema.extend({
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  parsedData: z.z.object({}).passthrough(),
+  contentType: contentTypeResponseSchema.optional()
+});
+z.z.object({
+  items: z.z.array(contentItemWithDataResponseSchema),
+  total: z.z.number(),
+  limit: z.z.number(),
+  offset: z.z.number()
+});
+
+exports.contentItemResponseSchema = contentItemResponseSchema;
+exports.contentItemWithDataResponseSchema = contentItemWithDataResponseSchema;
+exports.contentTypeResponseSchema = contentTypeResponseSchema;
+exports.listContentQuerySchema = listContentQuerySchema;

package/dist/packages/better-stack/src/plugins/cms/schemas.mjs

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+
+const listContentQuerySchema = z.object({
+  slug: z.string().optional(),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().min(0).optional().default(0)
+});
+z.object({
+  slug: z.string().min(1, "Slug is required"),
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  data: z.object({}).passthrough()
+});
+z.object({
+  slug: z.string().min(1, "Slug is required").optional(),
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  data: z.object({}).passthrough().optional()
+});
+const contentTypeResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullable().optional(),
+  jsonSchema: z.string(),
+  fieldConfig: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+const contentItemResponseSchema = z.object({
+  id: z.string(),
+  contentTypeId: z.string(),
+  slug: z.string(),
+  data: z.string(),
+  authorId: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+const contentItemWithDataResponseSchema = contentItemResponseSchema.extend({
+  // Use passthrough object instead of z.record(z.unknown()) due to Zod v4 bug
+  parsedData: z.object({}).passthrough(),
+  contentType: contentTypeResponseSchema.optional()
+});
+z.object({
+  items: z.array(contentItemWithDataResponseSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+});
+
+export { contentItemResponseSchema, contentItemWithDataResponseSchema, contentTypeResponseSchema, listContentQuerySchema };

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

@@ -0,0 +1,15 @@
+'use strict';
+
+require('clsx');
+require('tailwind-merge');
+const slug = require('slug');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const slug__default = /*#__PURE__*/_interopDefaultCompat(slug);
+
+function slugify(text, locale = "en") {
+  return slug__default(text, { lower: true, locale });
+}
+
+exports.slugify = slugify;

package/dist/packages/better-stack/src/plugins/cms/utils.mjs

@@ -0,0 +1,9 @@
+import 'clsx';
+import 'tailwind-merge';
+import slug from 'slug';
+
+function slugify(text, locale = "en") {
+  return slug(text, { lower: true, locale });
+}
+
+export { slugify };