@btst/stack 1.5.2 → 1.6.0

package/dist/plugins/form-builder/query-keys.d.ts

@@ -0,0 +1,74 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { P as PaginatedForms, S as SerializedForm, c as PaginatedFormSubmissions, b as SerializedFormSubmissionWithData } from '../../shared/stack.DzH_wcvr.js';
+import { FormBuilderApiRouter } from './api/index.js';
+import '@btst/stack/plugins/api';
+import 'better-call';
+import 'zod';
+
+interface FormListParams {
+    status?: "active" | "inactive" | "archived";
+    limit?: number;
+    offset?: number;
+}
+interface SubmissionListParams {
+    formId: string;
+    limit?: number;
+    offset?: number;
+}
+/**
+ * Create Form Builder query keys for React Query
+ * Used by consumers to fetch forms and submissions
+ */
+declare function createFormBuilderQueryKeys(client: ReturnType<typeof createApiClient<FormBuilderApiRouter>>, headers?: HeadersInit): {
+    forms: {
+        _def: readonly ["forms"];
+    } & {
+        list: ((params?: FormListParams | undefined) => Omit<{
+            queryKey: readonly ["forms", "list", string, FormListParams];
+            queryFn: _tanstack_react_query.QueryFunction<PaginatedForms, readonly ["forms", "list", string, FormListParams]>;
+        } & {
+            _def: readonly ["forms", "list"];
+        }, "_def">) & {
+            _def: readonly ["forms", "list"];
+        };
+        bySlug: ((slug: string) => Omit<{
+            queryKey: readonly ["forms", "bySlug", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedForm | null, readonly ["forms", "bySlug", string, string]>;
+        } & {
+            _def: readonly ["forms", "bySlug"];
+        }, "_def">) & {
+            _def: readonly ["forms", "bySlug"];
+        };
+        byId: ((id: string) => Omit<{
+            queryKey: readonly ["forms", "byId", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedForm | null, readonly ["forms", "byId", string, string]>;
+        } & {
+            _def: readonly ["forms", "byId"];
+        }, "_def">) & {
+            _def: readonly ["forms", "byId"];
+        };
+    };
+    formSubmissions: {
+        _def: readonly ["formSubmissions"];
+    } & {
+        list: ((params: SubmissionListParams) => Omit<{
+            queryKey: readonly ["formSubmissions", "list", SubmissionListParams];
+            queryFn: _tanstack_react_query.QueryFunction<PaginatedFormSubmissions<Record<string, unknown>>, readonly ["formSubmissions", "list", SubmissionListParams]>;
+        } & {
+            _def: readonly ["formSubmissions", "list"];
+        }, "_def">) & {
+            _def: readonly ["formSubmissions", "list"];
+        };
+        detail: ((formId: string, subId: string) => Omit<{
+            queryKey: readonly ["formSubmissions", "detail", string, string];
+            queryFn: _tanstack_react_query.QueryFunction<SerializedFormSubmissionWithData<Record<string, unknown>> | null, readonly ["formSubmissions", "detail", string, string]>;
+        } & {
+            _def: readonly ["formSubmissions", "detail"];
+        }, "_def">) & {
+            _def: readonly ["formSubmissions", "detail"];
+        };
+    };
+};
+
+export { createFormBuilderQueryKeys };

package/dist/plugins/form-builder/query-keys.mjs

@@ -0,0 +1,141 @@
+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 createFormBuilderQueryKeys(client, headers) {
+  const forms = createFormsQueries(client, headers);
+  const submissions = createSubmissionsQueries(client, headers);
+  return mergeQueryKeys(forms, submissions);
+}
+function createFormsQueries(client, headers) {
+  return createQueryKeys("forms", {
+    list: (params = {}) => ({
+      queryKey: ["list", params],
+      queryFn: async () => {
+        try {
+          const response = await client("/forms", {
+            method: "GET",
+            query: {
+              status: params.status,
+              limit: params.limit ?? 20,
+              offset: params.offset ?? 0
+            },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    bySlug: (slug) => ({
+      queryKey: ["bySlug", slug],
+      queryFn: async () => {
+        if (!slug) return null;
+        try {
+          const response = await client("/forms/:slug", {
+            method: "GET",
+            params: { slug },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    }),
+    byId: (id) => ({
+      queryKey: ["byId", id],
+      queryFn: async () => {
+        if (!id) return null;
+        try {
+          const response = await client("/forms/id/:id", {
+            method: "GET",
+            params: { id },
+            headers
+          });
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+function createSubmissionsQueries(client, headers) {
+  return createQueryKeys("formSubmissions", {
+    list: (params) => ({
+      queryKey: [params],
+      queryFn: async () => {
+        try {
+          const response = await client("/forms/:formId/submissions", {
+            method: "GET",
+            params: { formId: params.formId },
+            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: (formId, subId) => ({
+      queryKey: [formId, subId],
+      queryFn: async () => {
+        if (!formId || !subId) return null;
+        try {
+          const response = await client(
+            "/forms/:formId/submissions/:subId",
+            {
+              method: "GET",
+              params: { formId, subId },
+              headers
+            }
+          );
+          if (isErrorResponse(response)) {
+            throw toError(response.error);
+          }
+          return response.data;
+        } catch (error) {
+          throw error;
+        }
+      }
+    })
+  });
+}
+
+export { createFormBuilderQueryKeys };

package/dist/plugins/form-builder/style.css

@@ -0,0 +1,19 @@
+@import "./client.css";
+
+/*
+ * Form Builder 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/form-builder/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.AX5nZ6A3.d.cts

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+
+/**
+ * Unified Schema Converter Module
+ *
+ * Provides consistent bidirectional conversion between Zod schemas and JSON Schema,
+ * handling all edge cases in one place:
+ *
+ * 1. Date handling: z.date() ↔ { type: "string", format: "date-time" }
+ * 2. Steps metadata: Preserves multi-step form configuration
+ * 3. Step group mapping: Tracks which fields belong to which step
+ * 4. Date constraints: Preserves min/max date validations
+ *
+ * Usage:
+ * ```ts
+ * // Zod → JSON Schema (for storage/transport)
+ * const jsonSchema = zodToFormSchema(myZodSchema);
+ *
+ * // JSON Schema → Zod (for validation)
+ * const zodSchema = formSchemaToZod(jsonSchema);
+ * ```
+ */
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getStepGroupMap as a, formSchemaToZod as f, getSteps as g, hasSteps as h, zodToFormSchema as z };
+export type { FormStep as F, FormSchemaMetadata as b };

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+
+/**
+ * Unified Schema Converter Module
+ *
+ * Provides consistent bidirectional conversion between Zod schemas and JSON Schema,
+ * handling all edge cases in one place:
+ *
+ * 1. Date handling: z.date() ↔ { type: "string", format: "date-time" }
+ * 2. Steps metadata: Preserves multi-step form configuration
+ * 3. Step group mapping: Tracks which fields belong to which step
+ * 4. Date constraints: Preserves min/max date validations
+ *
+ * Usage:
+ * ```ts
+ * // Zod → JSON Schema (for storage/transport)
+ * const jsonSchema = zodToFormSchema(myZodSchema);
+ *
+ * // JSON Schema → Zod (for validation)
+ * const zodSchema = formSchemaToZod(jsonSchema);
+ * ```
+ */
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getStepGroupMap as a, formSchemaToZod as f, getSteps as g, hasSteps as h, zodToFormSchema as z };
+export type { FormStep as F, FormSchemaMetadata as b };

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+
+/**
+ * Unified Schema Converter Module
+ *
+ * Provides consistent bidirectional conversion between Zod schemas and JSON Schema,
+ * handling all edge cases in one place:
+ *
+ * 1. Date handling: z.date() ↔ { type: "string", format: "date-time" }
+ * 2. Steps metadata: Preserves multi-step form configuration
+ * 3. Step group mapping: Tracks which fields belong to which step
+ * 4. Date constraints: Preserves min/max date validations
+ *
+ * Usage:
+ * ```ts
+ * // Zod → JSON Schema (for storage/transport)
+ * const jsonSchema = zodToFormSchema(myZodSchema);
+ *
+ * // JSON Schema → Zod (for validation)
+ * const zodSchema = formSchemaToZod(jsonSchema);
+ * ```
+ */
+
+interface FormStep {
+    id: string;
+    title: string;
+}
+interface FormSchemaMetadata {
+    /** Multi-step form step definitions */
+    steps?: FormStep[];
+    /** Map of field names to their step indices */
+    stepGroupMap?: Record<string, number>;
+}
+interface JsonSchemaProperty {
+    type?: string;
+    format?: string;
+    formatMinimum?: string;
+    formatMaximum?: string;
+    stepGroup?: number;
+    properties?: Record<string, JsonSchemaProperty>;
+    [key: string]: unknown;
+}
+interface FormJsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    steps?: FormStep[];
+    stepGroupMap?: Record<string, number>;
+    [key: string]: unknown;
+}
+/**
+ * Convert a Zod schema to JSON Schema with proper handling for:
+ * - z.date() → { type: "string", format: "date-time" }
+ * - Date min/max constraints → formatMinimum/formatMaximum
+ * - Steps metadata (if provided via schema.meta() or explicit metadata param)
+ *
+ * @param schema - The Zod schema to convert
+ * @param metadata - Optional explicit metadata to include (overrides schema meta)
+ */
+declare function zodToFormSchema<T extends z.ZodType>(schema: T, metadata?: FormSchemaMetadata): FormJsonSchema;
+/**
+ * Convert JSON Schema to Zod schema with proper handling for:
+ * - { type: "string", format: "date-time" } → date field (with constraints)
+ * - Steps metadata re-attachment (preserved via .meta())
+ * - Step group mapping
+ *
+ * @param jsonSchema - The JSON Schema to convert
+ * @returns A Zod schema ready for validation, with all metadata preserved
+ */
+declare function formSchemaToZod(jsonSchema: FormJsonSchema): z.ZodType;
+/**
+ * Check if a JSON Schema has multi-step configuration.
+ */
+declare function hasSteps(jsonSchema: FormJsonSchema): boolean;
+/**
+ * Get steps from a JSON Schema.
+ */
+declare function getSteps(jsonSchema: FormJsonSchema): FormStep[];
+/**
+ * Get the step group map from a JSON Schema.
+ * Returns a map of field names to step indices.
+ */
+declare function getStepGroupMap(jsonSchema: FormJsonSchema): Record<string, number>;
+
+export { getStepGroupMap as a, formSchemaToZod as f, getSteps as g, hasSteps as h, zodToFormSchema as z };
+export type { FormStep as F, FormSchemaMetadata as b };

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

@@ -0,0 +1,123 @@
+import { ControllerRenderProps, FieldValues } from 'react-hook-form';
+import * as zod from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+declare function AutoFormCheckbox({ label, isRequired, field, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormDate({ label, isRequired, field, fieldConfigItem, fieldProps, zodItem, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormEnum({ label, isRequired, field, fieldConfigItem, zodItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormInput({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormNumber({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormRadioGroup({ label, isRequired, field, zodItem, fieldProps, fieldConfigItem, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormSwitch({ label, isRequired, field, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare function AutoFormTextarea({ label, isRequired, fieldConfigItem, fieldProps, }: AutoFormInputComponentProps): react_jsx_runtime.JSX.Element;
+
+declare const INPUT_COMPONENTS: {
+    checkbox: typeof AutoFormCheckbox;
+    date: typeof AutoFormDate;
+    select: typeof AutoFormEnum;
+    radio: typeof AutoFormRadioGroup;
+    switch: typeof AutoFormSwitch;
+    textarea: typeof AutoFormTextarea;
+    number: typeof AutoFormNumber;
+    fallback: typeof AutoFormInput;
+};
+
+/**
+ * Shared types between form-builder and auto-form.
+ *
+ * These types ensure consistency when:
+ * - form-builder creates JSON Schema properties
+ * - auto-form consumes JSON Schema properties
+ * - inputProps flow from form-builder → JSON Schema → auto-form
+ */
+
+/**
+ * Common input props shared by all field types.
+ */
+interface BaseInputProps {
+    /** Whether the field is disabled */
+    disabled?: boolean;
+    /** Whether the field is read-only */
+    readOnly?: boolean;
+    /** Whether the field is required */
+    required?: boolean;
+    /** Whether to show the label (auto-form specific) */
+    showLabel?: boolean;
+}
+/**
+ * Generic input props that accept any field type.
+ * Use this when the backing type is not known at compile time.
+ *
+ * This is the catch-all type used for runtime flexibility.
+ */
+interface SerializableInputProps extends BaseInputProps {
+    placeholder?: string;
+    type?: string;
+    defaultValue?: unknown;
+    min?: number | string;
+    max?: number | string;
+    step?: number | string;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    autoComplete?: string;
+    /** Allow additional props for extensibility */
+    [key: string]: unknown;
+}
+
+/**
+ * Input props for form fields.
+ *
+ * This is the runtime type that accepts any input props.
+ * For type-safe props, use the discriminated types:
+ * - StringInputProps for text inputs
+ * - NumberInputProps for number inputs
+ * - BooleanInputProps for checkboxes/switches
+ * - DateInputProps for date pickers
+ * - EnumInputProps for selects/radios
+ */
+type FieldInputProps = SerializableInputProps & Omit<React.InputHTMLAttributes<HTMLInputElement>, keyof SerializableInputProps> & Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, keyof SerializableInputProps>;
+/**
+ * Configuration for a single field in AutoForm.
+ *
+ * Note: This type is designed to align with form-builder's FormBuilderFieldProps
+ * so that JSON Schema properties can be easily converted to field configs.
+ */
+type FieldConfigItem = {
+    /** Description text or React node */
+    description?: React.ReactNode;
+    /** Input props passed to the field component */
+    inputProps?: FieldInputProps;
+    /** Display label */
+    label?: string;
+    /** Field type override - built-in type or custom component */
+    fieldType?: keyof typeof INPUT_COMPONENTS | React.FC<AutoFormInputComponentProps>;
+    /** Wrapper component for custom field layout */
+    renderParent?: (props: {
+        children: React.ReactNode;
+    }) => React.ReactElement | null;
+    /** Display order for field ordering */
+    order?: number;
+};
+/**
+ * A FormInput component can handle a specific Zod type (e.g. "ZodBoolean")
+ */
+type AutoFormInputComponentProps = {
+    zodInputProps: React.InputHTMLAttributes<HTMLInputElement>;
+    field: ControllerRenderProps<FieldValues, any>;
+    fieldConfigItem: FieldConfigItem;
+    label: string;
+    isRequired: boolean;
+    fieldProps: any;
+    zodItem: zod.ZodType;
+    className?: string;
+};
+
+export type { AutoFormInputComponentProps as A };