@btst/stack 2.12.2 → 3.0.0-rc.1

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

@@ -1,144 +1,133 @@
 'use strict';
 
-const queryKeyFactory = require('@lukemorales/query-key-factory');
+const client = require('@btst/stack/plugins/client');
 const queryKeyDefs = require('../../packages/stack/src/plugins/form-builder/api/query-key-defs.cjs');
 
-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 normalizeSearch(search) {
+  return search !== void 0 && search.trim() === "" ? void 0 : search;
 }
-function createFormBuilderQueryKeys(client, headers) {
-  const forms = createFormsQueries(client, headers);
-  const submissions = createSubmissionsQueries(client, headers);
-  return queryKeyFactory.mergeQueryKeys(forms, submissions);
+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;
 }
-function createFormsQueries(client, headers) {
-  return queryKeyFactory.createQueryKeys("forms", {
-    list: (params = {}) => ({
-      queryKey: ["list", queryKeyDefs.formsListDiscriminator(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;
-        }
+const formBuilderResources = {
+  forms: {
+    queries: {
+      list: {
+        path: "/forms",
+        query: (p) => ({
+          status: p.status,
+          limit: p.limit ?? 20,
+          search: normalizeSearch(p.search)
+        }),
+        key: (p) => ["list", queryKeyDefs.formsListDiscriminator(p)],
+        select: (data, _p) => data,
+        infinite: true,
+        pageSize: (p) => p.limit ?? 20,
+        nextPageParam: (lastPage, allPages, p) => paginatedNextPageParam(lastPage, allPages, p.limit ?? 20)
+      },
+      bySlug: {
+        path: "/forms/:slug",
+        params: (slug) => ({ slug }),
+        key: (slug) => ["bySlug", slug],
+        select: (data, _slug) => data ?? null,
+        skip: (slug) => !slug
+      },
+      byId: {
+        path: "/forms/id/:id",
+        params: (id) => ({ id }),
+        key: (id) => ["byId", id],
+        select: (data, _id) => data ?? null,
+        skip: (id) => !id
       }
-    }),
-    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;
+    },
+    mutations: {
+      create: {
+        path: "@post/forms",
+        method: "POST",
+        input: (vars) => ({ body: vars }),
+        select: (data) => data,
+        invalidates: ["forms"]
+      },
+      update: {
+        path: "@put/forms/:id",
+        method: "PUT",
+        input: (vars) => ({
+          params: { id: vars.id },
+          body: vars.data
+        }),
+        select: (data) => data,
+        invalidates: ["forms"],
+        setData: {
+          query: "byId",
+          args: (updated) => updated ? [updated.id] : null
         }
+      },
+      delete: {
+        path: "@delete/forms/:id",
+        method: "DELETE",
+        input: (id) => ({ params: { id } }),
+        select: (data) => data,
+        invalidates: ["forms"]
+      },
+      // Public form submission — no cache invalidation, and no router
+      // refresh: the success screen is client state in FormRenderer and a
+      // refresh (full reload on public pages) would wipe it.
+      submit: {
+        path: "@post/forms/:slug/submit",
+        method: "POST",
+        input: (vars) => ({
+          params: { slug: vars.slug },
+          body: { data: vars.data }
+        }),
+        select: (data) => data,
+        refresh: false
       }
-    }),
-    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;
-        }
+    }
+  },
+  formSubmissions: {
+    queries: {
+      list: {
+        path: "/forms/:formId/submissions",
+        params: (p) => ({ formId: p.formId }),
+        query: (p) => ({ limit: p.limit ?? 20 }),
+        key: (p) => [queryKeyDefs.submissionsListDiscriminator(p)],
+        select: (data, _p) => data,
+        infinite: true,
+        pageSize: (p) => p.limit ?? 20,
+        nextPageParam: (lastPage, allPages, p) => paginatedNextPageParam(lastPage, allPages, p.limit ?? 20)
+      },
+      detail: {
+        path: "/forms/:formId/submissions/:subId",
+        params: (formId, subId) => ({ formId, subId }),
+        key: (formId, subId) => [formId, subId],
+        select: (data, _formId, _subId) => data ?? null,
+        skip: (formId, subId) => !formId || !subId
       }
-    })
-  });
-}
-function createSubmissionsQueries(client, headers) {
-  return queryKeyFactory.createQueryKeys("formSubmissions", {
-    list: (params) => ({
-      queryKey: [queryKeyDefs.submissionsListDiscriminator(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;
-        }
+    },
+    mutations: {
+      delete: {
+        path: "@delete/forms/:formId/submissions/:subId",
+        method: "DELETE",
+        input: (vars) => ({
+          params: { formId: vars.formId, subId: vars.subId }
+        }),
+        select: (data) => data,
+        invalidates: ["formSubmissions"]
       }
-    }),
-    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;
-        }
-      }
-    })
-  });
+    }
+  }
+};
+function createFormBuilderQueryKeys(client$1, headers) {
+  return client.createResourceQueryKeys(client$1, formBuilderResources, headers);
 }
 
 exports.createFormBuilderQueryKeys = createFormBuilderQueryKeys;
+exports.formBuilderResources = formBuilderResources;

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

@@ -1,75 +1,365 @@
-import * as _tanstack_react_query from '@tanstack/react-query';
-import { F as FormBuilderApiRouter, a as FormsListDiscriminator, S as SubmissionsListDiscriminator } from '../../shared/stack.BYN8wCV6.cjs';
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
 import { createApiClient } from '@btst/stack/plugins/client';
-import { P as PaginatedForms, S as SerializedForm, c as PaginatedFormSubmissions, b as SerializedFormSubmissionWithData } from '../../shared/stack.BozPgbrZ.cjs';
+import { F as FormsListDiscriminator, S as SubmissionsListDiscriminator, a as FormBuilderApiRouter } from '../../shared/stack.B8vdOMnQ.cjs';
+import { P as PaginatedForms, S as SerializedForm, a as SerializedFormSubmission, c as PaginatedFormSubmissions, b as SerializedFormSubmissionWithData } from '../../shared/stack.BozPgbrZ.cjs';
 import '@btst/stack/plugins/api';
 import 'better-call';
 import 'zod';
 import '@btst/db';
+import '@tanstack/react-query';
 
+/** Params for the paginated forms list (one page per `limit`). */
 interface FormListParams {
     status?: "active" | "inactive" | "archived";
     limit?: number;
+    /**
+     * Included in the query key discriminator for compatibility with
+     * callers that pass it explicitly; the infinite query itself injects
+     * the page offset per page (always starting at 0).
+     */
     offset?: number;
+    /** Free-text search across form names and slugs */
+    search?: string;
 }
+/** Params for the paginated submissions list of one form. */
 interface SubmissionListParams {
     formId: string;
     limit?: number;
+    /** See {@link FormListParams.offset} */
     offset?: number;
 }
+/** Input for the create-form mutation. */
+interface CreateFormInput {
+    name: string;
+    slug: string;
+    description?: string;
+    schema: string;
+    successMessage?: string;
+    redirectUrl?: string;
+    status?: "active" | "inactive" | "archived";
+}
+/** Input for the update-form mutation. */
+interface UpdateFormInput {
+    name?: string;
+    slug?: string;
+    description?: string;
+    schema?: string;
+    successMessage?: string;
+    redirectUrl?: string;
+    status?: "active" | "inactive" | "archived";
+}
 /**
- * Create Form Builder query keys for React Query
- * Used by consumers to fetch forms and submissions
+ * Form Builder resource declaration — the single source of truth for query
+ * keys, HTTP mappings and mutations. Feeds both `createFormBuilderQueryKeys`
+ * (SSR loaders) and `createResource` (client hooks, see `client/hooks`).
+ *
+ * Key shapes intentionally match `FORM_QUERY_KEYS` in
+ * `api/query-key-defs.ts` so SSG `prefetchForRoute` hydration keeps working.
+ * List pages stay as `{ items, total, limit, offset }` envelopes (via
+ * `nextPageParam`) so `total` survives SSG dehydration.
  */
-declare function createFormBuilderQueryKeys(client: ReturnType<typeof createApiClient<FormBuilderApiRouter>>, headers?: HeadersInit): {
+declare const formBuilderResources: {
     forms: {
-        _def: readonly ["forms"];
-    } & {
-        list: ((params?: FormListParams | undefined) => Omit<{
-            queryKey: readonly ["forms", "list", string, FormsListDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<PaginatedForms, readonly ["forms", "list", string, FormsListDiscriminator]>;
-        } & {
-            _def: readonly ["forms", "list"];
-        }, "_def">) & {
-            _def: readonly ["forms", "list"];
+        queries: {
+            list: {
+                path: string;
+                query: (p: FormListParams) => {
+                    status: "active" | "inactive" | "archived" | undefined;
+                    limit: number;
+                    search: string | undefined;
+                };
+                key: (p: FormListParams) => (string | FormsListDiscriminator)[];
+                select: (data: any, _p: FormListParams) => PaginatedForms;
+                infinite: true;
+                pageSize: (p: FormListParams) => number;
+                nextPageParam: (lastPage: PaginatedForms, allPages: PaginatedForms[], p: FormListParams) => number | undefined;
+            };
+            bySlug: {
+                path: string;
+                params: (slug: string) => {
+                    slug: string;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedForm | null;
+                skip: (slug: string) => boolean;
+            };
+            byId: {
+                path: string;
+                params: (id: string) => {
+                    id: string;
+                };
+                key: (id: string) => string[];
+                select: (data: any, _id: string) => SerializedForm | null;
+                skip: (id: string) => boolean;
+            };
         };
-        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"];
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: CreateFormInput) => {
+                    body: CreateFormInput;
+                };
+                select: (data: any) => SerializedForm;
+                invalidates: string[];
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    id: string;
+                    data: UpdateFormInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: UpdateFormInput;
+                };
+                select: (data: any) => SerializedForm;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedForm) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+            submit: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    slug: string;
+                    data: Record<string, unknown>;
+                }) => {
+                    params: {
+                        slug: string;
+                    };
+                    body: {
+                        data: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedFormSubmission & {
+                    form: {
+                        successMessage?: string;
+                        redirectUrl?: string;
+                    };
+                };
+                refresh: false;
+            };
         };
     };
     formSubmissions: {
-        _def: readonly ["formSubmissions"];
-    } & {
-        list: ((params: SubmissionListParams) => Omit<{
-            queryKey: readonly ["formSubmissions", "list", SubmissionsListDiscriminator];
-            queryFn: _tanstack_react_query.QueryFunction<PaginatedFormSubmissions<Record<string, unknown>>, readonly ["formSubmissions", "list", SubmissionsListDiscriminator]>;
-        } & {
-            _def: readonly ["formSubmissions", "list"];
-        }, "_def">) & {
-            _def: readonly ["formSubmissions", "list"];
+        queries: {
+            list: {
+                path: string;
+                params: (p: SubmissionListParams) => {
+                    formId: string;
+                };
+                query: (p: SubmissionListParams) => {
+                    limit: number;
+                };
+                key: (p: SubmissionListParams) => SubmissionsListDiscriminator[];
+                select: (data: any, _p: SubmissionListParams) => PaginatedFormSubmissions;
+                infinite: true;
+                pageSize: (p: SubmissionListParams) => number;
+                nextPageParam: (lastPage: PaginatedFormSubmissions, allPages: PaginatedFormSubmissions[], p: SubmissionListParams) => number | undefined;
+            };
+            detail: {
+                path: string;
+                params: (formId: string, subId: string) => {
+                    formId: string;
+                    subId: string;
+                };
+                key: (formId: string, subId: string) => string[];
+                select: (data: any, _formId: string, _subId: string) => SerializedFormSubmissionWithData | null;
+                skip: (formId: string, subId: string) => boolean;
+            };
         };
-        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"];
+        mutations: {
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    formId: string;
+                    subId: string;
+                }) => {
+                    params: {
+                        formId: string;
+                        subId: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
         };
     };
 };
+/**
+ * Create Form Builder query keys for React Query
+ * Used by consumers and SSR loaders to fetch forms and submissions
+ */
+declare function createFormBuilderQueryKeys(client: ReturnType<typeof createApiClient<FormBuilderApiRouter>>, headers?: HeadersInit): _btst_stack_plugins_client.ResourceQueryKeys<{
+    forms: {
+        queries: {
+            list: {
+                path: string;
+                query: (p: FormListParams) => {
+                    status: "active" | "inactive" | "archived" | undefined;
+                    limit: number;
+                    search: string | undefined;
+                };
+                key: (p: FormListParams) => (string | FormsListDiscriminator)[];
+                select: (data: any, _p: FormListParams) => PaginatedForms;
+                infinite: true;
+                pageSize: (p: FormListParams) => number;
+                nextPageParam: (lastPage: PaginatedForms, allPages: PaginatedForms[], p: FormListParams) => number | undefined;
+            };
+            bySlug: {
+                path: string;
+                params: (slug: string) => {
+                    slug: string;
+                };
+                key: (slug: string) => string[];
+                select: (data: any, _slug: string) => SerializedForm | null;
+                skip: (slug: string) => boolean;
+            };
+            byId: {
+                path: string;
+                params: (id: string) => {
+                    id: string;
+                };
+                key: (id: string) => string[];
+                select: (data: any, _id: string) => SerializedForm | null;
+                skip: (id: string) => boolean;
+            };
+        };
+        mutations: {
+            create: {
+                path: string;
+                method: "POST";
+                input: (vars: CreateFormInput) => {
+                    body: CreateFormInput;
+                };
+                select: (data: any) => SerializedForm;
+                invalidates: string[];
+            };
+            update: {
+                path: string;
+                method: "PUT";
+                input: (vars: {
+                    id: string;
+                    data: UpdateFormInput;
+                }) => {
+                    params: {
+                        id: string;
+                    };
+                    body: UpdateFormInput;
+                };
+                select: (data: any) => SerializedForm;
+                invalidates: string[];
+                setData: {
+                    query: string;
+                    args: (updated: SerializedForm) => string[] | null;
+                };
+            };
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (id: string) => {
+                    params: {
+                        id: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+            submit: {
+                path: string;
+                method: "POST";
+                input: (vars: {
+                    slug: string;
+                    data: Record<string, unknown>;
+                }) => {
+                    params: {
+                        slug: string;
+                    };
+                    body: {
+                        data: Record<string, unknown>;
+                    };
+                };
+                select: (data: any) => SerializedFormSubmission & {
+                    form: {
+                        successMessage?: string;
+                        redirectUrl?: string;
+                    };
+                };
+                refresh: false;
+            };
+        };
+    };
+    formSubmissions: {
+        queries: {
+            list: {
+                path: string;
+                params: (p: SubmissionListParams) => {
+                    formId: string;
+                };
+                query: (p: SubmissionListParams) => {
+                    limit: number;
+                };
+                key: (p: SubmissionListParams) => SubmissionsListDiscriminator[];
+                select: (data: any, _p: SubmissionListParams) => PaginatedFormSubmissions;
+                infinite: true;
+                pageSize: (p: SubmissionListParams) => number;
+                nextPageParam: (lastPage: PaginatedFormSubmissions, allPages: PaginatedFormSubmissions[], p: SubmissionListParams) => number | undefined;
+            };
+            detail: {
+                path: string;
+                params: (formId: string, subId: string) => {
+                    formId: string;
+                    subId: string;
+                };
+                key: (formId: string, subId: string) => string[];
+                select: (data: any, _formId: string, _subId: string) => SerializedFormSubmissionWithData | null;
+                skip: (formId: string, subId: string) => boolean;
+            };
+        };
+        mutations: {
+            delete: {
+                path: string;
+                method: "DELETE";
+                input: (vars: {
+                    formId: string;
+                    subId: string;
+                }) => {
+                    params: {
+                        formId: string;
+                        subId: string;
+                    };
+                };
+                select: (data: any) => {
+                    success: boolean;
+                };
+                invalidates: string[];
+            };
+        };
+    };
+}>;
 
-export { createFormBuilderQueryKeys };
+export { createFormBuilderQueryKeys, formBuilderResources };
+export type { CreateFormInput, FormListParams, SubmissionListParams, UpdateFormInput };