@daeda/mcp-pro 0.1.1 → 0.1.5

package/dist/index.js

@@ -4190,31 +4190,94 @@ var batchDeleteRecordsMeta = {
 
 // ../shared/operations/create-list/meta.ts
 import { z as z28 } from "zod";
+var FilterSchema = z28.object({
+  filterType: z28.string(),
+  property: z28.string().optional(),
+  operation: z28.record(z28.unknown()).optional()
+}).passthrough();
+var FilterBranchSchema = z28.object({
+  filterBranchType: z28.enum(["AND", "ASSOCIATION", "UNIFIED_EVENTS"]),
+  filterBranches: z28.lazy(() => z28.array(FilterBranchSchema)).default([]),
+  filters: z28.array(FilterSchema).default([])
+}).passthrough();
+var RootFilterBranchSchema = z28.object({
+  filterBranchType: z28.literal("OR"),
+  filterBranches: z28.array(FilterBranchSchema).min(1),
+  filters: z28.array(FilterSchema).default([])
+}).passthrough();
 var CreateListOperationSchema = z28.object({
   type: z28.literal("create_list"),
   description: z28.string().min(1),
   name: z28.string().min(1),
   object_type_id: z28.string().min(1),
   processing_type: z28.enum(["MANUAL", "DYNAMIC"]),
-  filter_branch: z28.record(z28.unknown()).optional()
+  filter_branch: RootFilterBranchSchema.optional()
 });
+var FILTER_BRANCH_DESCRIPTION = `HubSpot filter definition for DYNAMIC lists. MUST follow the OR\u2192AND hierarchy:
+- Root: { filterBranchType: "OR", filters: [], filterBranches: [<one or more AND branches>] }
+- 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.
+
+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, for IS_KNOWN / IS_NOT_KNOWN checks.
+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)" },
+  { 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)" },
   { name: "processing_type", type: "string", required: true, description: "List type: 'MANUAL' (static) or 'DYNAMIC' (active)" },
-  { name: "filter_branch", type: "object", required: false, description: "HubSpot filter definition for DYNAMIC lists (passed as-is to API)" }
+  { name: "filter_branch", type: "object", required: false, description: FILTER_BRANCH_DESCRIPTION }
 ];
 var createListMeta = {
   type: "create_list",
   category: "create",
   summary: "Create a contact or company list (static or dynamic)",
-  description: "Create a new HubSpot list. MANUAL lists are static (members added manually). DYNAMIC lists are active (membership determined by filter criteria). For DYNAMIC lists, provide filter_branch with the HubSpot filter definition.",
+  description: `Create a new HubSpot list. MANUAL lists are static (members added manually). DYNAMIC lists are active (membership determined by filter criteria).
+For DYNAMIC lists, provide filter_branch with the HubSpot filter definition. The root filterBranchType MUST be "OR" with filters: [] and one or more "AND" child branches containing the actual filters. This structure is enforced by HubSpot's API.`,
   fields: fields17,
   example: {
     fields: {
-      name: "Hot Leads",
+      name: "Active Leads",
       object_type_id: "0-1",
-      processing_type: "MANUAL"
+      processing_type: "DYNAMIC",
+      filter_branch: {
+        filterBranchType: "OR",
+        filters: [],
+        filterBranches: [
+          {
+            filterBranchType: "AND",
+            filterBranches: [],
+            filters: [
+              {
+                filterType: "PROPERTY",
+                property: "lifecyclestage",
+                operation: {
+                  operationType: "ENUMERATION",
+                  operator: "IS_ANY_OF",
+                  values: ["lead"]
+                }
+              }
+            ]
+          }
+        ]
+      }
     }
   },
   toNested: (description, fields29) => {
@@ -4230,13 +4293,21 @@ var createListMeta = {
   },
   requiredScopes: () => ["crm.lists.write"],
   getSummary: (op) => `Create List \u2014 ${op.name} (${op.processing_type})`,
-  getResourceUrl: (portalId) => `${HUBSPOT_BASE}/contacts/${portalId}/lists`,
+  getResourceUrl: (portalId) => `${HUBSPOT_BASE}/contacts/${portalId}/objectLists/views/all`,
   renderDetails: (op) => {
     const rows = [
       { label: "Name", value: op.name },
       { label: "Object Type ID", value: op.object_type_id },
       { label: "Processing Type", value: op.processing_type }
     ];
+    if (op.filter_branch) {
+      const andCount = op.filter_branch.filterBranches?.length ?? 0;
+      const totalFilters = op.filter_branch.filterBranches?.reduce(
+        (sum, branch) => sum + (branch.filters?.length ?? 0),
+        0
+      ) ?? 0;
+      rows.push({ label: "Filter Groups", value: `${andCount} group(s), ${totalFilters} filter(s)` });
+    }
     return { rows };
   }
 };
@@ -7015,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) => {
@@ -7027,25 +7151,134 @@ var createListHandler = {
         message: `Processing type '${op.processing_type}' is invalid \u2014 must be "MANUAL" or "DYNAMIC"`
       });
     }
-    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)) {
+    if (op.processing_type === "DYNAMIC" && !op.filter_branch) {
+      issues.push({
+        severity: "warning",
+        operation_index: index,
+        code: "DYNAMIC_LIST_NO_FILTER",
+        message: `DYNAMIC list '${op.name}' has no filter_branch \u2014 it will match all records of the object type`
+      });
+    }
+    if (op.filter_branch) {
+      const result = RootFilterBranchSchema.safeParse(op.filter_branch);
+      if (!result.success) {
+        const zodIssues = result.error.issues.map((i) => i.message).join("; ");
         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`
+          code: "INVALID_FILTER_BRANCH",
+          message: `filter_branch is invalid: ${zodIssues}. Root must be { filterBranchType: "OR", filters: [], filterBranches: [{ filterBranchType: "AND", filters: [...], filterBranches: [] }] }`
         });
+      } else {
+        const fb = op.filter_branch;
+        if (fb.filterBranchType !== "OR") {
+          issues.push({
+            severity: "error",
+            operation_index: index,
+            code: "INVALID_FILTER_BRANCH_ROOT",
+            message: `Root filterBranchType must be "OR", got "${fb.filterBranchType}"`
+          });
+        }
+        const branches = fb.filterBranches;
+        const hasAndBranch = branches?.some((b) => b.filterBranchType === "AND");
+        if (!hasAndBranch) {
+          issues.push({
+            severity: "error",
+            operation_index: index,
+            code: "INVALID_FILTER_BRANCH_NO_AND",
+            message: `Root OR branch must contain at least one AND child branch`
+          });
+        }
+        const rootFilters = fb.filters;
+        if (rootFilters && rootFilters.length > 0) {
+          issues.push({
+            severity: "error",
+            operation_index: index,
+            code: "INVALID_FILTER_BRANCH_ROOT_FILTERS",
+            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;
-    }),
-    catchAllToWarning("VALIDATION_API_UNAVAILABLE", index, "Unable to verify existing lists during validation (API error)")
-  ),
+    }
+    return issues;
+  },
+  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.1",
+  "version": "0.1.5",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {