strapi-plugin-hubspot 0.4.2 → 0.6.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,88 @@
+/**
+ * The condition engine — pure functions, no Strapi.
+ */
+export type Primitive = string | number | boolean;
+export type Operator = "eq" | "neq" | "contains" | "empty" | "notEmpty" | "gt" | "lt";
+export interface Rule {
+    /** Stable id (`fld_…`) of the field the rule reads — never its name. */
+    field: string;
+    operator: Operator;
+    value?: string;
+}
+export interface Condition {
+    logic: "and" | "or";
+    rules: Rule[];
+}
+export interface FormFieldDef {
+    id: string;
+    name: string;
+    label?: string;
+    type: string;
+    required?: boolean;
+    visibleIf?: Condition | null;
+    [key: string]: unknown;
+}
+export interface FormStepDef {
+    id: string;
+    title?: string;
+    visibleIf?: Condition | null;
+    fields: FormFieldDef[];
+    [key: string]: unknown;
+}
+export interface FormDefinition {
+    version: 1;
+    steps: FormStepDef[];
+}
+export interface SubmissionResolution {
+    /** Visible, non-empty values keyed by field name. */
+    values: Record<string, Primitive>;
+    /** Names of fields masked by a condition (their values were discarded). */
+    hidden: string[];
+    /** Visible required fields the submission left empty. */
+    missingRequired: {
+        id: string;
+        name: string;
+        label: string;
+    }[];
+    /** Submitted keys the definition doesn't declare (discarded). */
+    unknown: string[];
+}
+export type DefinitionError = {
+    code: "duplicate-name";
+    fieldId: string;
+    name: string;
+} | {
+    code: "missing-name";
+    fieldId: string;
+    name: string;
+} | {
+    code: "unknown-field";
+    fieldId?: string;
+    stepId?: string;
+    target: string;
+} | {
+    code: "forward-reference";
+    fieldId?: string;
+    stepId?: string;
+    target: string;
+} | {
+    code: "missing-value";
+    fieldId?: string;
+    stepId?: string;
+    target: string;
+};
+/**
+ * Structural check of a definition — what the builder enforces, re-checked
+ * server-side so a hand-crafted PUT can't save a form the engine can't run:
+ * unique non-empty names, and conditions that only look back.
+ */
+export declare function validateDefinition(definition: FormDefinition): DefinitionError[];
+/** An absent condition, or one with no rules, never hides anything. */
+export declare function evaluateCondition(condition: Condition | null | undefined, get: (fieldId: string) => unknown): boolean;
+/**
+ * Single pass in document order. The builder only lets a rule reference an
+ * earlier field, so by the time a condition is evaluated every field it can
+ * read has already been resolved — and a hidden one reads as `undefined`,
+ * which cascades: fields depending on it fall with it.
+ */
+export declare function resolveSubmission(definition: FormDefinition, rawValues: Record<string, unknown>): SubmissionResolution;

package/dist/server/src/content-types.d.ts

@@ -1,13 +1,165 @@
-/**
- * The dead-letter queue for submissions HubSpot couldn't take: transient
- * failures land here after the in-process retries are exhausted, and
- * `retryFailures()` replays them.
- *
- * Visible in the Content Manager on purpose — an admin can inspect a stuck
- * payload and delete it — but hidden from the Content-Type Builder: its shape
- * belongs to the plugin.
- */
 declare const _default: {
+    /**
+     * A form built in the plugin's builder page. The flat, queryable identity
+     * lives as attributes; the structure (steps → fields → conditions) lives in
+     * `definition`, a versioned JSON document — plugins cannot ship components,
+     * and the builder is a better editor for it than the Content Manager, which
+     * is why the type is hidden there.
+     */
+    form: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+                i18n: {
+                    localized: boolean;
+                };
+            };
+            attributes: {
+                name: {
+                    type: string;
+                    required: boolean;
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                slug: {
+                    type: string;
+                    targetField: string;
+                    required: boolean;
+                };
+                title: {
+                    type: "string" | "text";
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                subtitle: {
+                    type: "string" | "text";
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                nextLabel: {
+                    type: "string" | "text";
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                submitLabel: {
+                    type: "string" | "text";
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                successMessage: {
+                    type: "string" | "text";
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+                definition: {
+                    type: string;
+                    required: boolean;
+                    pluginOptions: {
+                        i18n: {
+                            localized: boolean;
+                        };
+                    };
+                };
+            };
+        };
+    };
+    /**
+     * One visitor submission of a built form — the source of truth for the
+     * lead, stored whatever the CRM's mood. Visible in the Content Manager so
+     * the team can browse and export; hidden from the Content-Type Builder.
+     */
+    submission: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+                description: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                form: {
+                    type: string;
+                    required: boolean;
+                };
+                formTitle: {
+                    type: string;
+                };
+                email: {
+                    type: string;
+                };
+                values: {
+                    type: string;
+                    required: boolean;
+                };
+                meta: {
+                    type: string;
+                };
+                locale: {
+                    type: string;
+                };
+                hubspotSynced: {
+                    type: string;
+                    default: boolean;
+                };
+                contactId: {
+                    type: string;
+                };
+                companyId: {
+                    type: string;
+                };
+                rejected: {
+                    type: string;
+                };
+            };
+        };
+    };
     failure: {
         schema: {
             kind: string;

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

@@ -0,0 +1,81 @@
+/**
+ * The form-builder server side: shaping a published form for the public API,
+ * and turning a submission into HubSpot upserts.
+ *
+ * The pipeline mirrors what a B2B lead capture needs: the person is upserted
+ * as a Contact (email is the dedup key); when the email is on a corporate
+ * domain the company is found-or-created by `domain` and associated to the
+ * contact; a timeline note recaps the whole submission for whoever picks the
+ * lead up. Company and note are best-effort — the contact is the lead.
+ */
+import type { Core } from "@strapi/strapi";
+import { type FormDefinition, type Primitive } from "./conditions";
+import { checkMapping, type Problem } from "./properties";
+export interface FormEntry {
+    name: string;
+    slug: string;
+    title?: string | null;
+    subtitle?: string | null;
+    nextLabel?: string | null;
+    submitLabel?: string | null;
+    successMessage?: string | null;
+    locale?: string | null;
+    definition: FormDefinition;
+    [key: string]: unknown;
+}
+export interface PublicForm {
+    slug: string;
+    title?: string | null;
+    subtitle?: string | null;
+    nextLabel?: string | null;
+    submitLabel?: string | null;
+    successMessage?: string | null;
+    locale?: string | null;
+    steps: FormDefinition["steps"];
+}
+/** The public shape: rendering meta + structure, minus the CRM mapping. */
+export declare function publicForm(entry: FormEntry): PublicForm;
+/**
+ * Resolved values → one property bag per CRM object. A field with no mapping
+ * writes to `contact` under its own name, like the legacy pipeline did.
+ */
+export declare function groupByObject(definition: FormDefinition, values: Record<string, Primitive>): Record<string, Record<string, Primitive>>;
+/**
+ * Every CRM mapping of a definition, checked against the portal schema — the
+ * builder's save-time equivalent of the content-type validation middleware.
+ * A select's own options are checked against the enumeration too.
+ */
+export declare function mappingProblems(definition: FormDefinition, portalProperties: Parameters<typeof checkMapping>[0]): (Problem & {
+    fieldId: string;
+})[];
+/** First value that looks like an email — the field named `email` wins. */
+export declare function findEmail(values: Record<string, unknown>): string | undefined;
+export declare function corporateDomain(email?: string): string | undefined;
+export declare const SUBMISSION_UID = "plugin::hubspot.submission";
+/**
+ * The raw request body → a flat bag of primitives, or null when the shape is
+ * abusive (not an object, too many keys). Non-primitive values are dropped —
+ * the definition decides what counts anyway — and long strings are clipped.
+ */
+export declare function sanitizeRawValues(raw: unknown): Record<string, Primitive> | null;
+export interface SubmitMeta {
+    pagePath?: string;
+    pageUrl?: string;
+    originPath?: string;
+    originLabel?: string;
+    [key: string]: unknown;
+}
+export interface SubmitOutcome {
+    ok: boolean;
+    hubspotSynced?: boolean;
+    missingRequired?: {
+        id: string;
+        name: string;
+        label: string;
+    }[];
+}
+export declare function createFormsService(strapi: Core.Strapi, _opts?: {
+    sleep?: (ms: number) => Promise<void>;
+}): {
+    submit: (form: FormEntry, rawValues: Record<string, unknown>, meta?: SubmitMeta) => Promise<SubmitOutcome>;
+};

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

@@ -0,0 +1,39 @@
+/**
+ * The builder's own API — admin routes consumed by the Forms page. CRUD over
+ * `plugin::hubspot.form` through the Document Service (drafts, locales,
+ * publish), with the structural check and the mapping check applied where the
+ * Content Manager middleware can't reach: this content type is hidden there,
+ * the builder is its only editor.
+ */
+import type { Core } from "@strapi/strapi";
+export declare const FORM_UID = "plugin::hubspot.form";
+export interface Ctx {
+    params: {
+        documentId?: string;
+    };
+    query: {
+        locale?: string;
+    };
+    request: {
+        body?: Record<string, unknown>;
+    };
+    body: unknown;
+    throw: (status: number, message: string) => never;
+}
+export declare function createFormsAdminController(strapi: Core.Strapi): {
+    list(ctx: Ctx): Promise<void>;
+    findOne(ctx: Ctx): Promise<void>;
+    create(ctx: Ctx): Promise<void>;
+    update(ctx: Ctx): Promise<void>;
+    publish(ctx: Ctx): Promise<void>;
+    unpublish(ctx: Ctx): Promise<void>;
+    /** Entries of the configured legacy content type, offered for import. */
+    listSources(ctx: Ctx): Promise<void>;
+    /**
+     * Converts one legacy entry (every locale of it) into a plugin form
+     * draft. Same slug: re-importing overwrites the draft, never touches the
+     * published version, and never modifies the source.
+     */
+    runImport(ctx: Ctx): Promise<void>;
+    remove(ctx: Ctx): Promise<void>;
+};

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

@@ -0,0 +1,25 @@
+/**
+ * Conversion of a host-app form entry (content type + components) into the
+ * plugin's definition model — the migration path for forms built before the
+ * builder existed. The attribute names default to the shape this plugin's
+ * README always documented (steps/fields, hsObject/hsProperty) and every one
+ * of them can be remapped for a different host schema.
+ */
+import type { FormDefinition } from "./conditions";
+export interface ImportMap {
+    steps?: string;
+    fields?: string;
+    step?: Partial<Record<"title" | "description" | "class", string>>;
+    field?: Partial<Record<"label" | "name" | "object" | "property" | "type" | "placeholder" | "required" | "icon" | "options" | "width" | "helpText" | "class" | "persist", string>>;
+}
+export interface ConvertedForm {
+    name: string;
+    slug: string;
+    title?: string | null;
+    subtitle?: string | null;
+    nextLabel?: string | null;
+    submitLabel?: string | null;
+    successMessage?: string | null;
+    definition: FormDefinition;
+}
+export declare function convertLegacyForm(entry: Record<string, unknown>, map?: ImportMap): ConvertedForm;

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

@@ -1,4 +1,5 @@
 import type { Core } from "@strapi/strapi";
+import { type FormEntry, type SubmitMeta } from "./forms";
 import { type ValidateTarget } from "./validation";
 declare const _default: {
     config: {
@@ -6,29 +7,166 @@ declare const _default: {
             apiKey: string;
             objects: unknown[];
             validate: ValidateTarget[];
+            forms: {
+                companyFromDomain: boolean;
+                timelineNote: boolean;
+            };
         };
         validator(cfg: {
             validate?: unknown;
         }): void;
     };
     contentTypes: {
+        form: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string; /** RBAC action gating the settings screen and its routes. */
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                    i18n: {
+                        localized: boolean;
+                    };
+                };
+                attributes: {
+                    name: {
+                        type: string;
+                        required: boolean;
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    slug: {
+                        type: string;
+                        targetField: string;
+                        required: boolean;
+                    };
+                    title: {
+                        type: "string" | "text";
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    subtitle: {
+                        type: "string" | "text";
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    nextLabel: {
+                        type: "string" | "text";
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    submitLabel: {
+                        type: "string" | "text";
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    successMessage: {
+                        type: "string" | "text";
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                    definition: {
+                        type: string;
+                        required: boolean;
+                        pluginOptions: {
+                            i18n: {
+                                localized: boolean;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        submission: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    form: {
+                        type: string;
+                        required: boolean;
+                    };
+                    formTitle: {
+                        type: string;
+                    };
+                    email: {
+                        type: string;
+                    };
+                    values: {
+                        type: string;
+                        required: boolean;
+                    };
+                    meta: {
+                        type: string;
+                    };
+                    locale: {
+                        type: string;
+                    };
+                    hubspotSynced: {
+                        type: string;
+                        default: boolean;
+                    };
+                    contactId: {
+                        type: string;
+                    };
+                    companyId: {
+                        type: string;
+                    };
+                    rejected: {
+                        type: string;
+                    };
+                };
+            };
+        };
         failure: {
-            /**
-             * 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.
-             */
-            /** RBAC action gating the settings screen and its routes. */
             schema: {
                 kind: string;
                 collectionName: string;
@@ -103,6 +241,50 @@ declare const _default: {
                 body: unknown;
             }): Promise<void>;
         };
+        formsAdmin: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            list(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            findOne(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            create(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            update(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            publish(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            unpublish(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            listSources(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            runImport(ctx: import("./formsAdmin").Ctx): Promise<void>;
+            remove(ctx: import("./formsAdmin").Ctx): Promise<void>;
+        };
+        forms: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            /** Published form for the host frontend — CRM mapping stripped. */
+            findOne(ctx: {
+                params: {
+                    slug: string;
+                };
+                query: {
+                    locale?: string;
+                };
+                body: unknown;
+                throw: (s: number, m: string) => never;
+            }): Promise<void>;
+            submit(ctx: {
+                params: {
+                    slug: string;
+                };
+                query: {
+                    locale?: string;
+                };
+                request: {
+                    body?: {
+                        values?: unknown;
+                        meta?: Record<string, unknown>;
+                    };
+                };
+                body: unknown;
+                throw: (s: number, m: string) => never;
+            }): Promise<void>;
+        };
         settings: ({ strapi }: {
             strapi: Core.Strapi;
         }) => {
@@ -139,6 +321,17 @@ declare const _default: {
                 };
             }[];
         };
+        "content-api": {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: any[];
+                };
+            }[];
+        };
     };
     services: {
         submit: ({ strapi }: {
@@ -155,6 +348,11 @@ declare const _default: {
                 failed: number;
             }>;
         };
+        forms: ({ strapi }: {
+            strapi: Core.Strapi;
+        }) => {
+            submit: (form: FormEntry, rawValues: Record<string, unknown>, meta?: SubmitMeta) => Promise<import("./forms").SubmitOutcome>;
+        };
     };
     register({ strapi }: {
         strapi: Core.Strapi;