@servicenow/sdk-build-core 4.5.0 → 4.6.1

package/src/plugins/plugin.ts

@@ -12,7 +12,7 @@ import { Database, DiffDatabase } from './database'
 import type { Context as BaseContext } from './context'
 import { getFileType, isSNScope } from '../util'
 import { Cache } from './cache'
-import { NOW_FILE_EXTENSION } from '..'
+import { NOW_FILE_EXTENSION, NowConfig } from '..'
 import { path } from '@servicenow/sdk-build-core'
 
 type Context = Omit<BaseContext, 'keys'>
@@ -66,17 +66,8 @@ export type Relationship = {
      *             properties, where each is a tuple: [columnName, regexPattern]. The regex extracts
      *             values from the respective columns using capturing groups, and records are related
      *             if all captured groups match between parent and child
-     * - Function: Takes the parent and child records as arguments and returns a boolean to
-     *             indicate whether the records are related or not (WARNING: Do not use this
-     *             unless absolutely necessary as it can negatively impact performance and
-     *             cannot be serialized by the relationship resolver, requiring changes to
-     *             the REST API it invokes)
      */
-    via:
-        | string
-        | { [column: string]: string }
-        | ((parent: Record, child: Record) => boolean)
-        | { parent: [string, string]; child: [string, string] }[]
+    via: string | { [column: string]: string } | { parent: [string, string]; child: [string, string] }[]
 
     /**
      * When true, the relationship direction is reversed - the parent references the child
@@ -657,16 +648,22 @@ export class Plugin {
     }
 
     getDescendants(parent: Record, database: Database): Record[] {
+        return this.traverseDescendants(parent, database)
+    }
+
+    private traverseDescendants(parent: Record, database: Database, visited: Set<string> = new Set()): Record[] {
+        visited.add(parent.getId().getValue())
+
         const descendantRelationships = Object.entries(this.relationships[parent.getTable()] ?? {}).filter(
             ([, { descendant }]) => descendant
         )
-
         const descendants: Record[] = []
         const push = (children: Record | Record[] | undefined) => {
             for (const child of [children].flat()) {
-                if (child && parent !== child) {
+                if (child && !visited.has(child.getId().getValue())) {
+                    visited.add(child.getId().getValue())
                     descendants.push(child)
-                    descendants.push(...this.getDescendants(child, database))
+                    descendants.push(...this.traverseDescendants(child, database, visited))
                 }
             }
         }
@@ -682,8 +679,6 @@ export class Plugin {
                 } else {
                     push(database.query(childTable, { [via]: parent.toString().getValue() }))
                 }
-            } else if (typeof via === 'function') {
-                push(database.query(childTable).filter((child) => via(parent, child)))
             } else if (Array.isArray(via)) {
                 push(
                     database.query(childTable).filter((child) => {
@@ -692,16 +687,26 @@ export class Plugin {
                                 parent: [pCol, pReg],
                                 child: [cCol, cReg],
                             } = entry
-                            const parentValue = parent
-                                .get(pCol)
-                                .ifString()
-                                ?.asString(`Expected string value for column ${pCol} in regex-based via relationship`)
-                                .getValue()
-                            const childValue = child
-                                .get(cCol)
-                                .ifString()
-                                ?.asString(`Expected string value for column ${cCol} in regex-based via relationship`)
-                                .getValue()
+                            const parentValue =
+                                pCol === 'sys_id'
+                                    ? parent.getId().getValue()
+                                    : parent
+                                          .get(pCol)
+                                          .ifString()
+                                          ?.asString(
+                                              `Expected string value for column ${pCol} in regex-based via relationship`
+                                          )
+                                          .getValue()
+                            const childValue =
+                                cCol === 'sys_id'
+                                    ? child.getId().getValue()
+                                    : child
+                                          .get(cCol)
+                                          .ifString()
+                                          ?.asString(
+                                              `Expected string value for column ${cCol} in regex-based via relationship`
+                                          )
+                                          .getValue()
                             if (!parentValue || !childValue) {
                                 return false
                             }
@@ -952,6 +957,8 @@ export class Plugin {
     }): Promise<Result<Shape[]>> {
         let success = false
         const shapes: Shape[] = []
+        const unhandledRecords: Record[] = []
+        const unhandledRecordIds: Set<string> = new Set()
 
         for (const [table, { toShape }] of Object.entries(this.config.records ?? {})) {
             if (!toShape) {
@@ -1006,14 +1013,10 @@ export class Plugin {
                     descendants: nonDeletedDescendants,
                 })
 
-                // Track unhandled records to avoid marking them as handled
-                const unhandledRecords: Record[] = []
-                const unhandledRecordIds: string[] = []
-
                 if (result.success === 'partial') {
                     for (const unhandledRecord of result.unhandledRecords) {
                         unhandledRecords.push(unhandledRecord)
-                        unhandledRecordIds.push(unhandledRecord.getId().getValue())
+                        unhandledRecordIds.add(unhandledRecord.getId().getValue())
                     }
                 }
 
@@ -1030,7 +1033,7 @@ export class Plugin {
 
                     // Mark all descendants as handled
                     for (const descendant of [...deletedDescendants, ...nonDeletedDescendants]) {
-                        if (!unhandledRecordIds.includes(descendant.getId().getValue())) {
+                        if (!unhandledRecordIds.has(descendant.getId().getValue())) {
                             // This descendent was known to the plugin because it is not deleted, and handling was deferred
                             // delete_multiple should also be marked 'handled'
                             if (descendant.getAction() !== 'DELETE') {
@@ -1045,17 +1048,17 @@ export class Plugin {
                             }
                         }
                     }
-
-                    if (unhandledRecords.length > 0) {
-                        context.logger.debug(
-                            `Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => r.getTable() + '_' + r.getId().getValue()).join(', ')}`
-                        )
-                        return { success: 'partial', value: shapes, unhandledRecords }
-                    }
                 }
             }
         }
 
+        if (unhandledRecords.length > 0) {
+            context.logger.debug(
+                `Plugin ${this.getName()} deferred handling of records: ${unhandledRecords.map((r) => r.getTable() + '_' + r.getId().getValue()).join(', ')}`
+            )
+            return { success: 'partial', value: shapes, unhandledRecords }
+        }
+
         return { success, value: shapes }
     }
 
@@ -1132,12 +1135,31 @@ export class Plugin {
                     const filePath = path.normalize(record.getOriginalFilePath())
                     if (isSNScope(context.config.scope) && filePath.endsWith(NOW_FILE_EXTENSION)) {
                         const relativePath = path.relative(path.join(context.config.fluentDir, 'if'), filePath)
-                        if (!relativePath.startsWith('..') && path.dirname(relativePath) !== '.') {
+                        const relativePathGenerated = path.relative(
+                            path.join(context.config.generatedDir, 'if'),
+                            filePath
+                        )
+                        if (
+                            !relativePath.startsWith('..') ||
+                            (!relativePathGenerated.startsWith('..') && path.dirname(relativePath) !== '.')
+                        ) {
+                            const subPath = relativePath.startsWith('..') ? relativePathGenerated : relativePath
                             return {
                                 success: true,
                                 value: outputFiles.map((f) => ({
                                     ...f,
-                                    ifDirectoryPackage: path.join('if', path.dirname(relativePath)),
+                                    ifDirectoryPackage: path.join('if', subPath.split(path.sep)[0]!),
+                                })),
+                            }
+                        }
+
+                        const hosted = NowConfig.getHostedDirectory(context.config, filePath)
+                        if (hosted) {
+                            return {
+                                success: true,
+                                value: outputFiles.map((f) => ({
+                                    ...f,
+                                    hostedPluginDir: hosted,
                                 })),
                             }
                         }
@@ -1294,6 +1316,13 @@ export class Plugins {
         return this.plugins
     }
 
+    remove(name: string): void {
+        const index = this.plugins.findIndex((plugin) => plugin.getName() === name)
+        if (index !== -1) {
+            this.plugins.splice(index, 1)
+        }
+    }
+
     prepend(...plugins: Plugin[]): void {
         this.plugins.unshift(...plugins)
     }

package/src/plugins/post-install.ts

@@ -10,6 +10,14 @@ export type PostInstallTask = {
     /** Human-readable description for the --skip flag help text */
     skipFlagDescription: string
 
+    /**
+     * Controls which project type triggers this task.
+     * - `'app'` — only runs after installing a scoped app.
+     * - `'configuration'` — only runs after installing a configuration project.
+     * - `'both'` — runs after either install path.
+     */
+    runFor: 'app' | 'configuration' | 'both'
+
     /** Execute the post-install task */
     run(context: PostInstallContext): Promise<void>
 }

package/src/plugins/shape.ts

@@ -1170,7 +1170,10 @@ export class ObjectShape extends Shape<globalThis.Record<string, unknown>> {
     }
 
     static quotePropertyNameIfNeeded(name: string): string {
-        return name === '' || /[^\w$]/.test(name) ? `'${name}'` : name
+        // Valid JS identifier (e.g. short_description, $id) — no quotes needed
+        // Pure numeric literal without leading zeros (e.g. 0, 100, 1.5) — valid as object key without quotes
+        // Everything else (empty string, hyphens, digit-leading non-numeric chars, octal-like 007) — must be quoted
+        return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name) || /^(0|[1-9]\d*)(\.\d+)?$/.test(name) ? name : `'${name}'`
     }
 }
 

package/src/xml.ts

@@ -1,7 +1,15 @@
 import { Record, RecordId, ResolvableShape, Shape } from './plugins'
 import { js2xml, type Element } from 'xml-js'
 
-export function unloadBuilder({ scope, scopeId, table }: { scope: string; scopeId: string; table?: string }) {
+export function unloadBuilder({
+    scope,
+    scopeId,
+    table,
+}: {
+    scope?: string | undefined
+    scopeId: string
+    table?: string
+}) {
     const recordUpdateElements = []
     const xmlJsObj = {
         declaration: {
@@ -41,7 +49,8 @@ export function unloadBuilder({ scope, scopeId, table }: { scope: string; scopeI
             const rec = recordXml(recordUpdateElements, table, record.getId().getValue(), {
                 attr: { action: record.getAction(), ...extraAttributes },
             })
-            rec.field('sys_scope', scopeId, { display_value: scope })
+
+            scope ? rec.field('sys_scope', scopeId, { display_value: scope }) : rec.field('sys_scope', scopeId)
             rec.field('sys_update_name', updateName)
             return rec
         },