@btst/plugin-form-builder 0.0.0-stage → 1.0.0-beta.0

package/dist/query-keys.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+const client = require('@btst/stack/plugins/client');
+const queryKeyDefs = require('./api/query-key-defs.cjs');
+
+function normalizeSearch(search) {
+  return search !== void 0 && search.trim() === "" ? void 0 : search;
+}
+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;
+}
+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
+      },
+      forUpdate: {
+        path: "/forms/id/:id/edit",
+        params: (id) => ({ id }),
+        key: (id) => ["forUpdate", id],
+        select: (data, _id) => data ?? null,
+        skip: (id) => !id
+      }
+    },
+    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
+      }
+    }
+  },
+  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, _identityPartition) => ({ formId, subId }),
+        key: (formId, subId, identityPartition) => identityPartition === void 0 ? [formId, subId] : [formId, subId, { identity: identityPartition }],
+        select: (data, _formId, _subId, _identityPartition) => data ?? null,
+        skip: (formId, subId, _identityPartition) => !formId || !subId
+      }
+    },
+    mutations: {
+      delete: {
+        path: "@delete/forms/:formId/submissions/:subId",
+        method: "DELETE",
+        input: (vars) => ({
+          params: { formId: vars.formId, subId: vars.subId }
+        }),
+        select: (data) => data,
+        invalidates: ["formSubmissions"]
+      }
+    }
+  }
+};
+function createFormBuilderQueryKeys(client$1, headers) {
+  return client.createResourceQueryKeys(client$1, formBuilderResources, headers);
+}
+
+exports.createFormBuilderQueryKeys = createFormBuilderQueryKeys;
+exports.formBuilderResources = formBuilderResources;

package/dist/query-keys.d.cts

@@ -0,0 +1,392 @@
+import * as _btst_stack_plugins_client from '@btst/stack/plugins/client';
+import { createApiClient } from '@btst/stack/plugins/client';
+import { j as FormsListDiscriminator, k as SubmissionsListDiscriminator } from './shared/plugin-form-builder.Bbl9NufB.cjs';
+import { FormBuilderApiRouter } from './api/index.cjs';
+import { PaginatedForms, SerializedForm, SerializedFormSubmission, PaginatedFormSubmissions, SerializedFormSubmissionWithData } from './types.cjs';
+import { StackIdentity } from '@btst/stack/context';
+import '@btst/stack/plugins/api';
+import '@btst/db';
+import 'zod';
+import './permissions.cjs';
+import '@btst/stack/authorization';
+import 'zod/v4/core';
+import 'better-call';
+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";
+}
+/**
+ * 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 const formBuilderResources: {
+    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;
+            };
+            forUpdate: {
+                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, _identityPartition?: StackIdentity | null) => {
+                    formId: string;
+                    subId: string;
+                };
+                key: (formId: string, subId: string, identityPartition?: StackIdentity | null) => (string | {
+                    identity: StackIdentity | null;
+                })[];
+                select: (data: any, _formId: string, _subId: string, _identityPartition?: StackIdentity | null) => SerializedFormSubmissionWithData | null;
+                skip: (formId: string, subId: string, _identityPartition?: StackIdentity | null) => 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[];
+            };
+        };
+    };
+};
+/**
+ * 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;
+            };
+            forUpdate: {
+                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, _identityPartition?: StackIdentity | null) => {
+                    formId: string;
+                    subId: string;
+                };
+                key: (formId: string, subId: string, identityPartition?: StackIdentity | null) => (string | {
+                    identity: StackIdentity | null;
+                })[];
+                select: (data: any, _formId: string, _subId: string, _identityPartition?: StackIdentity | null) => SerializedFormSubmissionWithData | null;
+                skip: (formId: string, subId: string, _identityPartition?: StackIdentity | null) => 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, formBuilderResources };
+export type { CreateFormInput, FormListParams, SubmissionListParams, UpdateFormInput };