@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/rest-api-plugin.ts

@@ -163,13 +163,12 @@ async function generateRouteAttributeRecords(
     attrType: string,
     attrMap: Map<string, Record>,
     factory: Factory,
-    diagnostics: Diagnostics,
-    callExpression: CallExpressionShape
+    diagnostics: Diagnostics
 ): Promise<Record[]> {
     const records: Record[] = []
     for (const attr of attributes) {
         const attrRecord = await factory.createRecord({
-            source: callExpression,
+            source: attr,
             table: `sys_ws_${attrType}`,
             explicitId: attr.asObject().get('$id'),
             properties: attr.asObject().transform(({ $ }) => ({
@@ -179,17 +178,19 @@ async function generateRouteAttributeRecords(
                 example_value: $.from('exampleValue').def(''),
                 web_service_definition: $.val(restDef.getId()),
             })),
+            installCategory: restDef.getInstallCategory(),
         })
 
         checkForDuplicateRecords(attrMap, attrRecord, attr.asObject(), diagnostics)
 
         const attributeMappingRecord = await factory.createRecord({
-            source: callExpression,
+            source: attr,
             table: `sys_ws_${attrType}_map`,
             properties: attr.asObject().transform(({ $ }) => ({
                 web_service_operation: $.val(routeDef.getId()),
                 [`web_service_${attrType}`]: $.val(attrRecord.getId()),
             })),
+            installCategory: restDef.getInstallCategory(),
         })
 
         records.push(attrRecord.with(attributeMappingRecord))
@@ -293,8 +294,7 @@ async function generateRouteAndRouteAttrRecords(
             'header',
             headersMap,
             factory,
-            diagnostics,
-            callExpression
+            diagnostics
         )
 
         const routeParameters = route.get('parameters')?.ifArray()?.getElements() ?? []
@@ -309,8 +309,7 @@ async function generateRouteAndRouteAttrRecords(
             'query_parameter',
             parametersMap,
             factory,
-            diagnostics,
-            callExpression
+            diagnostics
         )
 
         routeRecords.push(routeRecord.with(...headerRecords, ...parameterRecords))
@@ -319,11 +318,11 @@ async function generateRouteAndRouteAttrRecords(
     return routeRecords
 }
 
-function validateAttributesAndAssociations(
+function findOrphanedAttributes(
     attributes: Record[],
     attributeRouteAssociations: Record[],
     attributeType: string
-) {
+): Record[] {
     const attributeIdToRecordMap = new Map<string, Record>()
     attributes.forEach((attribute) => {
         attributeIdToRecordMap.set(attribute.getId().getValue(), attribute)
@@ -337,20 +336,21 @@ function validateAttributesAndAssociations(
         })
     )
 
-    const orphanedAttributes = Array.from(attributeIds).filter((id) => !referencedAttributeIds.has(id))
-    if (orphanedAttributes.length > 0) {
-        const orphanedAttributeNames = orphanedAttributes
-            .map((id) => {
-                const attribute = attributeIdToRecordMap.get(id)
-                return attribute?.get('name')?.getValue() || id
-            })
-            .join(', ')
+    const orphanedAttributeIds = Array.from(attributeIds).filter((id) => !referencedAttributeIds.has(id))
+    return orphanedAttributeIds
+        .map((id) => attributeIdToRecordMap.get(id))
+        .filter((record): record is Record => record !== undefined)
+}
 
-        throw new Error(
-            `Found ${orphanedAttributes.length} attribute record(s) without route associations: ${orphanedAttributeNames}. ` +
-                `Either associate these attributes with routes or delete them.`
-        )
-    }
+function validateAttributesAndAssociations(
+    attributes: Record[],
+    attributeRouteAssociations: Record[],
+    attributeType: string
+) {
+    const attributeIdToRecordMap = new Map<string, Record>()
+    attributes.forEach((attribute) => {
+        attributeIdToRecordMap.set(attribute.getId().getValue(), attribute)
+    })
 
     const invalidAttributeAssociations = attributeRouteAssociations.filter((association) => {
         const attr = association.get(`web_service_${attributeType}`)
@@ -467,9 +467,7 @@ export const RestApiPlugin = Plugin.create({
                  * Case 1: No m2m records exists for a header or parameter record. Can happen in following scenarios:
                  *      - User has created a header or parameter record but these records are not associated with any routes on instance.
                  *      - User has removed all the m2m associations on instance but not the actual header or parameter record.
-                 * Solution: Throw error guiding user to do one of the following:
-                 *      - Associate the header or parameter record with a route
-                 *      - Delete the header or parameter record
+                 * Solution: Return orphaned attributes as unhandled records for partial success
                  *
                  * Case 2: Deleting a header record on instance wouldn't delete the m2m records which map those headers to a route.
                  * Solution: Throw error and request the user to cleanup the m2m records on instance.
@@ -477,6 +475,10 @@ export const RestApiPlugin = Plugin.create({
                 validateAttributesAndAssociations(headers, headerRouteAssociations, 'header')
                 validateAttributesAndAssociations(parameters, paramRouteAssociations, 'query_parameter')
 
+                const orphanedHeaders = findOrphanedAttributes(headers, headerRouteAssociations, 'header')
+                const orphanedParameters = findOrphanedAttributes(parameters, paramRouteAssociations, 'query_parameter')
+                const unhandledRecords = [...orphanedHeaders, ...orphanedParameters]
+
                 const routesWithScript = await Promise.all(
                     routes.map(async (r) => {
                         const script = await NowIncludeShape.fromRecord(r, r.get('operation_script'), transform)
@@ -519,32 +521,42 @@ export const RestApiPlugin = Plugin.create({
                     })
                 )
 
+                const shape = new CallExpressionShape({
+                    source: record,
+                    callee: 'RestApi',
+                    args: [
+                        record
+                            .transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                active: $.toBoolean().def(true),
+                                consumes: $.def(DEFAULT_MEDIA_TYPE),
+                                produces: $.def(DEFAULT_MEDIA_TYPE),
+                                enforceAcl: $.from('enforce_acl')
+                                    .map((v) => splitAcls(v))
+                                    .def([DEFAULT_REST_ENFORCED_ACL]),
+                                serviceId: $.from('service_id'),
+                                shortDescription: $.from('short_description').def(''),
+                                policy: $.from('sys_policy').def(''),
+                                docLink: $.from('doc_link').def(''),
+                                routes: $.val(routesWithScript).def([]),
+                                versions: $.val(versionsTransform(versions)).def([]),
+                            }))
+                            .withAliasedKeys(restDefAliases),
+                    ],
+                })
+
+                if (unhandledRecords.length > 0) {
+                    return {
+                        success: 'partial',
+                        value: shape,
+                        unhandledRecords,
+                    }
+                }
+
                 return {
                     success: true,
-                    value: new CallExpressionShape({
-                        source: record,
-                        callee: 'RestApi',
-                        args: [
-                            record
-                                .transform(({ $ }) => ({
-                                    $id: $.val(NowIdShape.from(record)),
-                                    name: $,
-                                    active: $.toBoolean().def(true),
-                                    consumes: $.def(DEFAULT_MEDIA_TYPE),
-                                    produces: $.def(DEFAULT_MEDIA_TYPE),
-                                    enforceAcl: $.from('enforce_acl')
-                                        .map((v) => splitAcls(v))
-                                        .def([DEFAULT_REST_ENFORCED_ACL]),
-                                    serviceId: $.from('service_id'),
-                                    shortDescription: $.from('short_description').def(''),
-                                    policy: $.from('sys_policy').def(''),
-                                    docLink: $.from('doc_link').def(''),
-                                    routes: $.val(routesWithScript).def([]),
-                                    versions: $.val(versionsTransform(versions)).def([]),
-                                }))
-                                .withAliasedKeys(restDefAliases),
-                        ],
-                    }),
+                    value: shape,
                 }
             },
         },

package/src/server-module-plugin/index.ts

@@ -13,13 +13,12 @@ import {
     type Package,
     type Record,
 } from '@servicenow/sdk-build-core'
-import { NowConfig, path as pathModule, ts, type FileSystem } from '@servicenow/sdk-build-core'
+import { NowConfig, path as pathModule, ts, type FileSystem, type Logger } from '@servicenow/sdk-build-core'
 import { RepackService } from '../repack'
 import { SBOMBuilder } from './sbom-builder'
 import isEqual from 'lodash/isEqual'
 import { INVALID_XML_CHARACTERS, applyPathMappings } from '../utils'
 import zip from 'lodash/zip'
-import type { DependencyNode } from '@servicenow/sdk-repack'
 
 const GLUE_CODE_PREFIX = '// @fluent-module'
 const GLUE_CODE_META_REGEX = new RegExp(`^${GLUE_CODE_PREFIX} (.*);(true|false);(.*)`) // name;isDefault;path
@@ -32,7 +31,34 @@ const GLUE_CODE_WARNING = `
 // SDK from regenerating it. However, you will then be responsible for the
 // management of this code in your Fluent file.`
 
-const NODE_MODULES = 'node_modules'
+export const NODE_MODULES = 'node_modules'
+
+/**
+ * Check if a module matches any trusted module patterns.
+ * Supports exact matches ('lodash', '@servicenow/sdk') and org wildcards ('@servicenow/*').
+ * Invalid patterns (like '*' or 'lodash-*-utils') are ignored.
+ */
+function isModuleTrusted(moduleName: string, trustedModules: string[], logger: Logger): boolean {
+    if (trustedModules.length === 0) {
+        return false
+    }
+
+    return trustedModules.some((pattern) => {
+        // @org/* pattern
+        if (pattern.startsWith('@') && pattern.endsWith('/*')) {
+            return moduleName.startsWith(pattern.slice(0, -1))
+        }
+
+        // Exact match (no wildcards allowed)
+        if (!pattern.includes('*')) {
+            return moduleName === pattern
+        }
+
+        // Invalid pattern, ignore
+        logger.warn(`Invalid trusted module pattern used in fluent config: ${pattern}`)
+        return false
+    })
+}
 
 type GlueCodeMeta = {
     name: string
@@ -223,41 +249,7 @@ function isValidRequireCall(callExpression: ts.CallExpression, requirePath: ts.S
     return isRequire && !isRelativePath
 }
 
-function buildParentPathMap(dependencyNodes: DependencyNode[]): { [key: string]: string[] } {
-    const importerMap: { [key: string]: string[] } = {}
-    for (const node of dependencyNodes) {
-        let parent = node.parentPackage
-
-        while (parent) {
-            const importerMapKey = `${node.pkgName}@${node.updatedManifest.version}`
-            if (!importerMap[importerMapKey]) {
-                importerMap[importerMapKey] = []
-            }
-            if (parent.pkgName) {
-                importerMap[importerMapKey].push(parent.pkgName)
-            }
-
-            const newParent = dependencyNodes.find((potentialParent) => {
-                if (!parent || !parent.pkgName) {
-                    return false
-                }
-                if (potentialParent.updatedManifest.dependencies[parent!.pkgName]) {
-                    return potentialParent
-                }
-                return false
-            })
-            parent = newParent
-                ? {
-                      pkgName: newParent.updatedManifest.name,
-                      version: newParent.updatedManifest.version,
-                  }
-                : undefined
-        }
-    }
-    return importerMap
-}
-
-class ModuleDependencyShape extends Shape {
+export class ModuleDependencyShape extends Shape {
     private readonly moduleName: string
 
     constructor({
@@ -278,9 +270,12 @@ class ModuleDependencyShape extends Shape {
 
 // TODO: Need to have some invalidation mechanism. Maybe the plugin framework can provide plugins with a managed cache to use for stuff like this?
 let DEPENDENCY_CACHE: globalThis.Record<string, Result<ModuleDependencyShape>> = {}
+// Track external module record IDs for SBOM generation (not persisted to XML)
+let EXTERNAL_MODULE_IDS: Set<string> = new Set()
 // Expose cache clearing for tests
 export function clearDependencyCache() {
     DEPENDENCY_CACHE = {}
+    EXTERNAL_MODULE_IDS = new Set()
 }
 
 function parseModuleDependency(
@@ -321,7 +316,11 @@ function parseModuleDependency(
 
 function generateSBOMContent(context: RecordContext) {
     const { database } = context
-    const moduleRecords = database.query('sys_module', { external_source: true })
+    // Query sys_module records that are tracked as external
+    const moduleRecords = database.query('sys_module').filter((mod) => {
+        const recordId = mod.getId().getValue()
+        return EXTERNAL_MODULE_IDS.has(recordId)
+    })
     const sbomBuilder = new SBOMBuilder()
     for (const mod of moduleRecords) {
         const modulePath = mod.get('path').asString().getValue()
@@ -335,34 +334,16 @@ function generateSBOMContent(context: RecordContext) {
 
 function getModuleDependencyPath(
     config: NowConfig,
-    module: { name: string; file: string; version: string; packageJson: Package; importerPath?: string[] }
+    module: { name: string; file: string; version: string; packageJson: Package; modulePath?: string }
 ) {
-    const { name, file, packageJson, importerPath, version } = module
+    const { name, file, packageJson, modulePath, version } = module
 
     if (NowConfig.legacyPackageResolution(config)) {
         return NowConfig.moduleResolutionPath(config, packageJson, true, name, version, file)
     }
 
-    if (config.hoistDependencies) {
-        return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
-    }
-
-    if (importerPath && importerPath.length > 0) {
-        const pathSegments = [...importerPath].reverse()
-        const pathSegmentsWithNodeModules: string[] = []
-        pathSegments.forEach((segment) => {
-            pathSegmentsWithNodeModules.push(NODE_MODULES)
-            pathSegmentsWithNodeModules.push(segment)
-        })
-        return NowConfig.moduleResolutionPath(
-            config,
-            packageJson,
-            true,
-            ...pathSegmentsWithNodeModules,
-            NODE_MODULES,
-            name,
-            file
-        )
+    if (modulePath) {
+        return NowConfig.moduleResolutionPath(config, packageJson, true, modulePath, file)
     }
 
     return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
@@ -477,7 +458,8 @@ export const ServerModulePlugin = Plugin.create({
             shape: ModuleDependencyShape,
             fileTypes: ['module'],
             // TODO: When managed cache is provided to plugins, cache dependencies that were already handled to avoid reprocessing
-            async toRecord(shape, { packageJson, diagnostics, fs, logger, project, factory, config }) {
+            async toRecord(shape, context) {
+                const { packageJson, diagnostics, fs, logger, project, factory, config } = context
                 if (config.type === 'configuration') {
                     throw new Error(`Modules cannot be used in a configuration project`)
                 }
@@ -491,27 +473,30 @@ export const ServerModulePlugin = Plugin.create({
                     return { success: false }
                 }
 
+                const isTrusted = isModuleTrusted(parentName, config.trustedModules, logger)
                 const id = `${parentName}@${version}`
                 const repack = await RepackService.create(logger, fs, project.getRootDir())
                 const dependencyNodes = await repack.execute({
                     id,
                     entry: entry ? [entry] : ['.'],
+                    legacyPackageResolution: NowConfig.legacyPackageResolution(config),
                 })
                 if (!dependencyNodes) {
                     throw new Error(`Failed to build dependency ${id}`)
                 }
 
-                let importerMap: { [key: string]: string[] } = {}
-                if (!config.hoistDependencies) {
-                    importerMap = buildParentPathMap(dependencyNodes)
-                }
-
                 const modules: { id: string; path: string; content: string }[] = []
                 const { Lint } = await import('../repack/lint/index.js')
                 for (const node of dependencyNodes) {
-                    const { packagePath, files, updatedManifest, pkgName } = node
+                    const { packagePath, files, updatedManifest, originalPath } = node
                     const { name, version } = updatedManifest
 
+                    const { modulePath, idPath } = buildDependencyPackagePath(
+                        project.getRootDir(),
+                        name,
+                        version,
+                        originalPath
+                    )
                     for (const file of files) {
                         const fileContent = fs.readFileSync(pathModule.join(packagePath, file)).toString('utf-8')
                         if (/(.js|.cjs|.mjs)$/.test(pathModule.extname(file))) {
@@ -522,15 +507,16 @@ export const ServerModulePlugin = Plugin.create({
                             }
                         }
 
-                        const importerPath = importerMap[`${pkgName}@${version}`]
                         modules.push({
-                            id: `${name}@${version}/${file}`,
+                            id: NowConfig.legacyPackageResolution(config)
+                                ? `${name}@${version}/${file}`
+                                : `${idPath}@${version}/${file}`,
                             path: getModuleDependencyPath(config, {
                                 name,
                                 file,
                                 version,
                                 packageJson,
-                                ...(importerPath ? { importerPath } : {}),
+                                modulePath,
                             }),
                             content: fileContent,
                         })
@@ -539,21 +525,22 @@ export const ServerModulePlugin = Plugin.create({
 
                 const records: Record[] = []
                 for (const m of modules) {
-                    records.push(
-                        await factory.createRecord({
-                            source: shape,
-                            table: 'sys_module',
-                            explicitId: m.id,
-                            properties: {
-                                path: m.path,
-                                content: Shape.from(shape, sanitizeModuleContent(m.content))
-                                    .asString()
-                                    .withContentType('cdata'),
-                                external_source: true,
-                                sys_name: m.path,
-                            },
-                        })
-                    )
+                    const record = await factory.createRecord({
+                        source: shape,
+                        table: 'sys_module',
+                        explicitId: m.id,
+                        properties: {
+                            path: m.path,
+                            content: Shape.from(shape, sanitizeModuleContent(m.content))
+                                .asString()
+                                .withContentType('cdata'),
+                            external_source: !isTrusted,
+                            sys_name: m.path,
+                        },
+                    })
+                    // Track external module IDs for SBOM generation
+                    EXTERNAL_MODULE_IDS.add(record.getId().getValue())
+                    records.push(record)
                 }
 
                 const [first, ...rest] = records
@@ -599,3 +586,42 @@ export const ServerModulePlugin = Plugin.create({
         },
     ],
 })
+
+/**
+ * Builds a relative dependency package path from an absolute path.
+ * Handles special cases for monorepo dependencies and pnpm-style paths.
+ *
+ * @param rootDir - The project root directory
+ * @param name - The package name
+ * @param version - The package version
+ * @param path - The absolute path to the package (optional)
+ * @returns Relative path suitable for module resolution
+ */
+function buildDependencyPackagePath(
+    rootDir: string,
+    name: string,
+    version: string,
+    path?: string
+): {
+    modulePath: string
+    idPath: string
+} {
+    let relative = pathModule.relative(rootDir, path ?? '')
+    const isMonorepoDependency = relative.includes(`../`)
+    const isPnpm = relative.includes('.pnpm')
+    if (isMonorepoDependency) {
+        // Treat monorepo node_modules as if they are inside app node_modules
+        relative = relative.replaceAll('../', '').replaceAll('+', '/')
+    }
+    if (isPnpm) {
+        // Do our best to turn this pnpm path into an npm path
+        relative = relative.replaceAll('+', '/').replaceAll(`node_modules/.pnpm/${name}@${version}/`, '')
+    }
+
+    // IDs will resemble the legacy paths and share sys_ids if possible
+    const idPath = relative.replaceAll('node_modules/', '').replaceAll('.pnpm/', '')
+    return {
+        modulePath: relative,
+        idPath,
+    }
+}

package/src/service-catalog/catalog-clientscript-plugin.ts

@@ -0,0 +1,140 @@
+import { CallExpressionShape, Plugin, type PropertyAccessShape } from '@servicenow/sdk-build-core'
+import { NowIdShape } from '../now-id-plugin'
+import {
+    getUITypeFromId,
+    getUITypeId,
+    APPLIES_TO_CATALOG_ITEM,
+    createScript,
+    createVariablePropertyAccess,
+    getTargetRecord,
+    resolveCatalogReferences,
+    resolveAndValidateVariableId,
+} from './utils'
+import { validateCatalogItemVariableSetExclusivity } from './service-catalog-diagnostics'
+
+export const CatalogClientScriptPlugin = Plugin.create({
+    name: 'CatalogClientScriptPlugin',
+    records: {
+        catalog_script_client: {
+            async toShape(record, { database, transform }) {
+                let propertyAccess: PropertyAccessShape | string | undefined
+                if (
+                    record.get('type').asString().getValue() === 'onChange' &&
+                    !record.get('cat_variable')?.ifString()?.isEmpty()
+                ) {
+                    const variableId = record.get('cat_variable').asString()?.getValue()?.replace('IO:', '')
+                    const varRecord = database.get('item_option_new', variableId)
+
+                    if (varRecord?.isRecord()) {
+                        const appliesToRecord = getTargetRecord(record, database)
+                        propertyAccess =
+                            (appliesToRecord?.isRecord() &&
+                                createVariablePropertyAccess(varRecord, record, appliesToRecord)) ||
+                            variableId
+                    } else {
+                        propertyAccess = variableId
+                    }
+                }
+
+                const { catalogItemReference, variableSetReference } = resolveCatalogReferences(record, database)
+                const script = await createScript(record, record.get('script'), transform, 'script')
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'CatalogClientScript',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                script: $.val(script).def(''),
+                                global: $.toBoolean().def(true),
+                                active: $.toBoolean().def(true),
+                                type: $,
+                                uiType: $.from('ui_type')
+                                    .map((v) =>
+                                        v.ifString()?.isEmpty() ? undefined : getUITypeFromId(v.toNumber()?.getValue())
+                                    )
+                                    .def('desktop'),
+                                catalogItem: $.val(catalogItemReference).def(''),
+                                variableName: $.val(propertyAccess).def(''),
+                                variableSet: $.val(variableSetReference).def(''),
+                                appliesTo: $.from('applies_to').def(APPLIES_TO_CATALOG_ITEM),
+                                appliesOnCatalogItemView: $.from('applies_catalog').toBoolean().def(true),
+                                appliesOnRequestedItems: $.from('applies_req_item').toBoolean().def(false),
+                                appliesOnCatalogTasks: $.from('applies_sc_task').toBoolean().def(false),
+                                appliesOnTargetRecord: $.from('applies_target_record').toBoolean().def(false),
+                                vaSupported: $.from('va_supported').toBoolean().def(false),
+                                publishedRef: $.from('published_ref').def(''),
+                                isolateScript: $.from('isolate_script').toBoolean().def(true),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'CatalogClientScript') {
+                    return { success: false }
+                }
+                const catalogClientScriptArgs = callExpression.getArgument(0).asObject()
+
+                // Validate catalogItem and variableSet are mutually exclusive
+                validateCatalogItemVariableSetExclusivity(catalogClientScriptArgs, diagnostics, 'CatalogClientScript')
+
+                // Check that uiType is 'onChange' only
+                const typeValue = catalogClientScriptArgs.get('type')?.toString()?.getValue()
+                // Handle variableName - extract name and ID from PropertyAccessShape
+
+                let variableId: string | undefined
+                const appliedTo: 'set' | 'item' =
+                    catalogClientScriptArgs.get('appliesTo')?.toString()?.getValue() === 'set'
+                        ? 'set'
+                        : APPLIES_TO_CATALOG_ITEM
+                if (typeValue && typeValue === 'onChange') {
+                    variableId = resolveAndValidateVariableId(
+                        catalogClientScriptArgs.get('variableName', false),
+                        appliedTo,
+                        catalogClientScriptArgs.get('variableSet', false),
+                        catalogClientScriptArgs.get('catalogItem', false),
+                        diagnostics
+                    )
+                }
+
+                const record = await factory.createRecord({
+                    source: callExpression,
+                    table: 'catalog_script_client',
+                    explicitId: catalogClientScriptArgs.get('$id'),
+                    properties: catalogClientScriptArgs.transform(({ $ }) => ({
+                        name: $,
+                        active: $.def(true),
+                        global: $.def(true),
+                        script: $.toCdata(),
+                        type: $,
+                        applies_to: $.from('appliesTo').def(APPLIES_TO_CATALOG_ITEM),
+                        cat_item: $.from('catalogItem').def(''),
+                        variable_set: $.from('variableSet').def(''),
+                        cat_variable: $.val(variableId).def(''),
+                        applies_catalog: $.from('appliesOnCatalogItemView').def(true),
+                        applies_req_item: $.from('appliesOnRequestedItems').def(false),
+                        applies_sc_task: $.from('appliesOnCatalogTasks').def(false),
+                        applies_target_record: $.from('appliesOnTargetRecord').def(false),
+                        isolate_script: $.from('isolateScript').def(true),
+                        ui_type: $.from('uiType')
+                            .map((v) => (v.isString() && !v.isEmpty() ? getUITypeId(v.getValue()) : undefined))
+                            .def(0),
+                        va_supported: $.from('vaSupported').toBoolean().def(false),
+                        published_ref: $.from('publishedRef').def(''),
+                    })),
+                })
+                return { success: true, value: record }
+            },
+        },
+    ],
+})