snow-flow 3.6.18 → 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,50 +1037,115 @@ ${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
-                    const actionData = {
-                        // ✅ Main connection: to the variable with required IO: prefix (if valid sys_id)
-                        catalog_variable: catalogVariableWithPrefix
-                    };
-                    // ✅ CRITICAL FIX: ui_policy field expects the NAME (short_description), NOT the sys_id!
-                    // ServiceNow uses the policy name as the reference value
-                    if (args.short_description) {
-                        actionData.ui_policy = args.short_description; // ✅ Use the policy NAME, not sys_id!
-                        this.logger.info(`🔗 Linking action to policy by NAME: "${args.short_description}"`);
+                    // ✅ 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 {
-                        // Fallback if somehow we don't have the name
-                        this.logger.error(`❌ CRITICAL: No policy name (short_description) available for linking!`);
-                        actionData.ui_policy = policyId; // Use sys_id as last resort
+                        actionData.visible = 'ignore'; // Default to ignore if not specified
                     }
-                    // Voeg alleen GEDEFINIEERDE action properties toe 
                     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';
                     }
-                    if (action.value) {
-                        actionData.value = action.value;
+                    else {
+                        actionData.disabled = 'ignore'; // Default to ignore if not specified
+                    }
+                    // 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;
                         this.logger.info(`✅ Created action with sys_id: ${createdActionId}`);
-                        // 🔍 VERIFICATION: Check if action was actually created
-                        this.logger.info(`🔍 Verifying action ${i + 1} creation...`);
+                        // 🔍 VERIFICATION: Check if action was actually created AND fields are populated
+                        this.logger.info(`🔍 Verifying action ${i + 1} creation and field population...`);
                         const actionVerification = await this.client.searchRecords('catalog_ui_policy_action', `sys_id=${createdActionId}`, 1);
                         if (!actionVerification.success || actionVerification.data.result.length === 0) {
                             this.logger.error('❌ ACTION VERIFICATION FAILED: Action not found after creation!');
                             throw new Error(`Action creation verification failed - action ${i + 1} not found in database`);
                         }
-                        this.logger.info(`✅ Action ${i + 1} verified in database`);
+                        // ✅ NEW: Verify that critical fields are actually populated
+                        const createdAction = actionVerification.data.result[0];
+                        this.logger.info(`📋 Created action data:`, {
+                            sys_id: createdAction.sys_id,
+                            ui_policy: createdAction.ui_policy || '❌ EMPTY',
+                            catalog_variable: createdAction.catalog_variable || '❌ EMPTY',
+                            catalog_item: createdAction.catalog_item || '❌ EMPTY',
+                            visible: createdAction.visible,
+                            mandatory: createdAction.mandatory,
+                            disabled: createdAction.disabled
+                        });
+                        // ✅ 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!`);
+                        }
+                        // 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 (!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,
                             variable: action.catalog_variable,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "snow-flow",
-  "version": "3.6.18",
-  "description": "FUNDAMENTAL TABLE FIX - v3.6.18 corrects critical table structure: policies now created in sys_ui_policy (NOT catalog_ui_policy), conditions use IO:sys_id format, actions properly link to sys_ui_policy. This matches ServiceNow's actual catalog UI policy structure where catalog_ui_policy_action references sys_ui_policy, not catalog_ui_policy.",
+  "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": {