@btst/plugin-cms 0.0.0-stage → 1.0.0

package/dist/query-keys.d.ts

@@ -0,0 +1,8 @@
+export { e as ContentListDiscriminator, f as ContentListParams, g as cmsResources, h as contentListDiscriminator, d as createCMSQueryKeys } from './shared/plugin-cms.DQLAoogy.js';
+import '@btst/stack/plugins/client';
+import './types.js';
+import '@btst/stack/authorization';
+import '@btst/stack/plugins/api';
+import 'better-call';
+import '@tanstack/react-query';
+import 'zod';

package/dist/query-keys.mjs

@@ -0,0 +1,225 @@
+import { normalizeContentFields } from './schemas.mjs';
+import { createResourceQueryKeys } from '@btst/stack/plugins/client';
+import { contentReadKey, contentListDiscriminator, contentReadDiscriminator } from './api/query-key-defs.mjs';
+
+function normalizeSearch(search) {
+  return search !== void 0 && search.trim() === "" ? void 0 : search;
+}
+function contentReadQuery(options) {
+  return {
+    view: options?.view,
+    fields: options?.fields === void 0 ? void 0 : JSON.stringify(normalizeContentFields(options.fields))
+  };
+}
+function relationPageKey(params) {
+  const limit = params.limit ?? 20;
+  const offset = params.offset ?? 0;
+  return limit === 20 && offset === 0 && !params.view && params.fields === void 0 ? [] : [{ limit, offset, ...contentReadDiscriminator(params) }];
+}
+function paginatedNextPageParam(lastPage, allPages, limit) {
+  const items = Array.isArray(lastPage?.items) ? lastPage.items : [];
+  if (items.length < limit) return void 0;
+  const loadedCount = allPages.reduce(
+    (sum, page) => sum + (Array.isArray(page?.items) ? page.items.length : 0),
+    0
+  );
+  const total = lastPage?.total ?? 0;
+  if (loadedCount >= total) return void 0;
+  return loadedCount;
+}
+const cmsResources = {
+  cmsTypes: {
+    queries: {
+      list: {
+        path: "/content-types",
+        key: () => ["list"],
+        select: (data) => data ?? []
+      },
+      detail: {
+        path: "/content-types/:slug",
+        params: (slug) => ({ slug }),
+        key: (slug) => [slug],
+        select: (data, _slug) => data ?? null,
+        skip: (slug) => !slug
+      },
+      inverseRelations: {
+        path: "/content-types/:slug/inverse-relations",
+        params: (p) => ({ slug: p.slug }),
+        query: (p) => ({ itemId: p.itemId }),
+        key: (p) => [p.slug, p.itemId],
+        select: (data) => data?.inverseRelations ?? []
+      },
+      inverseRelationItems: {
+        path: "/content-types/:slug/inverse-relations/:sourceType",
+        params: (p) => ({
+          slug: p.slug,
+          sourceType: p.sourceType
+        }),
+        query: (p) => ({
+          ...contentReadQuery(p),
+          itemId: p.itemId,
+          fieldName: p.fieldName,
+          limit: p.limit ?? 20,
+          offset: p.offset ?? 0
+        }),
+        key: (p) => [
+          p.slug,
+          p.sourceType,
+          p.itemId,
+          p.fieldName,
+          ...relationPageKey(p)
+        ],
+        select: (data) => data ?? { items: [], total: 0 }
+      }
+    }
+  },
+  cmsContent: {
+    queries: {
+      list: {
+        path: "/content/:typeSlug",
+        params: (p) => ({ typeSlug: p.typeSlug }),
+        query: (p) => ({
+          ...contentReadQuery(p),
+          limit: p.limit ?? 20,
+          search: normalizeSearch(p.search)
+        }),
+        key: (p) => [contentListDiscriminator(p)],
+        select: (data, _p) => data,
+        infinite: true,
+        pageSize: (p) => p.limit ?? 20,
+        nextPageParam: (lastPage, allPages, p) => paginatedNextPageParam(lastPage, allPages, p.limit ?? 20)
+      },
+      detail: {
+        path: "/content/:typeSlug/:id",
+        params: (typeSlug, id, _options) => ({
+          typeSlug,
+          id
+        }),
+        query: (_typeSlug, _id, options) => contentReadQuery(options),
+        key: (typeSlug, id, options) => [
+          typeSlug,
+          id,
+          ...contentReadKey(options)
+        ],
+        select: (data, _typeSlug, _id, _options) => data ?? null,
+        skip: (typeSlug, id) => !typeSlug || !id
+      },
+      bySlug: {
+        path: "/content/:typeSlug",
+        params: (typeSlug, _slug, _options) => ({ typeSlug }),
+        query: (_typeSlug, slug, options) => ({
+          slug,
+          limit: 1,
+          ...contentReadQuery(options)
+        }),
+        key: (typeSlug, slug, options) => [
+          "bySlug",
+          typeSlug,
+          slug,
+          ...contentReadKey(options)
+        ],
+        select: (data) => data?.items?.[0] ?? null,
+        skip: (typeSlug, slug) => !typeSlug || !slug
+      },
+      populated: {
+        path: "/content/:typeSlug/:id/populated",
+        params: (typeSlug, id) => ({ typeSlug, id }),
+        key: (typeSlug, id) => [typeSlug, id],
+        select: (data) => data ?? null,
+        skip: (typeSlug, id) => !typeSlug || !id
+      },
+      byRelation: {
+        path: "/content/:typeSlug/by-relation",
+        params: (p) => ({ typeSlug: p.typeSlug }),
+        query: (p) => ({
+          ...contentReadQuery(p),
+          field: p.field,
+          targetId: p.targetId,
+          limit: p.limit ?? 20
+        }),
+        key: (p) => [
+          p.typeSlug,
+          p.field,
+          p.targetId,
+          ...relationPageKey(p)
+        ],
+        select: (data, _p) => data,
+        infinite: true,
+        pageSize: (p) => p.limit ?? 20,
+        nextPageParam: (lastPage, allPages, p) => paginatedNextPageParam(lastPage, allPages, p.limit ?? 20)
+      },
+      // Non-infinite options query for relation pickers (useSelect)
+      options: {
+        path: "/content/:typeSlug",
+        params: (p) => ({ typeSlug: p.typeSlug }),
+        query: (p) => ({
+          ...contentReadQuery(p),
+          search: normalizeSearch(p.search),
+          limit: p.limit ?? 50
+        }),
+        key: (p) => [
+          "options",
+          p.typeSlug,
+          normalizeSearch(p.search),
+          p.limit ?? 50,
+          ...contentReadKey(p)
+        ],
+        select: (data, _p) => data?.items ?? []
+      }
+    },
+    mutations: {
+      create: {
+        path: "@post/content/:typeSlug",
+        method: "POST",
+        input: (vars) => ({
+          params: { typeSlug: vars.typeSlug },
+          body: { slug: vars.slug, data: vars.data }
+        }),
+        select: (data) => data,
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.list",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ]
+      },
+      update: {
+        path: "@put/content/:typeSlug/:id",
+        method: "PUT",
+        input: (vars) => ({
+          params: { typeSlug: vars.typeSlug, id: vars.id },
+          body: vars.data
+        }),
+        select: (data) => data,
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ],
+        setData: {
+          query: "detail",
+          args: (updated) => updated?.contentType?.slug ? [updated.contentType.slug, updated.id] : null
+        }
+      },
+      delete: {
+        path: "@delete/content/:typeSlug/:id",
+        method: "DELETE",
+        input: (vars) => ({
+          params: { typeSlug: vars.typeSlug, id: vars.id }
+        }),
+        select: (data) => data,
+        invalidates: [
+          "cmsContent",
+          "cmsTypes.list",
+          "cmsTypes.inverseRelationItems",
+          "cmsTypes.inverseRelations"
+        ]
+      }
+    }
+  }
+};
+function createCMSQueryKeys(client, headers) {
+  return createResourceQueryKeys(client, cmsResources, headers);
+}
+
+export { cmsResources, contentListDiscriminator, createCMSQueryKeys };

package/dist/schemas.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+const z = require('zod');
+
+function normalizeContentFields(fields) {
+  return fields === void 0 ? void 0 : [...new Set(fields)].sort();
+}
+const DEFAULT_MAX_PAGE_SIZE = 1e3;
+const contentReadOptionsSchema = z.z.object({
+  view: z.z.literal("content").optional(),
+  fields: z.z.array(z.z.string()).min(1).transform((fields) => normalizeContentFields(fields)).optional()
+});
+const contentReadQuerySchema = contentReadOptionsSchema.extend({
+  fields: z.z.preprocess((value) => {
+    if (value === void 0) return void 0;
+    if (typeof value !== "string") return z.z.NEVER;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }, contentReadOptionsSchema.shape.fields)
+});
+function createListContentQuerySchema(maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
+  return z.z.object({
+    ...contentReadOptionsSchema.shape,
+    slug: z.z.string().optional(),
+    search: z.z.string().max(200).optional(),
+    limit: z.z.coerce.number().min(1).max(maxPageSize).optional().default(20),
+    offset: z.z.coerce.number().min(0).optional().default(0)
+  });
+}
+createListContentQuerySchema();
+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(),
+  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.DEFAULT_MAX_PAGE_SIZE = DEFAULT_MAX_PAGE_SIZE;
+exports.contentItemResponseSchema = contentItemResponseSchema;
+exports.contentItemWithDataResponseSchema = contentItemWithDataResponseSchema;
+exports.contentReadOptionsSchema = contentReadOptionsSchema;
+exports.contentReadQuerySchema = contentReadQuerySchema;
+exports.contentTypeResponseSchema = contentTypeResponseSchema;
+exports.createListContentQuerySchema = createListContentQuerySchema;
+exports.normalizeContentFields = normalizeContentFields;

package/dist/schemas.mjs

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+
+function normalizeContentFields(fields) {
+  return fields === void 0 ? void 0 : [...new Set(fields)].sort();
+}
+const DEFAULT_MAX_PAGE_SIZE = 1e3;
+const contentReadOptionsSchema = z.object({
+  view: z.literal("content").optional(),
+  fields: z.array(z.string()).min(1).transform((fields) => normalizeContentFields(fields)).optional()
+});
+const contentReadQuerySchema = contentReadOptionsSchema.extend({
+  fields: z.preprocess((value) => {
+    if (value === void 0) return void 0;
+    if (typeof value !== "string") return z.NEVER;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }, contentReadOptionsSchema.shape.fields)
+});
+function createListContentQuerySchema(maxPageSize = DEFAULT_MAX_PAGE_SIZE) {
+  return z.object({
+    ...contentReadOptionsSchema.shape,
+    slug: z.string().optional(),
+    search: z.string().max(200).optional(),
+    limit: z.coerce.number().min(1).max(maxPageSize).optional().default(20),
+    offset: z.coerce.number().min(0).optional().default(0)
+  });
+}
+createListContentQuerySchema();
+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(),
+  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 { DEFAULT_MAX_PAGE_SIZE, contentItemResponseSchema, contentItemWithDataResponseSchema, contentReadOptionsSchema, contentReadQuerySchema, contentTypeResponseSchema, createListContentQuerySchema, normalizeContentFields };

package/dist/shared/plugin-cms.BBshPRkb.d.cts

@@ -0,0 +1,6 @@
+'use client';
+import * as react from 'react';
+
+declare function DashboardPageComponent(): react.JSX.Element;
+
+export { DashboardPageComponent as D };

package/dist/shared/plugin-cms.BBshPRkb.d.mts

@@ -0,0 +1,6 @@
+'use client';
+import * as react from 'react';
+
+declare function DashboardPageComponent(): react.JSX.Element;
+
+export { DashboardPageComponent as D };

package/dist/shared/plugin-cms.BBshPRkb.d.ts

@@ -0,0 +1,6 @@
+'use client';
+import * as react from 'react';
+
+declare function DashboardPageComponent(): react.JSX.Element;
+
+export { DashboardPageComponent as D };