@daeda/mcp-pro 0.1.4 → 0.1.6

package/dist/index.js

@@ -4218,9 +4218,27 @@ var FILTER_BRANCH_DESCRIPTION = `HubSpot filter definition for DYNAMIC lists. MU
 - Each AND branch: { filterBranchType: "AND", filters: [<actual filters>], filterBranches: [] }
 - For OR logic between filter groups, use multiple AND branches under the root OR.
 - For AND logic within a group, put multiple filters in the same AND branch's filters array.
-- ASSOCIATION and UNIFIED_EVENTS branches can be nested inside AND branches.
-Property filter example: { filterType: "PROPERTY", property: "lifecyclestage", operation: { operationType: "MULTISTRING", operator: "IS_EQUAL_TO", values: ["lead"] } }
-Common operationTypes: MULTISTRING (strings), NUMBER (numbers), BOOL (booleans), ENUMERATION (select/multi-select), ALL_PROPERTY (IS_KNOWN/IS_NOT_KNOWN), TIME_POINT (date comparison), TIME_RANGED (date ranges).`;
+
+operationType MUST match the HubSpot property type:
+- ENUMERATION \u2192 for enumeration properties (lifecyclestage, pipeline, dealstage, hs_lead_status, hs_pipeline, etc.). Operators: IS_ANY_OF, IS_NONE_OF, HAS_EVER_BEEN_ANY_OF, HAS_NEVER_BEEN_ANY_OF, IS_EXACTLY, IS_NOT_EXACTLY, CONTAINS_ALL_OF, DOES_NOT_CONTAIN_ALL_OF. WARNING: IS_EQUAL_TO is NOT valid for ENUMERATION \u2014 use IS_ANY_OF instead.
+- MULTISTRING \u2192 for string properties (firstname, lastname, email, city, company, etc.). Operators: IS_EQUAL_TO, IS_NOT_EQUAL_TO, CONTAINS, DOES_NOT_CONTAIN, STARTS_WITH, ENDS_WITH.
+- NUMBER \u2192 for number properties. Operators: IS_EQUAL_TO, IS_NOT_EQUAL_TO, IS_BETWEEN, IS_GREATER_THAN, IS_LESS_THAN.
+- BOOL \u2192 for boolean properties. Operators: IS_EQUAL_TO, IS_NOT_EQUAL_TO.
+- TIME_POINT \u2192 for date/datetime properties (single point comparison).
+- TIME_RANGED \u2192 for date/datetime properties (range with lowerBoundTimePoint / upperBoundTimePoint).
+- ALL_PROPERTY \u2192 any property type. Operators: IS_KNOWN, IS_UNKNOWN, IS_BLANK, IS_NOT_BLANK. WARNING: IS_NOT_KNOWN is NOT valid \u2014 use IS_UNKNOWN instead.
+Enum filter example: { filterType: "PROPERTY", property: "lifecyclestage", operation: { operationType: "ENUMERATION", operator: "IS_ANY_OF", values: ["lead"] } }
+
+ASSOCIATION branches filter by associated records and MUST include these required fields:
+- filterBranchType: "ASSOCIATION"
+- objectTypeId: the associated object type ID (e.g. "0-3" for deals)
+- operator: "IN_LIST"
+- associationTypeId: (number) the association type ID \u2014 required by HubSpot (e.g. 4 for contact\u2192deal, 1 for contact\u2192company, 5 for deal\u2192company)
+- associationCategory: (string) usually "HUBSPOT_DEFINED" (also: "USER_DEFINED", "INTEGRATOR_DEFINED")
+- filters: property filters on the associated object
+- filterBranches: [] (no further nesting except CONTACT\u2192LINE_ITEM)
+ASSOCIATION branches must be nested inside an AND branch.
+Association example: { filterBranchType: "ASSOCIATION", objectTypeId: "0-3", operator: "IN_LIST", associationTypeId: 4, associationCategory: "HUBSPOT_DEFINED", filters: [{ filterType: "PROPERTY", property: "dealstage", operation: { operationType: "ENUMERATION", operator: "IS_NONE_OF", values: ["closedwon", "closedlost"] } }], filterBranches: [] }`;
 var fields17 = [
   { name: "name", type: "string", required: true, description: "Name for the new list" },
   { name: "object_type_id", type: "string", required: true, description: "Object type ID (e.g. '0-1' for contacts, '0-2' for companies, '0-3' for deals)" },
@@ -4251,8 +4269,8 @@ For DYNAMIC lists, provide filter_branch with the HubSpot filter definition. The
                 filterType: "PROPERTY",
                 property: "lifecyclestage",
                 operation: {
-                  operationType: "MULTISTRING",
-                  operator: "IS_EQUAL_TO",
+                  operationType: "ENUMERATION",
+                  operator: "IS_ANY_OF",
                   values: ["lead"]
                 }
               }
@@ -7068,6 +7086,59 @@ var batchDeleteRecordsHandler = {
 // ../shared/operations/create-list/index.ts
 import { Effect as Effect53, pipe as pipe42 } from "effect";
 var VALID_PROCESSING_TYPES = /* @__PURE__ */ new Set(["MANUAL", "DYNAMIC"]);
+var OPERATION_TYPE_FOR_PROPERTY_TYPE = {
+  enumeration: "ENUMERATION",
+  string: "MULTISTRING",
+  number: "NUMBER",
+  bool: "BOOL",
+  date: "TIME_POINT",
+  datetime: "TIME_POINT"
+};
+var collectPropertyFilters = (branches, parentObjectTypeId) => {
+  const refs = [];
+  for (const branch of branches) {
+    const ctxObjectTypeId = branch.filterBranchType === "ASSOCIATION" && typeof branch.objectTypeId === "string" ? branch.objectTypeId : parentObjectTypeId;
+    const filters = branch.filters;
+    if (filters) {
+      for (const f of filters) {
+        if (f.filterType === "PROPERTY" && typeof f.property === "string") {
+          const op = f.operation;
+          if (op && typeof op.operationType === "string") {
+            refs.push({ property: f.property, operationType: op.operationType, objectTypeId: ctxObjectTypeId });
+          }
+        }
+      }
+    }
+    const nested = branch.filterBranches;
+    if (nested?.length) {
+      refs.push(...collectPropertyFilters(nested, ctxObjectTypeId));
+    }
+  }
+  return refs;
+};
+var collectAssociationIssues = (branches, index) => {
+  const issues = [];
+  for (const branch of branches) {
+    if (branch.filterBranchType === "ASSOCIATION") {
+      const missing = [];
+      if (branch.associationTypeId == null) missing.push("associationTypeId");
+      if (branch.associationCategory == null) missing.push("associationCategory");
+      if (missing.length > 0) {
+        issues.push({
+          severity: "error",
+          operation_index: index,
+          code: "ASSOCIATION_MISSING_REQUIRED_FIELDS",
+          message: `ASSOCIATION filter branch (objectTypeId: ${branch.objectTypeId ?? "unknown"}) is missing required field(s): ${missing.join(", ")}. ASSOCIATION branches require associationTypeId (number) and associationCategory (string, usually "HUBSPOT_DEFINED").`
+        });
+      }
+    }
+    const nested = branch.filterBranches;
+    if (nested?.length) {
+      issues.push(...collectAssociationIssues(nested, index));
+    }
+  }
+  return issues;
+};
 var createListHandler = {
   type: "create_list",
   validate: (op, index) => {
@@ -7127,27 +7198,87 @@ var createListHandler = {
             message: `Root OR branch must have an empty filters array \u2014 filters belong inside AND child branches`
           });
         }
+        if (branches?.length) {
+          issues.push(...collectAssociationIssues(branches, index));
+        }
       }
     }
     return issues;
   },
-  validateEffectful: (op, index) => pipe42(
-    HubSpotService,
-    Effect53.flatMap((hs) => hs.getLists),
-    Effect53.map((lists) => {
-      const issues = [];
-      if (lists.find((l) => l.name === op.name)) {
-        issues.push({
-          severity: "error",
-          operation_index: index,
-          code: "LIST_ALREADY_EXISTS",
-          message: `A list named '${op.name}' already exists \u2014 HubSpot may reject a duplicate`
-        });
-      }
-      return issues;
-    }),
-    catchAllToWarning("VALIDATION_API_UNAVAILABLE", index, "Unable to verify existing lists during validation (API error)")
-  ),
+  validateEffectful: (op, index) => {
+    const checkDuplicateList = pipe42(
+      HubSpotService,
+      Effect53.flatMap((hs) => hs.getLists),
+      Effect53.map((lists) => {
+        const issues = [];
+        if (lists.find((l) => l.name === op.name)) {
+          issues.push({
+            severity: "error",
+            operation_index: index,
+            code: "LIST_ALREADY_EXISTS",
+            message: `A list named '${op.name}' already exists \u2014 HubSpot may reject a duplicate`
+          });
+        }
+        return issues;
+      }),
+      catchAllToWarning("VALIDATION_API_UNAVAILABLE", index, "Unable to verify existing lists during validation (API error)")
+    );
+    const checkOperationTypes = () => {
+      if (op.processing_type !== "DYNAMIC" || !op.filter_branch) return Effect53.succeed([]);
+      const filterRefs = collectPropertyFilters(
+        op.filter_branch.filterBranches ?? [],
+        op.object_type_id
+      );
+      if (filterRefs.length === 0) return Effect53.succeed([]);
+      const uniqueObjectTypes = Array.from(new Set(filterRefs.map((r) => r.objectTypeId)));
+      return pipe42(
+        HubSpotService,
+        Effect53.flatMap(
+          (hs) => Effect53.all(
+            uniqueObjectTypes.map(
+              (ot) => pipe42(
+                hs.getObjectPropertyDefinitions(ot),
+                Effect53.map((defs) => [ot, defs])
+              )
+            ),
+            { concurrency: "unbounded" }
+          )
+        ),
+        Effect53.map((results) => {
+          const propTypeByObject = /* @__PURE__ */ new Map();
+          for (const [ot, defs] of results) {
+            const m = /* @__PURE__ */ new Map();
+            for (const d of defs) m.set(d.name, d.type);
+            propTypeByObject.set(ot, m);
+          }
+          const issues = [];
+          for (const ref of filterRefs) {
+            const propMap = propTypeByObject.get(ref.objectTypeId);
+            if (!propMap) continue;
+            const propType = propMap.get(ref.property);
+            if (!propType) continue;
+            const expected = OPERATION_TYPE_FOR_PROPERTY_TYPE[propType];
+            if (!expected) continue;
+            if (ref.operationType === expected) continue;
+            if (ref.operationType === "ALL_PROPERTY") continue;
+            if (ref.operationType === "TIME_RANGED" && (propType === "date" || propType === "datetime")) continue;
+            issues.push({
+              severity: "error",
+              operation_index: index,
+              code: "INVALID_OPERATION_TYPE",
+              message: `Property '${ref.property}' has type '${propType}' but filter uses operationType '${ref.operationType}'. Use '${expected}' instead.${propType === "enumeration" ? " For enumeration properties use operators like IS_ANY_OF, IS_NONE_OF (not IS_EQUAL_TO)." : ""}`
+            });
+          }
+          return issues;
+        }),
+        catchAllToWarning("VALIDATION_API_UNAVAILABLE", index, "Unable to verify filter operationTypes during validation (API error)")
+      );
+    };
+    return pipe42(
+      Effect53.all([checkDuplicateList, checkOperationTypes()], { concurrency: "unbounded" }),
+      Effect53.map(([dupeIssues, opTypeIssues]) => [...dupeIssues, ...opTypeIssues])
+    );
+  },
   preCheck: (op, index, seen) => pipe42(
     HubSpotService,
     Effect53.flatMap((hs) => hs.getLists),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daeda/mcp-pro",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {