strapi-plugin-hubspot 0.2.1 → 0.4.0

package/dist/server/index.js

@@ -1,6 +1,6 @@
 "use strict";
 const utils = require("@strapi/utils");
-const HS_BASE = "https://api.hubapi.com";
+const HS_BASE$1 = "https://api.hubapi.com";
 const TTL_MS = 10 * 60 * 1e3;
 const STANDARD_OBJECTS = [
   { name: "contact", path: "contacts" },
@@ -14,7 +14,7 @@ const STANDARD_OBJECTS = [
 let cache = null;
 let inFlight = null;
 async function hsGet(apiKey, path) {
-  const res = await fetch(`${HS_BASE}${path}`, {
+  const res = await fetch(`${HS_BASE$1}${path}`, {
     headers: { Authorization: `Bearer ${apiKey}` }
   });
   if (!res.ok) {
@@ -25,18 +25,29 @@ async function hsGet(apiKey, path) {
   }
   return await res.json();
 }
+async function fetchGroups(apiKey, path) {
+  try {
+    const res = await hsGet(
+      apiKey,
+      `/crm/v3/properties/${path}/groups`
+    );
+    return Object.fromEntries((res.results ?? []).map((g) => [g.name, g.label || g.name]));
+  } catch {
+    return {};
+  }
+}
 async function fetchObject(apiKey, object) {
-  const res = await hsGet(
-    apiKey,
-    `/crm/v3/properties/${object.path}`
-  );
+  const [res, groups] = await Promise.all([
+    hsGet(apiKey, `/crm/v3/properties/${object.path}`),
+    fetchGroups(apiKey, object.path)
+  ]);
   return (res.results ?? []).filter((p) => !p.modificationMetadata?.readOnlyValue).map((p) => ({
     name: p.name,
     label: p.label || p.name,
     object: object.name,
     type: p.type,
-    options: (p.options ?? []).map((o) => o.value),
-    group: p.groupName
+    options: (p.options ?? []).map((o) => ({ value: o.value, label: o.label })),
+    group: p.groupName ? groups[p.groupName] ?? p.groupName : void 0
   }));
 }
 async function fetchAccount(apiKey) {
@@ -69,14 +80,14 @@ async function loadSchema(strapi, apiKey, objects, { force = false } = {}) {
       for (const entry of settled) {
         if ("error" in entry && entry.error) {
           unavailable.push({ object: entry.object.name, reason: entry.error });
-          strapi.log.warn(`[hubspot] ${entry.object.name} illisible — ${entry.error}`);
+          strapi.log.warn(`[hubspot] ${entry.object.name} unreadable — ${entry.error}`);
           continue;
         }
         available.push(entry.object.name);
         properties.push(...entry.properties ?? []);
       }
       if (!available.length) {
-        throw new Error(unavailable[0]?.reason ?? "Aucun objet lisible");
+        throw new Error(unavailable[0]?.reason ?? "No readable object");
       }
       properties.sort(
         (a, b) => a.object.localeCompare(b.object) || a.label.localeCompare(b.label)
@@ -100,16 +111,36 @@ async function loadSchema(strapi, apiKey, objects, { force = false } = {}) {
 function clearCache() {
   cache = null;
 }
-function checkProperty(properties, object, name) {
-  const trimmed = name.trim();
+function checkMapping(properties, mapping) {
+  const { object, property } = mapping;
+  const trimmed = property.trim();
   if (!trimmed) return null;
   const match = properties.find((p) => p.object === object && p.name === trimmed);
-  if (match) return trimmed === name ? null : `« ${name} » contient un espace superflu`;
-  const onOther = properties.find((p) => p.name === trimmed);
-  if (onOther) {
-    return `« ${trimmed} » existe sur l'objet ${onOther.object}, pas sur ${object}`;
+  if (!match) {
+    const elsewhere = properties.find((p) => p.name === trimmed);
+    return elsewhere ? { code: "wrong-object", property: trimmed, object, actualObject: elsewhere.object } : { code: "unknown", property: trimmed, object };
+  }
+  if (trimmed !== property) return { code: "whitespace", property, object };
+  if (match.type === "enumeration" && match.options.length && mapping.values?.length) {
+    const allowed = match.options.map((o) => o.value);
+    const stray = mapping.values.filter((v) => v && !allowed.includes(v));
+    if (stray.length) {
+      return { code: "bad-option", property: trimmed, object, values: stray };
+    }
+  }
+  return null;
+}
+function describeProblem(problem) {
+  switch (problem.code) {
+    case "unknown":
+      return `"${problem.property}" does not exist on ${problem.object} in this HubSpot portal`;
+    case "wrong-object":
+      return `"${problem.property}" exists on ${problem.actualObject}, not on ${problem.object}`;
+    case "whitespace":
+      return `"${problem.property}" has surrounding whitespace`;
+    case "bad-option":
+      return `"${problem.property}" does not accept ${problem.values.map((v) => `"${v}"`).join(", ")}`;
   }
-  return `« ${trimmed} » n'existe pas dans ce portail HubSpot`;
 }
 function resolveObjects(configured) {
   if (!Array.isArray(configured) || !configured.length) {
@@ -153,6 +184,337 @@ async function publicSettings(strapi) {
     hint: apiKey ? `…${apiKey.slice(-4)}` : ""
   };
 }
+function collectMappings(node, target, found = []) {
+  if (Array.isArray(node)) {
+    for (const item of node) collectMappings(item, target, found);
+    return found;
+  }
+  if (!node || typeof node !== "object") return found;
+  const obj = node;
+  const property = obj[target.propertyField];
+  if (typeof property === "string" && property.trim()) {
+    const object = obj[target.objectField];
+    const rawOptions = obj[target.optionsField || "options"];
+    const values = Array.isArray(rawOptions) ? rawOptions.map((o) => {
+      const opt = o ?? {};
+      const v = typeof opt.value === "string" && opt.value.trim() ? opt.value : opt.label;
+      return typeof v === "string" ? v.trim() : "";
+    }).filter(Boolean) : void 0;
+    found.push({
+      object: typeof object === "string" && object ? object : "contact",
+      property,
+      values
+    });
+  }
+  for (const value of Object.values(obj)) collectMappings(value, target, found);
+  return found;
+}
+function makeValidationMiddleware(strapi, target) {
+  return async (context, next) => {
+    const isWrite = ["create", "update"].includes(context.action);
+    if (!isWrite || context.uid !== target.uid) return next();
+    const mappings = collectMappings(
+      context.params?.data,
+      target
+    );
+    if (!mappings.length) return next();
+    const { apiKey } = await resolveApiKey(strapi);
+    if (!apiKey) return next();
+    let schema;
+    try {
+      schema = await loadSchema(
+        strapi,
+        apiKey,
+        resolveObjects(strapi.plugin("hubspot").config("objects", []))
+      );
+    } catch {
+      strapi.log.warn("[hubspot] schema unavailable — validation skipped");
+      return next();
+    }
+    const problems = mappings.map((m) => checkMapping(schema.properties, m)).filter((p) => Boolean(p));
+    const blocking = target.strict === false ? problems.filter((p) => p.code !== "unknown") : problems;
+    const soft = problems.filter((p) => !blocking.includes(p));
+    if (soft.length) {
+      const sentences = [...new Set(soft.map(describeProblem))];
+      strapi.log.warn(
+        `[hubspot] ${target.uid}: ${sentences.join("; ")} — allowed (strict: false)`
+      );
+    }
+    if (blocking.length) {
+      const sentences = [...new Set(blocking.map(describeProblem))];
+      throw new utils.errors.ValidationError(
+        `Invalid HubSpot mapping — ${sentences.join("; ")}`,
+        { problems: blocking }
+      );
+    }
+    return next();
+  };
+}
+function buildPopulate(components, schema, depth = 0) {
+  if (depth > 8) return {};
+  const populate = {};
+  for (const [key, attr] of Object.entries(schema.attributes ?? {})) {
+    if (attr.type === "component" && attr.component) {
+      const child = components[attr.component];
+      const nested = child ? buildPopulate(components, child, depth + 1) : {};
+      populate[key] = { populate: Object.keys(nested).length ? nested : "*" };
+    } else if (attr.type === "dynamiczone" && attr.components?.length) {
+      const on = {};
+      for (const uid of attr.components) {
+        const child = components[uid];
+        const nested = child ? buildPopulate(components, child, depth + 1) : {};
+        on[uid] = { populate: Object.keys(nested).length ? nested : "*" };
+      }
+      populate[key] = { on };
+    }
+  }
+  return populate;
+}
+function entryLabel(entry) {
+  for (const key of ["title", "name", "label", "heading", "slug"]) {
+    const value = entry[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return String(entry.documentId ?? entry.id ?? "?");
+}
+async function fetchEntries(strapi, uid, schema, populate) {
+  const params = {};
+  if (Object.keys(populate).length) params.populate = populate;
+  if (schema.options?.draftAndPublish) params.status = "draft";
+  let locales = [void 0];
+  if (schema.pluginOptions?.i18n?.localized) {
+    try {
+      const known = await strapi.plugin("i18n").service("locales").find();
+      if (known.length) locales = known.map((l) => l.code);
+    } catch {
+    }
+  }
+  const out = [];
+  for (const locale of locales) {
+    const docs = await strapi.documents(uid).findMany({
+      ...params,
+      ...locale ? { locale } : {}
+    });
+    for (const doc of docs ?? []) out.push(locale ? { ...doc, __auditLocale: locale } : doc);
+  }
+  return out;
+}
+async function runAudit(strapi, targets, schema) {
+  const reports = [];
+  for (const target of targets) {
+    const contentType = strapi.contentType(target.uid);
+    if (!contentType) {
+      reports.push({
+        uid: target.uid,
+        entries: 0,
+        mappings: 0,
+        invalid: [],
+        error: `unknown content type "${target.uid}"`
+      });
+      continue;
+    }
+    const populate = buildPopulate(
+      strapi.components,
+      contentType
+    );
+    let entries;
+    try {
+      entries = await fetchEntries(strapi, target.uid, contentType, populate);
+    } catch (err) {
+      reports.push({
+        uid: target.uid,
+        entries: 0,
+        mappings: 0,
+        invalid: [],
+        error: err.message
+      });
+      continue;
+    }
+    const report = {
+      uid: target.uid,
+      entries: entries.length,
+      mappings: 0,
+      invalid: []
+    };
+    for (const entry of entries) {
+      const mappings = collectMappings(entry, target);
+      report.mappings += mappings.length;
+      const problems = mappings.map((m) => checkMapping(schema.properties, m)).filter((p) => Boolean(p));
+      if (problems.length) {
+        report.invalid.push({
+          documentId: String(entry.documentId ?? entry.id ?? "?"),
+          locale: entry.__auditLocale ?? void 0,
+          label: entryLabel(entry),
+          problems
+        });
+      }
+    }
+    reports.push(report);
+  }
+  return reports;
+}
+const contentTypes = {
+  failure: {
+    schema: {
+      kind: "collectionType",
+      collectionName: "hubspot_failures",
+      info: {
+        singularName: "failure",
+        pluralName: "failures",
+        displayName: "HubSpot failed submissions",
+        description: "Submissions HubSpot couldn't take, waiting to be replayed"
+      },
+      options: { draftAndPublish: false },
+      pluginOptions: {
+        "content-manager": { visible: true },
+        "content-type-builder": { visible: false }
+      },
+      attributes: {
+        object: { type: "string", required: true },
+        idProperty: { type: "string", required: true },
+        properties: { type: "json", required: true },
+        error: { type: "text" },
+        attempts: { type: "integer", default: 1 }
+      }
+    }
+  }
+};
+const HS_BASE = "https://api.hubapi.com";
+const FAILURE_UID = "plugin::hubspot.failure";
+const RETRY_DELAYS_MS = [500, 2e3];
+const sleepFor = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function coerceProperties(properties) {
+  const out = {};
+  for (const [key, value] of Object.entries(properties)) {
+    if (value === null || value === void 0 || value === "") continue;
+    out[key] = String(value);
+  }
+  return out;
+}
+class HsError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+  }
+}
+const isTransient = (err) => !(err instanceof HsError) || err.status === 429 || err.status >= 500;
+function createSubmitService(strapi, { sleep = sleepFor } = {}) {
+  const objectPath = (object) => resolveObjects(strapi.plugin("hubspot").config("objects", [])).find(
+    (o) => o.name === object
+  )?.path ?? object;
+  async function sendOnce(apiKey, input, properties) {
+    const res = await fetch(`${HS_BASE}/crm/v3/objects/${objectPath(input.object)}/batch/upsert`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
+      body: JSON.stringify({
+        inputs: [{ idProperty: input.idProperty, id: properties[input.idProperty], properties }]
+      })
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) throw new HsError(body.message || `HubSpot ${res.status}`, res.status);
+    return body.results?.[0]?.id ?? "";
+  }
+  async function sendWithRetries(apiKey, input, properties) {
+    let lastError;
+    for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt += 1) {
+      if (attempt > 0) await sleep(RETRY_DELAYS_MS[attempt - 1]);
+      try {
+        return await sendOnce(apiKey, input, properties);
+      } catch (err) {
+        lastError = err;
+        if (!isTransient(err)) throw err;
+      }
+    }
+    throw lastError;
+  }
+  async function validateAgainstSchema(apiKey, input, properties) {
+    let schema;
+    try {
+      schema = await loadSchema(
+        strapi,
+        apiKey,
+        resolveObjects(strapi.plugin("hubspot").config("objects", []))
+      );
+    } catch {
+      return null;
+    }
+    const problems = [];
+    for (const [name, value] of Object.entries(properties)) {
+      const problem = checkMapping(schema.properties, {
+        object: input.object,
+        property: name,
+        values: value.split(";").map((v) => v.trim()).filter(Boolean)
+      });
+      if (problem) problems.push(problem);
+    }
+    return problems;
+  }
+  async function upsert(input, { queueOnFailure = true } = {}) {
+    const { apiKey } = await resolveApiKey(strapi);
+    if (!apiKey) return { ok: false, error: "No HubSpot API key configured" };
+    const properties = coerceProperties(input.properties);
+    if (!properties[input.idProperty]) {
+      return { ok: false, error: `Missing value for idProperty "${input.idProperty}"` };
+    }
+    const problems = await validateAgainstSchema(apiKey, input, properties);
+    if (problems?.length) return { ok: false, problems };
+    try {
+      const id = await sendWithRetries(apiKey, input, properties);
+      return { ok: true, id };
+    } catch (err) {
+      const message = err.message;
+      if (!isTransient(err) || !queueOnFailure) {
+        strapi.log.error(`[hubspot] upsert refused — ${message}`);
+        return { ok: false, error: message };
+      }
+      strapi.log.warn(`[hubspot] upsert failed, queued for retry — ${message}`);
+      try {
+        await strapi.documents(FAILURE_UID).create({
+          data: {
+            object: input.object,
+            idProperty: input.idProperty,
+            properties: input.properties,
+            error: message,
+            attempts: 1
+          }
+        });
+        return { ok: false, queued: true, error: message };
+      } catch (storeErr) {
+        strapi.log.error(`[hubspot] could not queue the failure — ${storeErr.message}`);
+        return { ok: false, queued: false, error: message };
+      }
+    }
+  }
+  async function retryFailures({ limit = 50 } = {}) {
+    const rows = await strapi.documents(FAILURE_UID).findMany({
+      limit,
+      sort: "createdAt:asc"
+    });
+    let succeeded = 0;
+    for (const row of rows) {
+      const result = await upsert(
+        { object: row.object, idProperty: row.idProperty, properties: row.properties ?? {} },
+        { queueOnFailure: false }
+        // Already queued — don't duplicate the row.
+      );
+      if (result.ok) {
+        await strapi.documents(FAILURE_UID).delete({ documentId: row.documentId });
+        succeeded += 1;
+      } else {
+        await strapi.documents(FAILURE_UID).update({
+          documentId: row.documentId,
+          data: {
+            attempts: (row.attempts ?? 1) + 1,
+            error: result.error ?? (result.problems ? `invalid mapping: ${JSON.stringify(result.problems)}` : "unknown")
+          }
+        });
+      }
+    }
+    return { retried: rows.length, succeeded, failed: rows.length - succeeded };
+  }
+  return { upsert, retryFailures };
+}
+const SETTINGS_ACTION = "plugin::hubspot.settings";
 const config = {
   default: {
     apiKey: "",
@@ -185,10 +547,41 @@ const controllers = {
         ctx.body = { configured: true, ...schema };
       } catch (err) {
         strapi.log.error(`[hubspot] ${err.message}`);
-        ctx.throw(502, "Impossible de joindre HubSpot — vérifiez la clé API.");
+        ctx.throw(502, "Cannot reach HubSpot — check the API key.");
+      }
+    }
+  }),
+  audit: ({ strapi }) => ({
+    async run(ctx) {
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) {
+        ctx.body = { configured: false, targets: [] };
+        return;
+      }
+      const targets = strapi.plugin("hubspot").config("validate", []);
+      try {
+        const schema = await loadSchema(
+          strapi,
+          apiKey,
+          resolveObjects(strapi.plugin("hubspot").config("objects", [])),
+          { force: true }
+        );
+        ctx.body = { configured: true, targets: await runAudit(strapi, targets, schema) };
+      } catch (err) {
+        strapi.log.error(`[hubspot] audit failed — ${err.message}`);
+        ctx.throw(502, "Cannot reach HubSpot — check the API key.");
       }
     }
   }),
+  failures: ({ strapi }) => ({
+    async list(ctx) {
+      const total = await strapi.documents(FAILURE_UID).count({});
+      ctx.body = { total };
+    },
+    async retry(ctx) {
+      ctx.body = await strapi.plugin("hubspot").service("submit").retryFailures();
+    }
+  }),
   settings: ({ strapi }) => ({
     async get(ctx) {
       ctx.body = await publicSettings(strapi);
@@ -204,82 +597,65 @@ const controllers = {
     }
   })
 };
-const adminRoute = (method, path, handler) => ({
+const adminRoute = (method, path, handler, actions) => ({
   method,
   path,
   handler,
-  config: { policies: ["admin::isAuthenticatedAdmin"] }
+  config: {
+    policies: [
+      "admin::isAuthenticatedAdmin",
+      // The token is a portal-wide secret; reading properties is not. Only the
+      // settings routes carry the extra permission.
+      ...actions ? [{ name: "admin::hasPermissions", config: { actions } }] : []
+    ]
+  }
 });
 const routes = {
   admin: {
     type: "admin",
     routes: [
       adminRoute("GET", "/properties", "properties.list"),
-      adminRoute("GET", "/settings", "settings.get"),
-      adminRoute("PUT", "/settings", "settings.update"),
-      adminRoute("DELETE", "/settings", "settings.reset")
+      adminRoute("GET", "/audit", "audit.run", [SETTINGS_ACTION]),
+      adminRoute("GET", "/failures", "failures.list", [SETTINGS_ACTION]),
+      adminRoute("POST", "/failures/retry", "failures.retry", [SETTINGS_ACTION]),
+      adminRoute("GET", "/settings", "settings.get", [SETTINGS_ACTION]),
+      adminRoute("PUT", "/settings", "settings.update", [SETTINGS_ACTION]),
+      adminRoute("DELETE", "/settings", "settings.reset", [SETTINGS_ACTION])
     ]
   }
 };
-function collectMappings(node, target, found = []) {
-  if (Array.isArray(node)) {
-    for (const item of node) collectMappings(item, target, found);
-    return found;
-  }
-  if (!node || typeof node !== "object") return found;
-  const obj = node;
-  const property = obj[target.propertyField];
-  if (typeof property === "string" && property.trim()) {
-    const object = obj[target.objectField];
-    found.push({
-      object: typeof object === "string" && object ? object : "contact",
-      property
-    });
-  }
-  for (const value of Object.values(obj)) collectMappings(value, target, found);
-  return found;
-}
 const index = {
   config,
+  contentTypes,
   controllers,
   routes,
+  services: {
+    submit: ({ strapi }) => createSubmitService(strapi)
+  },
   register({ strapi }) {
     strapi.customFields.register({
       name: "property",
       plugin: "hubspot",
       type: "string"
     });
+    strapi.customFields.register({
+      name: "object",
+      plugin: "hubspot",
+      type: "string"
+    });
   },
-  bootstrap({ strapi }) {
+  async bootstrap({ strapi }) {
+    await strapi.service("admin::permission").actionProvider.registerMany([
+      {
+        section: "plugins",
+        displayName: "Access the HubSpot settings",
+        uid: "settings",
+        pluginName: "hubspot"
+      }
+    ]);
     const targets = strapi.plugin("hubspot").config("validate", []);
-    if (!targets.length) return;
     for (const target of targets) {
-      strapi.documents.use(async (context, next) => {
-        const isWrite = ["create", "update"].includes(context.action);
-        if (!isWrite || context.uid !== target.uid) return next();
-        const mappings = collectMappings(context.params?.data, target);
-        if (!mappings.length) return next();
-        const { apiKey } = await resolveApiKey(strapi);
-        if (!apiKey) return next();
-        let schema;
-        try {
-          schema = await loadSchema(
-            strapi,
-            apiKey,
-            resolveObjects(strapi.plugin("hubspot").config("objects", []))
-          );
-        } catch {
-          strapi.log.warn("[hubspot] schéma indisponible — validation ignorée");
-          return next();
-        }
-        const problems = mappings.map((m) => checkProperty(schema.properties, m.object, m.property)).filter((reason) => Boolean(reason));
-        if (problems.length) {
-          throw new utils.errors.ValidationError(
-            `Mapping HubSpot invalide — ${[...new Set(problems)].join(" ; ")}`
-          );
-        }
-        return next();
-      });
+      strapi.documents.use(makeValidationMiddleware(strapi, target));
     }
   }
 };