@servicenow/sdk-build-plugins 4.0.1 → 4.1.0

package/src/role-plugin.ts

@@ -1,4 +1,4 @@
-import { isSNScope } from '@servicenow/sdk-build-core'
+import { isSNScope, type Record } from '@servicenow/sdk-build-core'
 import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { generateDeprecatedDiagnostics } from './utils'
 
@@ -77,7 +77,7 @@ export const RolePlugin = Plugin.create({
                     diagnostics.error(name.getOriginalNode(), `Role name must begin with '${scope}.'`)
                 }
 
-                const role = factory.createRecord({
+                const role = await factory.createRecord({
                     explicitId: arg.get('$id'),
                     source: callExpression,
                     table: 'sys_user_role',
@@ -98,26 +98,26 @@ export const RolePlugin = Plugin.create({
                     })),
                 })
 
-                const containedRoles = arg
-                    .get('containsRoles')
-                    .ifArray()
-                    ?.map((e) =>
-                        factory.createRecord({
+                const containedRoles: Record[] = []
+                for (const e of arg.get('containsRoles').ifArray()?.getElements() ?? []) {
+                    containedRoles.push(
+                        await factory.createRecord({
                             source: callExpression,
                             table: 'sys_user_role_contains',
                             properties: {
                                 role,
-                                contains:
-                                    e.ifStringLiteral()?.pipe((roleName) =>
-                                        factory.createReference({
-                                            source: roleName,
-                                            table: 'sys_user_role',
-                                            keys: { name: roleName },
-                                        })
-                                    ) ?? e,
+                                contains: e.isStringLiteral()
+                                    ? await factory.createReference({
+                                          source: e,
+                                          table: 'sys_user_role',
+                                          keys: { name: e },
+                                      })
+                                    : e,
                             },
                         })
                     )
+                }
+
                 return {
                     success: true,
                     value: role.with(...(containedRoles ?? [])),

package/src/script-action-plugin.ts

@@ -39,7 +39,7 @@ export const ScriptActionPlugin = Plugin.create({
                 }
 
                 const args = callExpression.getArgument(0).asObject()
-                const record = factory.createRecord({
+                const record = await factory.createRecord({
                     source: callExpression,
                     table: 'sysevent_script_action',
                     explicitId: args.get('$id'),

package/src/script-include-plugin.ts

@@ -1,5 +1,6 @@
 import { CallExpressionShape, isSNScope, Plugin } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
+import { NowIncludeShape } from './now-include-plugin'
 
 const nameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]+$/
 
@@ -7,7 +8,9 @@ export const ScriptIncludePlugin = Plugin.create({
     name: `ScriptIncludePlugin`,
     records: {
         sys_script_include: {
-            toShape(record) {
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
+
                 return {
                     success: true,
                     value: new CallExpressionShape({
@@ -17,9 +20,9 @@ export const ScriptIncludePlugin = Plugin.create({
                             record.transform(({ $ }) => ({
                                 $id: $.val(NowIdShape.from(record)),
                                 name: $,
-                                script: $,
+                                script: $.val(script),
                                 description: $.def(''),
-                                apiName: $.from('api_name').def(``),
+                                apiName: $.from('api_name').def(''),
                                 callerAccess: $.from('caller_access').map((v) =>
                                     v
                                         .ifString()
@@ -67,7 +70,7 @@ export const ScriptIncludePlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: shape,
                         table: 'sys_script_include',
                         explicitId: prop.get('$id'),

package/src/server-module-plugin/index.ts

@@ -10,13 +10,16 @@ import {
     type Project,
     type RecordContext,
     type Compiler,
+    type Package,
+    type Record,
 } from '@servicenow/sdk-build-core'
-import { path as pathModule, ts, type FileSystem, type NowConfig } from '@servicenow/sdk-build-core'
+import { NowConfig, path as pathModule, ts, type FileSystem } from '@servicenow/sdk-build-core'
 import { RepackService } from '../repack'
 import { SBOMBuilder } from './sbom-builder'
 import isEqual from 'lodash/isEqual'
 import { INVALID_XML_CHARACTERS, applyPathMappings } from '../utils'
 import zip from 'lodash/zip'
+import type { DependencyNode } from '@servicenow/sdk-repack'
 
 const GLUE_CODE_PREFIX = '// @fluent-module'
 const GLUE_CODE_META_REGEX = new RegExp(`^${GLUE_CODE_PREFIX} (.*);(true|false);(.*)`) // name;isDefault;path
@@ -29,22 +32,26 @@ const GLUE_CODE_WARNING = `
 // SDK from regenerating it. However, you will then be responsible for the
 // management of this code in your Fluent file.`
 
+const NODE_MODULES = 'node_modules'
+
 type GlueCodeMeta = {
     name: string
     path: string
     isDefault: boolean
+    relativePath?: string
 }
 
-function isGlueCode(string: StringShape): boolean {
+function isGlueCode(string: StringShape | string): boolean {
     return string.startsWith(GLUE_CODE_PREFIX)
 }
 
-function parseMeta(string: StringShape): GlueCodeMeta {
-    const result = string.getValue().match(GLUE_CODE_META_REGEX)
+function parseMeta(string: StringShape | string): GlueCodeMeta {
+    const value = typeof string === 'string' ? string : string.getValue()
+    const result = value.match(GLUE_CODE_META_REGEX)
     const [, name, isDefault, path] = result ?? []
 
     if (typeof name !== 'string' || typeof isDefault !== 'string' || typeof path !== 'string') {
-        throw new Error(`Invalid glue code format: ${string.getValue()}`)
+        throw new Error(`Invalid glue code format: ${value}`)
     }
 
     return { name, path, isDefault: isDefault === 'true' }
@@ -62,34 +69,40 @@ export class ModuleFunctionShape extends Shape {
         callExpressionProvider: (functionName: string) => string = (name) => `${name}()`,
         defaultParams?: string[]
     ): StringShape {
-        const { name, path, isDefault } = this.meta
+        const { name, path, isDefault, relativePath } = this.meta
         const moduleParamNames = getFunctionParameters(this.getSource())
+
         const variables = zip(defaultParams ?? [], moduleParamNames).map(
             ([defaultParam, moduleParamName]) => defaultParam ?? moduleParamName
         )
         const moduleCallExpression = callExpressionProvider(name).replace('{{PARAMS}}', variables.join(', '))
 
+        const requirePath = relativePath ?? path
+
         const code = isDefault
-            ? `const ${name} = require('${path}').default;\n${moduleCallExpression};`
-            : `const { ${name} } = require('${path}');\n${moduleCallExpression};`
+            ? `const ${name} = require('${requirePath}').default;\n${moduleCallExpression};`
+            : `const { ${name} } = require('${requirePath}');\n${moduleCallExpression};`
 
         return Shape.from(this, `${GLUE_CODE_PREFIX} ${name};${isDefault};${path}${GLUE_CODE_WARNING}\n${code}`)
             .asString()
             .withContentType('cdata')
     }
 
-    override equals(other: Shape): boolean {
-        if (other.is(ModuleFunctionShape)) {
+    override equals(other: unknown): boolean {
+        if (other instanceof ModuleFunctionShape) {
             return isEqual(this.meta, other.meta)
-        } else if (other.isString()) {
-            if (!isGlueCode(other)) {
+        }
+
+        const string = other instanceof StringShape ? other.getValue() : other
+        if (typeof string === 'string') {
+            if (!isGlueCode(string)) {
                 return false
             }
 
-            return isEqual(this.meta, parseMeta(other))
-        } else {
-            return super.equals(other)
+            return isEqual(this.meta, parseMeta(string))
         }
+
+        return super.equals(other)
     }
 }
 
@@ -147,7 +160,7 @@ function getFunctionParameters(source: Source): string[] {
 
 async function parseDeclaration(
     node: ts.FunctionDeclaration | ts.VariableDeclaration,
-    { transform }: { transform: Transform }
+    { transform, project, config }: { transform: Transform; config: NowConfig; project: Project }
 ): Promise<Result<ModuleFunctionShape>> {
     const result = await transform.toRecord(node.getSourceFile())
     if (!result.success) {
@@ -159,11 +172,27 @@ async function parseDeclaration(
         return { success: false }
     }
 
+    const path = record.get('path').asString().getValue()
+
+    if (NowConfig.legacyPackageResolution(config) || config.scope === 'global') {
+        return {
+            success: true,
+            value: new ModuleFunctionShape(node, {
+                name: node.getName() ?? 'functionModule',
+                path: path,
+                isDefault: node.isDefaultExport(),
+            }),
+        }
+    }
+
+    const originalPath = (record.getSource() as SourceFileShape).getPath()
+    const relativePath = pathModule.relative(project.getRootDir(), project.resolvePath(originalPath))
     return {
         success: true,
         value: new ModuleFunctionShape(node, {
             name: node.getName() ?? 'functionModule',
-            path: record.get('path').asString().getValue(),
+            path: path,
+            relativePath: `./${relativePath}`,
             isDefault: node.isDefaultExport(),
         }),
     }
@@ -194,6 +223,38 @@ function isValidRequireCall(callExpression: ts.CallExpression, requirePath: ts.S
     return isRequire && !isRelativePath
 }
 
+function buildParentPathMap(dependencyNodes: DependencyNode[]) {
+    const importerMap = {}
+    for (const node of dependencyNodes) {
+        let parent = node.parentPackage
+
+        while (parent) {
+            const importerMapKey = `${node.pkgName}@${node.updatedManifest.version}`
+            if (!importerMap[importerMapKey]) {
+                importerMap[importerMapKey] = []
+            }
+            importerMap[importerMapKey].push(parent.pkgName)
+
+            const newParent = dependencyNodes.find((potentialParent) => {
+                if (!parent || !parent.pkgName) {
+                    return false
+                }
+                if (potentialParent.updatedManifest.dependencies[parent!.pkgName]) {
+                    return potentialParent
+                }
+                return false
+            })
+            parent = newParent
+                ? {
+                      pkgName: newParent.updatedManifest.name,
+                      version: newParent.updatedManifest.version,
+                  }
+                : undefined
+        }
+    }
+    return importerMap
+}
+
 class ModuleDependencyShape extends Shape {
     private readonly moduleName: string
 
@@ -214,7 +275,11 @@ class ModuleDependencyShape extends Shape {
 }
 
 // TODO: Need to have some invalidation mechanism. Maybe the plugin framework can provide plugins with a managed cache to use for stuff like this?
-const DEPENDENCY_CACHE: globalThis.Record<string, Result<ModuleDependencyShape>> = {}
+let DEPENDENCY_CACHE: globalThis.Record<string, Result<ModuleDependencyShape>> = {}
+// Expose cache clearing for tests
+export function clearDependencyCache() {
+    DEPENDENCY_CACHE = {}
+}
 
 function parseModuleDependency(
     node: ts.ImportDeclaration | ts.ExportDeclaration | ts.CallExpression
@@ -261,6 +326,41 @@ function generateSBOMContent(context: RecordContext) {
     return sbomBuilder.generateSBOM(context)
 }
 
+function getModuleDependencyPath(
+    config: NowConfig,
+    module: { name: string; file: string; version: string; packageJson: Package; importerPath?: string[] }
+) {
+    const { name, file, packageJson, importerPath, version } = module
+
+    if (NowConfig.legacyPackageResolution(config)) {
+        return NowConfig.moduleResolutionPath(config, packageJson, true, name, version, file)
+    }
+
+    if (config.hoistDependencies) {
+        return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
+    }
+
+    if (importerPath && importerPath.length > 0) {
+        const pathSegments = [...importerPath].reverse()
+        const pathSegmentsWithNodeModules: string[] = []
+        pathSegments.forEach((segment) => {
+            pathSegmentsWithNodeModules.push(NODE_MODULES)
+            pathSegmentsWithNodeModules.push(segment)
+        })
+        return NowConfig.moduleResolutionPath(
+            config,
+            packageJson,
+            true,
+            ...pathSegmentsWithNodeModules,
+            NODE_MODULES,
+            name,
+            file
+        )
+    }
+
+    return NowConfig.moduleResolutionPath(config, packageJson, true, NODE_MODULES, name, file)
+}
+
 export const ServerModulePlugin = Plugin.create({
     name: 'ServerModulePlugin',
     files: [
@@ -291,6 +391,7 @@ export const ServerModulePlugin = Plugin.create({
                 return {
                     success: true,
                     value: {
+                        source: record,
                         name: `sys_module_${record.getId().getValue()}.xml`,
                         category: record.getInstallCategory(),
                         content: `<?xml version="1.0"?>
@@ -315,7 +416,7 @@ export const ServerModulePlugin = Plugin.create({
         {
             shape: SourceFileShape,
             fileTypes: ['module'],
-            toRecord(file, { factory, fs, diagnostics, project, config, packageJson, compiler }) {
+            async toRecord(file, { factory, fs, diagnostics, project, config, packageJson, compiler }) {
                 const path = file.getPath()
                 if (!path.startsWith(project.resolvePath(config.serverModulesDir))) {
                     return { success: false }
@@ -340,11 +441,11 @@ export const ServerModulePlugin = Plugin.create({
                 }
 
                 const relativePath = pathModule.relative(project.getRootDir(), resolvedPath)
-                const sysModulePath = pathModule.join(config.scope, packageJson.name, packageJson.version, relativePath)
+                const sysModulePath = NowConfig.moduleResolutionPath(config, packageJson, false, relativePath)
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: file,
                         table: 'sys_module',
                         explicitId: relativePath.replaceAll(/[./\\]/g, '_'),
@@ -367,29 +468,33 @@ export const ServerModulePlugin = Plugin.create({
             // TODO: When managed cache is provided to plugins, cache dependencies that were already handled to avoid reprocessing
             async toRecord(shape, { packageJson, diagnostics, fs, logger, project, factory, config }) {
                 const dependencies = packageJson.dependencies ?? {}
-                const { name, entry } = validateAndGetModuleSpecifier(shape.getModuleName())
+                const { name: parentName, entry } = validateAndGetModuleSpecifier(shape.getModuleName())
 
-                const version = dependencies[name]
+                const version = dependencies[parentName]
                 if (!version) {
-                    diagnostics.error(shape, `Dependency ${name} is not found in package.json`)
+                    diagnostics.error(shape, `Dependency ${parentName} is not found in package.json`)
                     return { success: false }
                 }
 
-                const id = `${name}@${version}`
+                const id = `${parentName}@${version}`
                 const repack = await RepackService.create(logger, fs, project.getRootDir())
                 const dependencyNodes = await repack.execute({
                     id,
                     entry: entry ? [entry] : ['.'],
                 })
-
                 if (!dependencyNodes) {
                     throw new Error(`Failed to build dependency ${id}`)
                 }
 
+                let importerMap = {}
+                if (!config.hoistDependencies) {
+                    importerMap = buildParentPathMap(dependencyNodes)
+                }
+
                 const modules: { id: string; path: string; content: string }[] = []
                 const { Lint } = await import('../repack/lint/index.js')
                 for (const node of dependencyNodes) {
-                    const { packagePath, files, updatedManifest } = node
+                    const { packagePath, files, updatedManifest, pkgName } = node
                     const { name, version } = updatedManifest
 
                     for (const file of files) {
@@ -404,28 +509,38 @@ export const ServerModulePlugin = Plugin.create({
 
                         modules.push({
                             id: `${name}@${version}/${file}`,
-                            path: pathModule.join(config.scope, name, version, file),
+                            path: getModuleDependencyPath(config, {
+                                name,
+                                file,
+                                version,
+                                packageJson,
+                                importerPath: importerMap[`${pkgName}@${version}`],
+                            }),
                             content: fileContent,
                         })
                     }
                 }
 
-                const [first, ...rest] = modules.map((m) => {
-                    return factory.createRecord({
-                        source: shape,
-                        table: 'sys_module',
-                        explicitId: m.id,
-                        properties: {
-                            path: m.path,
-                            content: Shape.from(shape, sanitizeModuleContent(m.content))
-                                .asString()
-                                .withContentType('cdata'),
-                            external_source: true,
-                            sys_name: m.path,
-                        },
-                    })
-                })
+                const records: Record[] = []
+                for (const m of modules) {
+                    records.push(
+                        await factory.createRecord({
+                            source: shape,
+                            table: 'sys_module',
+                            explicitId: m.id,
+                            properties: {
+                                path: m.path,
+                                content: Shape.from(shape, sanitizeModuleContent(m.content))
+                                    .asString()
+                                    .withContentType('cdata'),
+                                external_source: true,
+                                sys_name: m.path,
+                            },
+                        })
+                    )
+                }
 
+                const [first, ...rest] = records
                 if (!first) {
                     return { success: false }
                 }

package/src/service-portal/angular-provider-plugin.ts

@@ -51,7 +51,7 @@ export const SPAngularProviderPlugin = Plugin.create({
                     .filter((provider) => provider.equals(providerId))
                     .forEach((provider) => diagnostics.error(provider, 'recursive dependency detected'))
 
-                const providerRecord = factory.createRecord({
+                const providerRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sp_angular_provider',
                     explicitId: providerObj.get('$id'),
@@ -65,16 +65,18 @@ export const SPAngularProviderPlugin = Plugin.create({
                 return {
                     success: true,
                     value: providerRecord.with(
-                        ...requires.map((child) => {
-                            return factory.createRecord({
-                                source: callExpression,
-                                table: 'm2m_sp_ng_pro_sp_ng_pro',
-                                properties: {
-                                    required_by: providerRecord.getId(),
-                                    requires: child.ifString()?.getValue() ?? child.ifRecord()?.getId(),
-                                },
+                        ...(await Promise.all(
+                            requires.map(async (child) => {
+                                return factory.createRecord({
+                                    source: callExpression,
+                                    table: 'm2m_sp_ng_pro_sp_ng_pro',
+                                    properties: {
+                                        required_by: providerRecord.getId(),
+                                        requires: child.ifString()?.getValue() ?? child.ifRecord()?.getId(),
+                                    },
+                                })
                             })
-                        })
+                        ))
                     ),
                 }
             },

package/src/service-portal/dependency-plugin.ts

@@ -123,7 +123,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: callExpression,
                         table: 'sp_js_include',
                         explicitId: jsIncludeId,
@@ -156,7 +156,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: callExpression,
                         table: 'sp_css_include',
                         explicitId: cssIncludeId,
@@ -199,7 +199,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
                         })
                         .filter((guid) => guid) as string[]) || []
 
-                const dependencyRecord = factory.createRecord({
+                const dependencyRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sp_dependency',
                     explicitId: dependency.get('$id'),
@@ -211,7 +211,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
                     })),
                 })
 
-                const cssIncludes = getIncludeRecords(
+                const cssIncludes = await getIncludeRecords(
                     dependency.get('cssIncludes'),
                     dependencyRecord.getId(),
                     factory,
@@ -220,7 +220,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
                     diagnostics
                 )
 
-                const jsIncludes = getIncludeRecords(
+                const jsIncludes = await getIncludeRecords(
                     dependency.get('jsIncludes'),
                     dependencyRecord.getId(),
                     factory,
@@ -238,7 +238,7 @@ export const SPWidgetDependencyPlugin = Plugin.create({
     ],
 })
 
-function getIncludeRecords(
+async function getIncludeRecords(
     shape: Shape,
     dependencyId: Shape,
     factory: Factory,
@@ -247,9 +247,8 @@ function getIncludeRecords(
     diagnostics: Diagnostics
 ) {
     return (
-        (shape
-            ?.ifArray()
-            ?.map((include) => {
+        await Promise.all(
+            shape?.ifArray()?.map(async (include) => {
                 const includeProps = include.ifObject()?.get('include')
 
                 let includeId: string | RecordId
@@ -270,7 +269,7 @@ function getIncludeRecords(
                     [includeTable]: includeId,
                     sp_dependency: dependencyId,
                 }
-                return factory.createRecord({
+                return await factory.createRecord({
                     source: shape,
                     table: m2mTable,
                     properties: {
@@ -278,7 +277,7 @@ function getIncludeRecords(
                         ...m2mProps,
                     },
                 })
-            })
-            .filter((rec) => rec) as Record[]) || []
-    )
+            }) ?? []
+        )
+    ).filter((rec) => rec) as Record[]
 }

package/src/service-portal/widget-plugin.ts

@@ -165,7 +165,7 @@ export const SPWidgetPlugin = Plugin.create({
                         (config.scope.startsWith('sn_') || config.scope.startsWith('snc_'))) ||
                     false
 
-                const widgetRecord = factory.createRecord({
+                const widgetRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sp_widget',
                     explicitId: widget.get('$id'),
@@ -207,38 +207,44 @@ export const SPWidgetPlugin = Plugin.create({
                 return {
                     success: true,
                     value: widgetRecord.with(
-                        ...templates.map((template: SPTemplate) => {
-                            return factory.createRecord({
-                                source: callExpression,
-                                table: 'sp_ng_template',
-                                explicitId: template.$id as string,
-                                properties: {
-                                    id: template.id,
-                                    sp_widget: widgetRecord.getId(),
-                                    template: template.htmlTemplate,
-                                },
+                        ...(await Promise.all(
+                            templates.map(async (template: SPTemplate) => {
+                                return await factory.createRecord({
+                                    source: callExpression,
+                                    table: 'sp_ng_template',
+                                    explicitId: template.$id as string,
+                                    properties: {
+                                        id: template.id,
+                                        sp_widget: widgetRecord.getId(),
+                                        template: template.htmlTemplate,
+                                    },
+                                })
                             })
-                        }),
-                        ...dependencies.map((dep) => {
-                            return factory.createRecord({
-                                source: callExpression,
-                                table: 'm2m_sp_widget_dependency',
-                                properties: {
-                                    sp_dependency: dep!,
-                                    sp_widget: widgetRecord.getId(),
-                                },
+                        )),
+                        ...(await Promise.all(
+                            dependencies.map(async (dep) => {
+                                return await factory.createRecord({
+                                    source: callExpression,
+                                    table: 'm2m_sp_widget_dependency',
+                                    properties: {
+                                        sp_dependency: dep!,
+                                        sp_widget: widgetRecord.getId(),
+                                    },
+                                })
                             })
-                        }),
-                        ...angularProviders.map((ap) => {
-                            return factory.createRecord({
-                                source: callExpression,
-                                table: 'm2m_sp_ng_pro_sp_widget',
-                                properties: {
-                                    sp_angular_provider: ap!,
-                                    sp_widget: widgetRecord.getId(),
-                                },
+                        )),
+                        ...(await Promise.all(
+                            angularProviders.map(async (ap) => {
+                                return await factory.createRecord({
+                                    source: callExpression,
+                                    table: 'm2m_sp_ng_pro_sp_widget',
+                                    properties: {
+                                        sp_angular_provider: ap!,
+                                        sp_widget: widgetRecord.getId(),
+                                    },
+                                })
                             })
-                        })
+                        ))
                     ),
                 }
             },