@servicenow/sdk-build-plugins 4.7.2 → 4.8.1

package/src/alias/retry-policy-plugin.ts

@@ -0,0 +1,138 @@
+import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
+import { NowIdShape } from '../now-id-plugin'
+
+const SYS_RETRY_POLICY = 'sys_retry_policy'
+
+const DEFAULT_CONNECTION_TYPE = 'http_retry_conditions'
+const DEFAULT_RETRY_STRATEGY = 'fixed_time_interval'
+const MAX_ELAPSED_TIME_SECONDS = 86400
+const DEFAULT_RESTRICT_TO = 'http_method,status_code,error,response_body,response_headers'
+
+export const RetryPolicyPlugin = Plugin.create({
+    name: 'RetryPolicyPlugin',
+
+    records: {
+        [SYS_RETRY_POLICY]: {
+            async toShape(record) {
+                const restrictToRaw = record.get('restrict_to')?.ifString()?.getValue()
+                const restrictToArray =
+                    restrictToRaw === undefined || restrictToRaw === DEFAULT_RESTRICT_TO
+                        ? undefined
+                        : restrictToRaw === ''
+                          ? []
+                          : restrictToRaw
+                                .split(',')
+                                .map((s) => s.trim())
+                                .filter(Boolean)
+
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'RetryPolicy',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $.def(''),
+                                connectionType: $.from('connection_type').def(DEFAULT_CONNECTION_TYPE),
+                                retryStrategy: $.from('retry_strategy').def(DEFAULT_RETRY_STRATEGY),
+                                count: $.map((v) => v.ifString()?.ifNotEmpty()?.toNumber()),
+                                interval: $.map((v) => v.ifString()?.ifNotEmpty()?.toNumber()),
+                                maxElapsedTime: $.from('max_elapsed_time').map((v) =>
+                                    v.ifString()?.ifNotEmpty()?.toNumber()
+                                ),
+                                condition: $.def(''),
+                                restrictTo: $.val(restrictToArray),
+                                protectionPolicy: $.from('sys_policy').def(''),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics }) {
+                if (callExpression.getCallee() !== 'RetryPolicy') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+
+                // Runtime validation for maxElapsedTime upper bound (TypeScript cannot enforce numeric ranges)
+                const maxElapsedTimeShape = arg.get('maxElapsedTime')
+                const maxElapsedTime = maxElapsedTimeShape.ifNumber()?.getValue()
+                if (maxElapsedTime !== undefined && maxElapsedTime > MAX_ELAPSED_TIME_SECONDS) {
+                    diagnostics.error(
+                        maxElapsedTimeShape,
+                        `maxElapsedTime must not exceed ${MAX_ELAPSED_TIME_SECONDS} seconds (24 hours). Received: ${maxElapsedTime}.`
+                    )
+                }
+
+                const countShape = arg.get('count')
+                const count = countShape.ifNumber()?.getValue()
+                if (count !== undefined && !Number.isInteger(count)) {
+                    diagnostics.error(countShape, `count must be an integer. Received: ${count}.`)
+                }
+
+                const intervalShape = arg.get('interval')
+                const interval = intervalShape.ifNumber()?.getValue()
+                if (interval !== undefined && !Number.isInteger(interval)) {
+                    diagnostics.error(intervalShape, `interval must be an integer. Received: ${interval}.`)
+                }
+
+                // Convert restrictTo string[] → comma-separated string for the DB
+                const restrictToShape = arg.get('restrictTo')
+                const restrictToArrayShape = restrictToShape.ifArray()
+                const restrictToCsv = restrictToArrayShape
+                    ? restrictToArrayShape
+                          .getElements()
+                          .map((el) => el.ifString()?.getValue() ?? '')
+                          .filter(Boolean)
+                          .join(',')
+                    : DEFAULT_RESTRICT_TO
+
+                // Validate condition only references fields in restrictTo
+                const allowedFields = (restrictToCsv || DEFAULT_RESTRICT_TO).split(',')
+                const conditionShape = arg.get('condition')
+                const conditionValue = conditionShape.ifString()?.ifNotEmpty()?.getValue()
+                if (conditionValue) {
+                    for (const part of conditionValue.split('^')) {
+                        const fieldPart = part.startsWith('OR') ? part.slice(2) : part
+                        if (!allowedFields.some((field) => fieldPart.startsWith(field))) {
+                            const fieldName = fieldPart.match(/^[a-z_]+/)?.[0] ?? fieldPart
+                            diagnostics.error(
+                                conditionShape,
+                                `Condition references field '${fieldName}' which is not in restrictTo. Allowed fields: ${allowedFields.join(', ')}.`
+                            )
+                            break
+                        }
+                    }
+                }
+
+                const record = await factory.createRecord({
+                    source: callExpression,
+                    table: SYS_RETRY_POLICY,
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        name: $.def(''),
+                        connection_type: $.from('connectionType').def(DEFAULT_CONNECTION_TYPE),
+                        retry_strategy: $.from('retryStrategy').def(DEFAULT_RETRY_STRATEGY),
+                        count: $,
+                        interval: $,
+                        max_elapsed_time: $.from('maxElapsedTime'),
+                        condition: $.def(''),
+                        restrict_to: $.val(restrictToCsv),
+                        sys_policy: $.from('protectionPolicy').def(''),
+                    })),
+                })
+
+                return { success: true, value: record }
+            },
+        },
+    ],
+})

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/flow-logic/flow-logic-diagnostics.ts

@@ -756,12 +756,13 @@ function validateEndFlowPlacement(expr: FlowLogicInstanceShape): string | undefi
         FLOW_LOGIC.IF,
         FLOW_LOGIC.ELSEIF,
         FLOW_LOGIC.ELSE,
+        FLOW_LOGIC.DO_IN_PARALLEL,
         // TODO: Add FLOW_LOGIC.DO_UNTIL when implemented
     ]
 
     const parentBlock = findAncestorByCalleeName(node, ...END_FLOW_BLOCKS)
     if (!parentBlock) {
-        return 'End Flow must be used within a Do Until, For Each, or If block'
+        return 'End Flow must be used within a Do In Parallel, Do Until, For Each, or If block'
     }
 
     return undefined

package/src/flow/flow-logic/flow-logic-plugin.ts

@@ -292,7 +292,6 @@ export const FlowLogicPlugin = Plugin.create({
                         parameters: [],
                         statements: catchStatements,
                     })
-
                     const handlersArg = new ObjectShape({
                         source: record,
                         properties: {