@servicenow/sdk-build-plugins 4.3.0 → 4.4.0

package/src/flow/plugins/flow-instance-plugin.ts

@@ -1,5 +1,7 @@
 import {
     CallExpressionShape,
+    type Database,
+    type Diagnostics,
     DurationShape,
     type Factory,
     IdentifierShape,
@@ -26,10 +28,17 @@ import { resolveComplexInput as _resolveComplexInput } from '../utils/complex-ob
 import {
     getCoreActionIdentifier,
     getDirectVariableIdentifier,
+    getIdentifierFromRecord,
     getIdentifierFromShape,
     resolveDataPillShape,
     sysIdToUuid,
 } from '../utils/utils'
+import {
+    convertSlushBucketToCatalogVariableArray,
+    createTemplateExpressionFromIdentifier,
+    findCatalogItemBySysId,
+    isCatalogAction,
+} from '../utils/service-catalog'
 import { getAttributeValue } from '../utils/schema-to-flow-object'
 import {
     ActionSubflowInstanceShape,
@@ -44,6 +53,7 @@ import {
     ACTION_INSTANCE_API_NAME,
     APPROVAL_RULES_DATA_TYPE_VALUE,
     APPROVAL_DUE_DATE_DATA_TYPE_VALUE,
+    CORE_ACTIONS_SYS_ID_NAME_MAP,
     DURATION_DATA_TYPE_VALUE,
     SUBFLOW_INSTANCE_API_NAME,
     TEMPLATE_DATA_TYPE_VALUE,
@@ -52,7 +62,10 @@ import {
     UTC_TIMEZONE_VALUE,
     APPROVAL_DUE_DATE_INPUT_FIELD_ACTIONS,
     ACTION_TYPE_KEY_NAME,
+    CATALOG_VARIABLE_TABLE,
+    CATALOG_VARIABLE_SET_TABLE,
 } from '../utils/flow-constants'
+
 import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
 import type { Duration } from '@servicenow/sdk-core/runtime/db'
 
@@ -304,8 +317,10 @@ function buildInstanceToShape({
         let inputsShape = buildInputsShapeFromZipped({
             zippedInputs,
             definitionInputs,
+            actionDefinition: instanceDef,
             record,
             logger,
+            database,
         })
         if (inputsShape === undefined) {
             return { success: false as const }
@@ -361,6 +376,79 @@ function buildInstanceToShape({
     }
 }
 
+/**
+ * Validates that all property accesses on a getCatalogVariables action output variable
+ * are declared in its catalog_variables input.
+ *
+ * Runs once per getCatalogVariables action instance (forward search from declaration to usages)
+ * rather than once per template expression (backward search from usage to declaration).
+ */
+function validateCatalogVariableOutputReferences(
+    callExpression: ActionSubflowInstanceShape,
+    instanceInputs: ObjectShape,
+    diagnostics: Diagnostics
+): void {
+    // Extract allowed variable names from the catalog_variables input
+    const catalogVarsShape = instanceInputs.get('catalog_variables')
+    if (!catalogVarsShape) {
+        return
+    }
+
+    const allowedVariables: string[] = []
+    if (catalogVarsShape.isArray()) {
+        for (const el of catalogVarsShape.asArray().getElements(false)) {
+            if (el instanceof PropertyAccessShape) {
+                const propElements = el.getElements()
+                const lastEl = propElements[propElements.length - 1]
+                if (lastEl instanceof IdentifierShape) {
+                    allowedVariables.push(lastEl.getName())
+                }
+            }
+        }
+    }
+
+    if (allowedVariables.length === 0) {
+        return
+    }
+
+    // Navigate from the wfa.action(...) call to its parent variable declaration
+    const originalNode = callExpression.getOriginalNode()
+    if (!ts.Node.isCallExpression(originalNode)) {
+        return
+    }
+
+    const parent = originalNode.getParent()
+    if (!ts.Node.isVariableDeclaration(parent)) {
+        return
+    }
+
+    const nameNode = parent.getNameNode()
+    if (!ts.Node.isIdentifier(nameNode)) {
+        return
+    }
+
+    // Find all references to the action output variable and validate each property access
+    for (const ref of nameNode.findReferencesAsNodes()) {
+        const refParent = ref.getParent()
+        if (!ts.Node.isPropertyAccessExpression(refParent)) {
+            continue
+        }
+        if (refParent.getExpression() !== ref) {
+            continue
+        } // ref must be the object base, not the property name
+
+        const propertyName = refParent.getName()
+        if (propertyName && !allowedVariables.includes(propertyName)) {
+            diagnostics.error(
+                catalogVarsShape,
+                `Property '${propertyName}' is not available in the getCatalogVariables output. ` +
+                    `Only the following variables are accessible: ${allowedVariables.join(', ')}. ` +
+                    `Please add '${propertyName}' to the catalog_variables input if you need to access it.`
+            )
+        }
+    }
+}
+
 export const FlowInstancePlugin = Plugin.create({
     name: 'FlowInstancePlugin',
     records: {
@@ -411,6 +499,15 @@ export const FlowInstancePlugin = Plugin.create({
                 let instanceRecord: Record | undefined
 
                 if (instanceType === ACTION_INSTANCE_API_NAME) {
+                    // Validate getCatalogVariables output references once, from the declaration
+                    if (instanceParentDef?.isRecord()) {
+                        const actionSysId = instanceParentDef.as(Record).getId().getValue()
+                        const actionName = CORE_ACTIONS_SYS_ID_NAME_MAP[actionSysId]
+                        if (actionName === 'getCatalogVariables') {
+                            validateCatalogVariableOutputReferences(callExpression, instanceInputs, diagnostics)
+                        }
+                    }
+
                     instanceRecord = await buildActionInstance({
                         actionDef: instanceParentDef,
                         inputs: instanceInputs,
@@ -485,13 +582,17 @@ function buildInlineScriptShapeFromXml(
 function buildInputsShapeFromZipped({
     zippedInputs,
     definitionInputs,
+    actionDefinition,
     record,
     logger,
+    database,
 }: {
     zippedInputs: string
     definitionInputs: Record[] | undefined
+    actionDefinition: Shape | undefined
     record: Record
     logger: Logger
+    database?: Database
 }): ObjectShape | undefined {
     if (!zippedInputs) {
         return undefined
@@ -509,6 +610,21 @@ function buildInputsShapeFromZipped({
             parameter: { type: string; attributes: { [key: string]: unknown } }
         }> = JSON.parse(unzipped)
 
+        // Check if this is a catalog-related action (getCatalogVariables or createCatalogTask)
+        const catalogAction = isCatalogAction(actionDefinition)
+        let catalogItemRecord: Record | undefined
+        if (catalogAction) {
+            // Find the catalog item record
+            const templateCatalogItemValue = values.find((v) => v.name === 'template_catalog_item')
+            catalogItemRecord = findCatalogItemBySysId(templateCatalogItemValue?.value as string, database)
+            if (!catalogItemRecord) {
+                logger.warn(
+                    `Catalog item not found for sys_id '${templateCatalogItemValue?.value}'. ` +
+                        `template_catalog_item and catalog_variables will fall back to raw string values.`
+                )
+            }
+        }
+
         for (const { name, value, scriptActive, script, parameter } of values) {
             const attributes = definitionInputs
                 ?.find((v) => v.get('element').asString()?.getValue() === name)
@@ -536,11 +652,31 @@ function buildInputsShapeFromZipped({
                 // Check if this is an inline script and convert to wfa.inlineScript() format
                 const inlineScriptShape = buildInlineScriptShapeFromXml(name, scriptActive, script, record)
 
+                // Determine the appropriate shape for this input
+                let inputShape: Shape | undefined
+
                 if (inlineScriptShape) {
                     props[name] = inlineScriptShape
                 } else {
-                    // Use displayValue for proper type conversion (e.g., boolean: '1' → true)
-                    props[name] = normalizeInputValue(value as string, uiType ?? parameter.type, record, logger)
+                    if (catalogAction) {
+                        if (name === 'template_catalog_item' && catalogItemRecord) {
+                            // Create template expression: `${catalogItemIdentifier}`
+                            const catalogItemIdentifier = getIdentifierFromRecord(catalogItemRecord)
+                            inputShape = catalogItemIdentifier
+                                ? createTemplateExpressionFromIdentifier(catalogItemIdentifier, record)
+                                : undefined
+                        } else if (name === 'catalog_variables' && catalogItemRecord) {
+                            // Convert slushbucket to array of catalog variable references
+                            inputShape = convertSlushBucketToCatalogVariableArray(
+                                value as string,
+                                catalogItemRecord,
+                                record
+                            )
+                        }
+                    }
+                    // Use the specialized shape or fallback to normalized value
+                    props[name] =
+                        inputShape ?? normalizeInputValue(value as string, uiType ?? parameter.type, record, logger)
                 }
             } catch (e) {
                 const recordInfo = `${record.getTable()}.${record.getId().getValue()}`
@@ -767,7 +903,8 @@ function processInputValue(
         actionDefRecord?: Record
         inputTableName?: string
         logger?: Logger
-    }
+    },
+    displayValues?: Map<string, string>
 ): unknown {
     const value = objShape.get(inputName)
     const primitiveValue = value.getValue()
@@ -797,7 +934,7 @@ function processInputValue(
     return {
         name: inputName,
         value: finalValue,
-        displayValue: finalValue,
+        displayValue: displayValues && displayValues.has(inputName) ? displayValues.get(inputName) : finalValue,
         scriptActive: false,
         parameter: {
             type: finalType,
@@ -849,6 +986,178 @@ function processDefaultOrHiddenInput(inputDef: Record, inputName: string): unkno
     return undefined
 }
 
+/**
+ * Resolve a catalog item record from a Shape (direct Record, TemplateExpressionShape, or IdentifierShape).
+ */
+function resolveCatalogItemRecord(shape: Shape): Record | undefined {
+    // Handle direct record reference (e.g., softwareInstallationCatalogItem)
+    if (shape?.isRecord && shape.isRecord()) {
+        return shape.as(Record)
+    }
+
+    // Handle template expression (e.g., `${softwareInstallationCatalogItem}`)
+    if (shape instanceof TemplateExpressionShape) {
+        const spans = shape.getSpans()
+        if (spans[0]) {
+            const expr = spans[0].getExpression()
+            const resolved = expr instanceof IdentifierShape ? expr.resolve() : undefined
+            if (resolved?.isRecord()) {
+                return resolved.as(Record)
+            }
+        }
+    }
+
+    // Handle identifier (e.g., variable reference)
+    if (shape instanceof IdentifierShape) {
+        const resolved = shape.resolve()
+        if (resolved?.isRecord()) {
+            return resolved.as(Record)
+        }
+    }
+
+    return undefined
+}
+
+/**
+ * Convert comma-separated variable names to SlushBucket format with sys_ids.
+ * Input: "html,email" + catalog item record
+ * Output: "sys_id1:item_option_new,sys_id2:item_option_new"
+ */
+function convertVariableNamesToSlushBucket(variableNames: string, catalogItemRecord: Record, logger: Logger): string {
+    const names = variableNames
+        .split(',')
+        .map((n) => n.trim())
+        .filter(Boolean)
+    if (names.length === 0) {
+        return ''
+    }
+    // Create a map of variable name to sys_id for quick lookup
+    const variableMap = new Map<string, string>()
+
+    // Single loop: flatten records and build the map
+    for (const rec of catalogItemRecord.flat()) {
+        // Check direct record
+        if (rec.getTable() === CATALOG_VARIABLE_TABLE) {
+            const varName = rec.get('name')?.asString()?.getValue()
+            if (varName && !variableMap.has(varName)) {
+                const sysId = rec.getId().getValue()
+                if (sysId && typeof sysId === 'string') {
+                    variableMap.set(varName, sysId)
+                }
+            }
+        }
+        // Check variable set records and their nested variables
+        if (rec.getTable() === CATALOG_VARIABLE_SET_TABLE) {
+            const variableSetRef = rec.get('variable_set')
+            if (!variableSetRef?.isRecord()) {
+                continue
+            }
+            for (const nestedRec of variableSetRef.flat().filter((r) => r.getTable() === CATALOG_VARIABLE_TABLE)) {
+                const varName = nestedRec.get('name')?.asString()?.getValue()
+                if (varName && !variableMap.has(varName)) {
+                    const sysId = nestedRec.getId().getValue()
+                    if (sysId) {
+                        variableMap.set(varName, sysId)
+                    }
+                }
+            }
+        }
+    }
+
+    // Generate entries in the same order as input names
+    const entries: string[] = []
+    for (const name of names) {
+        const variableSysId = variableMap.get(name)
+        if (variableSysId) {
+            entries.push(`${variableSysId}:${CATALOG_VARIABLE_TABLE}`)
+        } else {
+            logger.warn(`Catalog variable '${name}' not found in catalog item. It will be skipped.`)
+        }
+    }
+
+    return entries.join(',')
+}
+
+/**
+ * Process getCatalogVariables action inputs to extract sys_ids and display values.
+ * Handles:
+ * - template_catalog_item: extracts catalog item sys_id and name
+ * - catalog_variables: converts variable names to slushbucket format
+ */
+function processGetCatalogVariablesInputs(
+    instanceInputs: ObjectShape,
+    logger: Logger
+): {
+    overrideValues: Map<string, string>
+    displayValues: Map<string, string>
+} {
+    const overrideValues = new Map<string, string>()
+    const displayValues = new Map<string, string>()
+
+    // Get catalog item record from template_catalog_item input
+    const templateShape = instanceInputs.get('template_catalog_item')
+    const catalogItemRecord = resolveCatalogItemRecord(templateShape)
+
+    if (!catalogItemRecord) {
+        return { overrideValues, displayValues }
+    }
+
+    // Extract sys_id and name for template_catalog_item
+    const sysId = catalogItemRecord.getId().getValue()
+    const name = catalogItemRecord.get('name')?.asString()?.getValue()
+
+    if (sysId && typeof sysId === 'string') {
+        overrideValues.set('template_catalog_item', sysId)
+        if (name) {
+            displayValues.set('template_catalog_item', name)
+        }
+    }
+
+    // Convert catalog_variables to slushbucket format
+    const catalogVariablesShape = instanceInputs.get('catalog_variables')
+
+    // Handle string format: "html,email,ipAddress"
+    if (catalogVariablesShape?.isString()) {
+        const variableNames = catalogVariablesShape.asString().getValue()
+        if (variableNames) {
+            const slushBucketString = convertVariableNamesToSlushBucket(variableNames, catalogItemRecord, logger)
+            if (slushBucketString) {
+                overrideValues.set('catalog_variables', slushBucketString)
+            }
+        }
+    }
+    // Handle array format: [catalogItem.variables.html, catalogItem.variables.email, ...]
+    else if (catalogVariablesShape?.isArray()) {
+        const arrayShape = catalogVariablesShape.asArray()
+        const elements = arrayShape.getElements(false) // Get unresolved elements
+        const variableNames: string[] = []
+
+        // Extract variable names from PropertyAccessShapes
+        for (const element of elements) {
+            if (element instanceof PropertyAccessShape) {
+                const propElements = element.getElements()
+                const lastElement = propElements[propElements.length - 1]
+
+                if (lastElement instanceof IdentifierShape) {
+                    const varName = lastElement.getName()
+                    variableNames.push(varName)
+                }
+            }
+        }
+
+        // Look up sys_ids from catalog item's item_option_new descendants
+        if (variableNames.length > 0) {
+            const variableNamesString = variableNames.join(',')
+            const slushBucketString = convertVariableNamesToSlushBucket(variableNamesString, catalogItemRecord, logger)
+            if (slushBucketString) {
+                overrideValues.set('catalog_variables', slushBucketString)
+            }
+        }
+    }
+
+    return { overrideValues, displayValues }
+}
+
 async function prepareActionInstanceValueJson(
     instanceInputs: ObjectShape | undefined,
     actionDef: Record | StringShape,
@@ -860,8 +1169,29 @@ async function prepareActionInstanceValueJson(
         return []
     }
     const isActionDefString = actionDef instanceof StringShape
-    // Check for datapills and resolve them
-    const dataPillResults = await checkAndResolveDataPills(instanceInputs, transform)
+
+    // Special handling for getCatalogVariables action
+    let overrideValues = new Map<string, string>()
+    let displayValues = new Map<string, string>()
+
+    if (actionDefRecord) {
+        const actionSysId = actionDefRecord.getId().getValue()
+        const actionName = typeof actionSysId === 'string' ? CORE_ACTIONS_SYS_ID_NAME_MAP[actionSysId] : undefined
+
+        // Check if this is the getCatalogVariables action or createCatalogTask action
+        if (actionName === 'getCatalogVariables' || actionName === 'createCatalogTask') {
+            try {
+                const result = processGetCatalogVariablesInputs(instanceInputs, logger)
+                overrideValues = result.overrideValues
+                displayValues = result.displayValues
+            } catch (error) {
+                logger.error('[getCatalogVariables] Error:', error)
+            }
+        }
+    }
+
+    // Check for datapills and resolve them (skip keys already in overrideValues)
+    const dataPillResults = await checkAndResolveDataPills(instanceInputs, transform, overrideValues)
 
     // Check for inline script tags and resolve them (only returns scripts)
     const inlineScriptResults = await checkAndResolveInlineScripts(instanceInputs, transform)
@@ -869,7 +1199,13 @@ async function prepareActionInstanceValueJson(
 
     // Merge: use inline scripts where they exist, otherwise use datapill results
     // Note: Inline script can be applied to only top level properties; No need to handle nested objects
+    // Merge results: prioritize overrideValues > inline scripts > datapill results
     const mergedResults = dataPillResults.map(([key, value]) => {
+        // Use override value if available (catalog item sys_id or slushbucket string)
+        if (overrideValues.has(key)) {
+            return [key, overrideValues.get(key)]
+        }
+        // Otherwise use inline script if available
         return inlineScriptMap.has(key) ? [key, inlineScriptMap.get(key)] : [key, value]
     })
 
@@ -894,11 +1230,16 @@ async function prepareActionInstanceValueJson(
             }
             // If input is provided in objShape(ie provided by user), process it
             if (providedInputNames.has(inputName)) {
-                const processedValue = processInputValue(inputName, objShape, {
-                    actionDefRecord,
-                    inputTableName: 'sys_hub_action_input',
-                    logger,
-                })
+                const processedValue = processInputValue(
+                    inputName,
+                    objShape,
+                    {
+                        actionDefRecord,
+                        inputTableName: 'sys_hub_action_input',
+                        logger,
+                    },
+                    displayValues
+                )
                 result.push(processedValue)
             } else {
                 // Process default or hidden input
@@ -910,7 +1251,7 @@ async function prepareActionInstanceValueJson(
         }
     } else if (isActionDefString) {
         for (const inputName of objShape.keys()) {
-            const processedValue = processInputValue(inputName, objShape, { type: 'string' })
+            const processedValue = processInputValue(inputName, objShape, { type: 'string' }, displayValues)
             result.push(processedValue)
         }
     }
@@ -1087,11 +1428,21 @@ function wrapSpecialShape(shape: Shape, resolvedValue: unknown, source: Source):
  * @param transform - The transform instance
  * @returns Array of [key, value] pairs with resolved datapills
  */
-async function checkAndResolveDataPills(instanceInputs: ObjectShape, transform: Transform) {
+async function checkAndResolveDataPills(
+    instanceInputs: ObjectShape,
+    transform: Transform,
+    skipKeys?: Map<string, string>
+) {
     const entries = instanceInputs.entries({ resolve: false })
     const results: [string, unknown][] = []
 
     for (const [key, shape] of entries) {
+        // Skip datapill resolution for keys that have already been processed (e.g., catalog_variables in array format)
+        // But still add the override value so the key exists in results
+        if (skipKeys?.has(key)) {
+            results.push([key, skipKeys.get(key)])
+            continue
+        }
         if (shape && isDataPillShape(shape)) {
             const resolvedValue = await resolveDataPillShape(shape, transform)
             results.push([key, resolvedValue])

package/src/flow/plugins/flow-trigger-instance-plugin.ts

@@ -26,9 +26,10 @@ export const TriggerInstancePlugin = Plugin.create({
     name: 'TriggerInstancePlugin',
     records: {
         sys_hub_trigger_instance_v2: {
-            toShape(record, { logger }) {
+            toShape(record, { logger, database }) {
                 const gzStr = record.get('trigger_inputs').as(StringShape).getValue()
                 const inputsObj: globalThis.Record<string, unknown> = {}
+                const triggerType = record.get('trigger_type')?.getValue()
 
                 try {
                     const arr = JSON.parse(gunzipSync(Buffer.from(gzStr, 'base64')).toString('utf8')) as Array<{
@@ -50,10 +51,28 @@ export const TriggerInstancePlugin = Plugin.create({
                         }
                         // Safely extract uiType, guarding against missing parameter or attributes
                         const uiType = (parameter?.attributes?.['uiType'] ?? parameter?.type) as string | undefined
+
+                        let finalValue = value
+                        // For service catalog trigger's run_flow_in, read from sys_flow_catalog_trigger table when empty
+                        if (
+                            name === 'run_flow_in' &&
+                            (value === '' || value === undefined) &&
+                            triggerType === 'service_catalog'
+                        ) {
+                            const flowSysId = record.get('flow')?.ifString()?.getValue()
+                            const flowRecord = flowSysId ? database.get('sys_hub_flow', flowSysId) : undefined
+                            const remoteTriggerIdValue = flowRecord?.get('remote_trigger_id')?.ifString()?.getValue()
+                            const catalogTriggerRecord = remoteTriggerIdValue
+                                ? database.get('sys_flow_catalog_trigger', remoteTriggerIdValue)
+                                : undefined
+                            const runFlowInValue = catalogTriggerRecord?.get('run_flow_in')?.ifString()?.getValue()
+                            finalValue = runFlowInValue || 'background'
+                        }
+
                         if (name === RUN_ON_EXTENDED) {
-                            inputsObj[name] = value // As this is a choice value, we don't need to normalize it. It should remain as a string. Keep it as 'true' or 'false'
+                            inputsObj[name] = finalValue // As this is a choice value, we don't need to normalize it. It should remain as a string. Keep it as 'true' or 'false'
                         } else {
-                            inputsObj[name] = normalizeInputValue(value, uiType, record, logger)
+                            inputsObj[name] = normalizeInputValue(finalValue, uiType, record, logger)
                         }
                     }
                 } catch (err: unknown) {
@@ -68,7 +87,6 @@ export const TriggerInstancePlugin = Plugin.create({
                 }
 
                 let triggerIdentifier: IdentifierShape | undefined
-                const triggerType = record.get('trigger_type')?.getValue()
 
                 // Map sys_hub_trigger_instance_v2.trigger_type values to the corresponding
                 // `*.now.ts` TriggerDefinition identifier exported from /automation
@@ -89,7 +107,7 @@ export const TriggerInstancePlugin = Plugin.create({
 
                     // Application triggers
                     email: 'trigger.application.inboundEmail',
-                    // service_catalog: 'trigger.application.serviceCatalog',
+                    service_catalog: 'trigger.application.serviceCatalog',
                     remote_table_query: 'trigger.application.remoteTableQuery',
                     sla_task: 'trigger.application.slaTask',
                     knowledge_management: 'trigger.application.knowledgeManagement',
@@ -342,8 +360,8 @@ function createTriggerInputsForTriggerInstance({
                 userValue = userValue.join(',') // Convert array to comma-separated string
             }
 
-            // Apply default value if user didn't specify a value
-            if (userValue === undefined && fieldProps?.default !== undefined) {
+            // Apply default value if user didn't specify a value or provided empty string
+            if ((userValue === undefined || userValue === '') && fieldProps?.default !== undefined) {
                 userValue = fieldProps.default
             }
 

package/src/flow/utils/flow-constants.ts

@@ -10,6 +10,10 @@ export const SUBFLOW_INSTANCE_TABLE_V2 = 'sys_hub_sub_flow_instance_v2'
 export const FLOW_LOGIC_INSTANCE_TABLE = 'sys_hub_flow_logic'
 export const FLOW_STAGE_TABLE = 'sys_hub_flow_stage'
 export const PILL_COMPOUND_TABLE = 'sys_hub_pill_compound'
+export const CATALOG_ITEM_TABLE = 'sc_cat_item'
+export const CATALOG_VARIABLE_TABLE = 'item_option_new'
+export const CATALOG_VARIABLE_SET_TABLE = 'io_set_item'
+
 export const UNSUPPORTED_FLOW_DESCENDANTS = [
     FLOW_STAGE_TABLE,
     PILL_COMPOUND_TABLE,
@@ -72,7 +76,7 @@ export const CORE_ACTIONS_SYS_ID_NAME_MAP: { [sysId: string]: string } = {
     f8f2e9920b10030085c083eb37673abd: 'askForApproval',
     '7b95a4c0a73133008299b39f087901b4': 'associateRecordToEmail',
     '30fe6cdb0f973300dfd3694e68767e5a': 'copyAttachment',
-    // af51fd0e73141300612c273ffff6a785: 'createCatalogTask',
+    af51fd0e73141300612c273ffff6a785: 'createCatalogTask',
     ab575ae253b3230034c6ddeeff7b12f1: 'createOrUpdateRecord',
     '2de05916c31332002841b63b12d3aee1': 'createRecord',
     '2b3a6335531003003bf1d9109ec58759': 'createTask',
@@ -80,7 +84,7 @@ export const CORE_ACTIONS_SYS_ID_NAME_MAP: { [sysId: string]: string } = {
     c3e09916c31332002841b63b12d3aedf: 'deleteRecord',
     '80a30edeff30311077a95dac793bf19b': 'fireEvent',
     '082e70db0f4273003788001ea8767e02': 'getAttachmentsOnRecord',
-    // '330ba3abc31013002841b63b12d3aee8': 'getCatalogVariables',
+    '330ba3abc31013002841b63b12d3aee8': 'getCatalogVariables',
     a8cfa3efa70223008299b39f0879018b: 'getEmailHeader',
     a159d7820f13101051218e8ebc767eea: 'getLatestResponseTextFromEmail',
     '5bc1bcc6531003003bf1d9109ec587d4': 'log',
@@ -90,12 +94,12 @@ export const CORE_ACTIONS_SYS_ID_NAME_MAP: { [sysId: string]: string } = {
     '6ecdee36935023005e69925cf67ffb47': 'lookupAttachment',
     '7159823353cc10103a33ddeeff7b1216': 'moveAttachment',
     bd8fcd48a73133008299b39f087901fc: 'moveEmailAttachmentsToRecord',
-    // '87a397837333001098e194596bf6a7bc': 'recordProducer',
+    '87a397837333001098e194596bf6a7bc': 'recordProducer',
     c1806bf4a70323008299b39f087901cb: 'sendEmail',
     '0d8dd9f10f11101051218e8ebc767e27': 'sendNotification',
     '027499be7333001099792f163cf6a7a7': 'sendSms',
     a1a50c4573873300d70877186bf6a762: 'slaPercentageTimer',
-    // c7a04c4607312001098e194596bf6a72a: 'submitCatalogItemRequest',
+    c7a04c4607312001098e194596bf6a72a: 'submitCatalogItemRequest',
     '9daf2a72c75100105312134c95c26073': 'updateMultipleRecords',
     f9d01dd2c31332002841b63b12d3aea1: 'updateRecord',
     '89ce8a4187120010663ca1bb36cb0be3': 'waitForCondition',
@@ -274,3 +278,8 @@ export function slugifyString(value: unknown, opts: SlugifyOptions = {}): string
 
     return str.toLowerCase()
 }
+
+/**
+ * Core actions that require special catalog variable handling
+ */
+export const CATALOG_VARIABLE_ACTIONS = ['getCatalogVariables', 'createCatalogTask']