@btst/stack 2.6.2 → 2.8.0

package/dist/shared/{stack.CLQuVdwK.d.ts → stack.RuQ9JCLo.d.ts}

@@ -1,8 +1,8 @@
 import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
-import * as better_call from 'better-call';
 import { S as SerializedForm, b as SerializedFormSubmissionWithData, F as Form, d as FormSubmission, a as SerializedFormSubmission, e as FormSubmissionWithForm, f as FormBuilderBackendConfig } from './stack.BozPgbrZ.js';
+import * as better_call from 'better-call';
 import { z } from 'zod';
-import { Adapter } from '@btst/db';
+import { DBAdapter } from '@btst/db';
 import { QueryClient } from '@tanstack/react-query';
 
 /**
@@ -30,7 +30,7 @@ declare function serializeFormSubmissionWithData(submission: FormSubmissionWithF
  * @param adapter - The database adapter
  * @param params - Optional filter/pagination parameters
  */
-declare function getAllForms(adapter: Adapter, params?: {
+declare function getAllForms(adapter: DBAdapter, params?: {
     status?: string;
     limit?: number;
     offset?: number;
@@ -51,7 +51,7 @@ declare function getAllForms(adapter: Adapter, params?: {
  * @param adapter - The database adapter
  * @param id - The form UUID
  */
-declare function getFormById(adapter: Adapter, id: string): Promise<SerializedForm | null>;
+declare function getFormById(adapter: DBAdapter, id: string): Promise<SerializedForm | null>;
 /**
  * Retrieve a single form by its slug.
  * Returns null if the form is not found.
@@ -63,7 +63,7 @@ declare function getFormById(adapter: Adapter, id: string): Promise<SerializedFo
  * @param adapter - The database adapter
  * @param slug - The form slug
  */
-declare function getFormBySlug(adapter: Adapter, slug: string): Promise<SerializedForm | null>;
+declare function getFormBySlug(adapter: DBAdapter, slug: string): Promise<SerializedForm | null>;
 /**
  * Retrieve submissions for a form by form ID, with optional pagination.
  * Returns an empty result if the form does not exist.
@@ -76,7 +76,7 @@ declare function getFormBySlug(adapter: Adapter, slug: string): Promise<Serializ
  * @param formId - The form ID
  * @param params - Optional pagination parameters
  */
-declare function getFormSubmissions(adapter: Adapter, formId: string, params?: {
+declare function getFormSubmissions(adapter: DBAdapter, formId: string, params?: {
     limit?: number;
     offset?: number;
 }): Promise<{
@@ -104,17 +104,18 @@ interface FormBuilderPrefetchForRoute {
  * @param config - Configuration with optional hooks
  */
 declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _btst_stack_plugins_api.BackendPlugin<{
-    listForms: better_call.StrictEndpoint<"/forms", {
+    listForms: better_call.StrictEndpoint<"/forms", {} & {
         method: "GET";
-        query: z.ZodObject<{
-            status: z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>;
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        query: better_call.StandardSchemaV1<{
+            status?: "active" | "inactive" | "archived" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            status?: "active" | "inactive" | "archived" | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedForm[];
         total: number;
@@ -122,68 +123,88 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         offset?: number;
     }>;
     getFormBySlug: better_call.StrictEndpoint<"/forms/:slug", {
-        method: "GET";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedForm>;
     getFormById: better_call.StrictEndpoint<"/forms/id/:id", {
-        method: "GET";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedForm>;
-    createForm: better_call.StrictEndpoint<"/forms", {
+    createForm: better_call.StrictEndpoint<"/forms", {} & {
         method: "POST";
-        body: z.ZodObject<{
-            name: z.ZodString;
-            slug: z.ZodString;
-            description: z.ZodOptional<z.ZodString>;
-            schema: z.ZodString;
-            successMessage: z.ZodOptional<z.ZodString>;
-            redirectUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
-            status: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>>;
-        }, z.core.$strip>;
+        body: better_call.StandardSchemaV1<{
+            name: string;
+            slug: string;
+            schema: string;
+            description?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }, {
+            name: string;
+            slug: string;
+            schema: string;
+            description?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }>;
     }, SerializedForm>;
     updateForm: better_call.StrictEndpoint<"/forms/:id", {
-        method: "PUT";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            name: z.ZodOptional<z.ZodString>;
-            slug: z.ZodOptional<z.ZodString>;
-            description: z.ZodOptional<z.ZodString>;
-            schema: z.ZodOptional<z.ZodString>;
-            successMessage: z.ZodOptional<z.ZodString>;
-            redirectUrl: z.ZodUnion<[z.ZodOptional<z.ZodString>, z.ZodLiteral<"">]>;
-            status: z.ZodOptional<z.ZodEnum<{
-                active: "active";
-                inactive: "inactive";
-                archived: "archived";
-            }>>;
-        }, z.core.$strip>;
+    } & {
+        method: "PUT";
+        body: better_call.StandardSchemaV1<{
+            name?: string | undefined;
+            slug?: string | undefined;
+            description?: string | undefined;
+            schema?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }, {
+            name?: string | undefined;
+            slug?: string | undefined;
+            description?: string | undefined;
+            schema?: string | undefined;
+            successMessage?: string | undefined;
+            redirectUrl?: string | undefined;
+            status?: "active" | "inactive" | "archived" | undefined;
+        }>;
     }, SerializedForm>;
     deleteForm: better_call.StrictEndpoint<"/forms/:id", {
-        method: "DELETE";
         params: z.ZodObject<{
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
     }, {
         success: boolean;
     }>;
     submitForm: better_call.StrictEndpoint<"/forms/:slug/submit", {
-        method: "POST";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            data: z.ZodObject<{}, z.core.$loose>;
-        }, z.core.$strip>;
+    } & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            data: {
+                [x: string]: unknown;
+            };
+        }, {
+            data: {
+                [x: string]: unknown;
+            };
+        }>;
     }, {
         form: {
             successMessage: string | undefined;
@@ -198,14 +219,19 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         userAgent?: string | undefined;
     }>;
     listSubmissions: better_call.StrictEndpoint<"/forms/:formId/submissions", {
-        method: "GET";
         params: z.ZodObject<{
             formId: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedFormSubmissionWithData[];
         total: number;
@@ -213,18 +239,21 @@ declare const formBuilderBackendPlugin: (config?: FormBuilderBackendConfig) => _
         offset?: number;
     }>;
     getSubmission: better_call.StrictEndpoint<"/forms/:formId/submissions/:subId", {
-        method: "GET";
         params: z.ZodObject<{
             formId: z.ZodString;
             subId: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedFormSubmissionWithData<Record<string, unknown>>>;
     deleteSubmission: better_call.StrictEndpoint<"/forms/:formId/submissions/:subId", {
-        method: "DELETE";
         params: z.ZodObject<{
             formId: z.ZodString;
             subId: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
     }, {
         success: boolean;
     }>;

package/dist/shared/{stack.BwA7trxA.d.cts → stack.VF6FhyZw.d.ts}

@@ -1,5 +1,5 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { S as SerializedPost, c as createPostSchema, u as updatePostSchema, a as SerializedTag } from './stack.BQmuNl5p.cjs';
+import { S as SerializedPost, c as createPostSchema, u as updatePostSchema, a as SerializedTag } from './stack.BWp0hcm9.js';
 import { z } from 'zod';
 
 /**
@@ -135,14 +135,14 @@ declare function useCreatePost(): _tanstack_react_query.UseMutationResult<Serial
         name: string;
         slug: string;
     })[];
+    published: boolean;
     title: string;
     content: string;
     excerpt: string;
-    published: boolean;
     slug?: string | undefined;
+    publishedAt?: Date | undefined;
     createdAt?: Date | undefined;
     updatedAt?: Date | undefined;
-    publishedAt?: Date | undefined;
     image?: string | undefined;
 }, unknown>;
 /** Update an existing post by id */
@@ -184,13 +184,10 @@ interface UseNextPreviousPostsResult {
     refetch: () => void;
 }
 /**
- * Hook for fetching previous and next posts relative to a given date
- * Uses useInView to only fetch when the component is in view
+ * Hook for fetching previous and next posts relative to a given date.
+ * Pair with `<WhenVisible>` in the render tree for lazy loading.
  */
-declare function useNextPreviousPosts(createdAt: string | Date, options?: UseNextPreviousPostsOptions): UseNextPreviousPostsResult & {
-    ref: (node: Element | null) => void;
-    inView: boolean;
-};
+declare function useNextPreviousPosts(createdAt: string | Date, options?: UseNextPreviousPostsOptions): UseNextPreviousPostsResult;
 /**
  * Options for the useRecentPosts hook
  */
@@ -216,13 +213,10 @@ interface UseRecentPostsResult {
     refetch: () => void;
 }
 /**
- * Hook for fetching recent posts
- * Uses useInView to only fetch when the component is in view
+ * Hook for fetching recent posts.
+ * Pair with `<WhenVisible>` in the render tree for lazy loading.
  */
-declare function useRecentPosts(options?: UseRecentPostsOptions): UseRecentPostsResult & {
-    ref: (node: Element | null) => void;
-    inView: boolean;
-};
+declare function useRecentPosts(options?: UseRecentPostsOptions): UseRecentPostsResult;
 
 export { useSuspensePosts as f, usePost as g, useSuspensePost as h, useTags as i, useSuspenseTags as j, useCreatePost as k, useUpdatePost as l, useDeletePost as m, usePostSearch as n, useNextPreviousPosts as q, useRecentPosts as t, usePosts as u };
 export type { PostCreateInput as P, UsePostsOptions as U, UsePostsResult as a, UsePostSearchOptions as b, UsePostSearchResult as c, UsePostResult as d, PostUpdateInput as e, UseNextPreviousPostsOptions as o, UseNextPreviousPostsResult as p, UseRecentPostsOptions as r, UseRecentPostsResult as s };

package/dist/shared/{stack.sO33ZDhK.d.ts → stack.fQjVhw5a.d.ts}

@@ -2,7 +2,7 @@ import * as _btst_stack_plugins_api from '@btst/stack/plugins/api';
 import { a as SerializedContentItemWithType, S as SerializedContentType, b as ContentType, c as ContentItem, d as SerializedContentItem, e as ContentItemWithType, f as CMSBackendConfig, I as InverseRelation } from './stack.B8QD11QU.js';
 import * as better_call from 'better-call';
 import { z } from 'zod';
-import { Adapter } from '@btst/db';
+import { DBAdapter } from '@btst/db';
 import { QueryClient } from '@tanstack/react-query';
 
 /**
@@ -29,7 +29,7 @@ declare function serializeContentItemWithType(item: ContentItemWithType): Serial
  *
  * @param adapter - The database adapter
  */
-declare function getAllContentTypes(adapter: Adapter): Promise<SerializedContentType[]>;
+declare function getAllContentTypes(adapter: DBAdapter): Promise<SerializedContentType[]>;
 /**
  * Retrieve all content items for a given content type, with optional pagination.
  * Pure DB function — no hooks, no HTTP context. Safe for SSG and server-side use.
@@ -42,7 +42,7 @@ declare function getAllContentTypes(adapter: Adapter): Promise<SerializedContent
  * @param contentTypeSlug - The slug of the content type to query
  * @param params - Optional filter/pagination parameters
  */
-declare function getAllContentItems(adapter: Adapter, contentTypeSlug: string, params?: {
+declare function getAllContentItems(adapter: DBAdapter, contentTypeSlug: string, params?: {
     slug?: string;
     limit?: number;
     offset?: number;
@@ -63,7 +63,7 @@ declare function getAllContentItems(adapter: Adapter, contentTypeSlug: string, p
  * @param adapter - The database adapter
  * @param id - The content item ID (UUID)
  */
-declare function getContentItemById(adapter: Adapter, id: string): Promise<SerializedContentItemWithType | null>;
+declare function getContentItemById(adapter: DBAdapter, id: string): Promise<SerializedContentItemWithType | null>;
 /**
  * Retrieve a single content item by its slug within a content type.
  * Returns null if the content type or item is not found.
@@ -76,7 +76,7 @@ declare function getContentItemById(adapter: Adapter, id: string): Promise<Seria
  * @param contentTypeSlug - The slug of the content type
  * @param slug - The slug of the content item
  */
-declare function getContentItemBySlug(adapter: Adapter, contentTypeSlug: string, slug: string): Promise<SerializedContentItemWithType | null>;
+declare function getContentItemBySlug(adapter: DBAdapter, contentTypeSlug: string, slug: string): Promise<SerializedContentItemWithType | null>;
 
 /**
  * Input for creating a new CMS content item.
@@ -105,7 +105,7 @@ interface CreateCMSContentItemInput {
  * @param contentTypeSlug - Slug of the target content type
  * @param input - Item slug and data payload
  */
-declare function createCMSContentItem(adapter: Adapter, contentTypeSlug: string, input: CreateCMSContentItemInput): Promise<SerializedContentItem>;
+declare function createCMSContentItem(adapter: DBAdapter, contentTypeSlug: string, input: CreateCMSContentItemInput): Promise<SerializedContentItem>;
 
 /**
  * Route keys for the CMS plugin — matches the keys returned by
@@ -129,7 +129,7 @@ interface CMSPrefetchForRoute {
  * @param config - Configuration with content types and optional hooks
  */
 declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugins_api.BackendPlugin<{
-    listContentTypes: better_call.StrictEndpoint<"/content-types", {
+    listContentTypes: better_call.StrictEndpoint<"/content-types", {} & {
         method: "GET";
     }, {
         itemCount: number;
@@ -144,21 +144,28 @@ declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugin
         autoFormVersion?: number | undefined;
     }[]>;
     getContentTypeBySlug: better_call.StrictEndpoint<"/content-types/:slug", {
-        method: "GET";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedContentType>;
     listContentItems: better_call.StrictEndpoint<"/content/:typeSlug", {
-        method: "GET";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            slug: z.ZodOptional<z.ZodString>;
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            slug?: string | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            slug?: string | undefined;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedContentItemWithType[];
         total: number;
@@ -166,21 +173,30 @@ declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugin
         offset?: number;
     }>;
     getContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        method: "GET";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, SerializedContentItemWithType<Record<string, unknown>>>;
     createContentItem: better_call.StrictEndpoint<"/content/:typeSlug", {
-        method: "POST";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            slug: z.ZodString;
-            data: z.ZodObject<{}, z.core.$loose>;
-        }, z.core.$strip>;
+    } & {
+        method: "POST";
+        body: better_call.StandardSchemaV1<{
+            slug: string;
+            data: {
+                [x: string]: unknown;
+            };
+        }, {
+            slug: string;
+            data: {
+                [x: string]: unknown;
+            };
+        }>;
     }, {
         parsedData: Record<string, unknown>;
         createdAt: string;
@@ -192,31 +208,42 @@ declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugin
         authorId?: string | undefined;
     }>;
     updateContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        method: "PUT";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
             id: z.ZodString;
         }, z.core.$strip>;
-        body: z.ZodObject<{
-            slug: z.ZodOptional<z.ZodString>;
-            data: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
-        }, z.core.$strip>;
+    } & {
+        method: "PUT";
+        body: better_call.StandardSchemaV1<{
+            slug?: string | undefined;
+            data?: {
+                [x: string]: unknown;
+            } | undefined;
+        }, {
+            slug?: string | undefined;
+            data?: {
+                [x: string]: unknown;
+            } | undefined;
+        }>;
     }, SerializedContentItemWithType<Record<string, unknown>>>;
     deleteContentItem: better_call.StrictEndpoint<"/content/:typeSlug/:id", {
-        method: "DELETE";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "DELETE";
+        body: better_call.StandardSchemaV1<unknown, unknown>;
     }, {
         success: boolean;
     }>;
     getContentItemPopulated: better_call.StrictEndpoint<"/content/:typeSlug/:id/populated", {
-        method: "GET";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
             id: z.ZodString;
         }, z.core.$strip>;
+    } & {
+        method: "GET";
     }, {
         _relations: Record<string, SerializedContentItemWithType<Record<string, unknown>>[]>;
         parsedData: Record<string, unknown>;
@@ -230,16 +257,23 @@ declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugin
         authorId?: string | undefined;
     }>;
     listContentByRelation: better_call.StrictEndpoint<"/content/:typeSlug/by-relation", {
-        method: "GET";
         params: z.ZodObject<{
             typeSlug: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            field: z.ZodString;
-            targetId: z.ZodString;
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            field: string;
+            targetId: string;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            field: string;
+            targetId: string;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedContentItemWithType<Record<string, unknown>>[];
         total: number;
@@ -247,28 +281,39 @@ declare const cmsBackendPlugin: (config: CMSBackendConfig) => _btst_stack_plugin
         offset: number;
     }>;
     getInverseRelations: better_call.StrictEndpoint<"/content-types/:slug/inverse-relations", {
-        method: "GET";
         params: z.ZodObject<{
             slug: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            itemId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            itemId?: string | undefined;
+        }, {
+            itemId?: string | undefined;
+        }>;
     }, {
         inverseRelations: InverseRelation[];
     }>;
     listInverseRelationItems: better_call.StrictEndpoint<"/content-types/:slug/inverse-relations/:sourceType", {
-        method: "GET";
         params: z.ZodObject<{
             slug: z.ZodString;
             sourceType: z.ZodString;
         }, z.core.$strip>;
-        query: z.ZodObject<{
-            itemId: z.ZodString;
-            fieldName: z.ZodString;
-            limit: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-            offset: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
-        }, z.core.$strip>;
+    } & {
+        method: "GET";
+    } & {
+        query: better_call.StandardSchemaV1<{
+            itemId: string;
+            fieldName: string;
+            limit?: unknown;
+            offset?: unknown;
+        }, {
+            itemId: string;
+            fieldName: string;
+            limit?: unknown;
+            offset?: unknown;
+        }>;
     }, {
         items: SerializedContentItemWithType<Record<string, unknown>>[];
         total: number;