@servicenow/sdk-build-plugins 4.4.1 → 4.6.0

package/src/html-import-plugin.ts

@@ -25,6 +25,7 @@ const getDeclarationAndModuleSpecifierIfHtml = (node: ts.Node): [ts.ImportDeclar
 
 export const HtmlImportPlugin = Plugin.create({
     name: 'HtmlImportPlugin',
+    docs: [],
     shapes: [
         {
             shape: StringShape,

package/src/import-sets-plugin.ts

@@ -9,6 +9,7 @@ import {
 import { NowIdShape } from './now-id-plugin'
 import { ModuleFunctionShape } from './server-module-plugin'
 import { NowIncludeShape } from './now-include-plugin'
+import { createSdkDocEntry } from './utils'
 
 // ============================================================================
 // CONSTANTS & CONFIGURATION
@@ -223,6 +224,7 @@ async function mapTransformScriptsToShape(scripts: Record[], transform: Transfor
 
 export const ImportSetPlugin = Plugin.create({
     name: 'ImportSetPlugin',
+    docs: [createSdkDocEntry('ImportSet', ['sys_transform_map'])],
     records: {
         sys_transform_entry: {
             coalesce: ['map', 'target_field'],

package/src/inbound-email-action-plugin.ts

@@ -0,0 +1,145 @@
+import { CallExpressionShape, Plugin, isGUID, type Shape, type ShapeTransform } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+import { NowIncludeShape } from './now-include-plugin'
+import { ModuleFunctionShape } from './server-module-plugin'
+import { createSdkDocEntry, showGuidFieldDiagnostic } from './utils'
+import { parseString, convertRolesToString } from './service-catalog/utils'
+
+/**
+ * Plugin for handling Inbound Email Action records (sysevent_in_email_action).
+ *
+ * Default Behavior:
+ * - When reading from XML: If 'action' field is missing or empty, defaults to 'record_action'
+ * - When writing to Fluent: The 'action' field is required in the type definition for proper
+ *   discriminated union type narrowing
+ */
+export const InboundEmailActionPlugin = Plugin.create({
+    name: 'InboundEmailActionPlugin',
+    docs: [createSdkDocEntry('InboundEmailAction', ['sysevent_in_email_action'])],
+    records: {
+        sysevent_in_email_action: {
+            async toShape(record, { transform }) {
+                const actionType = record.get('action').getValue() || 'record_action'
+
+                // Process script
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'InboundEmailAction',
+                        args: [
+                            record.transform(({ $ }) => {
+                                const props: Record<string, ShapeTransform | undefined> = {
+                                    $id: $.val(NowIdShape.from(record)),
+                                    name: $,
+                                    description: $.def(''),
+                                    type: $.def('new'),
+                                    action: $.val(actionType),
+                                    active: $.toBoolean().def(false),
+                                    order: $.toNumber().def(100),
+                                    eventName: $.from('event_name').def('email.read'),
+                                    stopProcessing: $.from('stop_processing').toBoolean().def(false),
+                                    conditionScript: $.from('condition_script').def(''),
+                                    filterCondition: $.from('filter_condition').def(''),
+                                    from: $.def(''),
+                                    requiredRoles: $.from('required_roles')
+                                        .map((v: Shape) => parseString(v))
+                                        .def([]),
+                                }
+
+                                props['replyEmail'] = $.from('reply_email').def('')
+                                props['table'] = $.def('')
+                                props['script'] = $.val(script).def('')
+                                props['fieldAction'] = $.from('template').def('')
+                                props['assignmentOperator'] = $.from('assignment_operator').def('')
+
+                                return props
+                            }),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics }) {
+                if (callExpression.getCallee() !== 'InboundEmailAction') {
+                    return { success: false }
+                }
+
+                const args = callExpression.getArgument(0).asObject()
+
+                // Get action type to validate field restrictions
+                const actionArg = args.get('action')
+                const actionType = actionArg?.getValue() ?? 'record_action'
+
+                // Validate that fieldAction can only be used when table is set (for record_action)
+                if (actionType === 'record_action') {
+                    const tableArg = args.get('table')
+                    const fieldActionArg = args.get('fieldAction')
+                    const hasTable = tableArg?.isDefined() && !tableArg.toString().isEmpty()
+                    const hasFieldAction = fieldActionArg?.isDefined() && !fieldActionArg.toString().isEmpty()
+
+                    if (hasFieldAction && !hasTable) {
+                        diagnostics.error(
+                            fieldActionArg,
+                            `Field 'fieldAction' can only be used when 'table' is specified.`
+                        )
+                    }
+                }
+
+                // Validate the 'from' field: must be a GUID string or a Record<'sys_user'>
+                const fromArg = args.get('from')
+                if (fromArg?.isDefined()) {
+                    // Validate that if it's a string, it must be a valid GUID
+                    if (fromArg.isString() && !fromArg.isRecord()) {
+                        const fromStr = fromArg.asString().getValue()
+                        if (fromStr !== '' && !isGUID(fromStr)) {
+                            showGuidFieldDiagnostic(fromArg, 'from', 'sys_user', diagnostics)
+                        }
+                    }
+                }
+
+                const record = await factory.createRecord({
+                    source: callExpression,
+                    table: 'sysevent_in_email_action',
+                    explicitId: args.get('$id'),
+                    properties: args.transform(({ $ }) => ({
+                        name: $,
+                        description: $.def(''),
+                        table: $,
+                        type: $.def('new'),
+                        action: $.def('record_action'),
+                        active: $.toBoolean().def(false),
+                        order: $.toNumber().def(100),
+                        event_name: $.from('eventName').def('email.read'),
+                        stop_processing: $.from('stopProcessing').toBoolean().def(false),
+                        script: $.map(
+                            (v: Shape) =>
+                                v
+                                    .if(ModuleFunctionShape)
+                                    ?.toString(
+                                        (n) => `${n}({{PARAMS}})`,
+                                        ['current', 'event', 'email', 'logger', 'classifier']
+                                    ) ?? v
+                        ).toCdata(),
+                        condition_script: $.from('conditionScript').toCdata().def(''),
+                        filter_condition: $.from('filterCondition').def(''),
+                        template: $.from('fieldAction').toCdata().def(''),
+                        from: $.toString(),
+                        reply_email: $.from('replyEmail').toCdata().def(''),
+                        required_roles: $.from('requiredRoles').map(convertRolesToString).def(''),
+                        assignment_operator: $.from('assignmentOperator').def(''),
+                    })),
+                })
+
+                return { success: true, value: record }
+            },
+        },
+    ],
+})

package/src/index.ts

@@ -24,16 +24,24 @@ export * from './data-plugin'
 export * from './ui-page-plugin'
 export * from './list-plugin'
 export * from './ui-action-plugin'
+export * from './form-plugin'
 export * from './script-include-plugin'
 export * from './arrow-function-plugin'
 export * from './atf/test-plugin'
 export * from './service-portal/widget-plugin'
 export * from './service-portal/dependency-plugin'
 export * from './service-portal/angular-provider-plugin'
+export * from './service-portal/portal-plugin'
+export * from './service-portal/page-plugin'
+export * from './service-portal/theme-plugin'
+export * from './service-portal/menu-plugin'
+export * from './service-portal/header-footer-plugin'
+export * from './service-portal/page-route-map-plugin'
 export * from './rest-api-plugin'
 export * from './html-import-plugin'
 export * from './static-content-plugin'
 export * from './script-action-plugin'
+export * from './schedule-script'
 export * from './claims-plugin'
 export * from './flow/plugins/flow-action-definition-plugin'
 export * from './flow/plugins/wfa-datapill-plugin'
@@ -52,12 +60,17 @@ export * from './import-sets-plugin'
 export * from './now-attach-plugin'
 export * from './sla-plugin'
 export * from './email-notification-plugin'
+export * from './inbound-email-action-plugin'
 
 export * from './service-catalog'
 export * from './ux-list-menu-config-plugin'
 export * from './workspace-plugin'
 export * from './dashboard/dashboard-plugin'
 export * from './applicability-plugin'
+export * from './instance-scan-plugin'
 // non-plugins
 export * from './atf/step-configs'
 export { REPACK_OUTPUT_DIR, checkModuleExists, resolveModule } from './repack'
+export { FlowLogicValueProcessor } from './flow/flow-logic/flow-logic-plugin-helpers'
+export { FLOW_LOGIC } from './flow/flow-logic/flow-logic-constants'
+export { FlowActivationTask } from './flow/post-install'

package/src/instance-scan-plugin.ts

@@ -0,0 +1,313 @@
+import { CallExpressionShape, Plugin, type Record, type Context } from '@servicenow/sdk-build-core'
+import { ModuleFunctionShape } from './server-module-plugin'
+import { NowIdShape } from './now-id-plugin'
+import { NowIncludeShape } from './now-include-plugin'
+import { createSdkDocEntry } from './utils'
+
+const SCAN_COLUMN_TYPE_CHECK = 'scan_column_type_check'
+const SCAN_LINTER_CHECK = 'scan_linter_check'
+const SCAN_SCRIPT_ONLY_CHECK = 'scan_script_only_check'
+const SCAN_TABLE_CHECK = 'scan_table_check'
+
+export const InstanceScanPlugin = Plugin.create({
+    name: 'InstanceScanPlugin',
+    docs: [
+        createSdkDocEntry('ColumnTypeCheck', [SCAN_COLUMN_TYPE_CHECK]),
+        createSdkDocEntry('LinterCheck', [SCAN_LINTER_CHECK]),
+        createSdkDocEntry('ScriptOnlyCheck', [SCAN_SCRIPT_ONLY_CHECK]),
+        createSdkDocEntry('TableCheck', [SCAN_TABLE_CHECK]),
+    ],
+
+    records: {
+        [SCAN_COLUMN_TYPE_CHECK]: {
+            getUpdateName(record: Record, _context: Context) {
+                return { success: true, value: `${SCAN_COLUMN_TYPE_CHECK}_${record.getId().getValue()}` }
+            },
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'ColumnTypeCheck',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                active: $.toBoolean().def(true),
+                                category: $,
+                                priority: $,
+                                script: $.val(script).def(''),
+                                shortDescription: $.from('short_description'),
+                                description: $.def(''),
+                                resolutionDetails: $.from('resolution_details').def(''),
+                                documentationUrl: $.from('documentation_url').def(''),
+                                scoreMin: $.from('score_min').toNumber().def(0),
+                                scoreMax: $.from('score_max').toNumber().def(100),
+                                scoreScale: $.from('score_scale').toNumber().def(1),
+                                runCondition: $.from('run_condition').def(''),
+                                findingType: $.from('finding_type').def('scan_finding'),
+                                columnType: $.from('column_type'),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+        [SCAN_LINTER_CHECK]: {
+            getUpdateName(record: Record, _context: Context) {
+                return { success: true, value: `${SCAN_LINTER_CHECK}_${record.getId().getValue()}` }
+            },
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'LinterCheck',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                active: $.toBoolean().def(true),
+                                category: $,
+                                priority: $,
+                                script: $.val(script).def(''),
+                                shortDescription: $.from('short_description'),
+                                description: $.def(''),
+                                resolutionDetails: $.from('resolution_details').def(''),
+                                documentationUrl: $.from('documentation_url').def(''),
+                                scoreMin: $.from('score_min').toNumber().def(0),
+                                scoreMax: $.from('score_max').toNumber().def(100),
+                                scoreScale: $.from('score_scale').toNumber().def(1),
+                                runCondition: $.from('run_condition').def(''),
+                                findingType: $.from('finding_type').def('scan_finding'),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+        [SCAN_SCRIPT_ONLY_CHECK]: {
+            getUpdateName(record: Record, _context: Context) {
+                return { success: true, value: `${SCAN_SCRIPT_ONLY_CHECK}_${record.getId().getValue()}` }
+            },
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'ScriptOnlyCheck',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                active: $.toBoolean().def(true),
+                                category: $,
+                                priority: $,
+                                script: $.val(script).def(''),
+                                shortDescription: $.from('short_description'),
+                                description: $.def(''),
+                                resolutionDetails: $.from('resolution_details').def(''),
+                                documentationUrl: $.from('documentation_url').def(''),
+                                scoreMin: $.from('score_min').toNumber().def(0),
+                                scoreMax: $.from('score_max').toNumber().def(100),
+                                scoreScale: $.from('score_scale').toNumber().def(1),
+                                runCondition: $.from('run_condition').def(''),
+                                findingType: $.from('finding_type').def('scan_finding'),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+        [SCAN_TABLE_CHECK]: {
+            getUpdateName(record: Record, _context: Context) {
+                return { success: true, value: `${SCAN_TABLE_CHECK}_${record.getId().getValue()}` }
+            },
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'TableCheck',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                active: $.toBoolean().def(true),
+                                category: $,
+                                priority: $,
+                                script: $.val(script).def(''),
+                                shortDescription: $.from('short_description'),
+                                description: $.def(''),
+                                resolutionDetails: $.from('resolution_details').def(''),
+                                documentationUrl: $.from('documentation_url').def(''),
+                                scoreMin: $.from('score_min').toNumber().def(0),
+                                scoreMax: $.from('score_max').toNumber().def(100),
+                                scoreScale: $.from('score_scale').toNumber().def(1),
+                                runCondition: $.from('run_condition').def(''),
+                                findingType: $.from('finding_type').def('scan_finding'),
+                                table: $,
+                                advanced: $.toBoolean().def(false),
+                                conditions: $.def(''),
+                                useManifest: $.from('use_manifest').toBoolean().def(false),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(source, { factory }) {
+                if (source.getCallee() === 'ColumnTypeCheck') {
+                    const arg = source.getArgument(0).asObject()
+                    const record = await factory.createRecord({
+                        source,
+                        table: SCAN_COLUMN_TYPE_CHECK,
+                        explicitId: arg.get('$id'),
+                        properties: arg.transform(({ $ }) => ({
+                            name: $,
+                            active: $.toBoolean().def(true),
+                            category: $,
+                            priority: $,
+                            script: $.map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString((n) => `${n}({{PARAMS}})`, ['engine', 'current', 'columnValue']) ?? v
+                            )
+                                .toCdata()
+                                .def(''),
+                            short_description: $.from('shortDescription'),
+                            description: $.def(''),
+                            resolution_details: $.from('resolutionDetails').def(''),
+                            documentation_url: $.from('documentationUrl').def(''),
+                            score_min: $.from('scoreMin').toNumber().def(0),
+                            score_max: $.from('scoreMax').toNumber().def(100),
+                            score_scale: $.from('scoreScale').toNumber().def(1),
+                            run_condition: $.from('runCondition').def(''),
+                            finding_type: $.from('findingType').def('scan_finding'),
+                            column_type: $.from('columnType'),
+                        })),
+                    })
+                    return { success: true, value: record }
+                }
+
+                if (source.getCallee() === 'LinterCheck') {
+                    const arg = source.getArgument(0).asObject()
+                    const record = await factory.createRecord({
+                        source,
+                        table: SCAN_LINTER_CHECK,
+                        explicitId: arg.get('$id'),
+                        properties: arg.transform(({ $ }) => ({
+                            name: $,
+                            active: $.toBoolean().def(true),
+                            category: $,
+                            priority: $,
+                            script: $.map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString((n) => `${n}({{PARAMS}})`, ['engine', 'current', 'rootNode']) ?? v
+                            )
+                                .toCdata()
+                                .def(''),
+                            short_description: $.from('shortDescription'),
+                            description: $.def(''),
+                            resolution_details: $.from('resolutionDetails').def(''),
+                            documentation_url: $.from('documentationUrl').def(''),
+                            score_min: $.from('scoreMin').toNumber().def(0),
+                            score_max: $.from('scoreMax').toNumber().def(100),
+                            score_scale: $.from('scoreScale').toNumber().def(1),
+                            run_condition: $.from('runCondition').def(''),
+                            finding_type: $.from('findingType').def('scan_finding'),
+                        })),
+                    })
+                    return { success: true, value: record }
+                }
+
+                if (source.getCallee() === 'ScriptOnlyCheck') {
+                    const arg = source.getArgument(0).asObject()
+                    const record = await factory.createRecord({
+                        source,
+                        table: SCAN_SCRIPT_ONLY_CHECK,
+                        explicitId: arg.get('$id'),
+                        properties: arg.transform(({ $ }) => ({
+                            name: $,
+                            active: $.toBoolean().def(true),
+                            category: $,
+                            priority: $,
+                            script: $.map(
+                                (v) => v.if(ModuleFunctionShape)?.toString((n) => `${n}({{PARAMS}})`, ['engine']) ?? v
+                            )
+                                .toCdata()
+                                .def(''),
+                            short_description: $.from('shortDescription'),
+                            description: $.def(''),
+                            resolution_details: $.from('resolutionDetails').def(''),
+                            documentation_url: $.from('documentationUrl').def(''),
+                            score_min: $.from('scoreMin').toNumber().def(0),
+                            score_max: $.from('scoreMax').toNumber().def(100),
+                            score_scale: $.from('scoreScale').toNumber().def(1),
+                            run_condition: $.from('runCondition').def(''),
+                            finding_type: $.from('findingType').def('scan_finding'),
+                        })),
+                    })
+                    return { success: true, value: record }
+                }
+
+                if (source.getCallee() === 'TableCheck') {
+                    const arg = source.getArgument(0).asObject()
+
+                    const record = await factory.createRecord({
+                        source,
+                        table: SCAN_TABLE_CHECK,
+                        explicitId: arg.get('$id'),
+                        properties: arg.transform(({ $ }) => ({
+                            name: $,
+                            active: $.toBoolean().def(true),
+                            category: $,
+                            priority: $,
+                            script: $.map(
+                                (v) =>
+                                    v
+                                        .if(ModuleFunctionShape)
+                                        ?.toString((n) => `${n}({{PARAMS}})`, ['engine', 'current']) ?? v
+                            )
+                                .toCdata()
+                                .def(''),
+                            short_description: $.from('shortDescription'),
+                            description: $.def(''),
+                            resolution_details: $.from('resolutionDetails').def(''),
+                            documentation_url: $.from('documentationUrl').def(''),
+                            score_min: $.from('scoreMin').toNumber().def(0),
+                            score_max: $.from('scoreMax').toNumber().def(100),
+                            score_scale: $.from('scoreScale').toNumber().def(1),
+                            run_condition: $.from('runCondition').def(''),
+                            finding_type: $.from('findingType').def('scan_finding'),
+                            table: $,
+                            advanced: $.toBoolean().def(false),
+                            conditions: $.def(''),
+                            use_manifest: $.from('useManifest').toBoolean().def(false),
+                        })),
+                    })
+                    return { success: true, value: record }
+                }
+
+                return { success: false }
+            },
+        },
+    ],
+})

package/src/json-plugin.ts

@@ -49,6 +49,7 @@ export class JsonFileShape extends SourceFileShape {
 
 export const JsonPlugin = Plugin.create({
     name: 'JsonPlugin',
+    docs: [],
     shapes: [
         {
             shape: SourceFileShape,

package/src/list-plugin.ts

@@ -9,7 +9,7 @@ import {
     Database,
 } from '@servicenow/sdk-build-core'
 import { create } from 'xmlbuilder2'
-import { generateDeprecatedDiagnostics } from './utils'
+import { createSdkDocEntry, generateDeprecatedDiagnostics } from './utils'
 
 const DEFAULT_VIEW = 'Default view'
 const listElementAliases = {
@@ -65,6 +65,7 @@ function getListUpdateName(list: Record): string {
 
 export const ListPlugin = Plugin.create({
     name: 'ListPlugin',
+    docs: [createSdkDocEntry('List', ['sys_ui_list'])],
     records: {
         sys_ui_list: {
             composite: true,

package/src/now-attach-plugin.ts

@@ -211,6 +211,7 @@ export class NowAttachShape extends CallExpressionShape implements AssociateReco
 
 export const NowAttachPlugin = Plugin.create({
     name: 'NowAttachPlugin',
+    docs: [],
     records: {
         '*': {
             async toFile(record, { config, database, factory, transform }) {