@servicenow/sdk-build-plugins 4.1.1 → 4.3.0

package/src/service-catalog/catalog-ui-policy-plugin.ts

@@ -0,0 +1,324 @@
+import {
+    CallExpressionShape,
+    Plugin,
+    type Record,
+    PropertyAccessShape,
+    type TemplateExpressionShape,
+} from '@servicenow/sdk-build-core'
+import {
+    createVariablePropertyAccess,
+    createScript,
+    getTargetRecord,
+    resolveVariableAccess,
+    processCatalogCondition,
+    processCatalogConditionsToShape,
+    resolveCatalogReferences,
+    convertToNumber,
+    resolveAndValidateVariableId,
+} from './utils'
+import { NowIdShape } from '../now-id-plugin'
+import {
+    APPLIES_TO_CATALOG_ITEM,
+    getUITypeFromId,
+    getUITypeId,
+    getValueActionFromDb,
+    getValueActionToDb,
+} from './utils'
+import { validateCatalogItemVariableSetExclusivity, validateUiPolicyActionMessage } from './service-catalog-diagnostics'
+
+// Define table names as constants since they're not exported from the core tables
+const CATALOG_UI_POLICY = 'catalog_ui_policy'
+const CATALOG_UI_POLICY_ACTION = 'catalog_ui_policy_action'
+const DEFAULT_SCRIPT = 'function onCondition() {\n\n}'
+
+/**
+ * Helper function to convert ServiceNow string format ('true'/'false'/'ignore') to boolean | 'ignore'
+ */
+const getBooleanOrIgnore = (action: Record, field: string): boolean | 'ignore' | undefined => {
+    const value = action.isRecord() ? action.asRecord() : action
+    if (value.get(field)?.ifString()?.getValue() === 'ignore' || value.get(field)?.ifString()?.isEmpty()) {
+        return 'ignore'
+    }
+    return value.get(field)?.toBoolean()?.getValue()
+}
+/**
+ * Helper function to strip IO: prefix from variable names
+ */
+const stripIOPrefix = (value: string): string => {
+    return value.startsWith('IO:') ? value.substring(3) : value
+}
+
+export const CatalogUiPolicyPlugin = Plugin.create({
+    name: 'CatalogUiPolicyPlugin',
+    records: {
+        [CATALOG_UI_POLICY]: {
+            relationships: {
+                [CATALOG_UI_POLICY_ACTION]: {
+                    via: 'ui_policy',
+                    descendant: true,
+                },
+            },
+            async toShape(record, { descendants, database, transform }) {
+                let processedConditions: string | TemplateExpressionShape | undefined
+
+                // Handle catalog_condition - convert variables to PropertyAccessShape in template expression
+
+                if (!record.get('catalog_conditions')?.ifString()?.isEmpty()) {
+                    processedConditions = processCatalogConditionsToShape(record, database)
+                }
+
+                const { catalogItemReference, variableSetReference } = resolveCatalogReferences(record, database)
+                const actions = descendants.query(CATALOG_UI_POLICY_ACTION).map((action) => {
+                    const variableValue = action.get('catalog_variable')?.ifString()?.getValue()
+                    if (!variableValue) {
+                        return {
+                            success: false,
+                        }
+                    }
+                    const variableId = stripIOPrefix(variableValue)
+                    const varRecord = database.get('item_option_new', variableId)
+
+                    let variableName: PropertyAccessShape | string | undefined
+                    if (varRecord?.isRecord()) {
+                        const appliesToRecord = getTargetRecord(record, database)
+                        variableName =
+                            (appliesToRecord?.isRecord() &&
+                                createVariablePropertyAccess(varRecord, record, appliesToRecord)) ||
+                            variableId
+                    } else {
+                        variableName = variableId
+                    }
+
+                    return action.transform(({ $ }) => {
+                        const visible = getBooleanOrIgnore(action, 'visible')
+                        const readOnly = getBooleanOrIgnore(action, 'disabled')
+                        const mandatory = getBooleanOrIgnore(action, 'mandatory')
+                        const cleared = action.get('cleared')?.toBoolean()?.getValue()
+                        const variableMessage = action.get('field_message')?.ifString()?.getValue()
+                        const variableMessageType = action.get('field_message_type')?.ifString()?.getValue()
+                        const valueActionDb = action.get('value_action')?.ifString()?.getValue()
+                        const valueAction = valueActionDb ? getValueActionFromDb(valueActionDb) : undefined
+                        const order = convertToNumber(action.get('order'), 100)
+                        const value = action.get('value')?.ifString()?.getValue()
+
+                        return {
+                            variableName: $.val(variableName),
+                            ...(visible !== 'ignore' && visible !== undefined && { visible: $.val(visible) }),
+                            ...(readOnly !== 'ignore' && readOnly !== undefined && { readOnly: $.val(readOnly) }),
+                            ...(mandatory !== 'ignore' && mandatory !== undefined && { mandatory: $.val(mandatory) }),
+                            ...(cleared && { cleared: $.val(cleared) }),
+                            ...(variableMessageType &&
+                                variableMessageType !== 'none' && {
+                                    variableMessageType: $.val(variableMessageType),
+                                }),
+                            ...(variableMessage &&
+                                variableMessageType !== 'none' && {
+                                    variableMessage: $.val(variableMessage),
+                                }),
+                            ...(valueAction && { valueAction: $.val(valueAction) }),
+                            ...(order && order !== 100 && { order: $.val(order) }),
+                            ...(value && { value: $.val(value) }),
+                        }
+                    })
+                })
+
+                const executeIfTrue = await createScript(record, record.get('script_true'), transform, 'script-true')
+                const executeIfFalse = await createScript(record, record.get('script_false'), transform, 'script-false')
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'CatalogUiPolicy',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                appliesTo: $.from('applies_to').def(APPLIES_TO_CATALOG_ITEM),
+                                catalogItem: $.val(catalogItemReference).def(''),
+                                variableSet: $.val(variableSetReference).def(''),
+                                shortDescription: $.from('short_description'),
+                                active: $.toBoolean().def(true),
+                                global: $.toBoolean().def(true),
+                                onLoad: $.from('on_load').toBoolean().def(true),
+                                reverseIfFalse: $.from('reverse_if_false').toBoolean().def(true),
+                                inherit: $.toBoolean().def(false),
+                                isolateScript: $.from('isolate_script').toBoolean().def(true),
+                                conditions: $.def(''),
+                                catalogCondition: $.val(processedConditions).def(''),
+                                appliesOnCatalogItemView: $.from('applies_catalog').toBoolean().def(true),
+                                appliesOnTargetRecord: $.from('applies_target_record').toBoolean().def(false),
+                                appliesOnCatalogTasks: $.from('applies_sc_task').toBoolean().def(false),
+                                appliesOnRequestedItems: $.from('applies_req_item').toBoolean().def(false),
+                                runScripts: $.from('run_scripts').toBoolean().def(false),
+                                executeIfTrue: $.val(executeIfTrue).def(DEFAULT_SCRIPT),
+                                executeIfFalse: $.val(executeIfFalse).def(DEFAULT_SCRIPT),
+                                description: $.from('description').def(''),
+                                modelId: $.from('model_id').def(''),
+                                modelTable: $.from('model_table').def(''),
+                                order: $.map((c) => convertToNumber(c, 100)).def(100),
+                                setValues: $.from('set_values').def(''),
+                                vaSupported: $.from('va_supported').toBoolean().def(true),
+                                view: $.from('view').def(''),
+                                publishedRef: $.from('published_ref').def(''),
+                                runScriptsInUiType: $.from('ui_type')
+                                    .map((v) =>
+                                        v.ifString()?.isEmpty() ? undefined : getUITypeFromId(v.toNumber()?.getValue())
+                                    )
+                                    .def('desktop'),
+                                actions: $.val(actions.length > 0 ? actions : []).def([]),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+        [CATALOG_UI_POLICY_ACTION]: {
+            coalesce: ['ui_policy', 'catalog_variable'],
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'CatalogUiPolicy') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+
+                // Validate catalogItem and variableSet are mutually exclusive
+                validateCatalogItemVariableSetExclusivity(arg, diagnostics, 'CatalogUiPolicy')
+
+                const catalogConditionShape = arg.get('catalogCondition')
+                let catalogConditionIO: string | TemplateExpressionShape | undefined
+                const appliedTo: 'set' | 'item' =
+                    arg.get('appliesTo')?.toString()?.getValue() === 'set' ? 'set' : APPLIES_TO_CATALOG_ITEM
+                if (catalogConditionShape.isDefined()) {
+                    catalogConditionIO = processCatalogCondition(
+                        catalogConditionShape,
+                        appliedTo,
+                        arg.get('variableSet', false),
+                        arg.get('catalogItem', false),
+                        diagnostics
+                    )
+                }
+
+                // Create the Catalog UI Policy record
+                const catalogUiPolicyRecord = await factory.createRecord({
+                    source: callExpression,
+                    table: CATALOG_UI_POLICY,
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        catalog_item: $.from('catalogItem').def(''),
+                        variable_set: $.from('variableSet').def(''),
+                        applies_to: $.from('appliesTo').def(APPLIES_TO_CATALOG_ITEM),
+                        short_description: $.from('shortDescription'),
+                        active: $.def(true),
+                        global: $.def(true),
+                        on_load: $.from('onLoad').def(true),
+                        reverse_if_false: $.from('reverseIfFalse').def(true),
+                        inherit: $.def(false),
+                        isolate_script: $.from('isolateScript').def(true),
+                        conditions: $.def(''),
+                        catalog_conditions: $.val(catalogConditionIO).def(''),
+                        applies_catalog: $.from('appliesOnCatalogItemView').def(true),
+                        applies_target_record: $.from('appliesOnTargetRecord').def(false),
+                        applies_sc_task: $.from('appliesOnCatalogTasks').def(false),
+                        applies_req_item: $.from('appliesOnRequestedItems').def(false),
+                        run_scripts: $.from('runScripts').def(false),
+                        script_true: $.from('executeIfTrue').toCdata().def('function onCondition() {\n\n}'),
+                        script_false: $.from('executeIfFalse').toCdata().def('function onCondition() {\n\n}'),
+                        description: $.from('description').def(''),
+                        model_id: $.from('modelId').def(''),
+                        model_table: $.from('modelTable').def(''),
+                        order: $.def(100),
+                        set_values: $.from('setValues').def(''),
+                        published_ref: $.from('publishedRef').def(''),
+                        ui_type: $.from('runScriptsInUiType')
+                            .map((v) => (v.isString() && !v.isEmpty() ? getUITypeId(v.getValue()) : undefined))
+                            .def(0),
+                        table: $.def(''),
+                        va_supported: $.from('vaSupported').def(true),
+                        view: $.def(''),
+                    })),
+                })
+
+                // Process actions if they exist
+                const actions = arg.get('actions')?.ifArray()?.getElements() ?? []
+                const actionRecords: Record[] = []
+                if (actions?.length > 0) {
+                    const variableNames = new Set<string>()
+                    // Process each action sequentially
+                    for (const action of actions) {
+                        const actionObj = action.asObject()
+
+                        // Validate variableMessageType/variableMessage consistency
+                        validateUiPolicyActionMessage(actionObj, diagnostics)
+
+                        const variableNameShape = actionObj.get('variableName', false)
+
+                        // Resolve and validate catalog_variable
+                        const catalogVariable = resolveAndValidateVariableId(
+                            variableNameShape,
+                            appliedTo,
+                            arg.get('variableSet', false),
+                            arg.get('catalogItem', false),
+                            diagnostics
+                        )
+
+                        // Extract variable name for duplicate checking
+                        let catalogVariableName: string | undefined
+                        if (variableNameShape?.is(PropertyAccessShape)) {
+                            const variableAccess = resolveVariableAccess(variableNameShape.as(PropertyAccessShape))
+                            if (variableAccess) {
+                                catalogVariableName = variableAccess.variableName
+                            } else {
+                                catalogVariableName = variableNameShape.toString()?.getValue()
+                            }
+                        } else {
+                            catalogVariableName = variableNameShape?.toString()?.getValue()
+                        }
+
+                        if (catalogVariableName) {
+                            if (variableNames.has(catalogVariableName)) {
+                                diagnostics.error(
+                                    variableNameShape,
+                                    `Duplicate variableName '${catalogVariableName}' found in actions. Each action must have a unique variableName.`
+                                )
+                            }
+                            variableNames.add(catalogVariableName)
+                        }
+
+                        actionRecords.push(
+                            await factory.createRecord({
+                                source: action, // Use the action as source instead of callExpression
+                                table: CATALOG_UI_POLICY_ACTION,
+                                properties: actionObj.transform(({ $ }) => ({
+                                    ui_policy: $.val(catalogUiPolicyRecord.getId()),
+                                    catalog_item: $.val(arg.get('catalogItem')?.toString()?.getValue() ?? ''),
+                                    variable_set: $.val(arg.get('variableSet')?.toString()?.getValue() ?? ''),
+                                    catalog_variable: $.val(catalogVariable).def(''),
+                                    variable: $.val(catalogVariableName).def(''),
+                                    visible: $.from('visible').def('ignore'),
+                                    disabled: $.from('readOnly').def('ignore'),
+                                    mandatory: $.from('mandatory').def('ignore'),
+                                    order: $.def(100),
+                                    cleared: $.from('cleared').toBoolean().def(false),
+                                    field_message: $.from('variableMessage').def(''),
+                                    field_message_type: $.from('variableMessageType').def('none'),
+                                    value: $.from('value').def(''),
+                                    value_action: $.from('valueAction')
+                                        .map((v) => getValueActionToDb(v.toString().getValue()))
+                                        .def('ignore'),
+                                })),
+                            })
+                        )
+                    }
+                }
+
+                return { success: true, value: catalogUiPolicyRecord.with(...actionRecords) }
+            },
+        },
+    ],
+})

package/src/service-catalog/index.ts

@@ -0,0 +1,5 @@
+export * from './variable-set-plugin'
+export * from './catalog-item-plugin'
+export * from './catalog-clientscript-plugin'
+export * from './catalog-ui-policy-plugin'
+export * from './sc-record-producer-plugin'

package/src/service-catalog/record-to-shape.ts

@@ -0,0 +1,109 @@
+import { CallExpressionShape, type Record, type Database, type Logger } from '@servicenow/sdk-build-core'
+import type { ExtendedChoices } from '@servicenow/sdk-core/service-catalog'
+import { VARIABLE_TYPE_TO_NAME, VariableTypeName } from './variable-helper'
+import { convertToNumber } from './utils'
+import { buildVariableTransform } from './variables-transform'
+
+/**
+ * Converts a ServiceNow variable record to a CallExpressionShape for code generation.
+ * This function queries the database for variable data and delegates transformation to buildVariableTransform.
+ */
+export function variableToCallExpression(variable: Record, descendants: Database, logger: Logger): CallExpressionShape {
+    const typeCode = variable.get('type').ifString()?.getValue() || ''
+    const callExpression = VARIABLE_TYPE_TO_NAME[typeCode]
+    if (!callExpression) {
+        throw new Error(`Unknown variable type: ${typeCode}`)
+    }
+    const choicesData: ExtendedChoices = {}
+
+    if (callExpression === VariableTypeName.MULTIPLE_CHOICE || callExpression === VariableTypeName.SELECT_BOX) {
+        const choices = descendants.query('question_choice', {
+            question: variable.getId()?.getValue(),
+        })
+
+        choices.forEach((choice) => {
+            const choicePriceDetails = descendants.query('fx_price', {
+                id: choice.getId()?.getValue(),
+            })
+            const choiceValue =
+                choice.get('value')?.ifString()?.getValue() ?? choice.get('value')?.ifNumber()?.getValue()
+
+            const pricingDetailsArray = choicePriceDetails.map((price) => {
+                const amount = convertToNumber(price.get('amount'), 0)
+                const currencyType = price.get('currency').ifString()?.getValue() || ''
+                const field = price.get('field').ifString()?.getValue() || ''
+                return { amount, currencyType, field }
+            })
+            if (choiceValue === undefined) {
+                return
+            }
+            choicesData[choiceValue] = {
+                label: choice.get('text').ifString()?.getValue() || '',
+                inactive: choice.get('inactive').toBoolean().getValue() || false,
+                sequence:
+                    choice.get('order').ifString()?.isEmpty() || choice.get('order').isUndefined()
+                        ? 0
+                        : choice.get('order').toNumber().getValue(),
+                ...(pricingDetailsArray.length > 0 && { pricingDetails: pricingDetailsArray }),
+            }
+        })
+    }
+    const prices = descendants.query('fx_price', {
+        id: variable.getId()?.getValue(),
+    })
+    let varPricingDetails: { amount: number; currencyType: string; field: string }[] = []
+    if (callExpression === VariableTypeName.CHECKBOX) {
+        varPricingDetails = prices.map((price) => {
+            const amount = convertToNumber(price.get('amount'), 0)
+            const currencyType = price.get('currency').ifString()?.getValue() || ''
+            const field = price.get('field').ifString()?.getValue() || ''
+            return { amount, currencyType, field }
+        })
+    }
+
+    // Determine discriminated union types before transform
+    let qualifierType: 'dynamic' | 'advanced' | 'simple' = 'simple'
+    if (
+        callExpression === VariableTypeName.REFERENCE ||
+        callExpression === VariableTypeName.REQUESTED_FOR ||
+        callExpression === VariableTypeName.LIST_COLLECTOR
+    ) {
+        const useRefQual = variable.get('use_reference_qualifier')?.ifString()?.getValue()
+        if (useRefQual === 'dynamic') {
+            qualifierType = 'dynamic'
+        } else if (useRefQual === 'advanced') {
+            qualifierType = 'advanced'
+        }
+    }
+
+    let lookupSource: 'choices' | 'table' = 'table'
+    if (
+        callExpression === VariableTypeName.LOOKUP_SELECT_BOX ||
+        callExpression === VariableTypeName.LOOKUP_MULTIPLE_CHOICE
+    ) {
+        const lookupSourceValue = variable.get('lookup_source')?.ifString()?.getValue()
+        if (lookupSourceValue === 'choices') {
+            lookupSource = 'choices'
+        }
+    }
+
+    return new CallExpressionShape({
+        source: variable,
+        callee: callExpression,
+        args: [
+            variable.transform(({ $ }) =>
+                buildVariableTransform(
+                    callExpression,
+                    $,
+                    {
+                        choicesData,
+                        varPricingDetails,
+                        qualifierType,
+                        lookupSource,
+                    },
+                    logger
+                )
+            ),
+        ],
+    })
+}

package/src/service-catalog/sc-record-producer-plugin.ts

@@ -0,0 +1,201 @@
+import {
+    CallExpressionShape,
+    Plugin,
+    type Record,
+    VariableStatementShape,
+    IdentifierShape,
+} from '@servicenow/sdk-build-core'
+import { buildVariableRecords } from './shape-to-record'
+import {
+    toValidIdentifier,
+    shouldWriteAsCallExpression,
+    defaultScript,
+    defaultpostInsertScript,
+    defaultSaveScript,
+    validateRequestedForVariableConflict,
+    validateVariableNameConflicts,
+    getRedirectUrlFromDb,
+    getRedirectUrlToDb,
+    createScript,
+} from './utils'
+import {
+    buildVariablesSchema,
+    CatalogItemBaseRelationships,
+    CatalogItemBaseCoalesce,
+    transformCatalogBaseFieldsToShape,
+    transformCatalogItemBaseFieldsToRecord,
+    createSharedM2MRecords,
+} from './service-catalog-base'
+import { validateFulfillmentProcessExclusivity, validateCategoriesRequireCatalogs } from './service-catalog-diagnostics'
+import { ModuleFunctionShape } from '../server-module-plugin'
+
+export const CatalogItemRecordProducerPlugin = Plugin.create({
+    name: 'CatalogItemRecordProducerPlugin',
+    records: {
+        sc_cat_item_producer: {
+            relationships: CatalogItemBaseRelationships,
+            async toShape(record, { descendants, transform, logger }) {
+                const variablesSchema = buildVariablesSchema(descendants, logger)
+                const script = await createScript(record, record.get('script'), transform, 'script')
+                const postInsertScript = await createScript(
+                    record,
+                    record.get('post_insert_script'),
+                    transform,
+                    'post-insert-script'
+                )
+                const saveScript = await createScript(record, record.get('save_script'), transform, 'save-script')
+                const callExpression = new CallExpressionShape({
+                    source: record,
+                    callee: 'CatalogItemRecordProducer',
+                    args: [
+                        record.transform(({ $ }) => ({
+                            ...transformCatalogBaseFieldsToShape(record, $, descendants),
+                            table: $.from('table_name'),
+                            script: $.val(script).def(defaultScript),
+                            postInsertScript: $.val(postInsertScript).def(defaultpostInsertScript),
+                            saveScript: $.val(saveScript).def(defaultSaveScript),
+                            redirectUrl: $.from('redirect_url')
+                                .map((v) => getRedirectUrlFromDb(v.toString().getValue()))
+                                .def('generatedRecord'),
+                            view: $.def(''),
+                            allowEdit: $.from('allow_edit').toBoolean().def(false),
+                            canCancel: $.from('can_cancel').toBoolean().def(false),
+                            saveOptions: $.from('save_options').def(''),
+                            variables: $.val(variablesSchema).def({}),
+                        })),
+                    ],
+                })
+
+                return {
+                    success: true,
+                    value: shouldWriteAsCallExpression(record)
+                        ? callExpression
+                        : new VariableStatementShape({
+                              source: record,
+                              isExported: true,
+                              variableName: new IdentifierShape({
+                                  source: record,
+                                  name: toValidIdentifier(record.get('name').asString().getValue()),
+                              }),
+                              initializer: callExpression,
+                          }),
+                }
+            },
+        },
+        ...CatalogItemBaseCoalesce,
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'CatalogItemRecordProducer') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+
+                // Validate mutually exclusive fulfillment process fields (executionPlan/flow/workflow)
+                validateFulfillmentProcessExclusivity(arg, diagnostics)
+
+                // Validate categories require catalogs
+                validateCategoriesRequireCatalogs(arg, diagnostics)
+
+                const recordProducer = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sc_cat_item_producer',
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        ...transformCatalogItemBaseFieldsToRecord($),
+                        table_name: $.from('table'),
+                        script: $.from('script')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString((n: string) => `${n}({{PARAMS}})`, ['producer', 'current']) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultScript),
+                        post_insert_script: $.from('postInsertScript')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString(
+                                            (n: string) => `${n}({{PARAMS}})`,
+                                            ['producer', 'current', 'cat_item']
+                                        ) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultpostInsertScript),
+                        save_script: $.from('saveScript')
+                            .map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString(
+                                            (n: string) => `${n}({{PARAMS}})`,
+                                            ['producer', 'current', 'cat_item']
+                                        ) ?? v
+                            )
+                            .toCdata()
+                            .def(defaultSaveScript),
+                        redirect_url: $.from('redirectUrl')
+                            .map((v) => getRedirectUrlToDb(v.toString().getValue()))
+                            .def('generated_record'),
+                        view: $.def(''),
+                        allow_edit: $.from('allowEdit').def(false),
+                        can_cancel: $.from('canCancel').def(false),
+                        save_options: $.from('saveOptions').def(''),
+                    })),
+                })
+
+                let variableRecords: Record[] = []
+
+                // Validate all RequestedForVariable constraints (direct variables + variable sets) in a single optimized pass
+                if (!validateRequestedForVariableConflict(arg, diagnostics, 'RecordProducer')) {
+                    return { success: false }
+                }
+
+                // Validate that variable names don't conflict between direct variables and variable sets
+                if (!validateVariableNameConflicts(arg, diagnostics, 'RecordProducer')) {
+                    return { success: false }
+                }
+
+                const m2mRecords = await createSharedM2MRecords(callExpression, arg, recordProducer, factory)
+
+                if (arg.get('variables').isDefined()) {
+                    const variablesConfig = arg.get('variables').asObject()
+
+                    variableRecords = await buildVariableRecords({
+                        variablesConfig,
+                        factory,
+                        parent: recordProducer,
+                        diagnostics,
+                    })
+
+                    const recordProducerTable = arg.get('table').getValue()
+                    variableRecords = variableRecords.map((variableRecord) => {
+                        return variableRecord.merge({
+                            record_producer_table: recordProducerTable,
+                        })
+                    })
+                }
+
+                return {
+                    success: true,
+                    value: recordProducer.with(
+                        ...m2mRecords.catalogsRecords,
+                        ...m2mRecords.categoriesRecords,
+                        ...m2mRecords.variableSetRecords,
+                        ...m2mRecords.availableForRecords,
+                        ...m2mRecords.notAvailableForRecords,
+                        ...m2mRecords.assignedTopicsRecords,
+                        ...variableRecords
+                    ),
+                }
+            },
+        },
+    ],
+})