@servicenow/sdk-build-plugins 4.6.0 → 4.6.1

package/src/ui-policy-plugin.ts

@@ -108,128 +108,35 @@ export const UiPolicyPlugin = Plugin.create({
                 },
             },
             toShape(record, { descendants }) {
-                const actions = descendants
-                    .query(SYS_UI_POLICY_ACTION)
-                    .map((action) => {
-                        const fieldValue = action.get('field')?.ifString()?.getValue()
-                        if (!fieldValue) {
-                            return null // Skip actions without a field
-                        }
-
-                        const actionObj: {
-                            field: string
-                            visible?: boolean | 'ignore'
-                            readOnly?: boolean | 'ignore'
-                            mandatory?: boolean | 'ignore'
-                            cleared?: boolean
-                            table?: string
-                            value?: string
-                            fieldMessage?: string
-                            fieldMessageType?: string
-                            valueAction?: string
-                        } = {
-                            field: fieldValue,
-                        }
-
-                        // Convert ServiceNow string format to boolean | 'ignore'
-                        const visible = stringToBoolean(action.get('visible')?.ifString()?.getValue())
-                        const disabled = stringToBoolean(action.get('disabled')?.ifString()?.getValue())
-                        const mandatory = stringToBoolean(action.get('mandatory')?.ifString()?.getValue())
-
-                        // Only include visible if it's not 'ignore'
-                        if (visible !== undefined && visible !== 'ignore') {
-                            actionObj.visible = visible
-                        }
-
-                        // Convert 'disabled' to 'readOnly'
-                        // Only include 'readOnly' if it's not 'ignore'
-                        if (disabled !== undefined && disabled !== 'ignore') {
-                            actionObj.readOnly = disabled
-                        }
-
-                        // Only include mandatory if it's not 'ignore'
-                        if (mandatory !== undefined && mandatory !== 'ignore') {
-                            actionObj.mandatory = mandatory
-                        }
-
-                        const cleared = action.get('cleared')?.ifBoolean()?.getValue()
-                        if (cleared) {
-                            actionObj.cleared = cleared
-                        }
-
-                        // Add new optional fields - only if they have meaningful values
-                        const table = action.get('table')?.ifString()?.getValue()
-                        const parentTable = record.get('table')?.ifString()?.getValue()
-                        // Only include table if it's different from the parent policy's table
-                        if (table && table !== parentTable) {
-                            actionObj.table = table
-                        }
-
-                        const value = action.get('value')?.ifString()?.getValue()
-                        if (value) {
-                            actionObj.value = value
-                        }
-
-                        const fieldMessage = action.get('field_message')?.ifString()?.getValue()
-                        if (fieldMessage) {
-                            actionObj.fieldMessage = fieldMessage
-                        }
-
-                        const fieldMessageType = action.get('field_message_type')?.ifString()?.getValue()
-                        // Only include if it's not the default value 'none'
-                        if (fieldMessageType && fieldMessageType !== 'none') {
-                            actionObj.fieldMessageType = fieldMessageType
-                        }
-
-                        const valueAction = action.get('value_action')?.ifString()?.getValue()
-                        // Only include if it's not the default value 'ignore'
-                        if (valueAction && valueAction !== 'ignore') {
-                            actionObj.valueAction = valueAction
-                        }
-
-                        // Skip actions that have no meaningful properties (all are 'ignore')
-                        if (Object.keys(actionObj).length === 1) {
-                            return null // Only 'field' property exists, skip this action
-                        }
+                const actions = descendants.query(SYS_UI_POLICY_ACTION).map((action) => {
+                    return action.transform(({ $ }) => ({
+                        field: $,
+                        visible: $.map((v) => stringToBoolean(v?.asString()?.getValue())).def('ignore'),
+                        readOnly: $.from('disabled')
+                            .map((v) => stringToBoolean(v?.asString()?.getValue()))
+                            .def('ignore'),
+                        mandatory: $.map((v) => stringToBoolean(v?.asString()?.getValue())).def('ignore'),
+                        cleared: $.toBoolean().def(false),
+                        table: $.def(''),
+                        value: $.def(''),
+                        fieldMessage: $.from('field_message').def(''),
+                        fieldMessageType: $.from('field_message_type').def('none'),
+                        valueAction: $.from('value_action').def('ignore'),
+                    }))
+                })
 
-                        return actionObj
-                    })
-                    .filter((action) => action !== null) // Remove null actions
-
-                // Process related list actions
-                const relatedListActions = descendants
-                    .query(SYS_UI_POLICY_RL_ACTION)
-                    .map((rlAction) => {
-                        const rlActionObj: {
-                            list?: string
-                            visible?: boolean | 'ignore'
-                        } = {}
-
-                        const listValue = rlAction.get('list')?.ifString()?.getValue()
-                        if (listValue) {
-                            // Strip REL: prefix if present (transform ServiceNow → Fluent)
-                            // Users write plain GUIDs or table.field format in Fluent code
-                            if (listValue.startsWith('REL:')) {
-                                rlActionObj.list = listValue.substring(4) // Remove 'REL:' prefix
-                            } else {
-                                rlActionObj.list = listValue
+                const relatedListActions = descendants.query(SYS_UI_POLICY_RL_ACTION).map((rlAction) =>
+                    rlAction.transform(({ $ }) => ({
+                        list: $.map((v) => {
+                            if (v?.ifString()?.ifDefined()) {
+                                const listVal = v.asString().getValue()
+                                return listVal.startsWith('REL:') ? listVal.substring(4) : listVal
                             }
-                        }
-
-                        // Convert ServiceNow string format to boolean | 'ignore'
-                        const visible = stringToBoolean(rlAction.get('visible')?.ifString()?.getValue())
-                        if (visible !== undefined && visible !== 'ignore') {
-                            rlActionObj.visible = visible
-                        }
-
-                        // Skip if no meaningful properties (only $id exists)
-                        if (Object.keys(rlActionObj).length === 0) {
-                            return null
-                        }
-
-                        return rlActionObj
-                    })
-                    .filter((rlAction) => rlAction !== null) // Remove null actions
+                            return ''
+                        }).def(''),
+                        visible: $.map((v) => stringToBoolean(v?.asString()?.getValue())).def('ignore'),
+                    }))
+                )
 
                 return {
                     success: true,
@@ -278,7 +185,7 @@ export const UiPolicyPlugin = Plugin.create({
                                     order: $.from('order').toNumber().def(100),
                                     setValues: $.from('set_values').def(''),
                                     view: $.from('view').def(''),
-                                    actions: $.val(actions.length > 0 ? actions : undefined),
+                                    actions: $.val(actions).def([]),
                                     relatedListActions: $.val(
                                         relatedListActions.length > 0 ? relatedListActions : undefined
                                     ),
@@ -401,11 +308,10 @@ export const UiPolicyPlugin = Plugin.create({
                         const hasClearedProp = action.get('cleared')?.isBoolean() || false
 
                         if (!hasVisibleProp && !hasReadOnlyProp && !hasMandatoryProp && !hasClearedProp) {
-                            diagnostics.error(
+                            diagnostics.hint(
                                 action,
-                                `Action at index ${i} must specify at least one of: visible, readOnly, mandatory, or cleared`
+                                `Action at index ${i} has no effect — consider specifying at least one of: visible, readOnly, mandatory, or cleared`
                             )
-                            continue
                         }
 
                         const actionRecord = await factory.createRecord({
@@ -475,14 +381,12 @@ export const UiPolicyPlugin = Plugin.create({
                             }
                         }
 
-                        // At least one property must be specified (visible or list)
                         const hasVisibleProp = isValidActionValue(rlAction.get('visible'))
                         if (!hasVisibleProp && !listValue) {
-                            diagnostics.error(
+                            diagnostics.hint(
                                 rlAction,
-                                `Related list action at index ${i} must specify at least one of: list or visible`
+                                `Related list action at index ${i} has no effect — consider specifying at least one of: list or visible`
                             )
-                            continue
                         }
 
                         const rlActionRecord = await factory.createRecord({

package/src/utils.ts

@@ -6,7 +6,10 @@ import {
     type Compiler,
     type PluginApiDoc,
     type Record as FluentRecord,
+    type OutputFile,
+    type Transform,
 } from '@servicenow/sdk-build-core'
+import { create } from 'xmlbuilder2'
 
 export function toReference(shape: Shape) {
     return shape.ifRecord()?.getId() ?? shape.ifString()?.getValue() ?? ''
@@ -130,6 +133,55 @@ export const showGuidFieldDiagnostic = (
     }
 }
 
+export async function generateChoiceSetFile(
+    choiceSet: FluentRecord,
+    choices: FluentRecord[],
+    config: { scope: string; scopeId: string },
+    transform: Transform
+): Promise<OutputFile> {
+    const tableName = choiceSet.get('name').asString().getValue()
+    const elementName = choiceSet.get('element').asString().getValue()
+    const xml = create().ele('record_update')
+    const root = xml.ele('sys_choice_set', { table: tableName, field: elementName })
+
+    choices.forEach((choice) => {
+        const child = root.ele('sys_choice', { action: choice.getAction() })
+        child.ele('sys_id').txt(choice.getId().getValue())
+        child.ele('name').txt(tableName)
+        child.ele('element').txt(elementName)
+
+        for (const prop of [
+            'label',
+            'value',
+            'sequence',
+            'dependent_value',
+            'hint',
+            'inactive',
+            'inactive_on_update',
+            'language',
+        ]) {
+            choice
+                .get(prop)
+                .ifDefined()
+                ?.toString()
+                .pipe((p) => child.ele(prop).txt(p.getValue()))
+        }
+    })
+
+    const child = root.ele('sys_choice_set', { action: choiceSet.getAction() })
+    child.ele('sys_id').txt(choiceSet.getId().getValue())
+    child.ele('sys_scope', { display_value: config.scope }).txt(config.scopeId)
+    child.ele('name').txt(tableName)
+    child.ele('element').txt(elementName)
+
+    return {
+        source: choiceSet,
+        name: `${await transform.getUpdateName(choiceSet)}.xml`,
+        category: choiceSet.getInstallCategory(),
+        content: xml.end({ prettyPrint: true }),
+    }
+}
+
 /**
  * Creates a documentation entry for first-party SDK plugins.
  *