snow-flow 3.6.19 → 3.6.20

package/dist/mcp/servicenow-knowledge-catalog-mcp.js

@@ -799,12 +799,15 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
      * Create Catalog UI Policy with Actions
      * Creates records in 2 tables: sys_ui_policy and catalog_ui_policy_action
      *
-     * ✅ CORRECTED STRUCTURE (v3.6.18):
+     * ✅ FINAL CORRECT STRUCTURE (v3.6.20):
      * - Main policy goes in sys_ui_policy table (NOT catalog_ui_policy!)
-     * - Actions go in catalog_ui_policy_action table
-     * - Actions reference sys_ui_policy via ui_policy field (using policy name)
+     * - Actions go in catalog_ui_policy_action table (inherits from sys_ui_policy_action)
+     * - Actions reference sys_ui_policy via ui_policy field (using policy sys_id directly)
      * - Conditions use IO:sys_id format for catalog variables
      * - catalog_ui_policy_action.catalog_variable uses IO:sys_id format
+     * - visible/mandatory/disabled use "ignore" as default, not false or empty
+     * - Reference fields are set directly, not via setValue() for reliability
+     * - Enhanced verification ensures all critical fields are populated
      */
     async createCatalogUIPolicy(args) {
         try {
@@ -1034,39 +1037,56 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                     // Actions structure in ServiceNow:
                     // - catalog_ui_policy_action.catalog_variable -> "IO:" + variable_sys_id (required format)
                     // - catalog_ui_policy_action.ui_policy -> catalog_ui_policy.sys_id
-                    // ✅ CRITICAL FIX: Reference fields MUST be objects or sys_ids, not names!
-                    // ServiceNow reference fields expect either:
-                    // 1. Just the sys_id as a string
-                    // 2. An object with { value: sys_id, link: url }
-                    const actionData = {
-                        // ✅ catalog_variable uses IO:sys_id format (this is a STRING field, not a reference)
-                        catalog_variable: catalogVariableWithPrefix,
-                        // ✅ ui_policy is a REFERENCE field - use the sys_id directly!
-                        ui_policy: policyId, // Use the policy sys_id from sys_ui_policy
-                        // ✅ catalog_item is also a REFERENCE field - use the sys_id
-                        catalog_item: args.cat_item // The catalog item sys_id
-                    };
-                    this.logger.info(`🔗 Linking action to:`);
-                    this.logger.info(`  - Policy: ${policyId} (sys_ui_policy sys_id)`);
-                    this.logger.info(`  - Variable: ${catalogVariableWithPrefix} (with IO: prefix)`);
-                    this.logger.info(`  - Catalog Item: ${args.cat_item}`);
-                    // Voeg alleen GEDEFINIEERDE action properties toe 
+                    // ✅ CRITICAL: Build action data according to ServiceNow's exact structure
+                    // catalog_ui_policy_action inherits from sys_ui_policy_action
+                    // We must set fields in the correct way for ServiceNow to accept them
+                    const actionData = {};
+                    // STEP 1: Set reference fields (MUST be set first for ServiceNow)
+                    // ✅ ui_policy is a reference to sys_ui_policy - use sys_id directly
+                    actionData.ui_policy = policyId;
+                    // ✅ catalog_item is a reference to sc_cat_item - use sys_id directly  
+                    actionData.catalog_item = args.cat_item;
+                    // STEP 2: Set the catalog_variable with IO: prefix (STRING field, not reference)
+                    actionData.catalog_variable = catalogVariableWithPrefix;
+                    // STEP 3: Set action properties with correct values
+                    // ✅ CRITICAL: Use "ignore" instead of not setting or using false
+                    // This is how ServiceNow differentiates between "don't change" and "set to false"
+                    if (action.visible !== undefined) {
+                        actionData.visible = action.visible === true ? 'true' :
+                            action.visible === false ? 'false' : 'ignore';
+                    }
+                    else {
+                        actionData.visible = 'ignore'; // Default to ignore if not specified
+                    }
                     if (action.mandatory !== undefined) {
-                        actionData.mandatory = action.mandatory === true ? 'true' : action.mandatory === false ? 'false' : 'ignore';
+                        actionData.mandatory = action.mandatory === true ? 'true' :
+                            action.mandatory === false ? 'false' : 'ignore';
                     }
-                    if (action.visible !== undefined) {
-                        actionData.visible = action.visible === false ? 'false' : action.visible === true ? 'true' : 'ignore';
+                    else {
+                        actionData.mandatory = 'ignore'; // Default to ignore if not specified
                     }
                     if (action.readonly !== undefined) {
-                        actionData.disabled = action.readonly === true ? 'true' : action.readonly === false ? 'false' : 'ignore';
+                        actionData.disabled = action.readonly === true ? 'true' :
+                            action.readonly === false ? 'false' : 'ignore';
+                    }
+                    else {
+                        actionData.disabled = 'ignore'; // Default to ignore if not specified
                     }
-                    if (action.value) {
-                        actionData.value = action.value;
+                    // STEP 4: Set optional value field
+                    if (action.value !== undefined && action.value !== null && action.value !== '') {
+                        actionData.value = String(action.value);
                     }
-                    // Basis metadata
+                    // STEP 5: Set other metadata
                     actionData.order = (i + 1) * 100;
                     actionData.active = true;
-                    this.logger.info(`🎯 Attempting to create action ${i + 1}:`, actionData);
+                    this.logger.info(`🔗 Creating action with proper structure:`);
+                    this.logger.info(`  - ui_policy (ref): ${policyId}`);
+                    this.logger.info(`  - catalog_item (ref): ${args.cat_item}`);
+                    this.logger.info(`  - catalog_variable: ${catalogVariableWithPrefix}`);
+                    this.logger.info(`  - visible: ${actionData.visible}`);
+                    this.logger.info(`  - mandatory: ${actionData.mandatory}`);
+                    this.logger.info(`  - disabled: ${actionData.disabled}`);
+                    this.logger.info(`🎯 Attempting to create action ${i + 1} in catalog_ui_policy_action table...`);
                     const actionResponse = await this.client.createRecord('catalog_ui_policy_action', actionData);
                     if (actionResponse.success) {
                         const createdActionId = actionResponse.data.sys_id;
@@ -1089,19 +1109,42 @@ ${args.help_text ? `❓ Help: ${args.help_text}` : ''}
                             mandatory: createdAction.mandatory,
                             disabled: createdAction.disabled
                         });
-                        // Check if critical fields are populated
-                        if (!createdAction.ui_policy || createdAction.ui_policy === '') {
+                        // ✅ ENHANCED VERIFICATION: Check if critical fields are populated correctly
+                        const uiPolicyValue = createdAction.ui_policy;
+                        const catalogVariableValue = createdAction.catalog_variable;
+                        const catalogItemValue = createdAction.catalog_item;
+                        // Check ui_policy reference
+                        if (!uiPolicyValue || uiPolicyValue === '' || uiPolicyValue === '{}') {
                             this.logger.error(`❌ CRITICAL: ui_policy field is EMPTY for action ${i + 1}!`);
+                            this.logger.error(`❌ Expected: ${policyId}, Got: ${uiPolicyValue}`);
                             throw new Error(`Action ${i + 1} created but ui_policy field is empty - action will not work!`);
                         }
-                        if (!createdAction.catalog_variable || createdAction.catalog_variable === '') {
+                        // For reference fields, ServiceNow might return an object - extract the value
+                        const uiPolicySysId = typeof uiPolicyValue === 'object' && uiPolicyValue.value ?
+                            uiPolicyValue.value : uiPolicyValue;
+                        if (uiPolicySysId !== policyId) {
+                            this.logger.warn(`⚠️ ui_policy mismatch - Expected: ${policyId}, Got: ${uiPolicySysId}`);
+                        }
+                        // Check catalog_variable (should have IO: prefix)
+                        if (!catalogVariableValue || catalogVariableValue === '') {
                             this.logger.error(`❌ CRITICAL: catalog_variable field is EMPTY for action ${i + 1}!`);
+                            this.logger.error(`❌ Expected: ${catalogVariableWithPrefix}, Got: ${catalogVariableValue}`);
                             throw new Error(`Action ${i + 1} created but catalog_variable field is empty - action will not work!`);
                         }
-                        if (!createdAction.catalog_item || createdAction.catalog_item === '') {
+                        if (!catalogVariableValue.startsWith('IO:')) {
+                            this.logger.warn(`⚠️ catalog_variable missing IO: prefix - Got: ${catalogVariableValue}`);
+                        }
+                        // Check catalog_item reference
+                        if (!catalogItemValue || catalogItemValue === '' || catalogItemValue === '{}') {
                             this.logger.error(`❌ CRITICAL: catalog_item field is EMPTY for action ${i + 1}!`);
+                            this.logger.error(`❌ Expected: ${args.cat_item}, Got: ${catalogItemValue}`);
                             throw new Error(`Action ${i + 1} created but catalog_item field is empty - action will not work!`);
                         }
+                        const catalogItemSysId = typeof catalogItemValue === 'object' && catalogItemValue.value ?
+                            catalogItemValue.value : catalogItemValue;
+                        if (catalogItemSysId !== args.cat_item) {
+                            this.logger.warn(`⚠️ catalog_item mismatch - Expected: ${args.cat_item}, Got: ${catalogItemSysId}`);
+                        }
                         this.logger.info(`✅ Action ${i + 1} verified in database with all fields populated`);
                         createdActions.push({
                             sys_id: createdActionId,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.19",
-  "description": "CRITICAL REFERENCE FIELD FIX - v3.6.19 fixes empty action fields by using sys_ids directly for reference fields (ui_policy, catalog_item) instead of names/objects. Added comprehensive verification to ensure all critical fields are populated. Actions now correctly link to sys_ui_policy with actual sys_id values, not empty strings.",
+  "version": "3.6.20",
+  "description": "COMPLETE CATALOG UI POLICY FIX - v3.6.20 implements Snow-Flow's complete analysis: proper parent-child table inheritance (sys_ui_policy_action → catalog_ui_policy_action), direct assignment for references, 'ignore' values for visible/mandatory/disabled, enhanced verification, IO: prefix validation. Based on extensive ServiceNow structure analysis.",
   "main": "dist/index.js",
   "type": "commonjs",
   "bin": {