strapi-plugin-hubspot 0.8.0 → 0.10.0

package/dist/server/index.mjs

@@ -1,5 +1,5 @@
 import { errors } from "@strapi/utils";
-const HS_BASE$2 = "https://api.hubapi.com";
+const HS_BASE$3 = "https://api.hubapi.com";
 const TTL_MS = 10 * 60 * 1e3;
 const STANDARD_OBJECTS = [
   { name: "contact", path: "contacts" },
@@ -12,8 +12,8 @@ const STANDARD_OBJECTS = [
 ];
 let cache = null;
 let inFlight = null;
-async function hsGet(apiKey, path) {
-  const res = await fetch(`${HS_BASE$2}${path}`, {
+async function hsGet$1(apiKey, path) {
+  const res = await fetch(`${HS_BASE$3}${path}`, {
     headers: { Authorization: `Bearer ${apiKey}` }
   });
   if (!res.ok) {
@@ -26,7 +26,7 @@ async function hsGet(apiKey, path) {
 }
 async function fetchGroups(apiKey, path) {
   try {
-    const res = await hsGet(
+    const res = await hsGet$1(
       apiKey,
       `/crm/v3/properties/${path}/groups`
     );
@@ -37,7 +37,7 @@ async function fetchGroups(apiKey, path) {
 }
 async function fetchObject(apiKey, object) {
   const [res, groups] = await Promise.all([
-    hsGet(apiKey, `/crm/v3/properties/${object.path}`),
+    hsGet$1(apiKey, `/crm/v3/properties/${object.path}`),
     fetchGroups(apiKey, object.path)
   ]);
   return (res.results ?? []).filter((p) => !p.modificationMetadata?.readOnlyValue).map((p) => ({
@@ -51,7 +51,7 @@ async function fetchObject(apiKey, object) {
 }
 async function fetchAccount(apiKey) {
   try {
-    return await hsGet(
+    return await hsGet$1(
       apiKey,
       "/account-info/v3/details"
     );
@@ -464,7 +464,17 @@ const contentTypes = {
     }
   }
 };
-const NEEDS_VALUE = /* @__PURE__ */ new Set(["eq", "neq", "contains", "gt", "lt"]);
+const NEEDS_VALUE = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "contains",
+  "notContains",
+  "startsWith",
+  "endsWith",
+  "gt",
+  "lt"
+]);
+const NEEDS_VALUES = /* @__PURE__ */ new Set(["in", "notIn"]);
 function validateDefinition(definition) {
   const errors2 = [];
   const allIds = /* @__PURE__ */ new Set();
@@ -481,6 +491,9 @@ function validateDefinition(definition) {
       if (NEEDS_VALUE.has(rule.operator) && (rule.value === void 0 || rule.value === "")) {
         errors2.push({ code: "missing-value", ...owner, target: rule.field });
       }
+      if (NEEDS_VALUES.has(rule.operator) && !rule.values?.length) {
+        errors2.push({ code: "missing-value", ...owner, target: rule.field });
+      }
     }
   };
   const seen = /* @__PURE__ */ new Set();
@@ -514,6 +527,16 @@ function evaluateRule(rule, get) {
       return asString(value) !== asString(rule.value);
     case "contains":
       return asString(value).toLowerCase().includes(asString(rule.value).toLowerCase());
+    case "notContains":
+      return !asString(value).toLowerCase().includes(asString(rule.value).toLowerCase());
+    case "startsWith":
+      return asString(value).toLowerCase().startsWith(asString(rule.value).toLowerCase());
+    case "endsWith":
+      return asString(value).toLowerCase().endsWith(asString(rule.value).toLowerCase());
+    case "in":
+      return (rule.values ?? []).some((v) => asString(v) === asString(value));
+    case "notIn":
+      return !(rule.values ?? []).some((v) => asString(v) === asString(value));
     case "empty":
       return isEmpty(value);
     case "notEmpty":
@@ -663,9 +686,9 @@ function sanitizeRawValues(raw) {
   }
   return values;
 }
-const HS_BASE$1 = "https://api.hubapi.com";
-const HS_COMPANIES = `${HS_BASE$1}/crm/v3/objects/companies`;
-const HS_NOTES = `${HS_BASE$1}/crm/v3/objects/notes`;
+const HS_BASE$2 = "https://api.hubapi.com";
+const HS_COMPANIES = `${HS_BASE$2}/crm/v3/objects/companies`;
+const HS_NOTES = `${HS_BASE$2}/crm/v3/objects/notes`;
 const ASSOC_NOTE_TO_CONTACT = 202;
 const ASSOC_NOTE_TO_COMPANY = 190;
 const escapeHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
@@ -827,7 +850,7 @@ function createFormsService(strapi, _opts = {}) {
           if (companyId) {
             await hsJson(
               apiKey,
-              `${HS_BASE$1}/crm/v4/objects/contacts/${contactId}/associations/default/companies/${companyId}`,
+              `${HS_BASE$2}/crm/v4/objects/contacts/${contactId}/associations/default/companies/${companyId}`,
               { method: "PUT" }
             );
           }
@@ -868,6 +891,168 @@ function createFormsService(strapi, _opts = {}) {
   }
   return { submit };
 }
+const HS_BASE$1 = "https://api.hubapi.com";
+const OBJECT_BY_TYPE_ID = {
+  "0-1": "contact",
+  "0-2": "company"
+};
+const TYPE_MAP = {
+  single_line_text: "text",
+  multi_line_text: "textarea",
+  email: "email",
+  phone: "tel",
+  mobile_phone: "tel",
+  number: "number",
+  dropdown: "select",
+  select: "select",
+  radio: "radio",
+  multiple_checkboxes: "checkbox",
+  single_checkbox: "checkbox",
+  booleancheckbox: "checkbox"
+};
+let counter$1 = 0;
+const makeId$1 = (prefix) => `${prefix}_${Date.now().toString(36)}${(counter$1 += 1).toString(36)}`;
+function convertCondition(parentFieldId, raw) {
+  const operator = (raw.operator ?? "").toUpperCase();
+  const values = (raw.values ?? []).map((v) => String(v)).filter((v) => v !== "");
+  const spread = (op, logic) => values.length ? { logic, rules: values.map((value) => ({ field: parentFieldId, operator: op, value })) } : null;
+  switch (operator) {
+    case "EQ":
+    case "SET_ANY":
+      return spread("eq", "or");
+    case "NEQ":
+    case "NOT_SET_ANY":
+      return spread("neq", "and");
+    case "CONTAINS":
+      return spread("contains", "or");
+    case "GT":
+      return spread("gt", "or");
+    case "LT":
+      return spread("lt", "or");
+    case "SET":
+    case "NOT_EMPTY":
+      return { logic: "and", rules: [{ field: parentFieldId, operator: "notEmpty" }] };
+    case "NOT_SET":
+    case "EMPTY":
+      return { logic: "and", rules: [{ field: parentFieldId, operator: "empty" }] };
+    default:
+      return null;
+  }
+}
+function convertField(raw, ctx) {
+  const label = raw.label || raw.name || "";
+  const name = raw.name ?? "";
+  if (raw.hidden) {
+    ctx.skipped.push({ code: "hidden-field", label });
+    return [];
+  }
+  const object = OBJECT_BY_TYPE_ID[raw.objectTypeId ?? "0-1"];
+  if (!object) {
+    ctx.skipped.push({ code: "object", label, detail: raw.objectTypeId });
+    return [];
+  }
+  const type = TYPE_MAP[raw.fieldType ?? ""];
+  if (!type || !name) {
+    ctx.skipped.push({ code: "field-type", label, detail: raw.fieldType });
+    return [];
+  }
+  if (ctx.usedNames.has(name)) {
+    ctx.skipped.push({ code: "duplicate", label, detail: name });
+    return [];
+  }
+  ctx.usedNames.add(name);
+  const options = (raw.options ?? []).map((o) => ({ value: String(o.value ?? ""), label: o.label || void 0 })).filter((o) => o.value !== "");
+  const field = {
+    id: makeId$1("fld"),
+    name,
+    label,
+    type,
+    required: Boolean(raw.required),
+    placeholder: raw.placeholder || void 0,
+    helpText: raw.description || void 0,
+    ...options.length ? { options } : {},
+    hubspot: { object, property: name },
+    ...ctx.parentCondition ? { visibleIf: ctx.parentCondition } : {}
+  };
+  const out = [field];
+  for (const dependent of raw.dependentFields ?? []) {
+    if (!dependent.field) continue;
+    const childLabel = dependent.field.label || dependent.field.name || "";
+    const condition = dependent.dependentCondition ? convertCondition(field.id, dependent.dependentCondition) : null;
+    if (!condition) {
+      ctx.skipped.push({
+        code: "condition",
+        label: childLabel,
+        detail: dependent.dependentCondition?.operator
+      });
+    }
+    out.push(...convertField(dependent.field, { ...ctx, parentCondition: condition }));
+  }
+  return out;
+}
+function convertHubspotForm(raw) {
+  const skipped = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const fields = [];
+  for (const group of raw.fieldGroups ?? []) {
+    if (group.richText && !(group.fields ?? []).length) {
+      skipped.push({ code: "rich-text", detail: group.richText.slice(0, 80) });
+      continue;
+    }
+    const groupFields = (group.fields ?? []).flatMap(
+      (f) => convertField(f, { usedNames, skipped })
+    );
+    const topLevel = (group.fields ?? []).length;
+    if (topLevel === 2 && groupFields.length >= 2) {
+      groupFields[0].width = "half";
+      groupFields[1].width = "half";
+    }
+    fields.push(...groupFields);
+  }
+  if (raw.legalConsentOptions && Object.keys(raw.legalConsentOptions).length) {
+    skipped.push({ code: "legal-consent" });
+  }
+  const postSubmit = raw.configuration?.postSubmitAction;
+  return {
+    name: raw.name ?? "",
+    submitLabel: raw.displayOptions?.submitButtonText || null,
+    successMessage: postSubmit?.type === "thank_you" && postSubmit.value ? postSubmit.value : null,
+    // HubSpot forms are single-page: one step, reorganizable in the builder.
+    definition: { version: 1, steps: [{ id: makeId$1("stp"), fields }] },
+    skipped
+  };
+}
+async function hsGet(apiKey, path) {
+  const res = await fetch(`${HS_BASE$1}${path}`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw Object.assign(new Error(body.message || `HubSpot ${res.status}`), {
+      status: res.status
+    });
+  }
+  return await res.json();
+}
+async function listHubspotForms(apiKey) {
+  const out = [];
+  let after;
+  for (let page = 0; page < 10; page += 1) {
+    const query = after ? `&after=${encodeURIComponent(after)}` : "";
+    const res = await hsGet(apiKey, `/marketing/v3/forms/?limit=100&formTypes=hubspot${query}`);
+    for (const form of res.results ?? []) {
+      if (form.id && !form.archived) {
+        out.push({ id: form.id, name: form.name || form.id, updatedAt: form.updatedAt });
+      }
+    }
+    after = res.paging?.next?.after;
+    if (!after) break;
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function fetchHubspotForm(apiKey, formId) {
+  return hsGet(apiKey, `/marketing/v3/forms/${encodeURIComponent(formId)}`);
+}
 let counter = 0;
 const makeId = (prefix) => `${prefix}_${Date.now().toString(36)}${(counter += 1).toString(36)}`;
 const slugifyName = (label) => label.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
@@ -1006,8 +1191,15 @@ function createFormsAdminController(strapi) {
         fields: ["slug"]
       });
       const publishedIds = new Set(published.map((e) => e.documentId));
+      const submissionCounts = await Promise.all(
+        drafts.map(
+          (entry) => strapi.documents(SUBMISSION_UID).count({
+            filters: { form: entry.slug }
+          })
+        )
+      );
       ctx.body = {
-        forms: drafts.map((entry) => ({
+        forms: drafts.map((entry, i) => ({
           documentId: entry.documentId,
           name: entry.name,
           slug: entry.slug,
@@ -1017,7 +1209,8 @@ function createFormsAdminController(strapi) {
           fields: (entry.definition?.steps ?? []).reduce(
             (n, step) => n + (step.fields?.length ?? 0),
             0
-          )
+          ),
+          submissions: submissionCounts[i] ?? 0
         }))
       };
     },
@@ -1208,6 +1401,66 @@ function createFormsAdminController(strapi) {
       if (!targetId) ctx.throw(404, "Source entry not found");
       ctx.body = { documentId: targetId, locales: imported };
     },
+    /**
+     * Forms of the connected HubSpot portal, offered for import. Needs the
+     * `forms` read scope on the private app token — a token without it gets
+     * a clear message rather than an empty list.
+     */
+    async listHubspotSources(ctx) {
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) {
+        ctx.body = { configured: false, forms: [] };
+        return;
+      }
+      try {
+        ctx.body = { configured: true, forms: await listHubspotForms(apiKey) };
+      } catch (err) {
+        strapi.log.warn(`[hubspot] portal forms unavailable — ${err.message}`);
+        ctx.throw(502, err.message || "Cannot reach HubSpot");
+      }
+    },
+    /**
+     * Converts one portal form into a plugin form draft, in the current
+     * locale. Slug derived from the HubSpot name: re-importing the same form
+     * overwrites the draft — never the published version, never the portal.
+     * What the builder can't express is skipped and returned in `skipped`.
+     */
+    async runHubspotImport(ctx) {
+      const formId = ctx.request.body?.formId;
+      if (typeof formId !== "string" || !formId) ctx.throw(400, "formId is required");
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) ctx.throw(400, "No HubSpot API key configured");
+      let converted;
+      try {
+        converted = convertHubspotForm(await fetchHubspotForm(apiKey, formId));
+      } catch (err) {
+        strapi.log.warn(`[hubspot] form import failed — ${err.message}`);
+        ctx.throw(502, err.message || "Cannot reach HubSpot");
+        return;
+      }
+      const name = converted.name || "HubSpot form";
+      const { skipped, definition, ...meta } = converted;
+      const slug = slugify(name);
+      const existing = await documents().findFirst({
+        filters: { slug }
+      });
+      let documentId;
+      if (existing) {
+        await documents().update({
+          documentId: existing.documentId,
+          locale: ctx.query.locale,
+          data: { ...meta, name, definition }
+        });
+        documentId = existing.documentId;
+      } else {
+        const created = await documents().create({
+          locale: ctx.query.locale,
+          data: { ...meta, name, slug, definition }
+        });
+        documentId = created.documentId;
+      }
+      ctx.body = { documentId, skipped };
+    },
     /**
      * Copies a form (every locale of its draft) into a new draft document —
      * the quickest way to A/B a variant or to start from an existing form.
@@ -1268,6 +1521,45 @@ function createFormsAdminController(strapi) {
     }
   };
 }
+function fieldOrder(definition) {
+  if (!definition) return [];
+  return definition.steps.flatMap((step) => step.fields.map((field) => field.name));
+}
+const escapeCell = (value) => {
+  if (value === null || value === void 0) return "";
+  const text = String(value);
+  return /[",\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+};
+function submissionsCsv(rows, knownFields) {
+  const extra = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row.values ?? {})) {
+      if (!knownFields.includes(key)) extra.add(key);
+    }
+  }
+  const valueColumns = [...knownFields, ...[...extra].sort()];
+  const header = [
+    "submittedAt",
+    ...valueColumns,
+    "hubspotSynced",
+    "locale",
+    "pagePath",
+    "source"
+  ];
+  const lines = [header.map(escapeCell).join(",")];
+  for (const row of rows) {
+    const cells = [
+      row.createdAt ?? "",
+      ...valueColumns.map((key) => row.values?.[key]),
+      row.hubspotSynced ? "true" : "false",
+      row.locale ?? "",
+      row.meta?.pagePath ?? "",
+      row.meta?.source ?? ""
+    ];
+    lines.push(cells.map(escapeCell).join(","));
+  }
+  return lines.join("\r\n");
+}
 const HS_BASE = "https://api.hubapi.com";
 const FAILURE_UID = "plugin::hubspot.failure";
 const RETRY_DELAYS_MS = [500, 2e3];
@@ -1478,6 +1770,49 @@ const controllers = {
     }
   }),
   formsAdmin: ({ strapi }) => createFormsAdminController(strapi),
+  submissions: ({ strapi }) => ({
+    /** Paged submissions, newest first, optionally narrowed to one form. */
+    async list(ctx) {
+      const filters = ctx.query.form ? { form: ctx.query.form } : void 0;
+      const page = Math.max(1, Number(ctx.query.page) || 1);
+      const pageSize = Math.min(100, Math.max(1, Number(ctx.query.pageSize) || 20));
+      const [rows, total] = await Promise.all([
+        strapi.documents(SUBMISSION_UID).findMany({
+          filters,
+          sort: "createdAt:desc",
+          limit: pageSize,
+          start: (page - 1) * pageSize
+        }),
+        strapi.documents(SUBMISSION_UID).count({ filters })
+      ]);
+      ctx.body = { submissions: rows, total, page, pageSize };
+    },
+    /**
+     * Whole history of one form as CSV, definition columns first. Returned as
+     * JSON (`{ csv, filename }`): the admin fetch client speaks JSON, and the
+     * page turns it into a download — no auth-header gymnastics.
+     */
+    async export(ctx) {
+      const slug = ctx.query.form;
+      if (!slug) ctx.throw(400, "form is required");
+      const [rows, entry] = await Promise.all([
+        strapi.documents(SUBMISSION_UID).findMany({
+          filters: { form: slug },
+          sort: "createdAt:desc",
+          limit: 1e4
+        }),
+        strapi.documents(FORM_UID).findFirst({
+          filters: { slug },
+          status: "draft"
+        })
+      ]);
+      ctx.body = {
+        csv: submissionsCsv(rows, fieldOrder(entry?.definition)),
+        filename: `${slug}-submissions-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.csv`,
+        total: rows.length
+      };
+    }
+  }),
   forms: ({ strapi }) => ({
     /** Published form for the host frontend — CRM mapping stripped. */
     async findOne(ctx) {
@@ -1564,7 +1899,11 @@ const routes = {
       // they pick properties — the builder itself stays gated.
       adminRoute("GET", "/forms-options", "formsAdmin.options"),
       adminRoute("GET", "/builder/import/sources", "formsAdmin.listSources", [FORMS_ACTION]),
-      adminRoute("POST", "/builder/import", "formsAdmin.runImport", [FORMS_ACTION])
+      adminRoute("POST", "/builder/import", "formsAdmin.runImport", [FORMS_ACTION]),
+      adminRoute("GET", "/builder/import/hubspot", "formsAdmin.listHubspotSources", [FORMS_ACTION]),
+      adminRoute("POST", "/builder/import/hubspot", "formsAdmin.runHubspotImport", [FORMS_ACTION]),
+      adminRoute("GET", "/builder/submissions", "submissions.list", [FORMS_ACTION]),
+      adminRoute("GET", "/builder/submissions/export", "submissions.export", [FORMS_ACTION])
     ]
   },
   // Public form delivery + submission, under /api/hubspot/…. Like any

package/dist/server/src/__tests__/importHubspot.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/src/__tests__/submissions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/src/conditions.d.ts

@@ -2,12 +2,14 @@
  * The condition engine — pure functions, no Strapi.
  */
 export type Primitive = string | number | boolean;
-export type Operator = "eq" | "neq" | "contains" | "empty" | "notEmpty" | "gt" | "lt";
+export type Operator = "eq" | "neq" | "contains" | "notContains" | "startsWith" | "endsWith" | "empty" | "notEmpty" | "gt" | "lt" | "in" | "notIn";
 export interface Rule {
     /** Stable id (`fld_…`) of the field the rule reads — never its name. */
     field: string;
     operator: Operator;
     value?: string;
+    /** For `in` / `notIn`: the values any one of which satisfies the rule. */
+    values?: string[];
 }
 export interface Condition {
     logic: "and" | "or";

package/dist/server/src/formsAdmin.d.ts

@@ -42,6 +42,19 @@ export declare function createFormsAdminController(strapi: Core.Strapi): {
      * published version, and never modifies the source.
      */
     runImport(ctx: Ctx): Promise<void>;
+    /**
+     * Forms of the connected HubSpot portal, offered for import. Needs the
+     * `forms` read scope on the private app token — a token without it gets
+     * a clear message rather than an empty list.
+     */
+    listHubspotSources(ctx: Ctx): Promise<void>;
+    /**
+     * Converts one portal form into a plugin form draft, in the current
+     * locale. Slug derived from the HubSpot name: re-importing the same form
+     * overwrites the draft — never the published version, never the portal.
+     * What the builder can't express is skipped and returned in `skipped`.
+     */
+    runHubspotImport(ctx: Ctx): Promise<void>;
     /**
      * Copies a form (every locale of its draft) into a new draft document —
      * the quickest way to A/B a variant or to start from an existing form.

package/dist/server/src/importHubspot.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Conversion of a HubSpot-hosted form (marketing v3 Forms API) into the
+ * plugin's definition model — the second import path of the builder, next to
+ * the legacy content-type one (importLegacy.ts).
+ *
+ * The translation is deliberately lossy-but-honest: everything the builder
+ * can express is carried over (fields, options, required, two-per-row
+ * layouts, dependent-field conditions), and everything it can't is *skipped
+ * and reported* rather than half-imported — the caller shows the report so
+ * the editor knows exactly what to rebuild by hand.
+ *
+ * A HubSpot form field IS a CRM property (`name` + `objectTypeId`), so an
+ * imported form arrives with a mapping that is already valid for the portal.
+ */
+import type { FormDefinition } from "./conditions";
+/** One row of the portal's form list, as offered for import. */
+export interface HubspotFormSummary {
+    id: string;
+    name: string;
+    updatedAt?: string;
+}
+/** Something the converter could not express in the builder's model. */
+export interface SkippedItem {
+    code: "field-type" | "hidden-field" | "object" | "duplicate" | "condition" | "rich-text" | "legal-consent";
+    /** Field label or name, when the item is a field. */
+    label?: string;
+    /** Raw detail (the fieldType, the operator…) for the report. */
+    detail?: string;
+}
+export interface ConvertedHubspotForm {
+    name: string;
+    submitLabel?: string | null;
+    successMessage?: string | null;
+    definition: FormDefinition;
+    skipped: SkippedItem[];
+}
+interface RawDependent {
+    dependentCondition?: {
+        operator?: string;
+        values?: unknown[];
+    };
+    field?: RawField;
+}
+interface RawField {
+    objectTypeId?: string;
+    name?: string;
+    label?: string;
+    fieldType?: string;
+    required?: boolean;
+    hidden?: boolean;
+    placeholder?: string;
+    description?: string;
+    options?: {
+        value?: unknown;
+        label?: string;
+    }[];
+    dependentFields?: RawDependent[];
+}
+interface RawFieldGroup {
+    richText?: string;
+    fields?: RawField[];
+}
+export interface RawHubspotForm {
+    id?: string;
+    name?: string;
+    fieldGroups?: RawFieldGroup[];
+    displayOptions?: {
+        submitButtonText?: string;
+    };
+    configuration?: {
+        postSubmitAction?: {
+            type?: string;
+            value?: string;
+        };
+    };
+    legalConsentOptions?: {
+        type?: string;
+    } | null;
+}
+export declare function convertHubspotForm(raw: RawHubspotForm): ConvertedHubspotForm;
+/** Every regular form of the portal, name-sorted. Needs the `forms` scope. */
+export declare function listHubspotForms(apiKey: string): Promise<HubspotFormSummary[]>;
+/** One form, full definition. */
+export declare function fetchHubspotForm(apiKey: string, formId: string): Promise<RawHubspotForm>;
+export {};

package/dist/server/src/index.d.ts

@@ -22,7 +22,7 @@ declare const _default: {
                 kind: string;
                 collectionName: string;
                 info: {
-                    singularName: string; /** RBAC action gating the settings screen and its routes. */
+                    singularName: string;
                     pluralName: string;
                     displayName: string;
                     description: string;
@@ -256,9 +256,36 @@ declare const _default: {
             options(ctx: import("./formsAdmin").Ctx): Promise<void>;
             listSources(ctx: import("./formsAdmin").Ctx): Promise<void>;
             runImport(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            listHubspotSources(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            runHubspotImport(ctx: import("./formsAdmin").Ctx): Promise<void>;
             duplicate(ctx: import("./formsAdmin").Ctx): Promise<void>;
             remove(ctx: import("./formsAdmin").Ctx): Promise<void>;
         };
+        submissions: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            /** Paged submissions, newest first, optionally narrowed to one form. */
+            list(ctx: {
+                query: {
+                    form?: string;
+                    page?: string;
+                    pageSize?: string;
+                };
+                body: unknown;
+            }): Promise<void>;
+            /**
+             * Whole history of one form as CSV, definition columns first. Returned as
+             * JSON (`{ csv, filename }`): the admin fetch client speaks JSON, and the
+             * page turns it into a download — no auth-header gymnastics.
+             */
+            export(ctx: {
+                query: {
+                    form?: string;
+                };
+                body: unknown;
+                throw: (s: number, m: string) => never;
+            }): Promise<void>;
+        };
         forms: ({ strapi }: {
             strapi: Core.Strapi;
         }) => {

package/dist/server/src/submissions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Reading side of the submissions store — the admin's Submissions tab and its
+ * CSV export. Pure shaping here; the controller does the fetching.
+ *
+ * The CSV columns follow the *form definition* order (the way the editor
+ * reads the form), then any extra keys found in older submissions — a field
+ * renamed or removed since doesn't lose its historical answers.
+ */
+import type { FormDefinition } from "./conditions";
+export interface SubmissionRow {
+    documentId: string;
+    form: string;
+    formTitle?: string | null;
+    email?: string | null;
+    values: Record<string, string | number | boolean>;
+    meta?: Record<string, string> | null;
+    locale?: string | null;
+    hubspotSynced?: boolean;
+    createdAt?: string;
+}
+/** Field names in definition order — the natural reading order of the form. */
+export declare function fieldOrder(definition: FormDefinition | null | undefined): string[];
+/**
+ * Submissions → CSV. `knownFields` (usually `fieldOrder(definition)`) leads;
+ * keys present in the rows but not in the definition are appended, sorted, so
+ * nothing recorded is ever silently dropped from an export.
+ */
+export declare function submissionsCsv(rows: SubmissionRow[], knownFields: string[]): string;