@servicenow/sdk-build-plugins 4.4.1 → 4.6.0

package/src/now-id-plugin.ts

@@ -22,6 +22,7 @@ export class NowIdShape extends ElementAccessExpressionShape {
 
 export const NowIdPlugin = Plugin.create({
     name: 'NowIdPlugin',
+    docs: [],
     shapes: [
         {
             shape: ElementAccessExpressionShape,

package/src/now-include-plugin.ts

@@ -60,6 +60,7 @@ export class NowIncludeShape extends CallExpressionShape {
 
 export const NowIncludePlugin = Plugin.create({
     name: 'NowIncludePlugin',
+    docs: [],
     shapes: [
         {
             shape: CallExpressionShape,

package/src/now-ref-plugin.ts

@@ -3,6 +3,7 @@ import { CallExpressionPlugin } from './call-expression-plugin'
 
 export const NowRefPlugin = Plugin.create({
     name: 'NowRefPlugin',
+    docs: [],
     nodes: [
         {
             node: 'CallExpression',

package/src/now-unresolved-plugin.ts

@@ -2,6 +2,7 @@ import { Plugin, UnresolvedShape } from '@servicenow/sdk-build-core'
 
 export const NowUnresolvedPlugin = Plugin.create({
     name: 'NowUnresolvedPlugin',
+    docs: [],
     shapes: [
         {
             shape: UnresolvedShape,

package/src/package-json-plugin.ts

@@ -12,6 +12,7 @@ import { JsonFileShape } from './json-plugin'
 
 export const PackageJsonPlugin = Plugin.create({
     name: 'PackageJsonPlugin',
+    docs: [],
     shapes: [
         {
             shape: JsonFileShape,

package/src/property-plugin.ts

@@ -1,6 +1,7 @@
 import { isSNScope } from '@servicenow/sdk-build-core'
 import { CallExpressionShape, Plugin, type Shape } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
+import { createSdkDocEntry } from './utils'
 
 const getRolesArray = (roles: string): Array<string> => {
     return roles
@@ -11,6 +12,7 @@ const getRolesArray = (roles: string): Array<string> => {
 
 export const PropertyPlugin = Plugin.create({
     name: 'PropertyPlugin',
+    docs: [createSdkDocEntry('Property', ['sys_properties'])],
     records: {
         sys_properties: {
             toShape(record, { config }) {
@@ -68,7 +70,10 @@ export const PropertyPlugin = Plugin.create({
                 const name = prop.get('name').asString()
 
                 if (!isSNScope(scope) && config.scope !== 'global' && !name.asString().startsWith(`${scope}.`)) {
-                    diagnostics.error(name.getOriginalNode(), `Property name must begin with '${scope}.'`)
+                    diagnostics.warn(
+                        name.getOriginalNode(),
+                        `Property names should begin with '${scope}.' to match the app scope and avoid collisions with properties from other scopes`
+                    )
                 }
 
                 return {

package/src/record-plugin.ts

@@ -1,5 +1,6 @@
 import { CallExpressionShape, Database, Plugin, unloadBuilder, type Record } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
+import { createSdkDocEntry } from './utils'
 import {
     Acl,
     ApplicationMenu,
@@ -13,11 +14,17 @@ import {
     Sla,
 } from '@servicenow/sdk-core/runtime/app'
 import {
+    ServicePortal,
     SPWidget,
+    SPHeaderFooter,
     SPAngularProvider,
     SPWidgetDependency,
     CssInclude,
     JsInclude,
+    SPPage,
+    SPTheme,
+    SPMenu,
+    SPPageRouteMap,
 } from '@servicenow/sdk-core/runtime/service-portal'
 import {
     CatalogItem,
@@ -27,21 +34,27 @@ import {
     CatalogItemRecordProducer,
 } from '@servicenow/sdk-core/runtime/service-catalog'
 import { ClientScript } from '@servicenow/sdk-core/runtime/clientscript'
-import { ScriptAction, ScriptInclude } from '@servicenow/sdk-core/runtime/sys'
-import { List } from '@servicenow/sdk-core/runtime/ui'
+import { ScriptAction, ScriptInclude, ScheduledScript } from '@servicenow/sdk-core/runtime/sys'
+import { List, Form } from '@servicenow/sdk-core/runtime/ui'
 import { Table } from '@servicenow/sdk-core/runtime/db'
 import { RestApi } from '@servicenow/sdk-core/runtime/rest'
-import { EmailNotification } from '@servicenow/sdk-core/runtime/notification'
+import { EmailNotification, InboundEmailAction } from '@servicenow/sdk-core/runtime/notification'
 import { UiAction, UiPage, UiPolicy } from '@servicenow/sdk-core/runtime/ui'
+import { ActionStepDefinition } from '@servicenow/sdk-core/runtime/flow'
 import { Applicability, UxListMenuConfig, Workspace } from '@servicenow/sdk-core/runtime/uxf'
 import { Dashboard } from '@servicenow/sdk-core/runtime/dashboard'
+import { ColumnTypeCheck, LinterCheck, ScriptOnlyCheck, TableCheck } from '@servicenow/sdk-core/runtime/instancescan'
 
 export const RecordPlugin = Plugin.create({
     name: 'RecordPlugin',
+    docs: [createSdkDocEntry('Record', ['*'])],
     records: {
         '*': {
             getUpdateName(record) {
-                return { success: true, value: `${record.getTable()}_${record.getId().getValue()}` }
+                return {
+                    success: true,
+                    value: `${record.getTable()}_${record.getId().getValue()}`,
+                }
             },
             async diff(existing, incoming) {
                 const changeDatabase = existing.compare(incoming)
@@ -213,6 +226,10 @@ export const TableOwnership = {
     sys_script: BusinessRule.name,
     sys_script_client: ClientScript.name,
     sys_scope_privilege: CrossScopePrivilege.name,
+    sys_ui_form: Form.name,
+    sys_ui_section: Form.name,
+    sys_ui_form_section: Form.name,
+    sys_ui_element: Form.name,
     sys_ui_list_element: List.name,
     sys_ui_list: List.name,
     sys_properties: Property.name,
@@ -220,16 +237,26 @@ export const TableOwnership = {
     sys_user_role_contains: Role.name,
     sys_script_include: ScriptInclude.name,
     sp_widget: SPWidget.name,
+    sp_header_footer: SPHeaderFooter.name,
     m2m_sp_widget_dependency: SPWidget.name,
     m2m_sp_ng_pro_sp_widget: SPWidget.name,
+    sp_portal: ServicePortal.name,
     sp_ng_template: SPWidget.name,
     sp_dependency: SPWidgetDependency.name,
+    sp_container: SPPage.name,
+    sp_page: SPPage.name,
+    sp_row: SPPage.name,
+    sp_column: SPPage.name,
+    sp_instance: SPPage.name,
     m2m_sp_dependency_css_include: SPWidgetDependency.name,
     m2m_sp_dependency_js_include: SPWidgetDependency.name,
     sp_css_include: CssInclude.name,
     sp_js_include: JsInclude.name,
     sp_angular_provider: SPAngularProvider.name,
     m2m_sp_ng_pro_sp_ng_pro: SPAngularProvider.name,
+    sp_instance_menu: SPMenu.name,
+    sp_rectangle_menu_item: SPMenu.name,
+    sp_page_route_map: SPPageRouteMap.name,
     sys_atf_test: Test.name,
     sys_ws_header_map: RestApi.name,
     sys_ws_query_parameter_map: RestApi.name,
@@ -247,7 +274,9 @@ export const TableOwnership = {
     sys_ui_policy_action: UiPolicy.name,
     sys_ui_policy_rl_action: UiPolicy.name,
     sysevent_script_action: ScriptAction.name,
+    sysauto_script: ScheduledScript.name,
     sysevent_email_action: EmailNotification.name,
+    sysevent_in_email_action: InboundEmailAction.name,
     sys_db_object: Table.name,
     sys_dictionary: Table.name,
     sys_hub_flow: 'Flow',
@@ -255,10 +284,13 @@ export const TableOwnership = {
     sys_hub_action_instance_v2: 'wfa.action',
     sys_hub_sub_flow_instance_v2: 'wfa.subflow',
     sys_hub_flow_logic_instance_v2: 'wfa.flowLogic',
-    sys_flow_step_definition: 'ActionStepDefinition',
+    sys_flow_step_definition: ActionStepDefinition.name,
     sys_decision: 'DecisionTablePlugin',
     sys_hub_action_type_definition: 'Action',
-    sys_hub_step_instance: 'wfa.action_step',
+    sys_hub_step_instance: 'wfa.actionStep',
+    sp_theme: SPTheme.name,
+    m2m_sp_theme_css_include: SPTheme.name,
+    m2m_sp_theme_js_include: SPTheme.name,
     sys_transform_map: ImportSet.name,
     sys_transform_entry: ImportSet.name,
     sys_transform_script: ImportSet.name,
@@ -275,9 +307,27 @@ export const TableOwnership = {
     par_dashboard_widget: Dashboard.name,
     par_dashboard_permission: Dashboard.name,
     par_dashboard_visibility: Dashboard.name,
+    scan_column_type_check: ColumnTypeCheck.name,
+    scan_linter_check: LinterCheck.name,
+    scan_script_only_check: ScriptOnlyCheck.name,
+    scan_table_check: TableCheck.name,
     item_option_new_set: VariableSet.name,
     sc_cat_item: CatalogItem.name,
     sc_cat_item_producer: CatalogItemRecordProducer.name,
     catalog_script_client: CatalogClientScript.name,
     catalog_ui_policy: CatalogUiPolicy.name,
+    sn_aia_agent: 'AiAgentPlugin',
+    sn_aia_agent_config: 'AiAgentPlugin',
+    sn_aia_version: 'AiAgentPlugin',
+    sn_aia_tool: 'AiAgentPlugin',
+    sn_aia_agent_tool_m2m: 'AiAgentPlugin',
+    sn_aia_ltm_category_mapping: 'AiAgentPlugin',
+    sn_aia_trigger_configuration: 'AiAgentPlugin',
+    sn_aia_trigger_agent_usecase_m2m: 'AiAgentPlugin',
+    sn_aia_usecase: 'AiAgenticWorkflowPlugin',
+    sn_aia_usecase_config_override: 'AiAgenticWorkflowPlugin',
+    sn_aia_team: 'AiAgenticWorkflowPlugin',
+    sn_aia_team_member: 'AiAgenticWorkflowPlugin',
+    sn_nowassist_skill_config: 'NowAssistSkillPlugin',
+    sys_one_extend_capability: 'NowAssistSkillPlugin',
 }

package/src/repack/lint/Rules.ts

@@ -1,8 +1,8 @@
 import * as globals from 'globals'
-import mapValues from 'lodash/mapValues'
 import omit from 'lodash/omit'
 import { GlideAPIs } from '@servicenow/glide/util'
-import type { Rule, Linter } from 'eslint'
+import type { Rule, Linter, Scope } from 'eslint'
+import { ReferenceTracker } from '@eslint-community/eslint-utils'
 
 const BROWSER_API_WARNING = 'Web APIs are not supported by the now platform'
 const GLIDE_API_WARNING = 'Glide APIs are not supported by the now platform when used from a 3rd party dependency'
@@ -21,18 +21,129 @@ const glideAPIs = GlideAPIs
 
 const globalsAllowList: string[] = ['console', 'fetch']
 
-export const getPluginModules = async (): Promise<Record<string, Rule.RuleModule>> => {
+const coreNodeModules = [
+    'assert',
+    'buffer',
+    'child_process',
+    'cluster',
+    'crypto',
+    'dgram',
+    'dns',
+    'domain',
+    'events',
+    'freelist',
+    'fs',
+    'http',
+    'https',
+    'module',
+    'net',
+    'os',
+    'path',
+    'punycode',
+    'querystring',
+    'readline',
+    'repl',
+    'smalloc',
+    'stream',
+    'string_decoder',
+    'sys',
+    'timers',
+    'tls',
+    'tracing',
+    'tty',
+    'url',
+    'util',
+    'vm',
+    'zlib',
+]
+
+const getNodeGlobals = () => Object.keys(globals.nodeBuiltin).filter((key) => !globalsAllowList.includes(key))
+
+function createTrackMap(isNodeGlobals: boolean): Record<string, { [key: symbol]: { name: string } }> {
+    const trackMapItems = isNodeGlobals ? getNodeGlobals() : coreNodeModules
+    const trackMap: Record<string, { [key: symbol]: { name: string } }> = {}
+
+    for (const item of trackMapItems) {
+        trackMap[item] = {
+            [ReferenceTracker.READ]: {
+                name: item,
+            },
+        }
+    }
+
+    return trackMap
+}
+
+/**
+ * Custom rule: disallow unsupported Node.js built-in APIs.
+ * Replaces @servicenow/eslint-plugin-sdk-app-plugin/no-unsupported-node-builtins.
+ */
+const noUnsupportedNodeBuiltins: Rule.RuleModule = {
+    meta: {
+        docs: {
+            description: 'disallow unsupported Node.js built-in APIs',
+        },
+        messages: {
+            forbidden: 'The {{name}} Node.js API is not supported in now platform.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    create(context) {
+        return {
+            // biome-ignore lint/suspicious/noExplicitAny: ESLint rule listener typing
+            'Program:exit'(node: any) {
+                const sourceCode = context.sourceCode
+                const tracker = new ReferenceTracker(sourceCode.getScope(node) as Scope.Scope, { mode: 'legacy' })
+                const trackMap = createTrackMap(false)
+                const globalsTrackMap = createTrackMap(true)
+
+                const references = [
+                    ...tracker.iterateCjsReferences(trackMap),
+                    ...tracker.iterateEsmReferences(trackMap),
+                    ...tracker.iterateGlobalReferences(globalsTrackMap),
+                ]
+
+                for (const { node: refNode, info } of references) {
+                    context.report({
+                        node: refNode as Rule.Node,
+                        messageId: 'forbidden',
+                        data: info as Record<string, string>,
+                    })
+                }
+            },
+        }
+    },
+}
+
+/**
+ * Custom rule: disallow dynamic import() syntax.
+ * Replaces eslint-plugin-es-x/no-dynamic-import.
+ */
+const noDynamicImport: Rule.RuleModule = {
+    meta: {
+        docs: {
+            description: 'disallow dynamic import() syntax',
+        },
+        messages: {
+            forbidden: "Dynamic 'import()' syntax is not supported on the now platform.",
+        },
+        schema: [],
+        type: 'problem',
+    },
+    create(context) {
+        return {
+            ImportExpression(node: Rule.Node) {
+                context.report({ node, messageId: 'forbidden' })
+            },
+        }
+    },
+}
+
+export const getPluginRules = (): Record<string, Rule.RuleModule> => {
     return {
-        'es-x/no-dynamic-import': (await import('eslint-plugin-es-x/lib/rules/no-dynamic-import.js')).default,
-        'es-x/no-regexp-lookbehind-assertions': (
-            await import('eslint-plugin-es-x/lib/rules/no-regexp-lookbehind-assertions.js')
-        ).default,
-        'es-x/no-regexp-unicode-property-escapes': (
-            await import('eslint-plugin-es-x/lib/rules/no-regexp-unicode-property-escapes.js')
-        ).default,
-        '@servicenow/sdk-app-plugin/no-unsupported-node-builtins': (
-            await import('@servicenow/eslint-plugin-sdk-app-plugin')
-        ).default.rules['no-unsupported-node-builtins'],
+        'no-dynamic-import': noDynamicImport,
+        'no-unsupported-node-builtins': noUnsupportedNodeBuiltins,
     }
 }
 
@@ -63,19 +174,29 @@ const getGlideGlobalEslintRules = () => {
 const getGlideNamespaceEslintRules = () => {
     const namespacedAPIs = omit(glideAPIs, ['defaults'])
 
-    const namespaceRules: ESLintPropertyRule[] = []
-    const classRules: ESLintPropertyRule[] = []
+    // Deduplicate rules — the Glide API data contains duplicate object.property entries
+    // across namespaces, and ESLint v9 rejects arrays with duplicate items.
+    const deduplicatedRuleKeys = new Set<string>()
+    const rules: ESLintPropertyRule[] = []
+
+    const addRule = (rule: ESLintPropertyRule) => {
+        const key = `${rule.object}.${rule.property}`
+        if (!deduplicatedRuleKeys.has(key)) {
+            deduplicatedRuleKeys.add(key)
+            rules.push(rule)
+        }
+    }
 
     for (const [namespace, classes] of Object.entries(namespacedAPIs)) {
         for (const [className, properties] of Object.entries(classes)) {
-            classRules.push({
+            addRule({
                 object: namespace,
                 property: className,
                 message: GLIDE_API_WARNING,
             })
 
             for (const property of properties) {
-                namespaceRules.push({
+                addRule({
                     object: className,
                     property,
                     message: GLIDE_API_WARNING,
@@ -84,14 +205,42 @@ const getGlideNamespaceEslintRules = () => {
         }
     }
 
-    return classRules.concat(namespaceRules)
+    return rules
+}
+
+/**
+ * ESLint config for local modules — Rhino compatibility rules only (no Glide restrictions).
+ * Local modules can use Glide APIs since they run in the ServiceNow scope.
+ */
+export const getLocalModuleEslintConfig = (level: LogLevel = 'error'): Linter.LegacyConfig => {
+    const pluginRules = getPluginRules()
+    const restrictedGlobals = getRestrictedGlobals()
+    const rules: Linter.LegacyConfig['rules'] = {
+        ...Object.fromEntries(Object.keys(pluginRules).map((name) => [name, level])),
+        'no-restricted-globals': [level, ...restrictedGlobals],
+    }
+
+    return {
+        env: {
+            node: true,
+        },
+        parserOptions: {
+            ecmaVersion: 'latest',
+            sourceType: 'module',
+        },
+        rules,
+    }
 }
 
-export const getEslintConfig = async (level: LogLevel = 'warn'): Promise<Linter.Config> => {
-    const pluginModules = await getPluginModules()
+/**
+ * ESLint config for 3rd party dependencies — Rhino compatibility + Glide API restrictions.
+ * 3rd party code must not use Glide APIs (they are platform-internal).
+ */
+export const getEslintConfig = (level: LogLevel = 'warn'): Linter.LegacyConfig => {
+    const pluginRules = getPluginRules()
     const restrictedGlobals = getRestrictedGlobals()
     const rules = {
-        ...mapValues(pluginModules, () => level),
+        ...Object.fromEntries(Object.keys(pluginRules).map((name) => [name, level])),
         ...getDependencyConfig(level, restrictedGlobals),
     }
 
@@ -107,7 +256,7 @@ export const getEslintConfig = async (level: LogLevel = 'warn'): Promise<Linter.
     }
 }
 
-function getDependencyConfig(level: LogLevel, restrictedGlobals: ESLintPropertyRule[]): Linter.Config['rules'] {
+function getDependencyConfig(level: LogLevel, restrictedGlobals: ESLintPropertyRule[]): Linter.LegacyConfig['rules'] {
     const globalRules = getGlideGlobalEslintRules()
     const namespaceRules = getGlideNamespaceEslintRules()
     return {

package/src/repack/lint/index.ts

@@ -1,71 +1,95 @@
 import { Linter, type ESLint } from 'eslint'
 import formatter from 'eslint-formatter-stylish'
-import { getEslintConfig, getPluginModules } from './Rules'
+import { getEslintConfig, getLocalModuleEslintConfig, getPluginRules } from './Rules'
 
-export class Lint {
-    private linter: Linter | undefined
-    private config: Linter.Config | undefined
-
-    private async initESLint() {
-        if (!this.linter) {
-            this.linter = new Linter()
-            this.linter.defineRules(await getPluginModules())
-            this.config = await getEslintConfig()
-        }
-
-        return { linter: this.linter, config: this.config }
-    }
-
-    async check(fileContent: string): Promise<string | undefined> {
-        await this.initESLint()
+// Module-level singletons — the Linter and configs are shared across all Lint instances.
+// Uses configType: 'eslintrc' (legacy mode) because ESLint v9's flat config verify() path
+// re-validates the config (including 7000+ no-restricted-properties entries) on every call,
+// causing significant performance overhead. In legacy mode, defineRules() loads rules once
+// and verify() is lightweight — matching ESLint v8 behavior.
+//
+// TODO: configType: 'eslintrc' is deprecated and will be removed in ESLint v10.
+// When that happens, replace the 7000+ no-restricted-properties entries with a single
+// custom ESLint rule that internalizes the Glide API blocklist. This would make flat
+// config verify() fast by reducing the rule count, eliminating the need for legacy mode.
+let sharedLinter: Linter | undefined
+let dependencyConfig: Linter.LegacyConfig | undefined
+let localModuleConfig: Linter.LegacyConfig | undefined
 
-        const messages = this.linter!.verify(fileContent, this.config!)
-        return this.outputLintingResults(messages)
+function getSharedLinter(): Linter {
+    if (!sharedLinter) {
+        sharedLinter = new Linter({ configType: 'eslintrc' })
+        sharedLinter.defineRules(getPluginRules())
+        dependencyConfig = getEslintConfig()
+        localModuleConfig = getLocalModuleEslintConfig()
     }
+    return sharedLinter
+}
 
-    private outputLintingResults(messages: Linter.LintMessage[]): string | undefined {
-        const stats = messages.reduce(
-            (result, message) => {
-                if (message.fatal) {
-                    result.fatalErrorCount++
-                }
+function outputLintingResults(messages: Linter.LintMessage[]): string | undefined {
+    const stats = messages.reduce(
+        (result, message) => {
+            if (message.fatal) {
+                result.fatalErrorCount++
+            }
 
-                if (message.severity === 1) {
-                    result.warningCount++
-                    if (message.fix) {
-                        result.fixableWarningCount++
-                    }
+            if (message.severity === 1) {
+                result.warningCount++
+                if (message.fix) {
+                    result.fixableWarningCount++
                 }
-                if (message.severity === 2) {
-                    result.errorCount++
-                    if (message.fix) {
-                        result.fixableErrorCount++
-                    }
+            }
+            if (message.severity === 2) {
+                result.errorCount++
+                if (message.fix) {
+                    result.fixableErrorCount++
                 }
-
-                return result
-            },
-            {
-                errorCount: 0,
-                fatalErrorCount: 0,
-                warningCount: 0,
-                fixableErrorCount: 0,
-                fixableWarningCount: 0,
             }
-        )
-        const results: ESLint.LintResult = {
-            filePath: '',
-            messages,
-            suppressedMessages: [],
-            usedDeprecatedRules: [],
-            ...stats,
-        }
 
-        const problems = results.errorCount + results.warningCount + results.fatalErrorCount
-        if (problems <= 0) {
-            return
+            return result
+        },
+        {
+            errorCount: 0,
+            fatalErrorCount: 0,
+            warningCount: 0,
+            fixableErrorCount: 0,
+            fixableWarningCount: 0,
         }
+    )
+    const results: ESLint.LintResult = {
+        filePath: '',
+        messages,
+        suppressedMessages: [],
+        usedDeprecatedRules: [],
+        ...stats,
+    }
+
+    const problems = results.errorCount + results.warningCount + results.fatalErrorCount
+    if (problems <= 0) {
+        return
+    }
+
+    return (formatter as (results: ESLint.LintResult[]) => string)([results])
+}
+
+/**
+ * Lint for 3rd party dependencies — Rhino compatibility + Glide API restrictions.
+ */
+export class Lint {
+    check(fileContent: string): string | undefined {
+        const linter = getSharedLinter()
+        const messages = linter.verify(fileContent, dependencyConfig!)
+        return outputLintingResults(messages)
+    }
+}
 
-        return (formatter as (results: ESLint.LintResult[]) => string)([results])
+/**
+ * Lint for local modules — Rhino compatibility rules only (no Glide restrictions).
+ */
+export class LocalModuleLint {
+    check(fileContent: string): string | undefined {
+        const linter = getSharedLinter()
+        const messages = linter.verify(fileContent, localModuleConfig!)
+        return outputLintingResults(messages)
     }
 }