@servicenow/sdk-build-plugins 4.7.2 → 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-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,

package/src/form-plugin.ts

@@ -268,50 +268,51 @@ function getOptionalString(record: Record, field: string, defaultValue = ''): st
  * The name is needed as an attribute on the <view> XML element so the parser
  * can create a RecordId with proper coalesce keys when re-reading the XML.
  */
-function resolveView(view: ReturnType<Record['get']>, database: Database): { sysId: string; name: string } {
+function resolveView(
+    view: ReturnType<Record['get']>,
+    database: Database
+): { sysId: string; name: string; displayValue: string } {
     if (view.isRecordId() || view.isRecord()) {
         const viewId = view.isRecordId() ? view : view.getId()
         const sysId = viewId.getValue()
-        // Try to resolve the view record to get its name
+        // Try to resolve the view record to get its name and title
         const viewRecord = database.resolve(viewId)
         if (viewRecord) {
             const name = viewRecord.get('name').ifString()?.getValue() ?? ''
-            return { sysId, name }
+            const displayValue = viewRecord.get('title').ifString()?.getValue() ?? name
+            return { sysId, name, displayValue }
         }
         // Fall back to primary key (view name) if available
         if (view.isRecordId() && view.asRecordId().hasPrimaryKey()) {
             const pk = view.asRecordId().getPrimaryKey()
             if (pk && !isGUID(pk)) {
-                return { sysId, name: pk }
+                return { sysId, name: pk, displayValue: pk }
             }
         }
-        return { sysId, name: '' }
+        return { sysId, name: '', displayValue: '' }
     }
 
     const viewValue = view.getValue()
     if (viewValue === 'NULL' || viewValue === DEFAULT_VIEW) {
-        return { sysId: DEFAULT_VIEW, name: DEFAULT_VIEW }
+        return { sysId: DEFAULT_VIEW, name: DEFAULT_VIEW, displayValue: DEFAULT_VIEW }
     }
 
     // View is a string - try to resolve to record ID if it exists in database
     const viewNameStr = view.ifString()?.getValue() ?? ''
     if (!viewNameStr) {
-        return { sysId: '', name: '' }
+        return { sysId: '', name: '', displayValue: '' }
     }
 
     const viewRecord = database.query('sys_ui_view').find((v) => v.get('name').ifString()?.getValue() === viewNameStr)
     if (viewRecord) {
-        return { sysId: viewRecord.getId().getValue(), name: viewNameStr }
+        const displayValue = viewRecord.get('title').ifString()?.getValue() ?? viewNameStr
+        return { sysId: viewRecord.getId().getValue(), name: viewNameStr, displayValue }
+    }
+    return {
+        sysId: viewNameStr,
+        name: isGUID(viewNameStr) ? '' : viewNameStr,
+        displayValue: isGUID(viewNameStr) ? '' : viewNameStr,
     }
-    return { sysId: viewNameStr, name: isGUID(viewNameStr) ? '' : viewNameStr }
-}
-
-/**
- * Resolves a view value to its string representation (sys_id or name)
- * Handles RecordId, Record, string values, and database lookups
- */
-function resolveViewName(view: ReturnType<Record['get']>, database: Database): string {
-    return resolveView(view, database).sysId
 }
 
 type FormElement =
@@ -377,7 +378,11 @@ export const FormPlugin = Plugin.create({
                 const sectionName = section.get('name').asString().getValue()
                 const caption = getOptionalString(section, 'caption')
                 const sysDomain = getOptionalString(section, 'sys_domain', 'global')
-                const { sysId: viewName, name: viewDisplayName } = resolveView(section.get('view'), database)
+                const {
+                    sysId: viewSysId,
+                    name: viewName,
+                    displayValue: viewDisplayValue,
+                } = resolveView(section.get('view'), database)
 
                 const xml = create().ele('record_update')
                 const root = xml.ele('sys_ui_section', {
@@ -385,7 +390,7 @@ export const FormPlugin = Plugin.create({
                     section_id: section.getId().getValue(),
                     sys_domain: sysDomain,
                     table: sectionName,
-                    view: viewName,
+                    view: viewSysId === DEFAULT_VIEW ? '' : viewName,
                 })
 
                 // Add all sys_ui_annotation records for this section (excluding deleted ones)
@@ -427,7 +432,7 @@ export const FormPlugin = Plugin.create({
                             display_value: caption,
                             name: sectionName,
                             sys_domain: sysDomain,
-                            view: viewName,
+                            view: viewSysId,
                         })
                         .txt(section.getId().getValue())
                     child.ele('sys_user')
@@ -446,7 +451,13 @@ export const FormPlugin = Plugin.create({
                 sectionChild.ele('sys_user')
                 sectionChild.ele('title').txt(String(section.get('title').ifBoolean()?.getValue() ?? false))
                 sectionChild.ele('view_name')
-                sectionChild.ele('view', viewDisplayName ? { name: viewDisplayName } : {}).txt(viewName)
+                const isDefaultView = viewSysId === DEFAULT_VIEW
+                const sectionViewAttrs = isDefaultView
+                    ? { name: 'NULL', display_value: DEFAULT_VIEW }
+                    : viewName
+                      ? { name: viewName, display_value: viewDisplayValue || viewName }
+                      : {}
+                sectionChild.ele('view', sectionViewAttrs).txt(viewSysId)
 
                 return {
                     success: true,
@@ -702,7 +713,11 @@ export const FormPlugin = Plugin.create({
 
                 const formName = form.get('name').asString().getValue()
                 const formSysDomain = getOptionalString(form, 'sys_domain', 'global')
-                const { sysId: formViewName, name: formViewDisplayName } = resolveView(form.get('view'), database)
+                const {
+                    sysId: formViewSysId,
+                    name: formViewName,
+                    displayValue: formViewDisplayValue,
+                } = resolveView(form.get('view'), database)
 
                 const xml = create().ele('record_update')
                 const root = xml.ele('sys_ui_form_sections', {
@@ -727,7 +742,7 @@ export const FormPlugin = Plugin.create({
                             display_value: formName,
                             name: formName,
                             sys_domain: formSysDomain,
-                            view: formViewName,
+                            view: formViewSysId,
                         })
                         .txt(form.getId().getValue())
 
@@ -737,14 +752,14 @@ export const FormPlugin = Plugin.create({
 
                     if (section) {
                         const sectionCaption = getOptionalString(section, 'caption')
-                        const sectionViewName = resolveViewName(section.get('view'), database)
+                        const { sysId: sectionViewSysId } = resolveView(section.get('view'), database)
                         child
                             .ele('sys_ui_section', {
                                 caption: sectionCaption,
                                 display_value: sectionCaption,
                                 name: formName,
                                 sys_domain: getOptionalString(section, 'sys_domain', 'global'),
-                                view: sectionViewName,
+                                view: sectionViewSysId,
                             })
                             .txt(section.getId().getValue())
                     }
@@ -757,7 +772,13 @@ export const FormPlugin = Plugin.create({
                 formChild.ele('sys_id').txt(form.getId().getValue())
                 formChild.ele('sys_scope', { display_value: config.scope }).txt(config.scopeId)
                 formChild.ele('sys_user').txt(getOptionalString(form, 'sys_user'))
-                formChild.ele('view', formViewDisplayName ? { name: formViewDisplayName } : {}).txt(formViewName)
+                const isDefaultFormView = formViewSysId === DEFAULT_VIEW
+                const formViewAttrs = isDefaultFormView
+                    ? { name: 'NULL', display_value: DEFAULT_VIEW }
+                    : formViewName
+                      ? { name: formViewName, display_value: formViewDisplayValue || formViewName }
+                      : {}
+                formChild.ele('view', formViewAttrs).txt(formViewSysId)
                 formChild.ele('view_name')
 
                 return {

package/src/index.ts

@@ -6,6 +6,7 @@ export * from './cross-scope-privilege-plugin'
 export * from './record-plugin'
 export * from './now-id-plugin'
 export * from './now-ref-plugin'
+export * from './now-delete-plugin'
 export * from './now-unresolved-plugin'
 export * from './property-plugin'
 export * from './role-plugin'
@@ -21,6 +22,7 @@ export * from './now-include-plugin'
 export * from './table-plugin'
 export * from './column-plugin'
 export * from './data-plugin'
+export * from './data-lookup-plugin'
 export * from './ui-page-plugin'
 export * from './list-plugin'
 export * from './ui-action-plugin'
@@ -62,6 +64,7 @@ export * from './now-attach-plugin'
 export * from './sla-plugin'
 export * from './email-notification-plugin'
 export * from './inbound-email-action-plugin'
+export * from './rest-message-plugin'
 
 export * from './service-catalog'
 export * from './ux-list-menu-config-plugin'
@@ -69,6 +72,7 @@ export * from './workspace-plugin'
 export * from './dashboard/dashboard-plugin'
 export * from './applicability-plugin'
 export * from './instance-scan-plugin'
+export * from './alias'
 // non-plugins
 export * from './atf/step-configs'
 export { REPACK_OUTPUT_DIR, checkModuleExists, resolveModule } from './repack'

package/src/now-config-plugin.ts

@@ -787,6 +787,7 @@ export const NowConfigPlugin = Plugin.create({
                             packageResolverVersion: $.from('package_resolver_version').def(
                                 config.scope === 'global' ? MODULE_RESOLUTION.V2 : MODULE_RESOLUTION.V1
                             ),
+                            sysCode: $.from('sys_code').def(''),
                         })),
                     }),
                 }
@@ -936,7 +937,7 @@ export const NowConfigPlugin = Plugin.create({
                         package_resolver_version: $.from('packageResolverVersion').def(
                             scope === 'global' ? MODULE_RESOLUTION.V2 : MODULE_RESOLUTION.V1
                         ),
-                        sys_code: $.from('scope'),
+                        sys_code: $.from('sysCode'),
                     })),
                 })