@btst/stack 4.6.0 → 5.1.0

package/dist/shared/stack.DrB3L7Ih.d.ts

@@ -0,0 +1,330 @@
+import { z } from 'zod';
+
+/**
+ * Configuration for a content type defined by the developer.
+ *
+ * Field types are now specified directly in the Zod schema via .meta():
+ * @example
+ * ```typescript
+ * const ProductSchema = z.object({
+ *   description: z.string().meta({ fieldType: "textarea" }),
+ *   image: z.string().optional().meta({ fieldType: "file" }),
+ * });
+ * ```
+ */
+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. Use .meta({ fieldType: "..." }) for field type overrides. */
+    schema: z.ZodObject<z.ZodRawShape>;
+}
+/**
+ * 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;
+    /** @deprecated Legacy field config - now embedded in jsonSchema. Kept for backwards compat. */
+    fieldConfig?: string;
+    /** AutoForm schema version. 1 = legacy (separate fieldConfig), 2 = unified (fieldType in jsonSchema) */
+    autoFormVersion?: number;
+    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;
+};
+/**
+ * Content item with its content type joined
+ */
+type ContentItemWithType = ContentItem & {
+    contentType?: ContentType;
+};
+/**
+ * Represents an inverse relation (content types that reference this type via belongsTo)
+ */
+interface InverseRelation {
+    /** The content type slug that has the belongsTo relation */
+    sourceType: string;
+    /** Display name of the source content type */
+    sourceTypeName: string;
+    /** The field name that contains the belongsTo relation */
+    fieldName: string;
+    /** Count of items with this relation (when itemId is provided) */
+    count: number;
+}
+/**
+ * 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;
+    /**
+     * Populated relation data (only present when using populated endpoints/hooks).
+     * Keys are field names, values are arrays of related content items.
+     */
+    _relations?: Record<string, SerializedContentItemWithType[]>;
+}
+/** Output shape for CMS reads; omission retains the full editor envelope. */
+type CMSReadView = "content" | undefined;
+/** Literal top-level property names selected from parsed content. */
+type CMSContentFields = readonly string[] | undefined;
+/** Select known literal properties, or an honest partial shape for dynamic arrays. */
+type CMSSelectedData<TData, TFields extends CMSContentFields = undefined> = TFields extends readonly string[] ? string extends TFields[number] ? Partial<TData> : Pick<TData, Extract<TFields[number], keyof TData>> : TData;
+/** Optional output controls for CMS reads. These do not change access checks. */
+interface CMSReadOptions<TView extends CMSReadView = CMSReadView, TFields extends CMSContentFields = CMSContentFields> {
+    /** Return identity, parsed content and timestamps without editor metadata. */
+    view?: TView;
+    /** Literal declared top-level content properties. Requires content view. */
+    fields?: TFields;
+}
+/** Serialized content envelope without raw JSON or editor metadata. */
+type SerializedContentItemContent<TData = Record<string, unknown>> = Pick<SerializedContentItemWithType<TData>, "id" | "slug" | "parsedData" | "createdAt" | "updatedAt">;
+/** Result envelope selected by a statically known read view. */
+type CMSContentItemResult<TData = Record<string, unknown>, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined> = TView extends "content" ? SerializedContentItemContent<CMSSelectedData<TData, TFields>> : SerializedContentItemWithType<TData>;
+/**
+ * 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>, TView extends CMSReadView = undefined, TFields extends CMSContentFields = undefined> {
+    items: CMSContentItemResult<TData, TView, TFields>[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * Type helper to define a map of content type slugs to their data types.
+ * Use with z.infer to get the type from your Zod schemas.
+ *
+ * @example
+ * ```typescript
+ * import { z } from "zod"
+ *
+ * // Define your schemas
+ * export const ProductSchema = z.object({
+ *   name: z.string(),
+ *   price: z.number(),
+ * })
+ *
+ * export const TestimonialSchema = z.object({
+ *   author: z.string(),
+ *   quote: z.string(),
+ * })
+ *
+ * // Create the type map
+ * export type MyCMSTypes = {
+ *   product: z.infer<typeof ProductSchema>
+ *   testimonial: z.infer<typeof TestimonialSchema>
+ * }
+ *
+ * // Use in hooks for type-safe parsedData
+ * const { items } = useContent<MyCMSTypes, "product">("product")
+ * // items[0].parsedData.name is typed as string
+ * // items[0].parsedData.price is typed as number
+ * ```
+ */
+type CMSContentTypeMap = Record<string, Record<string, unknown>>;
+/** JSON-safe values accepted at the CMS operation boundary. */
+type CMSOperationData = string | number | boolean | null | readonly CMSOperationData[] | {
+    readonly [key: string]: CMSOperationData;
+};
+interface CMSOperationIdentity {
+    readonly id: string;
+    readonly [key: string]: unknown;
+}
+type CMSDeepReadonly<T> = T extends (...args: any[]) => unknown ? T : T extends readonly unknown[] ? {
+    readonly [TKey in keyof T]: CMSDeepReadonly<T[TKey]>;
+} : T extends object ? {
+    readonly [TKey in keyof T]: CMSDeepReadonly<T[TKey]>;
+} : T;
+interface CMSOperationContextBase<TInput, TFacts> {
+    /** Validated, deeply readonly input supplied to the operation. */
+    readonly input: Readonly<TInput>;
+    /** Trusted server-derived facts used by the authorization rule. */
+    readonly facts: Readonly<TFacts>;
+    /** Authorized request identity, or `null` for anonymous and trusted calls. */
+    readonly identity: Readonly<CMSOperationIdentity> | null;
+    /** Transport request when the operation was invoked through HTTP or `forRequest()`. */
+    readonly request?: Request;
+    /** Compatibility view of the transport request headers. */
+    readonly headers?: Headers;
+    /** Compatibility alias for the authorized identity ID. */
+    readonly userId?: string;
+    /** Compatibility alias for the operation's CMS content-type slug. */
+    readonly typeSlug?: string;
+}
+/** Authorized context supplied before a CMS record is created. */
+interface CMSCreateOperationContext extends CMSOperationContextBase<{
+    readonly typeSlug: string;
+    readonly body: {
+        readonly slug: string;
+        readonly data: Readonly<Record<string, CMSOperationData>>;
+    };
+}, {
+    contentType: string;
+}> {
+    /** Server-resolved content-type slug for the record being created. */
+    readonly typeSlug: string;
+    /** Validated create payload supplied to the operation. */
+    readonly body: {
+        /** Requested record slug before canonical slugification. */
+        readonly slug: string;
+        /** Validated JSON-safe request fields, including any inline `_new` relation values. */
+        readonly data: Readonly<Record<string, CMSOperationData>>;
+    };
+}
+/** CMS create context after execution. */
+interface CMSCreateResultContext extends CMSCreateOperationContext {
+    /** Fully serialized record returned by the successful create operation. */
+    readonly result: CMSDeepReadonly<SerializedContentItemWithType>;
+}
+/** Authorized context supplied before a CMS record is updated. */
+interface CMSUpdateOperationContext extends CMSOperationContextBase<{
+    readonly typeSlug: string;
+    readonly id: string;
+    readonly body: {
+        readonly slug?: string;
+        readonly data?: Readonly<Record<string, CMSOperationData>>;
+    };
+}, {
+    contentType: string;
+    recordId: string;
+    authorId?: string;
+}> {
+    /** Server-resolved content-type slug for the record being updated. */
+    readonly typeSlug: string;
+    /** Canonical route parameters for the authorized record. */
+    readonly params: {
+        readonly typeSlug: string;
+        readonly id: string;
+    };
+    /** Validated partial update payload supplied to the operation. */
+    readonly body: {
+        /** Optional replacement slug before canonical slugification. */
+        readonly slug?: string;
+        /** Optional record-field fragment; hooks receive its merged validated result. */
+        readonly data?: Readonly<Record<string, CMSOperationData>>;
+    };
+}
+/** CMS update context after execution. */
+interface CMSUpdateResultContext extends CMSUpdateOperationContext {
+    /** Fully serialized record returned by the successful update operation. */
+    readonly result: CMSDeepReadonly<SerializedContentItemWithType>;
+}
+/** Authorized context supplied before a CMS record is deleted. */
+interface CMSDeleteOperationContext extends CMSOperationContextBase<{
+    readonly typeSlug: string;
+    readonly id: string;
+}, {
+    contentType: string;
+    recordId: string;
+    authorId?: string;
+}> {
+    /** Server-resolved content-type slug for the record being deleted. */
+    readonly typeSlug: string;
+    /** Canonical route parameters for the authorized record. */
+    readonly params: {
+        readonly typeSlug: string;
+        readonly id: string;
+    };
+}
+/** CMS delete context after execution. */
+interface CMSDeleteResultContext extends CMSDeleteOperationContext {
+    /** Successful delete result. */
+    readonly result: {
+        readonly success: true;
+    };
+}
+interface CMSReadOperationContext extends CMSOperationContextBase<unknown, {
+    contentType?: string;
+    scope?: "collection" | "record";
+    recordId?: string;
+    authorId?: string;
+}> {
+}
+/** Authorized context shared by the CMS operation lifecycle hooks. */
+type CMSOperationLifecycleContext = CMSReadOperationContext | CMSCreateOperationContext | CMSUpdateOperationContext | CMSDeleteOperationContext;
+/** Authorized lifecycle context supplied to the observational error hook. */
+type CMSOperationErrorContext = CMSOperationLifecycleContext & {
+    /** Original post-authorization operation error observed by `onErrorExecuteContentOperation`. */
+    readonly error: unknown;
+};
+/** Domain lifecycle hooks that run only after successful CMS authorization. */
+interface CMSBackendHooks {
+    /** Runs with validated canonical record data after authorization and before any database write. */
+    onBeforeCreateContent?: (data: Readonly<Record<string, CMSOperationData>>, context: CMSCreateOperationContext) => Promise<void> | void;
+    /** Observes the fully created record after the atomic create succeeds. */
+    onAfterCreateContent?: (item: CMSDeepReadonly<SerializedContentItemWithType>, context: CMSCreateResultContext) => Promise<void> | void;
+    /** Runs for every update with the complete merged, validated record before any database write. */
+    onBeforeUpdateContent?: (id: string, data: Readonly<Record<string, CMSOperationData>>, context: CMSUpdateOperationContext) => Promise<void> | void;
+    /** Observes the fully updated record after the atomic update succeeds. */
+    onAfterUpdateContent?: (item: CMSDeepReadonly<SerializedContentItemWithType>, context: CMSUpdateResultContext) => Promise<void> | void;
+    /** Runs after authorization and before the record is deleted. */
+    onBeforeDeleteContent?: (id: string, context: CMSDeleteOperationContext) => Promise<void> | void;
+    /** Observes the deleted record ID after the atomic delete succeeds. */
+    onAfterDeleteContent?: (id: string, context: CMSDeleteResultContext) => Promise<void> | void;
+    /** Observes post-authorization failures without replacing the original error. */
+    onErrorExecuteContentOperation?: (error: Error, operation: "create" | "update" | "delete" | "list" | "get", context: CMSOperationErrorContext) => 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;
+    /**
+     * Maximum number of items that can be requested in a single page.
+     * Applied to all list endpoints (`/content/:typeSlug`, by-relation, and inverse-relation).
+     *
+     * Raise this when your content types have many items and you need to fetch
+     * large pages (e.g. for SSG, CSV export, or programmatic access).
+     *
+     * @default 1000
+     */
+    maxPageSize?: number;
+}
+
+export type { CMSReadOptions as C, InverseRelation as I, PaginatedContentItems as P, SerializedContentType as S, CMSReadView as a, SerializedContentItemWithType as b, CMSContentFields as c, CMSContentItemResult as d, CMSContentTypeMap as e, CMSBackendConfig as f, CMSSelectedData as g, ContentItem as h, SerializedContentItem as i, ContentItemWithType as j, ContentType as k, CMSBackendHooks as l, CMSCreateOperationContext as m, CMSCreateResultContext as n, CMSDeleteOperationContext as o, CMSDeleteResultContext as p, CMSOperationErrorContext as q, CMSOperationLifecycleContext as r, CMSUpdateOperationContext as s, CMSUpdateResultContext as t, ContentTypeConfig as u, SerializedContentItemContent as v };

package/dist/shared/stack.Dv_IYqqI.d.ts

@@ -0,0 +1,75 @@
+import { ZodObject, ZodSchema, ZodTuple } from 'zod';
+import { ComponentType, ReactNode } from 'react';
+import { b as FieldConfigItem } from './stack.TOEmfBQ4.js';
+
+type PropValue = ReactNode | VariableReference | Record<string, any> | any[] | string | number | boolean | null | undefined;
+type ComponentProps<TProps extends Record<string, PropValue> = Record<string, PropValue>> = TProps;
+interface ComponentLayer<TProps extends Record<string, PropValue> = Record<string, PropValue>> {
+    id: string;
+    name?: string;
+    type: string;
+    props: ComponentProps<TProps>;
+    children: ComponentLayer[] | string | VariableReference;
+}
+type VariableValueType = 'string' | 'number' | 'boolean' | 'function';
+type VariableValue<T extends VariableValueType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'function' ? string : never;
+interface Variable<T extends VariableValueType = VariableValueType> {
+    id: string;
+    name: string;
+    type: T;
+    defaultValue: VariableValue<T>;
+}
+interface VariableReference {
+    __variableRef: string;
+}
+interface DefaultVariableBinding {
+    propName: string;
+    variableId: string;
+    immutable?: boolean;
+}
+interface RegistryEntry<T extends ComponentType<any>> {
+    component?: T;
+    schema: ZodObject<any> | ZodSchema<any>;
+    from?: string;
+    isFromDefaultExport?: boolean;
+    defaultChildren?: ComponentLayer[] | string | VariableReference;
+    defaultVariableBindings?: DefaultVariableBinding[];
+    fieldOverrides?: Record<string, FieldConfigFunction>;
+    /**
+     * If defined, this component can only be added as a child of the specified parent types.
+     * Used to filter component options in the add popover and validate drag-and-drop.
+     * Example: TabsTrigger has childOf: ["TabsList"]
+     */
+    childOf?: string[];
+}
+type FieldConfigFunction = (layer: ComponentLayer, allowVariableBinding?: boolean) => FieldConfigItem;
+type ComponentRegistry = Record<string, RegistryEntry<ComponentType<any>>>;
+/**
+ * Function definition for the function registry.
+ * Describes a function that can be bound to component event handlers.
+ */
+interface FunctionDefinition {
+    /** Human-readable name for the function */
+    name: string;
+    /** Zod schema describing the function parameters (use z.tuple for ordered args, z.object for named params) */
+    schema: ZodTuple<any, any> | ZodObject<any> | ZodSchema<any>;
+    /** The actual function to call at runtime */
+    fn: (...args: any[]) => any;
+    /** Optional description shown in the UI */
+    description?: string;
+    /**
+     * Optional TypeScript type signature for code generation.
+     * Use this when the Zod schema uses z.custom<T>() or other types
+     * that can't be automatically inferred at runtime.
+     * @example "(e: React.FormEvent<HTMLFormElement>) => void"
+     * @example "(data: { name: string; email: string }) => Promise<void>"
+     */
+    typeSignature?: string;
+}
+/**
+ * Function registry type - a record of function ID to function definition.
+ * Used to provide callable functions that can be bound to component event handlers.
+ */
+type FunctionRegistry = Record<string, FunctionDefinition>;
+
+export type { ComponentLayer as C, FunctionRegistry as F, PropValue as P, RegistryEntry as R, Variable as V, ComponentRegistry as a, FieldConfigFunction as b };

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

@@ -0,0 +1,7 @@
+import * as react from 'react';
+
+declare function BoardsListPageComponent(): react.JSX.Element;
+
+declare function NewBoardPageComponent(): react.JSX.Element;
+
+export { BoardsListPageComponent as B, NewBoardPageComponent as N };

package/dist/shared/stack.DwYPRuWC.d.mts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+
+declare function BoardsListPageComponent(): react.JSX.Element;
+
+declare function NewBoardPageComponent(): react.JSX.Element;
+
+export { BoardsListPageComponent as B, NewBoardPageComponent as N };

package/dist/shared/stack.DwYPRuWC.d.ts

@@ -0,0 +1,7 @@
+import * as react from 'react';
+
+declare function BoardsListPageComponent(): react.JSX.Element;
+
+declare function NewBoardPageComponent(): react.JSX.Element;
+
+export { BoardsListPageComponent as B, NewBoardPageComponent as N };