feat(server): real draft/publish separation and per-submission field snapshots

- Publish freezes a publishedData snapshot; Save draft no longer touches it
- Public schema, page & submit serve/validate the published snapshot only
  (legacy published forms fall back to their current copy)
- Submissions store a fields snapshot at submit time so the record stays
  accurate after the form's fields are added, removed or renamed

Author: devCluna

admin/src/types.ts

@@ -86,6 +86,8 @@ export interface FormSubmission {
   id: number;
   form: { id: number; title: string; slug: string };
   data: Record<string, any>;
+  // schema snapshot captured at submit time (accurate even after the form changes)
+  fields?: Array<Pick<FormField, 'name' | 'label' | 'type' | 'order' | 'options'>>;
   metadata: Record<string, any>;
   ipAddress?: string;
   userAgent?: string;

server/src/content-types/form-submission/schema.json

@@ -22,6 +22,7 @@
       "inversedBy": "submissions"
     },
     "data": { "type": "json", "required": true },
+    "fields": { "type": "json" },
     "metadata": { "type": "json", "default": {} },
     "ipAddress": { "type": "string" },
     "userAgent": { "type": "string" },

server/src/content-types/form/schema.json

@@ -20,6 +20,7 @@
     "description": { "type": "text" },
     "fields": { "type": "json", "required": true, "default": [] },
     "conditionalLogic": { "type": "json", "default": [] },
+    "publishedData": { "type": "json" },
     "settings": {
       "type": "json",
       "default": {

server/src/services/form.ts

@@ -9,6 +9,17 @@ function generateSlug(title: string): string {
   return `${base}-${Date.now()}`;
 }
 
+// Frozen copy of the working form stored at publish time — what the public is served.
+function snapshotOf(data: any) {
+  return {
+    title: data.title,
+    description: data.description ?? '',
+    fields: data.fields ?? [],
+    conditionalLogic: data.conditionalLogic ?? [],
+    settings: data.settings ?? {},
+  };
+}
+
 export default ({ strapi }: { strapi: any }) => ({
   async find() {
     const forms = await strapi.db.query(FORM_UID).findMany({
@@ -40,11 +51,23 @@ export default ({ strapi }: { strapi: any }) => ({
 
   async create(data: any) {
     const slug = generateSlug(data.title || 'form');
-    return strapi.db.query(FORM_UID).create({ data: { ...data, slug } });
+    const payload: any = { ...data, slug };
+    // Publishing captures the working copy as the immutable live snapshot.
+    if (data.publishedAt) payload.publishedData = snapshotOf(data);
+    return strapi.db.query(FORM_UID).create({ data: payload });
   },
 
   async update(id: number, data: any) {
-    return strapi.db.query(FORM_UID).update({ where: { id }, data });
+    const payload: any = { ...data };
+    if (data.publishedAt) {
+      // Publish: freeze the current working copy as the live version.
+      payload.publishedData = snapshotOf(data);
+    } else {
+      // Save draft: never unpublish or overwrite what the public sees.
+      delete payload.publishedAt;
+      delete payload.publishedData;
+    }
+    return strapi.db.query(FORM_UID).update({ where: { id }, data: payload });
   },
 
   async delete(id: number) {
@@ -55,7 +78,7 @@ export default ({ strapi }: { strapi: any }) => ({
     const original = await strapi.db.query(FORM_UID).findOne({ where: { id } });
     if (!original) return null;
 
-    const { id: _id, slug, createdAt, updatedAt, publishedAt, ...rest } = original;
+    const { id: _id, slug, createdAt, updatedAt, publishedAt, publishedData, ...rest } = original;
     return strapi.db.query(FORM_UID).create({
       data: {
         ...rest,
@@ -65,35 +88,31 @@ export default ({ strapi }: { strapi: any }) => ({
     });
   },
 
+  // Public views serve the published snapshot only — draft edits never leak.
   async getPublicSchemaById(id: number) {
     const form = await this.findOne(id);
-    if (!form) return null;
-    return {
-      data: {
-        id: form.id,
-        title: form.title,
-        slug: form.slug,
-        description: form.description,
-        fields: form.fields || [],
-        settings: form.settings || {},
-      },
-    };
+    return publicSchemaFrom(form);
   },
 
   async getPublicSchema(slug: string) {
     const form = await this.findBySlug(slug);
-    if (!form) return null;
-
-    return {
-      data: {
-        id: form.id,
-        title: form.title,
-        slug: form.slug,
-        description: form.description,
-        fields: form.fields || [],
-        conditionalLogic: form.conditionalLogic || [],
-        settings: form.settings || {},
-      },
-    };
+    return publicSchemaFrom(form);
   },
 });
+
+function publicSchemaFrom(form: any) {
+  if (!form || !form.publishedAt) return null;
+  // Legacy fallback: forms published before publishedData existed serve their current copy.
+  const p = form.publishedData || snapshotOf(form);
+  return {
+    data: {
+      id: form.id,
+      slug: form.slug,
+      title: p.title,
+      description: p.description,
+      fields: p.fields || [],
+      conditionalLogic: p.conditionalLogic || [],
+      settings: p.settings || {},
+    },
+  };
+}

server/src/services/submission.ts

@@ -13,14 +13,19 @@ export default ({ strapi }: { strapi: any }) => ({
       .service('form')
       .findBySlug(slug);
 
-    if (!form) {
+    // Only a published form accepts submissions, and against its published
+    // snapshot — not the working draft the admin may be editing.
+    if (!form || !form.publishedAt) {
       const err: any = new Error('Form not found');
       err.name = 'NotFoundError';
       throw err;
     }
+    // Legacy fallback: forms published before publishedData existed use their current copy.
+    const pd = form.publishedData || { fields: form.fields, settings: form.settings };
+    const live = { fields: pd.fields || [], settings: pd.settings || {} };
 
     const validationService = strapi.plugin(PLUGIN_ID).service('validation');
-    const result = validationService.validate(form.fields || [], body);
+    const result = validationService.validate(live.fields, body);
 
     if (!result.valid) {
       const err: any = new Error('Validation failed');
@@ -30,13 +35,13 @@ export default ({ strapi }: { strapi: any }) => ({
     }
 
     // Honeypot check — bot filled the hidden trap field, pretend success and drop it
-    if (form.settings?.enableHoneypot && body._fc_hp) {
-      return { success: true, successMessage: form.settings?.successMessage };
+    if (live.settings?.enableHoneypot && body._fc_hp) {
+      return { success: true, successMessage: live.settings?.successMessage };
     }
 
     // Rate limit per form + IP over the last hour
-    if (form.settings?.enableRateLimit && meta.ip) {
-      const max = Number(form.settings?.maxSubmissionsPerHour) || 60;
+    if (live.settings?.enableRateLimit && meta.ip) {
+      const max = Number(live.settings?.maxSubmissionsPerHour) || 60;
       const since = new Date(Date.now() - 60 * 60 * 1000);
       // ponytail: naive per-request count, fine at this scale; move to a store if throughput matters
       const recent = await strapi.db.query(SUBMISSION_UID).count({
@@ -52,11 +57,19 @@ export default ({ strapi }: { strapi: any }) => ({
     // strip honeypot before persisting so it never lands in stored data
     const { _fc_hp, ...clean } = body;
 
+    // Freeze the field schema used at submit time so the record stays accurate
+    // even if the form's fields are later added, removed or renamed.
+    const decorative = ['heading', 'paragraph', 'divider'];
+    const fieldsSnapshot = (live.fields || [])
+      .filter((f: any) => !decorative.includes(f.type))
+      .map((f: any) => ({ name: f.name, label: f.label, type: f.type, order: f.order, options: f.options }));
+
     try {
       await strapi.db.query(SUBMISSION_UID).create({
         data: {
           form: form.id,
           data: clean,
+          fields: fieldsSnapshot,
           ipAddress: meta.ip,
           userAgent: meta.userAgent,
           status: 'new',
@@ -67,7 +80,7 @@ export default ({ strapi }: { strapi: any }) => ({
       throw createErr;
     }
 
-    return { success: true, successMessage: form.settings?.successMessage };
+    return { success: true, successMessage: live.settings?.successMessage };
   },
 
   async find(formId: number, query: any = {}) {