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

package/dist/query-keys.d.ts

@@ -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.CSP5HR2O.js';
+import { FormBuilderApiRouter } from './api/index.js';
+import { PaginatedForms, SerializedForm, SerializedFormSubmission, PaginatedFormSubmissions, SerializedFormSubmissionWithData } from './types.js';
+import { StackIdentity } from '@btst/stack/context';
+import '@btst/stack/plugins/api';
+import '@btst/db';
+import 'zod';
+import './permissions.js';
+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 };

package/dist/query-keys.mjs

@@ -0,0 +1,137 @@
+import { createResourceQueryKeys } from '@btst/stack/plugins/client';
+import { submissionsListDiscriminator, formsListDiscriminator } from './api/query-key-defs.mjs';
+
+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", 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) => [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, headers) {
+  return createResourceQueryKeys(client, formBuilderResources, headers);
+}
+
+export { createFormBuilderQueryKeys, formBuilderResources };

package/dist/schemas.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+const z = require('zod');
+
+const DEFAULT_MAX_PAGE_SIZE = 1e3;
+const listFormsQuerySchema = z.z.object({
+  status: z.z.enum(["active", "inactive", "archived"]).optional(),
+  limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.z.coerce.number().min(0).optional().default(0),
+  search: z.z.string().max(200).optional()
+});
+const createFormSchema = z.z.object({
+  name: z.z.string().min(1, "Name is required"),
+  slug: z.z.string().min(1, "Slug is required"),
+  description: z.z.string().optional(),
+  schema: z.z.string().min(1, "Schema is required"),
+  successMessage: z.z.string().optional(),
+  redirectUrl: z.z.string().url().optional().or(z.z.literal("")),
+  status: z.z.enum(["active", "inactive", "archived"]).optional().default("active")
+});
+const updateFormSchema = z.z.object({
+  name: z.z.string().min(1, "Name is required").optional(),
+  slug: z.z.string().min(1, "Slug is required").optional(),
+  description: z.z.string().optional(),
+  schema: z.z.string().min(1, "Schema is required").optional(),
+  successMessage: z.z.string().optional(),
+  redirectUrl: z.z.string().url().optional().or(z.z.literal("")),
+  status: z.z.enum(["active", "inactive", "archived"]).optional()
+});
+const formResponseSchema = z.z.object({
+  id: z.z.string(),
+  name: z.z.string(),
+  slug: z.z.string(),
+  description: z.z.string().nullable().optional(),
+  schema: z.z.string(),
+  successMessage: z.z.string().nullable().optional(),
+  redirectUrl: z.z.string().nullable().optional(),
+  status: z.z.string(),
+  createdBy: z.z.string().nullable().optional(),
+  createdAt: z.z.string(),
+  updatedAt: z.z.string()
+});
+z.z.object({
+  items: z.z.array(formResponseSchema),
+  total: z.z.number(),
+  limit: z.z.number(),
+  offset: z.z.number()
+});
+const listSubmissionsQuerySchema = z.z.object({
+  limit: z.z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.z.coerce.number().min(0).optional().default(0)
+});
+z.z.object({
+  // Use passthrough object for dynamic form data validation
+  data: z.z.object({}).passthrough()
+});
+const formSubmissionResponseSchema = z.z.object({
+  id: z.z.string(),
+  formId: z.z.string(),
+  data: z.z.string(),
+  submittedAt: z.z.string(),
+  submittedBy: z.z.string().nullable().optional(),
+  ipAddress: z.z.string().nullable().optional(),
+  userAgent: z.z.string().nullable().optional()
+});
+formSubmissionResponseSchema.extend({
+  // Use passthrough object for dynamic parsed data
+  parsedData: z.z.object({}).passthrough(),
+  form: formResponseSchema.optional()
+});
+const formSubmissionSummaryResponseSchema = z.z.object({
+  id: z.z.string(),
+  formId: z.z.string(),
+  submittedAt: z.z.string(),
+  submittedBy: z.z.string().optional()
+});
+z.z.object({
+  items: z.z.array(formSubmissionSummaryResponseSchema),
+  total: z.z.number(),
+  limit: z.z.number(),
+  offset: z.z.number()
+});
+
+exports.DEFAULT_MAX_PAGE_SIZE = DEFAULT_MAX_PAGE_SIZE;
+exports.createFormSchema = createFormSchema;
+exports.formResponseSchema = formResponseSchema;
+exports.formSubmissionResponseSchema = formSubmissionResponseSchema;
+exports.formSubmissionSummaryResponseSchema = formSubmissionSummaryResponseSchema;
+exports.listFormsQuerySchema = listFormsQuerySchema;
+exports.listSubmissionsQuerySchema = listSubmissionsQuerySchema;
+exports.updateFormSchema = updateFormSchema;

package/dist/schemas.mjs

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+
+const DEFAULT_MAX_PAGE_SIZE = 1e3;
+const listFormsQuerySchema = z.object({
+  status: z.enum(["active", "inactive", "archived"]).optional(),
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().min(0).optional().default(0),
+  search: z.string().max(200).optional()
+});
+const createFormSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  slug: z.string().min(1, "Slug is required"),
+  description: z.string().optional(),
+  schema: z.string().min(1, "Schema is required"),
+  successMessage: z.string().optional(),
+  redirectUrl: z.string().url().optional().or(z.literal("")),
+  status: z.enum(["active", "inactive", "archived"]).optional().default("active")
+});
+const updateFormSchema = z.object({
+  name: z.string().min(1, "Name is required").optional(),
+  slug: z.string().min(1, "Slug is required").optional(),
+  description: z.string().optional(),
+  schema: z.string().min(1, "Schema is required").optional(),
+  successMessage: z.string().optional(),
+  redirectUrl: z.string().url().optional().or(z.literal("")),
+  status: z.enum(["active", "inactive", "archived"]).optional()
+});
+const formResponseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  slug: z.string(),
+  description: z.string().nullable().optional(),
+  schema: z.string(),
+  successMessage: z.string().nullable().optional(),
+  redirectUrl: z.string().nullable().optional(),
+  status: z.string(),
+  createdBy: z.string().nullable().optional(),
+  createdAt: z.string(),
+  updatedAt: z.string()
+});
+z.object({
+  items: z.array(formResponseSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+});
+const listSubmissionsQuerySchema = z.object({
+  limit: z.coerce.number().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().min(0).optional().default(0)
+});
+z.object({
+  // Use passthrough object for dynamic form data validation
+  data: z.object({}).passthrough()
+});
+const formSubmissionResponseSchema = z.object({
+  id: z.string(),
+  formId: z.string(),
+  data: z.string(),
+  submittedAt: z.string(),
+  submittedBy: z.string().nullable().optional(),
+  ipAddress: z.string().nullable().optional(),
+  userAgent: z.string().nullable().optional()
+});
+formSubmissionResponseSchema.extend({
+  // Use passthrough object for dynamic parsed data
+  parsedData: z.object({}).passthrough(),
+  form: formResponseSchema.optional()
+});
+const formSubmissionSummaryResponseSchema = z.object({
+  id: z.string(),
+  formId: z.string(),
+  submittedAt: z.string(),
+  submittedBy: z.string().optional()
+});
+z.object({
+  items: z.array(formSubmissionSummaryResponseSchema),
+  total: z.number(),
+  limit: z.number(),
+  offset: z.number()
+});
+
+export { DEFAULT_MAX_PAGE_SIZE, createFormSchema, formResponseSchema, formSubmissionResponseSchema, formSubmissionSummaryResponseSchema, listFormsQuerySchema, listSubmissionsQuerySchema, updateFormSchema };