npm - strapi-plugin-form-builder-cms - Versions diffs - 1.0.0-alpha.1 - Mend

strapi-plugin-form-builder-cms 1.0.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/README.md +240 -0
package/dist/admin/App-By2VKpyh.mjs +1429 -0
package/dist/admin/App-D5YiNO1j.js +1429 -0
package/dist/admin/en-B4KWt_jN.js +4 -0
package/dist/admin/en-Byx4XI2L.mjs +4 -0
package/dist/admin/index-Cn0nOObD.mjs +66 -0
package/dist/admin/index-DtKNB8Gg.js +65 -0
package/dist/admin/index.js +4 -0
package/dist/admin/index.mjs +4 -0
package/dist/admin/src/index.d.ts +10 -0
package/dist/server/index.js +886 -0
package/dist/server/index.mjs +886 -0
package/dist/server/src/index.d.ts +248 -0
package/package.json +92 -0

package/dist/server/index.js ADDED Viewed

@@ -0,0 +1,886 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const kind$1 = "collectionType";
+const collectionName$1 = "formcraft_forms";
+const info$1 = { "singularName": "form", "pluralName": "forms", "displayName": "Form", "description": "Dynamic form definitions" };
+const options$1 = { "draftAndPublish": true };
+const pluginOptions$1 = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes$1 = { "title": { "type": "string", "required": true, "maxLength": 255 }, "slug": { "type": "uid", "targetField": "title", "required": true }, "description": { "type": "text" }, "fields": { "type": "json", "required": true, "default": [] }, "conditionalLogic": { "type": "json", "default": [] }, "settings": { "type": "json", "default": { "submitButtonText": "Enviar", "successMessage": "Formulario enviado correctamente", "enableHoneypot": true, "enableRateLimit": true, "maxSubmissionsPerHour": 60, "notificationEmails": [], "redirectUrl": "", "customCss": "" } }, "submissions": { "type": "relation", "relation": "oneToMany", "target": "plugin::strapi-plugin-form-builder-cms.form-submission", "mappedBy": "form" } };
+const form$2 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  options: options$1,
+  pluginOptions: pluginOptions$1,
+  attributes: attributes$1
+};
+const kind = "collectionType";
+const collectionName = "formcraft_submissions";
+const info = { "singularName": "form-submission", "pluralName": "form-submissions", "displayName": "Form Submission", "description": "Submitted form data" };
+const options = { "draftAndPublish": false };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const attributes = { "form": { "type": "relation", "relation": "manyToOne", "target": "plugin::strapi-plugin-form-builder-cms.form", "inversedBy": "submissions" }, "data": { "type": "json", "required": true }, "metadata": { "type": "json", "default": {} }, "ipAddress": { "type": "string" }, "userAgent": { "type": "string" }, "status": { "type": "enumeration", "enum": ["new", "read", "archived"], "default": "new" } };
+const formSubmission = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const contentTypes = {
+  form: { schema: form$2 },
+  "form-submission": { schema: formSubmission }
+};
+const PLUGIN_ID$3 = "strapi-plugin-form-builder-cms";
+function publicPageHtml(form2) {
+  const title = form2.title || "Form";
+  const description = form2.description || "";
+  const formId = form2.id;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>${title}</title>
+  <style>
+    *, *::before, *::after { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: #f5f5f9;
+      color: #32324d;
+      min-height: 100vh;
+      display: flex;
+      align-items: flex-start;
+      justify-content: center;
+      padding: 48px 20px;
+    }
+    .card {
+      background: #fff;
+      border: 1px solid #dcdce4;
+      border-radius: 8px;
+      padding: 40px 48px;
+      width: 100%;
+      max-width: 640px;
+    }
+    h1 { font-size: 22px; font-weight: 700; margin: 0 0 6px; }
+    .desc { font-size: 14px; color: #666687; margin: 0 0 28px; }
+    @media (max-width: 600px) { .card { padding: 28px 20px; } }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>${title}</h1>
+    ${description ? `<p class="desc">${description}</p>` : ""}
+    <div id="sfb-form-${formId}"></div>
+  </div>
+  <script
+    src="/api/strapi-plugin-form-builder-cms/embed.js"
+    data-form-id="${formId}"
+    async
+  ><\/script>
+</body>
+</html>`;
+}
+function embedScript() {
+  return `(function () {
+  var PLUGIN = 'strapi-plugin-form-builder-cms';
+  function init() {
+    document.querySelectorAll('script[data-form-id]').forEach(function (script) {
+      var formId = script.getAttribute('data-form-id');
+      var target = document.getElementById('sfb-form-' + formId);
+      if (!target) return;
+      var base = new URL(script.src).origin;
+      injectStyles();
+      fetch(base + '/api/' + PLUGIN + '/forms/' + formId + '/embed-schema')
+        .then(function (r) { return r.json(); })
+        .then(function (resp) {
+          var form = resp && resp.data;
+          if (!form) { target.textContent = 'Form not found.'; return; }
+          mount(target, form, base);
+        })
+        .catch(function () { target.textContent = 'Could not load form.'; });
+    });
+  }
+  function mount(el, form, base) {
+    var formEl = document.createElement('form');
+    formEl.className = 'sfb-form';
+    var grid = document.createElement('div');
+    grid.className = 'sfb-grid';
+    (form.fields || []).forEach(function (field) {
+      var node = renderField(field);
+      if (node) grid.appendChild(node);
+    });
+    formEl.appendChild(grid);
+    var btn = document.createElement('button');
+    btn.type = 'submit';
+    btn.className = 'sfb-btn';
+    btn.textContent = (form.settings && form.settings.submitButtonText) || 'Submit';
+    formEl.appendChild(btn);
+    var submitText = (form.settings && form.settings.submitButtonText) || 'Submit';
+    function clearErrors() {
+      formEl.querySelectorAll('.sfb-field-error').forEach(function (el) { el.remove(); });
+      formEl.querySelectorAll('.sfb-field').forEach(function (el) { el.classList.remove('sfb-field--error'); });
+      var ge = formEl.querySelector('.sfb-error');
+      if (ge) ge.remove();
+    }
+    function showFieldErrors(errors) {
+      Object.keys(errors).forEach(function (name) {
+        var fieldEl = formEl.querySelector('[data-field-name="' + name + '"]');
+        if (!fieldEl) return;
+        fieldEl.classList.add('sfb-field--error');
+        var errEl = document.createElement('p');
+        errEl.className = 'sfb-field-error';
+        errEl.textContent = errors[name][0];
+        fieldEl.appendChild(errEl);
+      });
+    }
+    formEl.addEventListener('submit', function (e) {
+      e.preventDefault();
+      clearErrors();
+      btn.disabled = true;
+      btn.textContent = 'Sending…';
+      // collect form data, handling checkbox-group arrays
+      var data = {};
+      new FormData(formEl).forEach(function (v, k) {
+        if (k.endsWith('[]')) {
+          var name = k.slice(0, -2);
+          if (!data[name]) data[name] = [];
+          data[name].push(v);
+        } else {
+          data[k] = v;
+        }
+      });
+      fetch(base + '/api/' + PLUGIN + '/forms/' + form.slug + '/submit', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ data: data }),
+      })
+        .then(function (r) {
+          return r.json().then(function (body) {
+            if (!r.ok) return Promise.reject(body);
+            return body;
+          });
+        })
+        .then(function () {
+          var msg = document.createElement('p');
+          msg.className = 'sfb-success';
+          msg.textContent = (form.settings && form.settings.successMessage) || 'Form submitted successfully';
+          el.innerHTML = '';
+          el.appendChild(msg);
+        })
+        .catch(function (body) {
+          btn.disabled = false;
+          btn.textContent = submitText;
+          if (body && body.errors && Object.keys(body.errors).length > 0) {
+            showFieldErrors(body.errors);
+          } else {
+            var errEl = document.createElement('p');
+            errEl.className = 'sfb-error';
+            errEl.textContent = (body && body.message) ? body.message : 'Something went wrong. Please try again.';
+            formEl.insertBefore(errEl, btn);
+          }
+        });
+    });
+    el.innerHTML = '';
+    el.appendChild(formEl);
+  }
+  function renderField(field) {
+    if (field.type === 'hidden') return null;
+    if (field.type === 'divider') {
+      var hr = document.createElement('hr');
+      hr.className = 'sfb-divider';
+      hr.style.gridColumn = '1 / -1';
+      return hr;
+    }
+    if (field.type === 'heading') {
+      var h = document.createElement('p');
+      h.className = 'sfb-heading';
+      h.style.gridColumn = '1 / -1';
+      h.textContent = field.label || '';
+      return h;
+    }
+    if (field.type === 'paragraph') {
+      var p = document.createElement('p');
+      p.className = 'sfb-paragraph';
+      p.style.gridColumn = '1 / -1';
+      p.textContent = field.label || '';
+      return p;
+    }
+    var wrapper = document.createElement('div');
+    wrapper.className = 'sfb-field';
+    wrapper.setAttribute('data-field-name', field.name);
+    if (field.width !== 'half') wrapper.style.gridColumn = '1 / -1';
+    if (field.type !== 'checkbox') {
+      var label = document.createElement('label');
+      label.className = 'sfb-label';
+      label.htmlFor = 'sfb-' + field.id;
+      label.textContent = field.label || '';
+      if (field.required) {
+        var req = document.createElement('span');
+        req.className = 'sfb-required';
+        req.textContent = ' *';
+        label.appendChild(req);
+      }
+      wrapper.appendChild(label);
+    }
+    var input = buildInput(field);
+    if (input) wrapper.appendChild(input);
+    if (field.helpText) {
+      var help = document.createElement('p');
+      help.className = 'sfb-help';
+      help.textContent = field.helpText;
+      wrapper.appendChild(help);
+    }
+    return wrapper;
+  }
+  function buildInput(field) {
+    var id = 'sfb-' + field.id;
+    if (field.type === 'textarea') {
+      var ta = document.createElement('textarea');
+      ta.id = id; ta.name = field.name; ta.className = 'sfb-input';
+      ta.placeholder = field.placeholder || '';
+      ta.required = !!field.required;
+      ta.rows = 4;
+      return ta;
+    }
+    if (field.type === 'select') {
+      var sel = document.createElement('select');
+      sel.id = id; sel.name = field.name; sel.className = 'sfb-input';
+      sel.required = !!field.required;
+      var def = document.createElement('option');
+      def.value = ''; def.textContent = field.placeholder || 'Select an option…';
+      sel.appendChild(def);
+      (field.options || []).forEach(function (o) {
+        var opt = document.createElement('option');
+        opt.value = o.value; opt.textContent = o.label || o.value;
+        sel.appendChild(opt);
+      });
+      return sel;
+    }
+    if (field.type === 'radio') {
+      var group = document.createElement('div');
+      group.className = 'sfb-radio-group';
+      (field.options || []).forEach(function (o) {
+        var lbl = document.createElement('label');
+        lbl.className = 'sfb-radio-label';
+        var inp = document.createElement('input');
+        inp.type = 'radio'; inp.name = field.name; inp.value = o.value;
+        inp.required = !!field.required;
+        lbl.appendChild(inp);
+        lbl.appendChild(document.createTextNode(o.label || o.value));
+        group.appendChild(lbl);
+      });
+      return group;
+    }
+    if (field.type === 'checkbox-group') {
+      var cgroup = document.createElement('div');
+      cgroup.className = 'sfb-radio-group';
+      (field.options || []).forEach(function (o) {
+        var lbl = document.createElement('label');
+        lbl.className = 'sfb-radio-label';
+        var inp = document.createElement('input');
+        inp.type = 'checkbox'; inp.name = field.name + '[]'; inp.value = o.value;
+        lbl.appendChild(inp);
+        lbl.appendChild(document.createTextNode(o.label || o.value));
+        cgroup.appendChild(lbl);
+      });
+      return cgroup;
+    }
+    if (field.type === 'checkbox') {
+      var clbl = document.createElement('label');
+      clbl.className = 'sfb-checkbox-label';
+      var cb = document.createElement('input');
+      cb.type = 'checkbox'; cb.id = id; cb.name = field.name; cb.value = '1';
+      cb.required = !!field.required;
+      clbl.appendChild(cb);
+      clbl.appendChild(document.createTextNode(' ' + (field.label || '')));
+      return clbl;
+    }
+    var typeMap = { text:'text', email:'email', number:'number', phone:'tel',
+                    password:'password', url:'url', date:'date', time:'time' };
+    var inp2 = document.createElement('input');
+    inp2.type = typeMap[field.type] || 'text';
+    inp2.id = id; inp2.name = field.name; inp2.className = 'sfb-input';
+    inp2.placeholder = field.placeholder || '';
+    inp2.required = !!field.required;
+    return inp2;
+  }
+  function injectStyles() {
+    if (document.getElementById('sfb-css')) return;
+    var s = document.createElement('style');
+    s.id = 'sfb-css';
+    s.textContent = [
+      '.sfb-form { font-family: inherit; }',
+      '.sfb-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; margin-bottom: 20px; }',
+      '.sfb-field { display: flex; flex-direction: column; gap: 4px; }',
+      '.sfb-label { font-size: 13px; font-weight: 600; color: #32324d; }',
+      '.sfb-required { color: #ee5e52; }',
+      '.sfb-input { width: 100%; height: 40px; padding: 0 12px; border: 1px solid #dcdce4; border-radius: var(--sfb-radius, 4px); font-size: 14px; font-family: inherit; color: #32324d; background: #fff; box-sizing: border-box; outline: none; transition: border-color .15s; }',
+      '.sfb-input:focus { border-color: var(--sfb-accent, #4945ff); box-shadow: 0 0 0 2px rgba(73,69,255,.15); }',
+      'textarea.sfb-input { height: auto; padding: 8px 12px; resize: vertical; }',
+      'select.sfb-input { appearance: none; cursor: pointer; }',
+      '.sfb-radio-group { display: flex; flex-direction: column; gap: 8px; }',
+      '.sfb-radio-label, .sfb-checkbox-label { display: flex; align-items: center; gap: 8px; font-size: 14px; color: #32324d; cursor: pointer; }',
+      '.sfb-radio-label input, .sfb-checkbox-label input { accent-color: var(--sfb-accent, #4945ff); width: 16px; height: 16px; cursor: pointer; }',
+      '.sfb-help { font-size: 12px; color: #666687; margin: 0; }',
+      '.sfb-btn { background: var(--sfb-accent, #4945ff); color: #fff; border: none; border-radius: var(--sfb-radius, 4px); padding: 10px 24px; font-size: 14px; font-weight: 600; font-family: inherit; cursor: pointer; transition: opacity .15s; }',
+      '.sfb-btn:hover { opacity: .88; }',
+      '.sfb-btn:disabled { opacity: .6; cursor: not-allowed; }',
+      '.sfb-heading { font-size: 18px; font-weight: 700; color: #32324d; margin: 4px 0; }',
+      '.sfb-paragraph { font-size: 14px; color: #666687; margin: 4px 0; line-height: 1.6; }',
+      '.sfb-divider { border: none; border-top: 1px solid #dcdce4; margin: 4px 0; }',
+      '.sfb-success { font-size: 15px; color: #27ae60; font-weight: 600; }',
+      '.sfb-error { font-size: 13px; color: #ee5e52; margin-bottom: 12px; }',
+      '.sfb-field-error { font-size: 12px; color: #ee5e52; margin: 4px 0 0; }',
+      '.sfb-field--error .sfb-input, .sfb-field--error .sfb-radio-group { border-color: #ee5e52 !important; }',
+      '.sfb-field--error > .sfb-label { color: #ee5e52; }',
+    ].join('\\n');
+    document.head.appendChild(s);
+  }
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', init);
+  } else {
+    init();
+  }
+})();`;
+}
+const form$1 = {
+  async find(ctx) {
+    const forms = await strapi.plugin(PLUGIN_ID$3).service("form").find(ctx.query);
+    ctx.body = forms;
+  },
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    const form2 = await strapi.plugin(PLUGIN_ID$3).service("form").findOne(Number(id));
+    if (!form2) return ctx.notFound("Form not found");
+    ctx.body = form2;
+  },
+  async create(ctx) {
+    const form2 = await strapi.plugin(PLUGIN_ID$3).service("form").create(ctx.request.body);
+    ctx.body = form2;
+  },
+  async update(ctx) {
+    const { id } = ctx.params;
+    const form2 = await strapi.plugin(PLUGIN_ID$3).service("form").update(Number(id), ctx.request.body);
+    if (!form2) return ctx.notFound("Form not found");
+    ctx.body = form2;
+  },
+  async delete(ctx) {
+    const { id } = ctx.params;
+    await strapi.plugin(PLUGIN_ID$3).service("form").delete(Number(id));
+    ctx.status = 204;
+  },
+  async duplicate(ctx) {
+    const { id } = ctx.params;
+    const form2 = await strapi.plugin(PLUGIN_ID$3).service("form").duplicate(Number(id));
+    if (!form2) return ctx.notFound("Form not found");
+    ctx.body = form2;
+  },
+  async getPublicSchema(ctx) {
+    const { slug } = ctx.params;
+    const schema = await strapi.plugin(PLUGIN_ID$3).service("form").getPublicSchema(slug);
+    if (!schema) return ctx.notFound("Form not found");
+    ctx.body = schema;
+  },
+  async getPublicSchemaById(ctx) {
+    const { id } = ctx.params;
+    const schema = await strapi.plugin(PLUGIN_ID$3).service("form").getPublicSchemaById(Number(id));
+    if (!schema) return ctx.notFound("Form not found");
+    ctx.body = schema;
+  },
+  async serveEmbed(ctx) {
+    ctx.set("Content-Type", "application/javascript; charset=utf-8");
+    ctx.set("Cache-Control", "public, max-age=3600");
+    ctx.body = embedScript();
+  },
+  async servePublicPage(ctx) {
+    const { slug } = ctx.params;
+    const schema = await strapi.plugin(PLUGIN_ID$3).service("form").getPublicSchema(slug);
+    if (!schema || !schema.data) return ctx.notFound("Form not found");
+    const form2 = schema.data;
+    if (!form2.settings?.publicPage) return ctx.notFound("This form does not have a public page enabled");
+    ctx.set("Content-Type", "text/html; charset=utf-8");
+    ctx.body = publicPageHtml(form2);
+  }
+};
+const PLUGIN_ID$2 = "strapi-plugin-form-builder-cms";
+const submission$1 = {
+  async submit(ctx) {
+    const { slug } = ctx.params;
+    try {
+      const body = ctx.request.body;
+      const raw = body && typeof body === "object" && "data" in body ? body.data : body;
+      const data = {};
+      for (const [k, v] of Object.entries(raw || {})) {
+        if (k.endsWith("[]")) {
+          const name = k.slice(0, -2);
+          if (!data[name]) data[name] = [];
+          data[name].push(v);
+        } else {
+          data[k] = v;
+        }
+      }
+      const result = await strapi.plugin(PLUGIN_ID$2).service("submission").submit(
+        slug,
+        data,
+        {
+          ip: ctx.request.ip,
+          userAgent: ctx.request.headers["user-agent"] || ""
+        }
+      );
+      ctx.body = result;
+    } catch (error) {
+      if (error.name === "ValidationError") {
+        ctx.status = 400;
+        ctx.body = { success: false, errors: error.details };
+      } else if (error.name === "NotFoundError") {
+        return ctx.notFound("Form not found");
+      } else {
+        console.error("[sfb] unhandled submit error:", error?.message, error?.stack);
+        ctx.status = 500;
+        ctx.body = { success: false, message: error?.message || "Internal server error" };
+      }
+    }
+  },
+  async find(ctx) {
+    const { formId } = ctx.params;
+    const submissions = await strapi.plugin(PLUGIN_ID$2).service("submission").find(Number(formId), ctx.query);
+    ctx.body = submissions;
+  },
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    const submission2 = await strapi.plugin(PLUGIN_ID$2).service("submission").findOne(Number(id));
+    if (!submission2) return ctx.notFound("Submission not found");
+    ctx.body = submission2;
+  },
+  async updateStatus(ctx) {
+    const { id } = ctx.params;
+    const { status } = ctx.request.body;
+    const submission2 = await strapi.plugin(PLUGIN_ID$2).service("submission").updateStatus(Number(id), status);
+    ctx.body = submission2;
+  },
+  async delete(ctx) {
+    const { id } = ctx.params;
+    await strapi.plugin(PLUGIN_ID$2).service("submission").delete(Number(id));
+    ctx.status = 204;
+  },
+  async export(ctx) {
+    const { formId } = ctx.params;
+    const format = ctx.query.format || "csv";
+    const data = await strapi.plugin(PLUGIN_ID$2).service("submission").export(Number(formId), format);
+    const ext = format === "xlsx" ? "xlsx" : "csv";
+    const mime = format === "xlsx" ? "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" : "text/csv";
+    ctx.set("Content-Disposition", `attachment; filename=submissions.${ext}`);
+    ctx.set("Content-Type", mime);
+    ctx.body = data;
+  },
+  async stats(ctx) {
+    const { formId } = ctx.params;
+    const stats = await strapi.plugin(PLUGIN_ID$2).service("submission").getStats(Number(formId));
+    ctx.body = stats;
+  }
+};
+const controllers = {
+  form: form$1,
+  submission: submission$1
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/embed.js",
+      handler: "form.serveEmbed",
+      config: { auth: false, policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/forms/:id/embed-schema",
+      handler: "form.getPublicSchemaById",
+      config: { auth: false, policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/forms/:slug/schema",
+      handler: "form.getPublicSchema",
+      config: { auth: false, policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/page/:slug",
+      handler: "form.servePublicPage",
+      config: { auth: false, policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/forms/:slug/submit",
+      handler: "submission.submit",
+      config: { auth: false, policies: [] }
+    }
+  ]
+};
+const adminAPIRoutes = {
+  type: "admin",
+  routes: [
+    { method: "GET", path: "/forms", handler: "form.find" },
+    { method: "GET", path: "/forms/:id", handler: "form.findOne" },
+    { method: "POST", path: "/forms", handler: "form.create" },
+    { method: "PUT", path: "/forms/:id", handler: "form.update" },
+    { method: "DELETE", path: "/forms/:id", handler: "form.delete" },
+    { method: "POST", path: "/forms/:id/duplicate", handler: "form.duplicate" },
+    { method: "GET", path: "/submissions/:formId", handler: "submission.find" },
+    { method: "GET", path: "/submissions/entry/:id", handler: "submission.findOne" },
+    { method: "PUT", path: "/submissions/:id/status", handler: "submission.updateStatus" },
+    { method: "DELETE", path: "/submissions/:id", handler: "submission.delete" },
+    { method: "GET", path: "/submissions/:formId/export", handler: "submission.export" },
+    { method: "GET", path: "/submissions/:formId/stats", handler: "submission.stats" }
+  ]
+};
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const PLUGIN_ID$1 = "strapi-plugin-form-builder-cms";
+const FORM_UID$1 = `plugin::${PLUGIN_ID$1}.form`;
+function generateSlug(title) {
+  const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "form";
+  return `${base}-${Date.now()}`;
+}
+const form = ({ strapi: strapi2 }) => ({
+  async find() {
+    return strapi2.db.query(FORM_UID$1).findMany({
+      orderBy: { createdAt: "desc" }
+    });
+  },
+  async findOne(id) {
+    return strapi2.db.query(FORM_UID$1).findOne({
+      where: { id },
+      orderBy: { updatedAt: "desc" }
+    });
+  },
+  async findBySlug(slug) {
+    return strapi2.db.query(FORM_UID$1).findOne({
+      where: { slug },
+      orderBy: { updatedAt: "desc" }
+    });
+  },
+  async create(data) {
+    const slug = generateSlug(data.title || "form");
+    return strapi2.db.query(FORM_UID$1).create({ data: { ...data, slug } });
+  },
+  async update(id, data) {
+    return strapi2.db.query(FORM_UID$1).update({ where: { id }, data });
+  },
+  async delete(id) {
+    return strapi2.db.query(FORM_UID$1).delete({ where: { id } });
+  },
+  async duplicate(id) {
+    const original = await strapi2.db.query(FORM_UID$1).findOne({ where: { id } });
+    if (!original) return null;
+    const { id: _id, slug, createdAt, updatedAt, publishedAt, ...rest } = original;
+    return strapi2.db.query(FORM_UID$1).create({
+      data: {
+        ...rest,
+        title: `${rest.title} (copy)`,
+        slug: generateSlug(`${rest.title} copy`)
+      }
+    });
+  },
+  async getPublicSchemaById(id) {
+    const form2 = await this.findOne(id);
+    if (!form2) return null;
+    return {
+      data: {
+        id: form2.id,
+        title: form2.title,
+        slug: form2.slug,
+        description: form2.description,
+        fields: form2.fields || [],
+        settings: form2.settings || {}
+      }
+    };
+  },
+  async getPublicSchema(slug) {
+    const form2 = await this.findBySlug(slug);
+    if (!form2) return null;
+    return {
+      data: {
+        id: form2.id,
+        title: form2.title,
+        slug: form2.slug,
+        description: form2.description,
+        fields: form2.fields || [],
+        conditionalLogic: form2.conditionalLogic || [],
+        settings: form2.settings || {}
+      }
+    };
+  }
+});
+const PLUGIN_ID = "strapi-plugin-form-builder-cms";
+const SUBMISSION_UID = `plugin::${PLUGIN_ID}.form-submission`;
+const FORM_UID = `plugin::${PLUGIN_ID}.form`;
+const submission = ({ strapi: strapi2 }) => ({
+  async submit(slug, body, meta) {
+    const form2 = await strapi2.plugin(PLUGIN_ID).service("form").findBySlug(slug);
+    if (!form2) {
+      const err = new Error("Form not found");
+      err.name = "NotFoundError";
+      throw err;
+    }
+    const validationService = strapi2.plugin(PLUGIN_ID).service("validation");
+    const result = validationService.validate(form2.fields || [], body);
+    if (!result.valid) {
+      const err = new Error("Validation failed");
+      err.name = "ValidationError";
+      err.details = result.errors;
+      throw err;
+    }
+    if (form2.settings?.enableHoneypot && body._fc_hp) {
+      return { success: true, successMessage: form2.settings?.successMessage };
+    }
+    try {
+      await strapi2.db.query(SUBMISSION_UID).create({
+        data: {
+          form: form2.id,
+          data: body,
+          ipAddress: meta.ip,
+          userAgent: meta.userAgent,
+          status: "new"
+        }
+      });
+    } catch (createErr) {
+      console.error("[sfb] create error:", createErr?.message, createErr?.stack);
+      throw createErr;
+    }
+    return { success: true, successMessage: form2.settings?.successMessage };
+  },
+  async find(formId, query = {}) {
+    const { page = 1, pageSize = 25, status } = query;
+    const where = { form: formId };
+    if (status) where.status = status;
+    const [results, total] = await Promise.all([
+      strapi2.db.query(SUBMISSION_UID).findMany({
+        where,
+        populate: ["form"],
+        orderBy: { createdAt: "desc" },
+        limit: Number(pageSize),
+        offset: (Number(page) - 1) * Number(pageSize)
+      }),
+      strapi2.db.query(SUBMISSION_UID).count({ where })
+    ]);
+    return {
+      results,
+      pagination: {
+        page: Number(page),
+        pageSize: Number(pageSize),
+        total,
+        pageCount: Math.ceil(total / Number(pageSize))
+      }
+    };
+  },
+  async findOne(id) {
+    return strapi2.db.query(SUBMISSION_UID).findOne({
+      where: { id },
+      populate: ["form"]
+    });
+  },
+  async updateStatus(id, status) {
+    return strapi2.db.query(SUBMISSION_UID).update({
+      where: { id },
+      data: { status }
+    });
+  },
+  async delete(id) {
+    return strapi2.db.query(SUBMISSION_UID).delete({ where: { id } });
+  },
+  async export(formId, format = "csv") {
+    const form2 = await strapi2.db.query(FORM_UID).findOne({ where: { id: formId } });
+    const submissions = await strapi2.db.query(SUBMISSION_UID).findMany({
+      where: { form: formId },
+      orderBy: { createdAt: "desc" }
+    });
+    const fields = form2?.fields || [];
+    const fieldNames = fields.filter((f) => !["heading", "paragraph", "divider"].includes(f.type)).map((f) => f.name);
+    const headers = ["id", "status", "createdAt", ...fieldNames];
+    const rows = submissions.map((s) => [
+      s.id,
+      s.status,
+      s.createdAt,
+      ...fieldNames.map((name) => s.data?.[name] ?? "")
+    ]);
+    if (format === "csv") {
+      const lines = [
+        headers.join(","),
+        ...rows.map(
+          (r) => r.map(String).map((v) => `"${v.replace(/"/g, '""')}"`).join(",")
+        )
+      ];
+      return lines.join("\n");
+    }
+    return rows;
+  },
+  async getStats(formId) {
+    const all = await strapi2.db.query(SUBMISSION_UID).findMany({
+      where: { form: formId }
+    });
+    const total = all.length;
+    const byStatus = { new: 0, read: 0, archived: 0 };
+    for (const s of all) {
+      byStatus[s.status] = (byStatus[s.status] || 0) + 1;
+    }
+    return { total, byStatus };
+  }
+});
+const validation$1 = {
+  validate(fields, data) {
+    const errors = {};
+    const decorative = ["heading", "paragraph", "divider", "hidden"];
+    for (const field of fields) {
+      if (decorative.includes(field.type)) continue;
+      const value = data[field.name];
+      const fieldErrors = [];
+      if (field.required && this.isEmpty(value)) {
+        const reqRule = field.validation?.find((v) => v.type === "required");
+        fieldErrors.push(reqRule?.message || `${field.label} is required`);
+      }
+      if (this.isEmpty(value) && !field.required) {
+        const hasLengthOrValueRule = (field.validation || []).some(
+          (r) => ["minLength", "min"].includes(r.type)
+        );
+        if (!hasLengthOrValueRule) continue;
+      }
+      if (!this.isEmpty(value)) {
+        if (field.type === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value))) {
+          fieldErrors.push(`${field.label}: enter a valid email address`);
+        }
+        if (field.type === "url") {
+          try {
+            new URL(String(value));
+          } catch {
+            fieldErrors.push(`${field.label}: enter a valid URL`);
+          }
+        }
+        if (field.type === "number" && isNaN(Number(value))) {
+          fieldErrors.push(`${field.label}: enter a valid number`);
+        }
+      }
+      for (const rule of field.validation || []) {
+        if (rule.type === "required") continue;
+        const error = this.runRule(rule, value, field, data);
+        if (error) fieldErrors.push(error);
+      }
+      if (fieldErrors.length > 0) {
+        errors[field.name] = fieldErrors;
+      }
+    }
+    return { valid: Object.keys(errors).length === 0, errors };
+  },
+  runRule(rule, value, field, allData) {
+    switch (rule.type) {
+      case "minLength":
+        if (String(value).length < Number(rule.value))
+          return rule.message || `Minimum ${rule.value} characters`;
+        break;
+      case "maxLength":
+        if (String(value).length > Number(rule.value))
+          return rule.message || `Maximum ${rule.value} characters`;
+        break;
+      case "min":
+        if (Number(value) < Number(rule.value))
+          return rule.message || `Minimum value is ${rule.value}`;
+        break;
+      case "max":
+        if (Number(value) > Number(rule.value))
+          return rule.message || `Maximum value is ${rule.value}`;
+        break;
+      case "pattern":
+        if (!new RegExp(rule.value).test(String(value)))
+          return rule.message || `Invalid format`;
+        break;
+      case "email":
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(value)))
+          return rule.message || `Enter a valid email address`;
+        break;
+      case "url":
+        try {
+          new URL(String(value));
+        } catch {
+          return rule.message || `Enter a valid URL`;
+        }
+        break;
+      case "matchField":
+        if (value !== allData[rule.value])
+          return rule.message || `Fields do not match`;
+        break;
+    }
+    return null;
+  },
+  isEmpty(value) {
+    return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+  }
+};
+const validation = () => validation$1;
+const services = {
+  form,
+  submission,
+  validation
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+exports.default = index;