@servicenow/sdk-build-plugins 4.0.1 → 4.1.0

package/src/list-plugin.ts

@@ -37,6 +37,7 @@ export const ListPlugin = Plugin.create({
     name: 'ListPlugin',
     records: {
         sys_ui_list: {
+            composite: true,
             coalesce: ['name', 'view', 'sys_domain', 'element', 'relationship', 'parent'],
             relationships: {
                 sys_ui_list_element: {
@@ -126,12 +127,17 @@ export const ListPlugin = Plugin.create({
                     }
                 })
 
-                const child = root.ele('sys_ui_list', { action: 'INSERT_OR_UPDATE' })
+                const child = root.ele('sys_ui_list', { action: list.getAction() })
                 child.ele('sys_id').txt(list.getId().getValue())
                 child.ele('sys_scope', { display_value: config.scope }).txt(config.scopeId)
 
-                const view = list.get('view').toRecordId()
-                child.ele('view', view.resolveKeys()).txt(view.getValue())
+                const view = list.get('view')
+                if (view.isRecordId() || view.isRecord()) {
+                    const viewId = view.isRecordId() ? view : view.getId()
+                    child.ele('view', viewId.resolveKeys()).txt(viewId.getValue())
+                } else {
+                    child.ele('view').txt(view.asString().getValue())
+                }
 
                 const name = list.get('name')
                 if (name.isDefined()) {
@@ -153,6 +159,7 @@ export const ListPlugin = Plugin.create({
                 return {
                     success: true,
                     value: {
+                        source: list,
                         name: `sys_ui_list_${list.getId().getValue()}.xml`,
                         category: list.getInstallCategory(),
                         content: xml.end({ prettyPrint: true }),
@@ -175,46 +182,48 @@ export const ListPlugin = Plugin.create({
 
                 const arg = callExpression.getArgument(0).asObject()
                 const columns = arg.get('columns').ifArray()?.getElements() ?? []
-                const list = factory.createRecord({
+                const view = arg.get('view')
+                const viewReference = view.isString()
+                    ? await factory.createReference({
+                          source: view,
+                          table: 'sys_ui_view',
+                          keys: { name: view },
+                      })
+                    : view
+
+                const list = await factory.createRecord({
                     source: callExpression,
                     table: 'sys_ui_list',
                     explicitId: arg.get('$id'),
                     properties: arg.transform(({ $ }) => ({
                         name: $.from('table'),
-                        view: $.map((v) =>
-                            v.ifString()
-                                ? factory.createReference({
-                                      source: v,
-                                      table: 'sys_ui_view',
-                                      keys: {
-                                          name: v,
-                                      },
-                                  })
-                                : v
-                        ),
+                        view: $.val(viewReference),
                         parent: $,
                         relationship: $.map((v) => v.if([Record, StringShape])),
                         sys_domain: $.val('global'), // TODO: Domain support?
                     })),
                 })
 
+                const columnRecords: Record[] = []
+                for (const [index, column] of columns.entries()) {
+                    columnRecords.push(
+                        await factory.createRecord({
+                            source: callExpression,
+                            table: 'sys_ui_list_element',
+                            properties: {
+                                list_id: list,
+                                position: index,
+                                ...(column.isString()
+                                    ? { element: column }
+                                    : generateListColumnProps(column.asObject(), index, diagnostics)),
+                            },
+                        })
+                    )
+                }
+
                 return {
                     success: true,
-                    value: list.with(
-                        ...columns.map((column, index) =>
-                            factory.createRecord({
-                                source: callExpression,
-                                table: 'sys_ui_list_element',
-                                properties: {
-                                    list_id: list,
-                                    position: index,
-                                    ...(column.isString()
-                                        ? { element: column }
-                                        : generateListColumnProps(column.asObject(), index, diagnostics)),
-                                },
-                            })
-                        )
-                    ),
+                    value: list.with(...columnRecords),
                 }
             },
         },

package/src/now-config-plugin.ts

@@ -1,4 +1,4 @@
-import { NowConfig, ObjectShape, Plugin, Shape } from '@servicenow/sdk-build-core'
+import { NowConfig, ObjectShape, MODULE_RESOLUTION, Plugin, Shape } from '@servicenow/sdk-build-core'
 
 import { JsonFileShape } from './json-plugin'
 
@@ -14,9 +14,8 @@ export const NowConfigPlugin = Plugin.create({
     ],
     records: {
         sys_app: {
-            toShape(record, { packageJson }) {
+            toShape(record, { packageJson, config }) {
                 const { name: packageName } = packageJson
-
                 return {
                     success: true,
                     value: new NowConfigShape({
@@ -114,6 +113,9 @@ export const NowConfigPlugin = Plugin.create({
                             logo: $.toString().def(''),
                             guidedSetupGuid: $.from('guided_setup_guid').toString().def(''),
                             installedAsDependency: $.from('installed_as_dependency').toBoolean().def(false),
+                            packageResolverVersion: $.from('package_resolver_version').def(
+                                config.scope === 'global' ? MODULE_RESOLUTION.V2 : MODULE_RESOLUTION.V1
+                            ),
                         })),
                     }),
                 }
@@ -123,7 +125,7 @@ export const NowConfigPlugin = Plugin.create({
     shapes: [
         {
             shape: JsonFileShape,
-            toRecord(file, { factory, config: rawConfig, packageJson }) {
+            async toRecord(file, { factory, config: rawConfig, packageJson, diagnostics }) {
                 if (file.getBaseName() !== NowConfig.FILE_NAME) {
                     return { success: false }
                 }
@@ -134,12 +136,19 @@ export const NowConfigPlugin = Plugin.create({
                 const { name: packageName, version } = packageJson
                 const name = config.get('name').isDefined() ? config.get('name').asString().getValue() : packageName
 
+                let packageJsonPath: string
+                try {
+                    packageJsonPath = NowConfig.moduleResolutionPath(rawConfig, packageJson, false, 'package.json')
+                } catch (e: any) {
+                    diagnostics.error(file, e.message)
+                }
+
                 const accessControls = config.get('accessControls').ifDefined()?.asObject()
                 const licensing = config.get('licensing').ifDefined()?.asObject()
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: config,
                         table: 'sys_app',
                         properties: config.transform(({ $ }) => ({
@@ -176,15 +185,17 @@ export const NowConfigPlugin = Plugin.create({
                             trackable: $.val(accessControls?.get('trackable')).toBoolean().def(true),
                             uninstall_blocked: $.val(accessControls?.get('uninstallBlocked')).toBoolean().def(false),
                             hide_on_ui: $.val(accessControls?.get('hideOnUI')).toBoolean().def(false),
-                            installed_as_dependency: $.toBoolean().def(false),
+                            installed_as_dependency: $.from('installedAsDependency').toBoolean().def(false),
                             license_category: $.val(licensing?.get('licenseCategory')).toString().def('none'),
-
                             scope: $.val(scope),
-                            package_json: $.val(`${scope}/${packageName}/${version}/package.json`),
+                            package_json: $.val(packageJsonPath),
                             name: $.val(name),
                             source: $.val(scope),
                             sys_id: $.from('scopeId'),
                             version: $.val(version),
+                            package_resolver_version: $.from('packageResolverVersion').def(
+                                scope === 'global' ? MODULE_RESOLUTION.V2 : MODULE_RESOLUTION.V1
+                            ),
                         })),
                     }),
                 }

package/src/now-include-plugin.ts

@@ -1,45 +1,53 @@
 import {
-    type ts,
     path as pathModule,
     CallExpressionShape,
     Plugin,
     type ProjectFile,
+    type Record,
     type Source,
     StringShape,
     Shape,
+    FileSystem,
+    type Transform,
 } from '@servicenow/sdk-build-core'
 import { CallExpressionPlugin } from './call-expression-plugin'
 
 export class NowIncludeShape extends CallExpressionShape {
-    private readonly includedFile: ProjectFile
+    private readonly includedText: string
 
-    constructor({ source, path, includedFile }: { source: Source; path: string; includedFile: ProjectFile }) {
+    constructor({ source, path, includedText }: { source: Source; path: string; includedText: string }) {
         super({ source, callee: 'Now.include', args: [path] })
-        this.includedFile = includedFile
+        this.includedText = includedText
     }
 
     getPath(): string {
         return this.getArgument(0).asString().getValue()
     }
 
-    getAbsolutePath(): string {
-        return this.getIncludedFile().getPath()
+    override getValue(): string {
+        return this.includedText
     }
 
-    getRelativePathFrom(node: ts.Node): string {
-        return pathModule.relative(pathModule.dirname(node.getSourceFile().getFilePath()), this.getAbsolutePath())
+    override toString(): StringShape {
+        return Shape.from(this, this.getValue()).asString().withContentType('cdata')
     }
 
-    getIncludedFile(): ProjectFile {
-        return this.includedFile
+    override equals(other: unknown): boolean {
+        if (typeof other === 'string') {
+            return this.includedText === other
+        } else if (other instanceof Shape) {
+            return other.equals(this.includedText)
+        } else {
+            return super.equals(other)
+        }
     }
 
-    override getValue(): string {
-        return this.getIncludedFile().getContent()
-    }
-
-    override toString(): StringShape {
-        return Shape.from(this, this.getValue()).asString().withContentType('cdata')
+    static async fromRecord(record: Record, text: string | Shape, transform: Transform): Promise<NowIncludeShape> {
+        return new NowIncludeShape({
+            source: record,
+            path: `./${await transform.getUpdateName(record)}.js`,
+            includedText: text instanceof Shape ? text.toString().getValue() : text,
+        })
     }
 }
 
@@ -61,7 +69,6 @@ export const NowIncludePlugin = Plugin.create({
                 }
 
                 const path = arg.getValue()
-
                 if (!/^\.\.?\/.*$/.test(path.trim()) && path.includes('/')) {
                     diagnostics.error(arg, 'Now.include() argument must be a relative path')
                     return { success: false }
@@ -86,38 +93,64 @@ export const NowIncludePlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: new NowIncludeShape({ source: callExpression, path, includedFile }),
+                    value: new NowIncludeShape({
+                        source: callExpression,
+                        path,
+                        includedText: includedFile.getContent(),
+                    }),
                 }
             },
         },
         {
             shape: NowIncludeShape,
-            async commit(shape, target, { transform, commit }) {
+            async commit(shape, target, { transform, commit, project, fs }) {
                 const targetResult = await transform.toShape(target)
                 if (!targetResult.success) {
                     return { success: false }
                 }
 
+                const targetDirPath = target.getSourceFile().getDirectoryPath()
+                const targetPath = project.resolvePath(targetDirPath, shape.getPath())
+
                 const { value: targetShape } = targetResult
+                if (targetShape.equals(shape.getValue())) {
+                    return { success: true }
+                }
+
                 if (targetShape.is(NowIncludeShape)) {
-                    if (targetShape.getAbsolutePath() === shape.getAbsolutePath()) {
-                        // It's already a Now.include() call pointing to the same file, so nothing to do
-                        return { success: true }
+                    // Never update the path of an existing Now.include() - just update the file content
+                    project
+                        .getFile(project.resolvePath(targetDirPath, targetShape.getPath()))
+                        .setContent(shape.getValue())
+                } else if (targetShape.is(CallExpressionShape) && targetShape.getCallee() === 'Now.include') {
+                    // TODO: This is hacky AF. When Now.include() is generated for the first time, it's
+                    //  just written to the file using getCode() which doesn't generate any file at the
+                    //  included path. Therefore, the shape is not parsed into a NowIncludeShape because
+                    //  we check if the file exists and return success: false if it doesn't. So it just
+                    //  comes back as a generic CallExpressionShape.
+                    await commit(shape, target, CallExpressionPlugin)
+                    if (FileSystem.existsSync(fs, targetPath)) {
+                        project
+                            .addFile(targetPath, { resolveDependencies: false, excludeFromCompiler: true })
+                            .setContent(shape.getValue())
+                    } else {
+                        project.addFile(
+                            { path: targetPath, content: shape.getValue() },
+                            { resolveDependencies: false, excludeFromCompiler: true }
+                        )
                     }
                 } else {
-                    if (targetShape.equals(shape.getIncludedFile().getContent())) {
-                        // It's not a Now.include() call, but it's equivalent to the content, so leave it (probably an inline string literal)
-                        return { success: true }
-                    }
+                    // If we reach this point it's likely an inline string literal or some other value that
+                    // just needs to be replaced.
+                    target.replaceWithText(shape.toString().getCode())
                 }
 
-                await commit(shape, target, CallExpressionPlugin)
                 return { success: true }
             },
         },
         {
             shape: StringShape,
-            async commit(shape, target, { transform }) {
+            async commit(shape, target, { transform, project }) {
                 const targetResult = await transform.toShape(target)
                 if (!targetResult.success) {
                     return { success: false }
@@ -128,8 +161,9 @@ export const NowIncludePlugin = Plugin.create({
                     return { success: false }
                 }
 
-                const file = targetShape.getIncludedFile()
-                if (!shape.equals(file.getContent())) {
+                if (!shape.equals(targetShape.getValue())) {
+                    const targetDirPath = target.getSourceFile().getDirectoryPath()
+                    const file = project.getFile(project.resolvePath(targetDirPath, targetShape.getPath()))
                     file.setContent(shape.getValue())
                 }
 

package/src/now-ref-plugin.ts

@@ -40,7 +40,7 @@ export const NowRefPlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: factory.createReference({ source: node, table, guid, keys }),
+                    value: await factory.createReference({ source: node, table, guid, keys }),
                 }
             },
         },

package/src/package-json-plugin.ts

@@ -5,6 +5,7 @@ import {
     Plugin,
     type ObjectShape,
     Shape,
+    NowConfig,
 } from '@servicenow/sdk-build-core'
 import { RepackService } from './repack'
 import { JsonFileShape } from './json-plugin'
@@ -20,22 +21,22 @@ export const PackageJsonPlugin = Plugin.create({
                 }
 
                 const relativePath = pathModule.relative(project.getRootDir(), file.getPath())
-                const sysModulePath = pathModule.join(config.scope, packageJson.name, packageJson.version, relativePath)
+                const sysModulePath = NowConfig.moduleResolutionPath(config, packageJson, false, relativePath)
 
-                const sbomRecord = factory.createRecord({
+                const sbomRecord = await factory.createRecord({
                     source: file,
                     table: 'sys_module',
                     explicitId: 'bom_json',
                     properties: {
-                        path: pathModule.join(config.scope, packageJson.name, packageJson.version, 'bom.json'),
+                        path: NowConfig.moduleResolutionPath(config, packageJson, false, 'bom.json'),
                         external_source: false,
                     },
                 })
 
                 return {
                     success: true,
-                    value: factory
-                        .createRecord({
+                    value: (
+                        await factory.createRecord({
                             source: file,
                             table: 'sys_module',
                             explicitId: relativePath.replaceAll(/[./\\]/g, '_'),
@@ -56,7 +57,7 @@ export const PackageJsonPlugin = Plugin.create({
                                 sys_name: sysModulePath,
                             },
                         })
-                        .with(sbomRecord),
+                    ).with(sbomRecord),
                 }
             },
         },

package/src/property-plugin.ts

@@ -73,7 +73,7 @@ export const PropertyPlugin = Plugin.create({
 
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: callExpression,
                         table: 'sys_properties',
                         explicitId: prop.get('$id'),

package/src/record-plugin.ts

@@ -29,6 +29,9 @@ export const RecordPlugin = Plugin.create({
     name: 'RecordPlugin',
     records: {
         '*': {
+            getUpdateName(record) {
+                return { success: true, value: `${record.getTable()}_${record.getId().getValue()}` }
+            },
             toShape(record) {
                 return {
                     success: true,
@@ -52,21 +55,34 @@ export const RecordPlugin = Plugin.create({
                     }),
                 }
             },
-            toFile(record, { config }) {
+            async toFile(record, { config, database, transform }) {
                 const recordBuilder = unloadBuilder(config)
-                const table = record.getTable()
-                const guid = record.getId().getValue()
-                const builder = recordBuilder.record(record)
+                const updateName = await transform.getUpdateName(record)
+                const builder = recordBuilder.record(record, updateName)
 
                 record
                     .entries()
                     .sort(([a], [b]) => a.localeCompare(b)) // Sort keys to make outputs more deterministic
                     .forEach(([prop, shape]) => builder.field(prop, shape))
 
+                const claims = database
+                    .query('sys_claim')
+                    .filter((claim) => claim.get('metadata_update_name').equals(updateName))
+
+                for (const claim of claims) {
+                    const claimUpdateName = await transform.getUpdateName(claim)
+                    const claimBuilder = recordBuilder.record(claim, claimUpdateName)
+                    claim
+                        .entries()
+                        .sort(([a], [b]) => a.localeCompare(b)) // Sort keys to make outputs more deterministic
+                        .forEach(([prop, shape]) => claimBuilder.field(prop, shape))
+                }
+
                 return {
                     success: true,
                     value: {
-                        name: `${table}_${guid}.xml`,
+                        source: record,
+                        name: `${updateName}.xml`,
                         category: record.getInstallCategory(),
                         content: recordBuilder.end(),
                     },
@@ -78,7 +94,7 @@ export const RecordPlugin = Plugin.create({
         {
             shape: CallExpressionShape,
             fileTypes: ['fluent'],
-            toRecord(callExpression, { factory, diagnostics }) {
+            async toRecord(callExpression, { factory, diagnostics }) {
                 if (callExpression.getCallee() !== 'Record') {
                     return { success: false }
                 }
@@ -94,7 +110,7 @@ export const RecordPlugin = Plugin.create({
                 }
                 return {
                     success: true,
-                    value: factory.createRecord({
+                    value: await factory.createRecord({
                         source: callExpression,
                         table,
                         explicitId: record.get('$id'),
@@ -107,9 +123,9 @@ export const RecordPlugin = Plugin.create({
     files: [
         {
             matcher: /\.xml$/,
-            toRecord(file, { parser, logger }) {
+            async toRecord(file, { parser, logger }) {
                 try {
-                    const [first, ...rest] = parser.parsePayload(file)
+                    const [first, ...rest] = await parser.parsePayload(file)
 
                     if (!first) {
                         return { success: false }

package/src/repack/index.ts

@@ -1,6 +1,16 @@
 import { path } from '@servicenow/sdk-build-core'
 import type { DependencyNode, RepackOptions } from '@servicenow/sdk-repack'
 
+export async function checkModuleExists(
+    module: string,
+    logger: RepackOptions['logger'],
+    fs: RepackOptions['fs'],
+    workingDir: RepackOptions['workingDir']
+) {
+    const repackService = await RepackService.create(logger, fs, workingDir)
+    return repackService.checkModuleExists(module)
+}
+
 export const REPACK_OUTPUT_DIR = path.join('.now', '.output')
 
 export class RepackService {
@@ -38,4 +48,8 @@ export class RepackService {
             logger: this.logger!,
         })
     }
+
+    async checkModuleExists(module: string) {
+        return this.repack.checkModuleExists(module, this.fs, this.workingDir, this.logger!)
+    }
 }

package/src/rest-api-plugin.ts

@@ -94,7 +94,7 @@ function getVersionId(
     return versionToVersionRecordMap.get(`v${version}`)!.getId()
 }
 
-function generateVersionRecords(
+async function generateVersionRecords(
     versions: Shape[],
     restApi: ObjectShape,
     restRecord: Record,
@@ -102,12 +102,12 @@ function generateVersionRecords(
     factory: Factory,
     diagnostics: Diagnostics,
     callExpression: CallExpressionShape
-): Map<string, Record> {
+): Promise<Map<string, Record>> {
     const versionMap = new Map<string, Record>()
     for (const v of versions) {
         const version = v.asObject().get('version').getValue()
         const versionId = `v${version}`
-        const versionRecord = factory.createRecord({
+        const versionRecord = await factory.createRecord({
             source: callExpression,
             table: 'sys_ws_version',
             explicitId: v.asObject().get('$id'),
@@ -155,7 +155,7 @@ function checkForDuplicateRecords(
     }
 }
 
-function generateRouteAttributeRecords(
+async function generateRouteAttributeRecords(
     attributes: Shape[],
     restDef: Record,
     routeDef: Record,
@@ -164,10 +164,10 @@ function generateRouteAttributeRecords(
     factory: Factory,
     diagnostics: Diagnostics,
     callExpression: CallExpressionShape
-): Record[] {
+): Promise<Record[]> {
     const records: Record[] = []
     for (const attr of attributes) {
-        const attrRecord = factory.createRecord({
+        const attrRecord = await factory.createRecord({
             source: callExpression,
             table: `sys_ws_${attrType}`,
             explicitId: attr.asObject().get('$id'),
@@ -182,7 +182,7 @@ function generateRouteAttributeRecords(
 
         checkForDuplicateRecords(attrMap, attrRecord, attr.asObject(), diagnostics)
 
-        const attributeMappingRecord = factory.createRecord({
+        const attributeMappingRecord = await factory.createRecord({
             source: callExpression,
             table: `sys_ws_${attrType}_map`,
             properties: attr.asObject().transform(({ $ }) => ({
@@ -197,7 +197,7 @@ function generateRouteAttributeRecords(
     return records
 }
 
-function generateRouteAndRouteAttrRecords(
+async function generateRouteAndRouteAttrRecords(
     routes: Shape[],
     restDef: Record,
     factory: Factory,
@@ -205,7 +205,7 @@ function generateRouteAndRouteAttrRecords(
     diagnostics: Diagnostics,
     versionToVersionRecordMap: Map<string, Record>,
     callExpression: CallExpressionShape
-): Record[] {
+): Promise<Record[]> {
     const routeRecords: Record[] = []
     const headersMap = new Map<string, Record>()
     const parametersMap = new Map<string, Record>()
@@ -246,7 +246,7 @@ function generateRouteAndRouteAttrRecords(
             )
         }
 
-        const routeRecord = factory.createRecord({
+        const routeRecord = await factory.createRecord({
             source: callExpression,
             table: 'sys_ws_operation',
             explicitId: route.get('$id'),
@@ -285,7 +285,7 @@ function generateRouteAndRouteAttrRecords(
             h.asObject().withAliasedKeys(attributeAliases)
             generateDeprecatedDiagnostics(h.asObject(), diagnostics)
         })
-        const headerRecords = generateRouteAttributeRecords(
+        const headerRecords = await generateRouteAttributeRecords(
             routeHeaders,
             restDef,
             routeRecord,
@@ -301,7 +301,7 @@ function generateRouteAndRouteAttrRecords(
             p.asObject().withAliasedKeys(attributeAliases)
             generateDeprecatedDiagnostics(p.asObject(), diagnostics)
         })
-        const parameterRecords = generateRouteAttributeRecords(
+        const parameterRecords = await generateRouteAttributeRecords(
             routeParameters,
             restDef,
             routeRecord,
@@ -594,7 +594,7 @@ export const RestApiPlugin = Plugin.create({
                 }
 
                 const enforceAcls = restApi.get('enforceAcl')
-                const restRecord = factory.createRecord({
+                const restRecord = await factory.createRecord({
                     source: callExpression,
                     table: 'sys_ws_definition',
                     explicitId: restApi.get('$id'),
@@ -622,7 +622,7 @@ export const RestApiPlugin = Plugin.create({
                         enforce_acl: $.val(mergeAcls(enforceAcls)),
                     })),
                 })
-                const versionToVersionRecordMap = generateVersionRecords(
+                const versionToVersionRecordMap = await generateVersionRecords(
                     versions,
                     restApi,
                     restRecord,
@@ -638,7 +638,7 @@ export const RestApiPlugin = Plugin.create({
                     generateDeprecatedDiagnostics(r.asObject(), diagnostics)
                 })
 
-                const routeAndRouteAttrRecords = generateRouteAndRouteAttrRecords(
+                const routeAndRouteAttrRecords = await generateRouteAndRouteAttrRecords(
                     routes,
                     restRecord,
                     factory,