strapi-plugin-hubspot 0.1.0

package/dist/_chunks/index-CER4BKjS.mjs

@@ -0,0 +1,42 @@
+const PLUGIN_ID = "hubspot";
+const index = {
+  register(app) {
+    app.customFields.register({
+      name: "property",
+      pluginId: PLUGIN_ID,
+      type: "string",
+      intlLabel: {
+        id: `${PLUGIN_ID}.property.label`,
+        defaultMessage: "Propriété HubSpot"
+      },
+      intlDescription: {
+        id: `${PLUGIN_ID}.property.description`,
+        defaultMessage: "Choisie dans les propriétés réelles du portail"
+      },
+      components: {
+        Input: async () => import("./HubspotPropertyInput-CTZYZS_7.mjs")
+      },
+      options: {}
+    });
+    app.createSettingSection(
+      {
+        id: PLUGIN_ID,
+        intlLabel: { id: `${PLUGIN_ID}.settings.section`, defaultMessage: "HubSpot" }
+      },
+      [
+        {
+          intlLabel: { id: `${PLUGIN_ID}.settings.link`, defaultMessage: "Configuration" },
+          id: `${PLUGIN_ID}-settings`,
+          to: `/settings/${PLUGIN_ID}`,
+          permissions: [],
+          Component: async () => (await import("./Settings-Byupubny.mjs")).default
+        }
+      ]
+    );
+    app.registerPlugin({ id: PLUGIN_ID, name: PLUGIN_ID });
+  }
+};
+export {
+  PLUGIN_ID as P,
+  index as i
+};

package/dist/_chunks/index-DVRLoCa1.js

@@ -0,0 +1,41 @@
+"use strict";
+const PLUGIN_ID = "hubspot";
+const index = {
+  register(app) {
+    app.customFields.register({
+      name: "property",
+      pluginId: PLUGIN_ID,
+      type: "string",
+      intlLabel: {
+        id: `${PLUGIN_ID}.property.label`,
+        defaultMessage: "Propriété HubSpot"
+      },
+      intlDescription: {
+        id: `${PLUGIN_ID}.property.description`,
+        defaultMessage: "Choisie dans les propriétés réelles du portail"
+      },
+      components: {
+        Input: async () => Promise.resolve().then(() => require("./HubspotPropertyInput-B0HpXoqz.js"))
+      },
+      options: {}
+    });
+    app.createSettingSection(
+      {
+        id: PLUGIN_ID,
+        intlLabel: { id: `${PLUGIN_ID}.settings.section`, defaultMessage: "HubSpot" }
+      },
+      [
+        {
+          intlLabel: { id: `${PLUGIN_ID}.settings.link`, defaultMessage: "Configuration" },
+          id: `${PLUGIN_ID}-settings`,
+          to: `/settings/${PLUGIN_ID}`,
+          permissions: [],
+          Component: async () => (await Promise.resolve().then(() => require("./Settings-BgRpG_a6.js"))).default
+        }
+      ]
+    );
+    app.registerPlugin({ id: PLUGIN_ID, name: PLUGIN_ID });
+  }
+};
+exports.PLUGIN_ID = PLUGIN_ID;
+exports.index = index;

package/dist/admin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const index = require("../_chunks/index-DVRLoCa1.js");
+module.exports = index.index;

package/dist/admin/index.mjs

@@ -0,0 +1,4 @@
+import { i } from "../_chunks/index-CER4BKjS.mjs";
+export {
+  i as default
+};

package/dist/admin/src/components/HubspotPropertyInput.d.ts

@@ -0,0 +1,34 @@
+import * as React from "react";
+interface InputProps {
+    name: string;
+    value?: string;
+    onChange: (event: {
+        target: {
+            name: string;
+            value: string;
+            type: string;
+        };
+    }) => void;
+    attribute?: unknown;
+    disabled?: boolean;
+    error?: string;
+    required?: boolean;
+    labelAction?: React.ReactNode;
+    hint?: React.ReactNode;
+    label?: string;
+    placeholder?: string;
+}
+/**
+ * Picker over the portal's writable properties.
+ *
+ * Contact and company properties share one list, each prefixed by its object,
+ * rather than being filtered by a sibling `hsObject` field: reading a sibling
+ * value from inside a repeatable component nested in a dynamic zone is brittle,
+ * and showing the object inline is arguably clearer anyway — the editor sees at
+ * a glance which record the answer lands on.
+ *
+ * Falls back to a plain text input when no API key is configured, so the field
+ * never blocks authoring on a fresh install.
+ */
+declare const HubspotPropertyInput: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<HTMLInputElement>>;
+export default HubspotPropertyInput;

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

@@ -0,0 +1,30 @@
+/**
+ * Registers two things:
+ *
+ *  - the `hubspot.property` custom field — a searchable picker fed by the
+ *    portal's real schema, in place of a free-text CRM property name;
+ *  - a Settings → HubSpot section holding the private app token.
+ *
+ * NOTE: the Component/Input entries must be async functions returning the
+ * module. React.lazy here crashes the admin silently — empty #strapi, no
+ * console error — the same trap link-graph hit with its menu link.
+ */
+declare const _default: {
+    register(app: {
+        customFields: {
+            register: (field: unknown) => void;
+        };
+        createSettingSection: (section: {
+            id: string;
+            intlLabel: {
+                id: string;
+                defaultMessage: string;
+            };
+        }, links: unknown[]) => void;
+        registerPlugin: (plugin: {
+            id: string;
+            name: string;
+        }) => void;
+    }): void;
+};
+export default _default;

package/dist/admin/src/pages/Settings.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare const HubspotSettings: () => React.JSX.Element;
+export default HubspotSettings;

package/dist/admin/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "hubspot";

package/dist/server/index.js

@@ -0,0 +1,206 @@
+"use strict";
+const utils = require("@strapi/utils");
+const HS_BASE = "https://api.hubapi.com";
+const TTL_MS = 10 * 60 * 1e3;
+const PLURAL = {
+  contact: "contacts",
+  company: "companies"
+};
+let cache = null;
+let inFlight = null;
+async function fetchObject(apiKey, object) {
+  const res = await fetch(`${HS_BASE}/crm/v3/properties/${PLURAL[object]}`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }).then(async (r) => {
+    if (!r.ok) throw new Error(`HubSpot ${r.status} sur ${PLURAL[object]}`);
+    return r.json();
+  });
+  return (res.results ?? []).filter((p) => !p.modificationMetadata?.readOnlyValue).map((p) => ({
+    name: p.name,
+    label: p.label || p.name,
+    object,
+    type: p.type,
+    options: (p.options ?? []).map((o) => o.value),
+    group: p.groupName
+  }));
+}
+async function listProperties(strapi, apiKey, { force = false } = {}) {
+  if (!force && cache && Date.now() - cache.at < TTL_MS) return cache.properties;
+  if (!force && inFlight) return inFlight;
+  inFlight = (async () => {
+    try {
+      const [contact, company] = await Promise.all([
+        fetchObject(apiKey, "contact"),
+        fetchObject(apiKey, "company")
+      ]);
+      const properties = [...contact, ...company].sort(
+        (a, b) => a.object.localeCompare(b.object) || a.label.localeCompare(b.label)
+      );
+      cache = { at: Date.now(), properties };
+      return properties;
+    } finally {
+      inFlight = null;
+    }
+  })();
+  return inFlight;
+}
+function clearCache() {
+  cache = null;
+}
+function checkProperty(properties, object, name) {
+  const trimmed = name.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.object !== object && p.name === trimmed);
+  if (onOther) {
+    return `« ${trimmed} » existe sur l'objet ${onOther.object === "contact" ? "Contact" : "Société"}, pas sur ${object === "contact" ? "Contact" : "Société"}`;
+  }
+  return `« ${trimmed} » n'existe pas dans ce portail HubSpot`;
+}
+const ENV_VAR = "HUBSPOT_API_KEY";
+const store = (strapi) => strapi.store({ type: "plugin", name: "hubspot" });
+async function getStoredSettings(strapi) {
+  return await store(strapi).get({ key: "settings" }) ?? {};
+}
+async function setStoredSettings(strapi, value) {
+  await store(strapi).set({ key: "settings", value });
+  clearCache();
+}
+async function resolveApiKey(strapi) {
+  const stored = await getStoredSettings(strapi);
+  if (stored.apiKey) return { apiKey: stored.apiKey, source: "settings" };
+  const fromConfig = strapi.plugin("hubspot").config("apiKey", "");
+  if (fromConfig) return { apiKey: fromConfig, source: "config" };
+  const fromEnv = process.env[ENV_VAR];
+  if (fromEnv) return { apiKey: fromEnv, source: "env" };
+  return { apiKey: "", source: null };
+}
+async function publicSettings(strapi) {
+  const { apiKey, source } = await resolveApiKey(strapi);
+  return {
+    configured: Boolean(apiKey),
+    keySource: source,
+    hint: apiKey ? `…${apiKey.slice(-4)}` : ""
+  };
+}
+const config = {
+  default: {
+    apiKey: "",
+    validate: []
+  },
+  validator(cfg) {
+    if (cfg.validate && !Array.isArray(cfg.validate)) {
+      throw new Error("hubspot: `validate` must be an array of { uid, objectField, propertyField }");
+    }
+  }
+};
+const controllers = {
+  properties: ({ strapi }) => ({
+    async list(ctx) {
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) {
+        ctx.body = { configured: false, properties: [] };
+        return;
+      }
+      try {
+        const properties = await listProperties(strapi, apiKey, {
+          force: ctx.query.refresh === "1"
+        });
+        ctx.body = { configured: true, properties };
+      } catch (err) {
+        strapi.log.error(`[hubspot] ${err.message}`);
+        ctx.throw(502, "Impossible de joindre HubSpot — vérifiez la clé API.");
+      }
+    }
+  }),
+  settings: ({ strapi }) => ({
+    async get(ctx) {
+      ctx.body = await publicSettings(strapi);
+    },
+    async update(ctx) {
+      const apiKey = (ctx.request.body?.apiKey ?? "").trim();
+      await setStoredSettings(strapi, apiKey ? { apiKey } : null);
+      ctx.body = await publicSettings(strapi);
+    },
+    async reset(ctx) {
+      await setStoredSettings(strapi, null);
+      ctx.body = await publicSettings(strapi);
+    }
+  })
+};
+const adminRoute = (method, path, handler) => ({
+  method,
+  path,
+  handler,
+  config: { policies: ["admin::isAuthenticatedAdmin"] }
+});
+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")
+    ]
+  }
+};
+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()) {
+    found.push({
+      object: obj[target.objectField] === "company" ? "company" : "contact",
+      property
+    });
+  }
+  for (const value of Object.values(obj)) collectMappings(value, target, found);
+  return found;
+}
+const index = {
+  config,
+  controllers,
+  routes,
+  register({ strapi }) {
+    strapi.customFields.register({
+      name: "property",
+      plugin: "hubspot",
+      type: "string"
+    });
+  },
+  bootstrap({ strapi }) {
+    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 properties;
+        try {
+          properties = await listProperties(strapi, apiKey);
+        } catch {
+          strapi.log.warn("[hubspot] schéma indisponible — validation ignorée");
+          return next();
+        }
+        const problems = mappings.map((m) => checkProperty(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();
+      });
+    }
+  }
+};
+module.exports = index;

package/dist/server/index.mjs

@@ -0,0 +1,207 @@
+import { errors } from "@strapi/utils";
+const HS_BASE = "https://api.hubapi.com";
+const TTL_MS = 10 * 60 * 1e3;
+const PLURAL = {
+  contact: "contacts",
+  company: "companies"
+};
+let cache = null;
+let inFlight = null;
+async function fetchObject(apiKey, object) {
+  const res = await fetch(`${HS_BASE}/crm/v3/properties/${PLURAL[object]}`, {
+    headers: { Authorization: `Bearer ${apiKey}` }
+  }).then(async (r) => {
+    if (!r.ok) throw new Error(`HubSpot ${r.status} sur ${PLURAL[object]}`);
+    return r.json();
+  });
+  return (res.results ?? []).filter((p) => !p.modificationMetadata?.readOnlyValue).map((p) => ({
+    name: p.name,
+    label: p.label || p.name,
+    object,
+    type: p.type,
+    options: (p.options ?? []).map((o) => o.value),
+    group: p.groupName
+  }));
+}
+async function listProperties(strapi, apiKey, { force = false } = {}) {
+  if (!force && cache && Date.now() - cache.at < TTL_MS) return cache.properties;
+  if (!force && inFlight) return inFlight;
+  inFlight = (async () => {
+    try {
+      const [contact, company] = await Promise.all([
+        fetchObject(apiKey, "contact"),
+        fetchObject(apiKey, "company")
+      ]);
+      const properties = [...contact, ...company].sort(
+        (a, b) => a.object.localeCompare(b.object) || a.label.localeCompare(b.label)
+      );
+      cache = { at: Date.now(), properties };
+      return properties;
+    } finally {
+      inFlight = null;
+    }
+  })();
+  return inFlight;
+}
+function clearCache() {
+  cache = null;
+}
+function checkProperty(properties, object, name) {
+  const trimmed = name.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.object !== object && p.name === trimmed);
+  if (onOther) {
+    return `« ${trimmed} » existe sur l'objet ${onOther.object === "contact" ? "Contact" : "Société"}, pas sur ${object === "contact" ? "Contact" : "Société"}`;
+  }
+  return `« ${trimmed} » n'existe pas dans ce portail HubSpot`;
+}
+const ENV_VAR = "HUBSPOT_API_KEY";
+const store = (strapi) => strapi.store({ type: "plugin", name: "hubspot" });
+async function getStoredSettings(strapi) {
+  return await store(strapi).get({ key: "settings" }) ?? {};
+}
+async function setStoredSettings(strapi, value) {
+  await store(strapi).set({ key: "settings", value });
+  clearCache();
+}
+async function resolveApiKey(strapi) {
+  const stored = await getStoredSettings(strapi);
+  if (stored.apiKey) return { apiKey: stored.apiKey, source: "settings" };
+  const fromConfig = strapi.plugin("hubspot").config("apiKey", "");
+  if (fromConfig) return { apiKey: fromConfig, source: "config" };
+  const fromEnv = process.env[ENV_VAR];
+  if (fromEnv) return { apiKey: fromEnv, source: "env" };
+  return { apiKey: "", source: null };
+}
+async function publicSettings(strapi) {
+  const { apiKey, source } = await resolveApiKey(strapi);
+  return {
+    configured: Boolean(apiKey),
+    keySource: source,
+    hint: apiKey ? `…${apiKey.slice(-4)}` : ""
+  };
+}
+const config = {
+  default: {
+    apiKey: "",
+    validate: []
+  },
+  validator(cfg) {
+    if (cfg.validate && !Array.isArray(cfg.validate)) {
+      throw new Error("hubspot: `validate` must be an array of { uid, objectField, propertyField }");
+    }
+  }
+};
+const controllers = {
+  properties: ({ strapi }) => ({
+    async list(ctx) {
+      const { apiKey } = await resolveApiKey(strapi);
+      if (!apiKey) {
+        ctx.body = { configured: false, properties: [] };
+        return;
+      }
+      try {
+        const properties = await listProperties(strapi, apiKey, {
+          force: ctx.query.refresh === "1"
+        });
+        ctx.body = { configured: true, properties };
+      } catch (err) {
+        strapi.log.error(`[hubspot] ${err.message}`);
+        ctx.throw(502, "Impossible de joindre HubSpot — vérifiez la clé API.");
+      }
+    }
+  }),
+  settings: ({ strapi }) => ({
+    async get(ctx) {
+      ctx.body = await publicSettings(strapi);
+    },
+    async update(ctx) {
+      const apiKey = (ctx.request.body?.apiKey ?? "").trim();
+      await setStoredSettings(strapi, apiKey ? { apiKey } : null);
+      ctx.body = await publicSettings(strapi);
+    },
+    async reset(ctx) {
+      await setStoredSettings(strapi, null);
+      ctx.body = await publicSettings(strapi);
+    }
+  })
+};
+const adminRoute = (method, path, handler) => ({
+  method,
+  path,
+  handler,
+  config: { policies: ["admin::isAuthenticatedAdmin"] }
+});
+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")
+    ]
+  }
+};
+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()) {
+    found.push({
+      object: obj[target.objectField] === "company" ? "company" : "contact",
+      property
+    });
+  }
+  for (const value of Object.values(obj)) collectMappings(value, target, found);
+  return found;
+}
+const index = {
+  config,
+  controllers,
+  routes,
+  register({ strapi }) {
+    strapi.customFields.register({
+      name: "property",
+      plugin: "hubspot",
+      type: "string"
+    });
+  },
+  bootstrap({ strapi }) {
+    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 properties;
+        try {
+          properties = await listProperties(strapi, apiKey);
+        } catch {
+          strapi.log.warn("[hubspot] schéma indisponible — validation ignorée");
+          return next();
+        }
+        const problems = mappings.map((m) => checkProperty(properties, m.object, m.property)).filter((reason) => Boolean(reason));
+        if (problems.length) {
+          throw new errors.ValidationError(
+            `Mapping HubSpot invalide — ${[...new Set(problems)].join(" ; ")}`
+          );
+        }
+        return next();
+      });
+    }
+  }
+};
+export {
+  index as default
+};

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

@@ -0,0 +1,83 @@
+import type { Core } from "@strapi/strapi";
+/**
+ * Plugin configuration (config/plugins.ts of the host app):
+ *
+ * hubspot: {
+ *   enabled: true,
+ *   config: {
+ *     apiKey: env("HUBSPOT_API_KEY"),   // optional — can be set from the admin UI
+ *     validate: [                       // optional — entries whose mappings are checked on save
+ *       { uid: "api::form.form", objectField: "hsObject", propertyField: "hsProperty" },
+ *     ],
+ *   },
+ * }
+ *
+ * The API key set from the admin UI takes precedence over both.
+ */
+interface ValidateTarget {
+    uid: string;
+    objectField: string;
+    propertyField: string;
+}
+declare const _default: {
+    config: {
+        default: {
+            apiKey: string;
+            validate: ValidateTarget[];
+        };
+        validator(cfg: {
+            validate?: unknown;
+        }): void;
+    };
+    controllers: {
+        properties: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            list(ctx: {
+                query: {
+                    refresh?: string;
+                };
+                body: unknown;
+                throw: (s: number, m: string) => never;
+            }): Promise<void>;
+        };
+        settings: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            get(ctx: {
+                body: unknown;
+            }): Promise<void>;
+            update(ctx: {
+                request: {
+                    body: {
+                        apiKey?: string;
+                    };
+                };
+                body: unknown;
+            }): Promise<void>;
+            reset(ctx: {
+                body: unknown;
+            }): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: string[];
+                };
+            }[];
+        };
+    };
+    register({ strapi }: {
+        strapi: Core.Strapi;
+    }): void;
+    bootstrap({ strapi }: {
+        strapi: Core.Strapi;
+    }): void;
+};
+export default _default;

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

@@ -0,0 +1,23 @@
+import type { Core } from "@strapi/strapi";
+export type HsObject = "contact" | "company";
+export interface HsProperty {
+    name: string;
+    label: string;
+    object: HsObject;
+    type?: string;
+    /** Allowed values, for enumeration properties. */
+    options: string[];
+    /** HubSpot's own grouping, shown to help editors locate a property. */
+    group?: string;
+}
+/** Writable properties of both objects, cached and de-duplicated across calls. */
+export declare function listProperties(strapi: Core.Strapi, apiKey: string, { force }?: {
+    force?: boolean;
+}): Promise<HsProperty[]>;
+/** Drop the cache — used after the API key changes. */
+export declare function clearCache(): void;
+/**
+ * Why a property can't be written, or `null` when it's fine. Returning a reason
+ * rather than a boolean lets the caller tell an editor what to fix.
+ */
+export declare function checkProperty(properties: HsProperty[], object: HsObject, name: string): string | null;