@servicenow/sdk-build-plugins 4.1.1 → 4.3.0

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

@@ -13,7 +13,7 @@ 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'
@@ -34,6 +34,33 @@ const GLUE_CODE_WARNING = `
 
 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
     path: string
@@ -223,8 +250,8 @@ function isValidRequireCall(callExpression: ts.CallExpression, requirePath: ts.S
     return isRequire && !isRelativePath
 }
 
-function buildParentPathMap(dependencyNodes: DependencyNode[]) {
-    const importerMap = {}
+function buildParentPathMap(dependencyNodes: DependencyNode[]): { [key: string]: string[] } {
+    const importerMap: { [key: string]: string[] } = {}
     for (const node of dependencyNodes) {
         let parent = node.parentPackage
 
@@ -233,7 +260,9 @@ function buildParentPathMap(dependencyNodes: DependencyNode[]) {
             if (!importerMap[importerMapKey]) {
                 importerMap[importerMapKey] = []
             }
-            importerMap[importerMapKey].push(parent.pkgName)
+            if (parent.pkgName) {
+                importerMap[importerMapKey].push(parent.pkgName)
+            }
 
             const newParent = dependencyNodes.find((potentialParent) => {
                 if (!parent || !parent.pkgName) {
@@ -276,14 +305,22 @@ 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(
     node: ts.ImportDeclaration | ts.ExportDeclaration | ts.CallExpression
 ): Result<ModuleDependencyShape> {
+    //Check if this is a type only import and skip it
+    if (node.asKind(ts.SyntaxKind.ImportDeclaration)?.getImportClause()?.isTypeOnly()) {
+        return { success: false }
+    }
+
     let moduleName: string | undefined
     if (ts.Node.isImportDeclaration(node) && !node.isModuleSpecifierRelative()) {
         moduleName = node.getModuleSpecifierValue()
@@ -314,7 +351,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()
@@ -386,6 +427,7 @@ export const ServerModulePlugin = Plugin.create({
                         success: false,
                     }
                 }
+
                 const sbomContent = generateSBOMContent(context)
 
                 return {
@@ -417,6 +459,9 @@ export const ServerModulePlugin = Plugin.create({
             shape: SourceFileShape,
             fileTypes: ['module'],
             async toRecord(file, { factory, fs, diagnostics, project, config, packageJson, compiler }) {
+                if (config.type === 'configuration') {
+                    throw new Error(`Modules cannot be used in a configuration project`)
+                }
                 const path = file.getPath()
                 if (!path.startsWith(project.resolvePath(config.serverModulesDir))) {
                     return { success: false }
@@ -467,6 +512,10 @@ export const ServerModulePlugin = Plugin.create({
             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 }) {
+                if (config.type === 'configuration') {
+                    throw new Error(`Modules cannot be used in a configuration project`)
+                }
+
                 const dependencies = packageJson.dependencies ?? {}
                 const { name: parentName, entry } = validateAndGetModuleSpecifier(shape.getModuleName())
 
@@ -476,6 +525,7 @@ 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({
@@ -486,7 +536,7 @@ export const ServerModulePlugin = Plugin.create({
                     throw new Error(`Failed to build dependency ${id}`)
                 }
 
-                let importerMap = {}
+                let importerMap: { [key: string]: string[] } = {}
                 if (!config.hoistDependencies) {
                     importerMap = buildParentPathMap(dependencyNodes)
                 }
@@ -507,6 +557,7 @@ export const ServerModulePlugin = Plugin.create({
                             }
                         }
 
+                        const importerPath = importerMap[`${pkgName}@${version}`]
                         modules.push({
                             id: `${name}@${version}/${file}`,
                             path: getModuleDependencyPath(config, {
@@ -514,7 +565,7 @@ export const ServerModulePlugin = Plugin.create({
                                 file,
                                 version,
                                 packageJson,
-                                importerPath: importerMap[`${pkgName}@${version}`],
+                                ...(importerPath ? { importerPath } : {}),
                             }),
                             content: fileContent,
                         })
@@ -523,21 +574,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

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 }
+            },
+        },
+    ],
+})

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

@@ -0,0 +1,162 @@
+import {
+    CallExpressionShape,
+    Plugin,
+    type Record,
+    VariableStatementShape,
+    IdentifierShape,
+} from '@servicenow/sdk-build-core'
+import { buildVariableRecords } from './shape-to-record'
+import {
+    toValidIdentifier,
+    shouldWriteAsCallExpression,
+    validateRequestedForVariableConflict,
+    validateVariableNameConflicts,
+    createScript,
+} from './utils'
+import { validateFulfillmentProcessExclusivity, validateCategoriesRequireCatalogs } from './service-catalog-diagnostics'
+import {
+    buildVariablesSchema,
+    CatalogItemBaseRelationships,
+    CatalogItemBaseCoalesce,
+    transformCatalogBaseFieldsToShape,
+    transformCatalogItemBaseFieldsToRecord,
+    transformCatalogItemSpecificFieldsToShape,
+    transformCatalogItemSpecificFieldsToRecord,
+    createSharedM2MRecords,
+} from './service-catalog-base'
+
+export const CatalogItemPlugin = Plugin.create({
+    name: 'CatalogItemPlugin',
+    records: {
+        sc_cat_item: {
+            relationships: CatalogItemBaseRelationships,
+            async toShape(record, { descendants, transform, logger }) {
+                const variablesSchema = buildVariablesSchema(descendants, logger)
+                const deliveryPlanScript = await createScript(
+                    record,
+                    record.get('delivery_plan_script'),
+                    transform,
+                    'delivery-plan-script'
+                )
+                const entitlementScript = await createScript(
+                    record,
+                    record.get('entitlement_script'),
+                    transform,
+                    'entitlement-script'
+                )
+                const callExpression = new CallExpressionShape({
+                    source: record,
+                    callee: 'CatalogItem',
+                    args: [
+                        record.transform(({ $ }) => ({
+                            ...transformCatalogBaseFieldsToShape(record, $, descendants),
+                            ...transformCatalogItemSpecificFieldsToShape(record, $, descendants),
+                            entitlementScript: $.val(entitlementScript).def(''),
+                            deliveryPlanScript: $.val(deliveryPlanScript).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').toString().getValue()),
+                              }),
+                              initializer: callExpression,
+                          }),
+                }
+            },
+        },
+        ...CatalogItemBaseCoalesce,
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'CatalogItem') {
+                    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)
+
+                // Validate all RequestedForVariable constraints (direct variables + variable sets) in a single optimized pass
+                if (!validateRequestedForVariableConflict(arg, diagnostics, 'CatalogItem')) {
+                    return { success: false }
+                }
+
+                // Validate that variable names don't conflict between direct variables and variable sets
+                if (!validateVariableNameConflicts(arg, diagnostics, 'CatalogItem')) {
+                    return { success: false }
+                }
+
+                const catItem = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sc_cat_item',
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        ...transformCatalogItemBaseFieldsToRecord($),
+                        ...transformCatalogItemSpecificFieldsToRecord(arg, $),
+                    })),
+                })
+                const m2mRecords = await createSharedM2MRecords(callExpression, arg, catItem, factory)
+                let variableRecords: Record[] = []
+                if (arg.get('variables').isDefined()) {
+                    const variablesConfig = arg.get('variables').asObject()
+                    variableRecords = await buildVariableRecords({
+                        variablesConfig,
+                        factory,
+                        parent: catItem,
+                        diagnostics,
+                    })
+                }
+                const pricingDetails = arg.get('pricingDetails').ifArray()?.getElements() ?? []
+                const pricingDetailsRecords: Record[] = []
+                for (const pricingDetail of pricingDetails) {
+                    const pricingDetailObj = pricingDetail.asObject()
+                    pricingDetailsRecords.push(
+                        await factory.createRecord({
+                            source: callExpression,
+                            table: 'fx_price',
+                            properties: {
+                                id: catItem,
+                                amount: pricingDetailObj.get('amount')?.getValue(),
+                                currency: pricingDetailObj.get('currencyType')?.getValue(),
+                                type: 'calculated',
+                                field: pricingDetailObj.get('field')?.getValue(),
+                                table: 'sc_cat_item',
+                            },
+                        })
+                    )
+                }
+
+                return {
+                    success: true,
+                    value: catItem.with(
+                        ...m2mRecords.catalogsRecords,
+                        ...m2mRecords.categoriesRecords,
+                        ...m2mRecords.variableSetRecords,
+                        ...m2mRecords.availableForRecords,
+                        ...m2mRecords.notAvailableForRecords,
+                        ...m2mRecords.assignedTopicsRecords,
+                        ...pricingDetailsRecords,
+                        ...variableRecords
+                    ),
+                }
+            },
+        },
+    ],
+})