@btst/stack 1.4.0 → 1.5.0

package/dist/plugins/cms/query-keys.cjs

@@ -0,0 +1,137 @@
+'use strict';
+
+const queryKeyFactory = require('@lukemorales/query-key-factory');
+
+function isErrorResponse(response) {
+  if (typeof response !== "object" || response === null) {
+    return false;
+  }
+  const obj = response;
+  return "error" in obj && obj.error !== null && obj.error !== void 0;
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const errorObj = error;
+    const message = (typeof errorObj.message === "string" ? errorObj.message : null) || (typeof errorObj.error === "string" ? errorObj.error : null) || JSON.stringify(error);
+    const err = new Error(message);
+    Object.assign(err, error);
+    return err;
+  }
+  return new Error(String(error));
+}
+function createCMSQueryKeys(client, headers) {
+  const contentTypes = createContentTypesQueries(client, headers);
+  const content = createContentQueries(client, headers);
+  return queryKeyFactory.mergeQueryKeys(contentTypes, content);
+}
+function createContentTypesQueries(client, headers) {
+  return queryKeyFactory.createQueryKeys("cmsTypes", {
+    list: () => ({
+      queryKey: ["list"],
+      queryFn: async () => {
+        try {
+          const response = await client("/content-types", {
+            method: "GET",
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data ?? [];
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    detail: (slug) => ({
+      queryKey: [slug],
+      queryFn: async () => {
+        if (!slug) return null;
+        try {
+          const response = await client("/content-types/:slug", {
+            method: "GET",
+            params: { slug },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+function createContentQueries(client, headers) {
+  return queryKeyFactory.createQueryKeys("cmsContent", {
+    list: (params) => ({
+      queryKey: [params],
+      queryFn: async () => {
+        try {
+          const response = await client("/content/:typeSlug", {
+            method: "GET",
+            params: { typeSlug: params.typeSlug },
+            query: {
+              limit: params.limit ?? 20,
+              offset: params.offset ?? 0
+            },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    detail: (typeSlug, id) => ({
+      queryKey: [typeSlug, id],
+      queryFn: async () => {
+        if (!typeSlug || !id) return null;
+        try {
+          const response = await client("/content/:typeSlug/:id", {
+            method: "GET",
+            params: { typeSlug, id },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    bySlug: (typeSlug, slug) => ({
+      queryKey: ["bySlug", typeSlug, slug],
+      queryFn: async () => {
+        if (!typeSlug || !slug) return null;
+        try {
+          const response = await client("/content/:typeSlug", {
+            method: "GET",
+            params: { typeSlug },
+            query: { slug, limit: 1 },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          const data = response.data;
+          return data.items[0] ?? null;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+
+exports.createCMSQueryKeys = createCMSQueryKeys;

package/dist/plugins/cms/query-keys.d.cts

@@ -0,0 +1,79 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.BwkyFwF8.cjs';
+import { CMSApiRouter } from './api/index.cjs';
+import 'zod';
+import '../../shared/stack.NZJogTUn.cjs';
+import 'react-hook-form';
+import 'react/jsx-runtime';
+import '@btst/stack/plugins/api';
+import 'better-call';
+
+interface ContentListParams {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create CMS query keys for React Query
+ * Used by consumers to fetch content types and content items
+ */
+declare function createCMSQueryKeys(client: ReturnType<typeof createApiClient<CMSApiRouter>>, headers?: HeadersInit): {
+    cmsTypes: {
+        _def: readonly ["cmsTypes"];
+    } & {
+        list: (() => Omit<{
+            queryKey: readonly ["cmsTypes", "list", string];
+            queryFn: _tanstack_react_query.QueryFunction<(SerializedContentType & {
+                itemCount: number;
+            })[], readonly ["cmsTypes", "list", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "list"];
+        };
+        detail: ((slug: string) => Omit<{
+            queryKey: readonly ["cmsTypes", "detail", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentType | null, readonly ["cmsTypes", "detail", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "detail"];
+        };
+    };
+    cmsContent: {
+        _def: readonly ["cmsContent"];
+    } & {
+        list: ((params: {
+            typeSlug: string;
+        } & ContentListParams) => Omit<{
+            queryKey: readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams];
+            queryFn: _tanstack_react_query.QueryFunction<PaginatedContentItems<Record<string, unknown>>, readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams]>;
+        } & {
+            _def: readonly ["cmsContent", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "list"];
+        };
+        detail: ((typeSlug: string, id: string) => Omit<{
+            queryKey: readonly ["cmsContent", "detail", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "detail", string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "detail"];
+        };
+        bySlug: ((typeSlug: string, slug: string) => Omit<{
+            queryKey: readonly ["cmsContent", "bySlug", string, string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "bySlug", string, string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "bySlug"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "bySlug"];
+        };
+    };
+};
+
+export { createCMSQueryKeys };

package/dist/plugins/cms/query-keys.d.mts

@@ -0,0 +1,79 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.DBqxCs0V.mjs';
+import { CMSApiRouter } from './api/index.mjs';
+import 'zod';
+import '../../shared/stack.NZJogTUn.mjs';
+import 'react-hook-form';
+import 'react/jsx-runtime';
+import '@btst/stack/plugins/api';
+import 'better-call';
+
+interface ContentListParams {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create CMS query keys for React Query
+ * Used by consumers to fetch content types and content items
+ */
+declare function createCMSQueryKeys(client: ReturnType<typeof createApiClient<CMSApiRouter>>, headers?: HeadersInit): {
+    cmsTypes: {
+        _def: readonly ["cmsTypes"];
+    } & {
+        list: (() => Omit<{
+            queryKey: readonly ["cmsTypes", "list", string];
+            queryFn: _tanstack_react_query.QueryFunction<(SerializedContentType & {
+                itemCount: number;
+            })[], readonly ["cmsTypes", "list", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "list"];
+        };
+        detail: ((slug: string) => Omit<{
+            queryKey: readonly ["cmsTypes", "detail", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentType | null, readonly ["cmsTypes", "detail", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "detail"];
+        };
+    };
+    cmsContent: {
+        _def: readonly ["cmsContent"];
+    } & {
+        list: ((params: {
+            typeSlug: string;
+        } & ContentListParams) => Omit<{
+            queryKey: readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams];
+            queryFn: _tanstack_react_query.QueryFunction<PaginatedContentItems<Record<string, unknown>>, readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams]>;
+        } & {
+            _def: readonly ["cmsContent", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "list"];
+        };
+        detail: ((typeSlug: string, id: string) => Omit<{
+            queryKey: readonly ["cmsContent", "detail", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "detail", string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "detail"];
+        };
+        bySlug: ((typeSlug: string, slug: string) => Omit<{
+            queryKey: readonly ["cmsContent", "bySlug", string, string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "bySlug", string, string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "bySlug"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "bySlug"];
+        };
+    };
+};
+
+export { createCMSQueryKeys };

package/dist/plugins/cms/query-keys.d.ts

@@ -0,0 +1,79 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { S as SerializedContentType, P as PaginatedContentItems, a as SerializedContentItemWithType } from '../../shared/stack.DwnJA87a.js';
+import { CMSApiRouter } from './api/index.js';
+import 'zod';
+import '../../shared/stack.NZJogTUn.js';
+import 'react-hook-form';
+import 'react/jsx-runtime';
+import '@btst/stack/plugins/api';
+import 'better-call';
+
+interface ContentListParams {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create CMS query keys for React Query
+ * Used by consumers to fetch content types and content items
+ */
+declare function createCMSQueryKeys(client: ReturnType<typeof createApiClient<CMSApiRouter>>, headers?: HeadersInit): {
+    cmsTypes: {
+        _def: readonly ["cmsTypes"];
+    } & {
+        list: (() => Omit<{
+            queryKey: readonly ["cmsTypes", "list", string];
+            queryFn: _tanstack_react_query.QueryFunction<(SerializedContentType & {
+                itemCount: number;
+            })[], readonly ["cmsTypes", "list", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "list"];
+        };
+        detail: ((slug: string) => Omit<{
+            queryKey: readonly ["cmsTypes", "detail", string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentType | null, readonly ["cmsTypes", "detail", string]>;
+        } & {
+            _def: readonly ["cmsTypes", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsTypes", "detail"];
+        };
+    };
+    cmsContent: {
+        _def: readonly ["cmsContent"];
+    } & {
+        list: ((params: {
+            typeSlug: string;
+        } & ContentListParams) => Omit<{
+            queryKey: readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams];
+            queryFn: _tanstack_react_query.QueryFunction<PaginatedContentItems<Record<string, unknown>>, readonly ["cmsContent", "list", {
+                typeSlug: string;
+            } & ContentListParams]>;
+        } & {
+            _def: readonly ["cmsContent", "list"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "list"];
+        };
+        detail: ((typeSlug: string, id: string) => Omit<{
+            queryKey: readonly ["cmsContent", "detail", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "detail", string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "detail"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "detail"];
+        };
+        bySlug: ((typeSlug: string, slug: string) => Omit<{
+            queryKey: readonly ["cmsContent", "bySlug", string, string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedContentItemWithType<Record<string, unknown>> | null, readonly ["cmsContent", "bySlug", string, string, string]>;
+        } & {
+            _def: readonly ["cmsContent", "bySlug"];
+        }, "_def">) & {
+            _def: readonly ["cmsContent", "bySlug"];
+        };
+    };
+};
+
+export { createCMSQueryKeys };

package/dist/plugins/cms/query-keys.mjs

@@ -0,0 +1,135 @@
+import { mergeQueryKeys, createQueryKeys } from '@lukemorales/query-key-factory';
+
+function isErrorResponse(response) {
+  if (typeof response !== "object" || response === null) {
+    return false;
+  }
+  const obj = response;
+  return "error" in obj && obj.error !== null && obj.error !== void 0;
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const errorObj = error;
+    const message = (typeof errorObj.message === "string" ? errorObj.message : null) || (typeof errorObj.error === "string" ? errorObj.error : null) || JSON.stringify(error);
+    const err = new Error(message);
+    Object.assign(err, error);
+    return err;
+  }
+  return new Error(String(error));
+}
+function createCMSQueryKeys(client, headers) {
+  const contentTypes = createContentTypesQueries(client, headers);
+  const content = createContentQueries(client, headers);
+  return mergeQueryKeys(contentTypes, content);
+}
+function createContentTypesQueries(client, headers) {
+  return createQueryKeys("cmsTypes", {
+    list: () => ({
+      queryKey: ["list"],
+      queryFn: async () => {
+        try {
+          const response = await client("/content-types", {
+            method: "GET",
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data ?? [];
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    detail: (slug) => ({
+      queryKey: [slug],
+      queryFn: async () => {
+        if (!slug) return null;
+        try {
+          const response = await client("/content-types/:slug", {
+            method: "GET",
+            params: { slug },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+function createContentQueries(client, headers) {
+  return createQueryKeys("cmsContent", {
+    list: (params) => ({
+      queryKey: [params],
+      queryFn: async () => {
+        try {
+          const response = await client("/content/:typeSlug", {
+            method: "GET",
+            params: { typeSlug: params.typeSlug },
+            query: {
+              limit: params.limit ?? 20,
+              offset: params.offset ?? 0
+            },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    detail: (typeSlug, id) => ({
+      queryKey: [typeSlug, id],
+      queryFn: async () => {
+        if (!typeSlug || !id) return null;
+        try {
+          const response = await client("/content/:typeSlug/:id", {
+            method: "GET",
+            params: { typeSlug, id },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    bySlug: (typeSlug, slug) => ({
+      queryKey: ["bySlug", typeSlug, slug],
+      queryFn: async () => {
+        if (!typeSlug || !slug) return null;
+        try {
+          const response = await client("/content/:typeSlug", {
+            method: "GET",
+            params: { typeSlug },
+            query: { slug, limit: 1 },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          const data = response.data;
+          return data.items[0] ?? null;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+
+export { createCMSQueryKeys };

package/dist/plugins/cms/style.css

@@ -0,0 +1,19 @@
+@import "./client.css";
+
+/*
+ * CMS Plugin CSS - Includes Tailwind class scanning
+ * 
+ * When consumed from npm, Tailwind v4 will automatically scan this package's
+ * source files for Tailwind classes. Consumers only need:
+ *   @import "@btst/stack/plugins/cms/css";
+ */
+
+/* Scan this package's source files for Tailwind classes */
+@source "../../../src/**/*.{ts,tsx}";
+
+/* Scan UI package components (when installed as npm package the UI package will be in this dir) */
+@source "../../packages/ui/src";
+
+/*
+* alternatively consumer can use @source "../node_modules/@btst/stack/src/**\/*.{ts,tsx}";
+*/

package/dist/shared/stack.BwkyFwF8.d.cts

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+import { A as AutoFormFieldType } from './stack.NZJogTUn.cjs';
+
+/**
+ * Configuration for a content type defined by the developer
+ */
+interface ContentTypeConfig {
+    /** Display name for the content type (e.g., "Product", "Testimonial") */
+    name: string;
+    /** URL-friendly slug (e.g., "product", "testimonial") */
+    slug: string;
+    /** Optional description shown in the admin UI */
+    description?: string;
+    /** Zod schema defining the content type's fields */
+    schema: z.ZodObject<z.ZodRawShape>;
+    /**
+     * Optional field configuration for AutoForm customization.
+     *
+     * fieldType can be:
+     * - A built-in AutoForm type: "checkbox", "date", "select", "radio", "switch", "textarea", "number", "file", "fallback"
+     * - A custom type name that maps to a component provided via `fieldComponents` in overrides
+     */
+    fieldConfig?: Record<string, {
+        fieldType?: AutoFormFieldType | (string & {});
+    }>;
+}
+/**
+ * Content type stored in the database
+ */
+type ContentType = {
+    id: string;
+    /** Display name */
+    name: string;
+    /** URL-friendly slug - unique identifier */
+    slug: string;
+    /** Optional description */
+    description?: string;
+    /** JSON Schema representation of the Zod schema (stringified) */
+    jsonSchema: string;
+    /** Optional field configuration JSON (stringified) */
+    fieldConfig?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+/**
+ * Content item stored in the database
+ */
+type ContentItem = {
+    id: string;
+    /** Reference to the content type */
+    contentTypeId: string;
+    /** URL-friendly slug - unique within content type */
+    slug: string;
+    /** JSON data matching the content type's schema (stringified) */
+    data: string;
+    /** Optional author ID for tracking who created/modified */
+    authorId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+};
+/**
+ * Serialized content type for API responses (dates as strings)
+ */
+interface SerializedContentType extends Omit<ContentType, "createdAt" | "updatedAt"> {
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Serialized content item for API responses (dates as strings)
+ */
+interface SerializedContentItem extends Omit<ContentItem, "createdAt" | "updatedAt"> {
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * Serialized content item with parsed data and joined content type
+ * @template TData - The type of the parsed data (defaults to Record<string, unknown>)
+ */
+interface SerializedContentItemWithType<TData = Record<string, unknown>> extends SerializedContentItem {
+    /** Parsed data object (JSON.parse of data field) */
+    parsedData: TData;
+    /** Joined content type */
+    contentType?: SerializedContentType;
+}
+/**
+ * Paginated list response for content items
+ * @template TData - The type of the parsed data (defaults to Record<string, unknown>)
+ */
+interface PaginatedContentItems<TData = Record<string, unknown>> {
+    items: SerializedContentItemWithType<TData>[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * Context passed to CMS backend hooks
+ */
+interface CMSHookContext {
+    /** Content type slug */
+    typeSlug: string;
+    /** User ID if authenticated */
+    userId?: string;
+    /** Request headers */
+    headers?: Headers;
+}
+/**
+ * Hooks for customizing CMS backend behavior
+ */
+interface CMSBackendHooks {
+    /** Called before creating a content item */
+    onBeforeCreate?: (data: Record<string, unknown>, context: CMSHookContext) => Promise<Record<string, unknown> | false> | Record<string, unknown> | false;
+    /** Called after creating a content item */
+    onAfterCreate?: (item: SerializedContentItem, context: CMSHookContext) => Promise<void> | void;
+    /** Called before updating a content item */
+    onBeforeUpdate?: (id: string, data: Record<string, unknown>, context: CMSHookContext) => Promise<Record<string, unknown> | false> | Record<string, unknown> | false;
+    /** Called after updating a content item */
+    onAfterUpdate?: (item: SerializedContentItem, context: CMSHookContext) => Promise<void> | void;
+    /** Called before deleting a content item */
+    onBeforeDelete?: (id: string, context: CMSHookContext) => Promise<boolean> | boolean;
+    /** Called after deleting a content item */
+    onAfterDelete?: (id: string, context: CMSHookContext) => Promise<void> | void;
+    /** Called on any CMS error */
+    onError?: (error: Error, operation: "create" | "update" | "delete" | "list" | "get", context: CMSHookContext) => Promise<void> | void;
+}
+/**
+ * Configuration for the CMS backend plugin
+ */
+interface CMSBackendConfig {
+    /** Content types defined by the developer */
+    contentTypes: ContentTypeConfig[];
+    /** Optional hooks for customizing behavior */
+    hooks?: CMSBackendHooks;
+}
+
+export type { CMSBackendConfig as C, PaginatedContentItems as P, SerializedContentType as S, SerializedContentItemWithType as a };