@servicenow/sdk-build-plugins 4.7.1 → 4.8.0

package/src/arrow-function-plugin.ts

@@ -71,6 +71,10 @@ export class ArrowFunctionShape extends Shape {
         return this.returnValue
     }
 
+    isImplicitReturn(): boolean {
+        return this.implicitReturn
+    }
+
     override getCode(): string {
         const params = `(${this.getParameters()
             .map((p) => p.getCode())
@@ -192,48 +196,88 @@ export const ArrowFunctionPlugin = Plugin.create({
         {
             shape: ArrowFunctionShape,
             async commit(shape, target, { commit }) {
-                const arrowFunction = ts.Node.isArrowFunction(target)
+                const originalTargetWasArrow = ts.Node.isArrowFunction(target)
+                const arrowTarget = originalTargetWasArrow
                     ? target
                     : target.replaceWithText('() => {}').asKindOrThrow(ts.SyntaxKind.ArrowFunction)
 
-                const nodeStatements = arrowFunction.getStatements()
                 const shapeStatements = shape.getStatements()
                 const returnValue = shape.getReturnValue()
+                const body = arrowTarget.getBody()
 
-                if (ts.Node.isArrowFunction(target)) {
-                    const body = target.getBody()
-                    if (!ts.Node.isBlock(body) && shapeStatements.length === 0 && returnValue) {
-                        // Already inline form - commit directly to the expression
+                // Preserve concise arrows when the shape is still an implicit return.
+                if (
+                    originalTargetWasArrow &&
+                    !ts.Node.isBlock(body) &&
+                    shapeStatements.length === 0 &&
+                    returnValue &&
+                    shape.isImplicitReturn()
+                ) {
+                    if (returnValue.is(ObjectShape)) {
+                        body.replaceWithText(`(${returnValue.getCode()})`)
+                    } else {
                         await commit(returnValue, body)
-                        return { success: true }
                     }
+                    return { success: true }
+                }
+
+                if (!ts.Node.isBlock(body)) {
+                    // ts-morph cannot grow expression-body arrows like `() => ({})` into
+                    // block bodies with statement APIs, so convert the body to an empty block
+                    // first and then continue through the normal commit flow below.
+                    body.replaceWithText('{}')
                 }
 
-                const totalExpected = shapeStatements.length + (returnValue ? 1 : 0)
-                const excess = nodeStatements.length - totalExpected
+                const getNonReturnStatements = () =>
+                    arrowTarget.getStatements().filter((statement) => !ts.Node.isReturnStatement(statement))
+
+                const existingStatements = getNonReturnStatements()
+                const excess = existingStatements.length - shapeStatements.length
                 for (let i = 1; i <= excess; i++) {
-                    arrowFunction.removeStatement(nodeStatements.length - i)
+                    existingStatements[existingStatements.length - i]?.remove()
                 }
 
                 for (const [i, statement] of shapeStatements.entries()) {
-                    const targetStatement = nodeStatements[i] ?? arrowFunction.addStatements('undefined')[0]!
-                    await commit(statement, targetStatement)
+                    const currentStatements = getNonReturnStatements()
+                    const targetStatement = currentStatements[i]
+                    if (targetStatement) {
+                        await commit(statement, targetStatement)
+                    } else {
+                        // Insert before `return` so return-only bodies can grow safely.
+                        const returnIndex = arrowTarget
+                            .getStatements()
+                            .findIndex((node) => ts.Node.isReturnStatement(node))
+                        const inserted =
+                            returnIndex >= 0
+                                ? arrowTarget.insertStatements(returnIndex, statement.getCode())[0]!
+                                : arrowTarget.addStatements(statement.getCode())[0]!
+                        await commit(statement, inserted)
+                    }
                 }
 
-                if (returnValue) {
-                    const returnIndex = shapeStatements.length
-                    const targetReturn =
-                        nodeStatements[returnIndex] ?? arrowFunction.addStatements('return undefined')[0]!
-                    if (ts.Node.isReturnStatement(targetReturn)) {
-                        const expr = targetReturn.getExpression()
-                        if (expr) {
-                            await commit(returnValue, expr)
-                        }
+                let existingReturn = arrowTarget
+                    .getStatements()
+                    .find((statement) => ts.Node.isReturnStatement(statement))
+                if (!returnValue) {
+                    existingReturn?.remove()
+                    return { success: true }
+                }
+
+                if (!existingReturn) {
+                    const inserted = arrowTarget.addStatements(`return ${returnValue.getCode()}`)[0]!
+                    existingReturn = ts.Node.isReturnStatement(inserted)
+                        ? inserted
+                        : arrowTarget.getStatements().find((statement) => ts.Node.isReturnStatement(statement))
+                }
+
+                if (existingReturn) {
+                    const expr = existingReturn.getExpression()
+                    if (expr) {
+                        await commit(returnValue, expr)
                     } else {
-                        targetReturn.replaceWithText(`return ${returnValue.getCode()}`)
+                        existingReturn.replaceWithText(`return ${returnValue.getCode()}`)
                     }
                 }
-
                 return { success: true }
             },
         },

package/src/atf/test-plugin.ts

@@ -242,7 +242,7 @@ export const TestPlugin = Plugin.create({
             },
         },
         sys_element_mapping: {
-            coalesce: ['field', 'id'],
+            coalesce: ['field', 'table', 'id'],
         },
     },
     shapes: [

package/src/basic-syntax-plugin.ts

@@ -85,13 +85,13 @@ export const BasicSyntaxPlugin = Plugin.create({
                 const conditionalDir = NowConfig.getConditionalDirectory(config, source.path)
                 const taxonomySubdir = tableName && taxonomy.mapping[tableName] ? taxonomy.mapping[tableName] : ''
 
-                const dir = hostedDir
-                    ? pathModule.join(generatedDir, hostedDir)
-                    : conditionalDir
-                      ? pathModule.join(generatedDir, conditionalDir)
-                      : taxonomySubdir
-                        ? pathModule.join(generatedDir, taxonomySubdir)
-                        : generatedDir
+                // The hosted/conditional plugin prefix (e.g. `if/com.<plugin>`) is orthogonal to
+                // the taxonomy folder (e.g. `data/table`). Compose them so records keep their
+                // taxonomy organization even when they live under a conditional/hosted plugin
+                // directory, instead of the plugin prefix overriding the taxonomy (DEF0844422).
+                // `pathModule.join` drops empty segments, so any of these may be absent.
+                const prefixDir = hostedDir ?? conditionalDir ?? ''
+                const dir = pathModule.join(generatedDir, prefixDir, taxonomySubdir)
 
                 let name = pathModule.basename(source.path).replace(RegExp(`${pathModule.extname(source.path)}$`), '')
                 if (!name) {

package/src/column/index.ts

@@ -0,0 +1,7 @@
+export {
+    addFieldsToColumn,
+    COLUMN_API_TO_TYPE,
+    COLUMN_TYPE_TO_API,
+    getDefaultMaxLength,
+} from './column-helper'
+export { getChoiceRecords, getDocumentationRecords, getLabelForDefaultLanguage } from './column-to-record'

package/src/dashboard/dashboard-plugin.ts

@@ -211,6 +211,8 @@ export const DashboardPlugin = Plugin.create({
                     $id: $.val(NowIdShape.from(record)),
                     name: $,
                     active: $.toBoolean().def(true),
+                    description: $.def(''),
+                    certified: $.toBoolean().def(false),
                     tabs: $.val(tabs).def([]),
                     visibilities: $.val(visibilities).def([]),
                     permissions: $.val(permissions).def([]),
@@ -272,6 +274,8 @@ export const DashboardPlugin = Plugin.create({
                     properties: arg.transform(({ $ }) => ({
                         name: $,
                         active: $.def(true),
+                        description: $.def(''),
+                        certified: $.def(false),
                     })),
                 })
 

package/src/data-lookup-plugin.ts

@@ -0,0 +1,191 @@
+import { CallExpressionShape, Plugin, isSNScope } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+
+const DL_DEFINITION = 'dl_definition'
+const DL_DEFINITION_REL_MATCH = 'dl_definition_rel_match'
+const DL_DEFINITION_REL_SET = 'dl_definition_rel_set'
+
+export const DataLookupPlugin = Plugin.create({
+    name: 'DataLookupPlugin',
+
+    records: {
+        [DL_DEFINITION]: {
+            relationships: {
+                [DL_DEFINITION_REL_MATCH]: {
+                    via: 'dl_definition',
+                    descendant: true,
+                },
+                [DL_DEFINITION_REL_SET]: {
+                    via: 'dl_definition',
+                    descendant: true,
+                },
+            },
+
+            async toShape(record, { descendants }) {
+                const matchRecords = descendants
+                    .query(DL_DEFINITION_REL_MATCH)
+                    .filter((r) => r.get('dl_definition').equals(record.getId()))
+
+                const setRecords = descendants
+                    .query(DL_DEFINITION_REL_SET)
+                    .filter((r) => r.get('dl_definition').equals(record.getId()))
+
+                const matchRules = matchRecords.map((r) =>
+                    r.transform(({ $ }) => ({
+                        $id: $.val(NowIdShape.from(r)),
+                        sourceField: $.from('source_table_field'),
+                        matcherField: $.from('matcher_table_field'),
+                        exactMatch: $.from('exact_match').toBoolean().def(false),
+                    }))
+                )
+
+                const setRules = setRecords.map((r) =>
+                    r.transform(({ $ }) => ({
+                        $id: $.val(NowIdShape.from(r)),
+                        targetField: $.from('source_table_field'),
+                        matcherField: $.from('matcher_table_field'),
+                        alwaysReplace: $.from('always_replace').toBoolean().def(false),
+                    }))
+                )
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'DataLookup',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                sourceTable: $.from('source_table'),
+                                matcherTable: $.from('matcher_table'),
+                                active: $.from('active').toBoolean().def(true),
+                                runOnInsert: $.from('run_on_insert').toBoolean().def(true),
+                                runOnUpdate: $.from('run_on_update').toBoolean().def(false),
+                                runOnFormChange: $.from('run_on_form_change').toBoolean().def(true),
+                                matchRules: $.val(matchRules.length ? matchRules : undefined),
+                                setRules: $.val(setRules.length ? setRules : undefined),
+                                protectionPolicy: $.from('sys_policy').def(''),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+
+        [DL_DEFINITION_REL_MATCH]: {
+            // Child records are pulled by the parent dl_definition toShape via descendants.query(),
+            // so they must not be transformed independently.
+            toShape() {
+                return { success: false }
+            },
+        },
+
+        [DL_DEFINITION_REL_SET]: {
+            // Same as dl_definition_rel_match — rendered inline by the parent's toShape.
+            toShape() {
+                return { success: false }
+            },
+        },
+    },
+
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics, config }) {
+                if (callExpression.getCallee() !== 'DataLookup') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+
+                const name = arg.get('name').ifString()?.getValue()
+                if (name && name.length > 40) {
+                    diagnostics.error(
+                        arg.get('name'),
+                        `Data Lookup Definition name must be 40 characters or fewer (got ${name.length}).`
+                    )
+                }
+
+                const sourceTable = arg.get('sourceTable').ifString()?.getValue() ?? ''
+                const matcherTable = arg.get('matcherTable').ifString()?.getValue() ?? ''
+
+                const scope = config.scope
+                if (sourceTable && !sourceTable.startsWith(`${scope}_`) && !isSNScope(scope) && scope !== 'global') {
+                    diagnostics.error(
+                        arg.get('sourceTable'),
+                        `sourceTable '${sourceTable}' must be in the same scope as the data lookup definition. Expected a table starting with '${scope}_'.`
+                    )
+                }
+                if (matcherTable && !matcherTable.startsWith(`${scope}_`) && !isSNScope(scope) && scope !== 'global') {
+                    diagnostics.error(
+                        arg.get('matcherTable'),
+                        `matcherTable '${matcherTable}' must be in the same scope as the data lookup definition. Expected a table starting with '${scope}_'.`
+                    )
+                }
+
+                const mainRecord = await factory.createRecord({
+                    source: callExpression,
+                    table: DL_DEFINITION,
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        name: $,
+                        source_table: $.from('sourceTable'),
+                        matcher_table: $.from('matcherTable'),
+                        active: $.from('active').def(true),
+                        run_on_insert: $.from('runOnInsert').def(true),
+                        run_on_update: $.from('runOnUpdate').def(false),
+                        run_on_form_change: $.from('runOnFormChange').def(true),
+                        sys_policy: $.from('protectionPolicy'),
+                    })),
+                })
+
+                const matchElements = arg.get('matchRules').ifArray()?.getElements() ?? []
+                const matchRecords = await Promise.all(
+                    matchElements.map(async (el) => {
+                        const rule = el.asObject()
+                        return factory.createRecord({
+                            source: el,
+                            table: DL_DEFINITION_REL_MATCH,
+                            explicitId: rule.get('$id'),
+                            properties: rule.transform(({ $ }) => ({
+                                dl_definition: $.val(mainRecord.getId()),
+                                source_table_field: $.from('sourceField'),
+                                matcher_table_field: $.from('matcherField'),
+                                exact_match: $.from('exactMatch').def(false),
+                                source_table: $.val(sourceTable),
+                                matcher_table: $.val(matcherTable),
+                            })),
+                        })
+                    })
+                )
+
+                const setElements = arg.get('setRules').ifArray()?.getElements() ?? []
+                const setRecords = await Promise.all(
+                    setElements.map(async (el) => {
+                        const rule = el.asObject()
+                        return factory.createRecord({
+                            source: el,
+                            table: DL_DEFINITION_REL_SET,
+                            explicitId: rule.get('$id'),
+                            properties: rule.transform(({ $ }) => ({
+                                dl_definition: $.val(mainRecord.getId()),
+                                source_table_field: $.from('targetField'),
+                                matcher_table_field: $.from('matcherField'),
+                                always_replace: $.from('alwaysReplace').def(false),
+                                source_table: $.val(sourceTable),
+                                matcher_table: $.val(matcherTable),
+                            })),
+                        })
+                    })
+                )
+
+                return {
+                    success: true,
+                    value: mainRecord.with(...matchRecords, ...setRecords),
+                }
+            },
+        },
+    ],
+})

package/src/flow/plugins/flow-action-definition-plugin.ts

@@ -34,7 +34,7 @@ import {
 } from '../utils/flow-constants'
 import { STEP_PILL_TYPE_REGEX, stripPillType, collectPillTypes } from '../utils/flow-pill-utils'
 import { COLUMN_TYPE_TO_API } from '../../column/column-helper'
-import { getAttributeValue } from '../utils/schema-to-flow-object'
+import { buildComplexObjectFromSchema, parseAttributesToObject } from '../utils/schema-to-flow-object'
 import { normalizeInputValue } from './flow-instance-plugin'
 import { ApprovalRulesShape, ApprovalDueDateShape } from '../utils/flow-shapes'
 import { ArrowFunctionShape } from '../../arrow-function-plugin'
@@ -1387,6 +1387,11 @@ const actionDefRelationships = {
                         via: { name: 'name', element: 'element' },
                         descendant: true,
                     },
+                    sys_complex_object: {
+                        via: [complexObjectMatchesIoRecord],
+                        descendant: true,
+                        inverse: true,
+                    },
                 },
             },
             sys_hub_input_scripts: {
@@ -1610,6 +1615,13 @@ export const ActionDefinitionPlugin = Plugin.create({
                         sys_hub_step_ext_output: {
                             via: 'model',
                             descendant: true,
+                            relationships: {
+                                sys_complex_object: {
+                                    via: [complexObjectMatchesIoRecord],
+                                    descendant: true,
+                                    inverse: true,
+                                },
+                            },
                         },
                         sys_translated_text: {
                             via: 'documentkey',
@@ -1871,8 +1883,42 @@ export const ActionDefinitionPlugin = Plugin.create({
                                 const mandatory = extOutput.get('mandatory')?.ifString()?.getValue() === 'true'
                                 const internalType = extOutput.get('internal_type')?.ifString()?.getValue() ?? 'string'
                                 // Check attributes for uiType to handle cases where internal_type is generic
-                                const attributes = extOutput.get('attributes')?.ifString()?.getValue() ?? ''
-                                const uiType = getAttributeValue(attributes, 'uiType') ?? internalType
+                                const attributesStr = extOutput.get('attributes')?.ifString()?.getValue() ?? ''
+                                const parsedAttributes = parseAttributesToObject(attributesStr)
+                                const uiType = parsedAttributes.uiType ?? internalType
+
+                                // Handle FlowObject/FlowArray complex types via co_type_name
+                                const maybeCoTypeName = parsedAttributes.co_type_name
+                                if (maybeCoTypeName) {
+                                    const coRecord = descendants.query('sys_complex_object', { name: maybeCoTypeName })
+                                    let serializedContent = coRecord[0]
+                                        ?.get('serialized_content')
+                                        ?.ifString()
+                                        ?.getValue()
+                                    let complexObjectSysId: string | undefined = coRecord[0]?.getId().getValue()
+                                    if (!serializedContent) {
+                                        const builtIn = builtInComplexObjects[maybeCoTypeName]
+                                        serializedContent = builtIn?.data.serialized_content
+                                        complexObjectSysId = undefined
+                                    }
+                                    if (serializedContent) {
+                                        const varSysId = extOutput.getId().getValue()
+                                        const isDeterministic = maybeCoTypeName === `FD${varSysId}`
+                                        const schema = JSON.parse(serializedContent)
+                                        outputVariablesObj[elementName] = buildComplexObjectFromSchema(
+                                            extOutput,
+                                            schema,
+                                            parsedAttributes,
+                                            isDeterministic ? undefined : complexObjectSysId,
+                                            isDeterministic ? undefined : maybeCoTypeName
+                                        )
+                                        continue
+                                    }
+                                    logger.warn(
+                                        `Unable to find sys_complex_object with co_type_name '${maybeCoTypeName}' for step output '${elementName}'; falling back to StringColumn`
+                                    )
+                                }
+
                                 const columnApiName = COLUMN_TYPE_TO_API[uiType] ?? 'StringColumn'
                                 const columnProps: Props = { label }
                                 if (mandatory) {

package/src/flow/plugins/flow-instance-plugin.ts

@@ -68,6 +68,7 @@ import {
     UNSUPPORTED_DATA_TYPES,
     UTC_TIMEZONE_VALUE,
     ELEMENT_MAPPING_FIELD_ALIASES,
+    ELEMENT_MAPPING_FIELD_ALIASES_REVERSE,
 } from '../utils/flow-constants'
 
 import type { ApprovalDueDateType, ApprovalRulesType } from '@servicenow/sdk-core/runtime/flow'
@@ -958,7 +959,7 @@ function processInputValue(
 
     // Return standard input object
     return {
-        name: inputName,
+        name: ELEMENT_MAPPING_FIELD_ALIASES_REVERSE[inputName] ?? inputName,
         value: finalValue,
         displayValue: displayValues && displayValues.has(inputName) ? displayValues.get(inputName) : finalValue,
         scriptActive: false,

package/src/flow/plugins/step-instance-plugin.ts

@@ -372,7 +372,7 @@ export const StepInstancePlugin = Plugin.create({
             coalesce: ['name'],
         },
         sys_element_mapping: {
-            coalesce: ['field', 'id'],
+            coalesce: ['field', 'table', 'id'],
         },
         sys_hub_step_instance: {
             relationships: {

package/src/flow/utils/flow-constants.ts

@@ -545,6 +545,14 @@ export const ELEMENT_MAPPING_FIELD_ALIASES: { [platformName: string]: string } =
     __snc_dont_fail_on_error: 'dont_fail_flow_on_error',
 }
 
+/**
+ * Reverse of ELEMENT_MAPPING_FIELD_ALIASES — maps Fluent API names back to their
+ * platform-internal names for serialization into sys_hub_action_instance_v2.
+ */
+export const ELEMENT_MAPPING_FIELD_ALIASES_REVERSE: { [fluentName: string]: string } = Object.fromEntries(
+    Object.entries(ELEMENT_MAPPING_FIELD_ALIASES).map(([platform, fluent]) => [fluent, platform])
+)
+
 export enum ChoiceDropdown {
     DROPDOWN_WITH_NONE = 1,
     DROPDOWN_WITHOUT_NONE = 3,