@servicenow/sdk-build-core 4.6.0 → 4.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@servicenow/sdk-build-core",
-  "version": "4.6.0",
+  "version": "4.7.0",
   "description": "ServiceNow SDK Build System Core Libraries",
   "license": "MIT",
   "main": "./dist/index.js",
@@ -10,7 +10,11 @@
     "now.config.schema.json"
   ],
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./telemetry": {
+      "types": "./dist/telemetry/index.d.ts",
+      "default": "./dist/telemetry/index.js"
+    }
   },
   "dependencies": {
     "ci-info": "4.4.0",
@@ -18,7 +22,7 @@
     "fflate": "0.8.2",
     "json5": "2.2.3",
     "jsonschema": "1.5.0",
-    "lodash": "4.17.23",
+    "lodash": "4.18.1",
     "pathe": "1.1.2",
     "prettier": "3.6.1",
     "readable-stream": "4.5.2",
@@ -27,7 +31,7 @@
     "xml-js": "1.6.11",
     "xmlbuilder2": "3.1.1",
     "zod": "3.23.8",
-    "@servicenow/sdk-core": "4.6.0"
+    "@servicenow/sdk-core": "4.7.0"
   },
   "overrides": {
     "micromatch": "4.0.7"
@@ -47,6 +51,6 @@
     "bundle:production": "tsc -b && tsx esbuild.config.ts",
     "clean": "tsc -b --clean",
     "watch": "tsc -b -w",
-    "test": "export NODE_OPTIONS=\"--max-old-space-size=8192 --experimental-vm-modules\" && jest --colors --reporters=default --no-cache --logHeapUsage"
+    "test": "export NODE_OPTIONS=\"--max-old-space-size=8192 --experimental-vm-modules\" && jest --colors --no-cache --logHeapUsage"
   }
 }

package/src/compiler.ts

@@ -40,6 +40,7 @@ export class Compiler extends ts.Project {
     private readonly rootDir: string
     private readonly sourceFileToRelativeModuleSpecifier: Record<string, string> = {}
     private readonly generatedTableFilePath: string
+    private readonly generatedBootstrappedTablesFilePath: string
     private moduleProject: ts.Project | undefined
 
     constructor(
@@ -63,6 +64,7 @@ export class Compiler extends ts.Project {
 
         this.rootDir = rootDir
         this.generatedTableFilePath = path.join(this.rootDir, '$$GENERATED$$_common_table.ts')
+        this.generatedBootstrappedTablesFilePath = path.join(this.rootDir, '$$GENERATED$$_bootstrapped_tables.ts')
         this.addGlobalTableDefinitionFile()
         if (typesDir) {
             this.addTypesTableDeclaration(typesDir)
@@ -89,7 +91,7 @@ export class Compiler extends ts.Project {
     }
 
     addGlobalTableDefinitionFile() {
-        const globalTableDefinitionContent = `
+        const tableDefinitionContent = `
 import '@servicenow/sdk/global'
 import { Table } from '@servicenow/sdk/core'
 
@@ -105,10 +107,18 @@ declare global {
     }
 }
 `
-        this.createSourceFile(this.generatedTableFilePath, globalTableDefinitionContent, {
+        this.createSourceFile(this.generatedTableFilePath, tableDefinitionContent, {
             overwrite: true,
             scriptKind: ts.ScriptKind.TS,
         })
+        this.createSourceFile(this.generatedBootstrappedTablesFilePath, tableDefinitionContent, {
+            overwrite: true,
+            scriptKind: ts.ScriptKind.TS,
+        })
+    }
+
+    getGeneratedBootstrappedTablesFile(): ts.SourceFile | undefined {
+        return this.getSourceFile(this.generatedBootstrappedTablesFilePath)
     }
 
     /**
@@ -332,16 +342,15 @@ declare module '*.html' {
         return this.generatedTableFilePath === sourcePath
     }
 
-    // Cache for table column types that need coercion (boolean/number only)
+    // Cache for table column types that need coercion (boolean/number only).
+    // Populated on first call to getTableColumnTypes(); subsequent calls return immediately.
     private tableColumnTypesCache = new Map<string, Map<string, 'boolean' | 'number' | 'array' | 'array-optional'>>()
 
     getTableColumnTypes(tableName: string): Map<string, 'boolean' | 'number' | 'array' | 'array-optional'> | undefined {
-        // Return cached value if available
         if (this.tableColumnTypesCache.has(tableName)) {
             return this.tableColumnTypesCache.get(tableName)
         }
 
-        // Lazily resolve and cache on first access
         const tempFilePath = path.join(this.rootDir, 'src', '$$TEMP_DATA_RESOLVER$$.ts')
         const typeDeclaration = `type T = import('@servicenow/sdk/core').Data<'${tableName}'>`
 
@@ -367,10 +376,8 @@ declare module '*.html' {
                 if (typeText === 'boolean' || typeText === 'number') {
                     columnTypes.set(property.getName(), typeText)
                 } else if (typeText.match(/^\(.*\)\[\]$/)) {
-                    // Matches `(...)[]` -> this field should always be an array
                     columnTypes.set(property.getName(), 'array')
                 } else if (typeText.match(/^.*\[\]$/)) {
-                    // Matches `[]` -> this field may be an array or a single value
                     columnTypes.set(property.getName(), 'array-optional')
                 }
             })

package/src/index.ts

@@ -17,6 +17,7 @@ export * from './path'
 export * from './typescript'
 export * from './crypto'
 export * from './compression'
+export * from './package-inventory'
 export * from './formatter'
 export * from './telemetry'
 export * from './claims'

package/src/now-config.ts

@@ -9,6 +9,7 @@ import { Compiler } from './compiler'
 import { GUID } from './guid'
 import { taxonomy } from './taxonomy'
 import { dependenciesSchema } from './now-config-dependencies'
+import { isSNScope } from './util'
 
 export type NowConfig = z.output<typeof NowConfigSchema>
 export type NowConfigOptions = z.input<typeof NowConfigSchema>
@@ -135,6 +136,15 @@ const NetworkPolicySchema = z
 
 export type NetworkPolicy = z.infer<typeof NetworkPolicySchema>
 
+/**
+ * Schema for Linter configuration options
+ */
+const LinterSchema = z
+    .object({
+        module: z.object({ enabled: z.boolean().default(true) }),
+    })
+    .default({ module: { enabled: true } })
+
 /**
  * Network Pillar Schema for Wildcard Policy
  */
@@ -247,7 +257,8 @@ const NowConfigSchema = z
         trustedModules: z.array(z.string()).default([]),
         tsconfigPath: z.string().optional(),
         scripts: z.record(z.string(), z.string()).default({}),
-        tableOutputFormat: z.enum(['bootstrap', 'component']).default('bootstrap'),
+        linter: LinterSchema,
+        tableOutputFormat: z.enum(['bootstrap', 'component']).default('bootstrap').optional(),
         defaultLanguage: z
             .string()
             .regex(/^[a-z]{2,3}(-[a-zA-Z0-9]{2,8})*$/)
@@ -296,6 +307,7 @@ const NowConfigSchema = z
         packageResolverVersion: z.string().optional(),
         type: z.enum(['configuration', 'package']).default('package'),
         taxonomy,
+        hostedPlugins: z.record(z.string(), z.string()).optional(),
 
         // Application Runtime Policy (ARP) fields
         applicationRuntimePolicy: z.enum(['none', 'tracking', 'enforcing']).default('none'),
@@ -332,12 +344,14 @@ const NowConfigSchema = z
                 | 'description'
                 | 'installedAsDependency'
                 | 'scripts'
+                | 'linter'
                 | 'tableOutputFormat'
                 | 'defaultLanguage'
                 | 'tableDefaultLanguage'
                 | 'packageResolverVersion'
                 | 'type'
                 | 'taxonomy'
+                | 'hostedPlugins'
                 | 'applicationRuntimePolicy'
                 | 'networkPolicies'
                 | 'wildcardPolicy'
@@ -491,6 +505,46 @@ export namespace NowConfig {
 
         return true
     }
+
+    export function getRecordScope(config: NowConfig, filePath: string): { scope?: string; scopeId: string } {
+        if (!isSNScope(config.scope) || !config.hostedPlugins) {
+            return { scope: config.scope, scopeId: config.scopeId }
+        }
+
+        const matchingDir = Object.keys(config.hostedPlugins).find((pluginDirectory) =>
+            filePath.includes(path.join(config.fluentDir, 'hosted_plugins', pluginDirectory))
+        )
+        if (!matchingDir) {
+            return { scope: config.scope, scopeId: config.scopeId }
+        }
+
+        return { scopeId: config.hostedPlugins[matchingDir]! }
+    }
+
+    export function getHostedDirectory(config: NowConfig, filePath: string): string | undefined {
+        if (!isSNScope(config.scope) || !config.hostedPlugins) {
+            return
+        }
+
+        const normalizedPath = path.normalize(filePath)
+        const match = Object.keys(config.hostedPlugins).find((pluginDirectory) =>
+            normalizedPath.includes(path.join('hosted_plugins', pluginDirectory))
+        )
+        if (!match) {
+            return
+        }
+
+        return path.join('hosted_plugins', match)
+    }
+
+    export function getConditionalDirectory(config: NowConfig, filePath: string): string | undefined {
+        if (!isSNScope(config.scope)) {
+            return
+        }
+
+        const match = filePath.match(/[/\\]if[/\\][^/\\]+/)
+        return match ? match[0] : undefined
+    }
 }
 
 const NOW_CONFIG_SCHEMA = require('../now.config.schema.json')
@@ -576,6 +630,7 @@ const DEPRECATED_FIELDS: Record<string, DeprecatedField> = {
     transpiledSourceDir: { replacedBy: 'modulePaths' },
     sourceDir: {},
     tableDefaultLanguage: { replacedBy: 'defaultLanguage', transfer: true },
+    tableOutputFormat: {},
 }
 
 function replaceDeprecatedFields(config: Record<string, unknown>, logger: Logger) {

package/src/package-inventory.ts

@@ -0,0 +1,75 @@
+import { crypto } from './crypto'
+import { FileSystem } from './fs'
+import { path } from './path'
+
+export interface PackageInventoryConfig {
+    build: string
+    type: 'scoped' | 'global'
+    appVersion: string
+    version?: string
+}
+
+/**
+ * Generate SHA-256 hash for file content (matches ServiceNow's package_inventory.csv format)
+ */
+export async function sha256(content: string | Uint8Array): Promise<string> {
+    const data = typeof content === 'string' ? new TextEncoder().encode(content) : content
+    const hashBuffer = await crypto.subtle.digest('SHA-256', data)
+    const hashArray = Array.from(new Uint8Array(hashBuffer))
+    return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}
+
+/**
+ * Recursively find all files in a directory
+ */
+function findAllFiles(fs: FileSystem, dir: string, baseDir: string): string[] {
+    const files: string[] = []
+
+    if (!FileSystem.existsSync(fs, dir)) {
+        return files
+    }
+
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name)
+        if (entry.isDirectory()) {
+            files.push(...findAllFiles(fs, fullPath, baseDir))
+        } else {
+            files.push(path.relative(baseDir, fullPath))
+        }
+    }
+
+    return files
+}
+
+/**
+ * Generate package_inventory.csv from files in a directory on disk (for pack command)
+ */
+export async function generatePackageInventoryFromDirectory(
+    fs: FileSystem,
+    appOutputDir: string,
+    config: PackageInventoryConfig
+): Promise<string> {
+    const headerLines: string[] = [
+        `#build=${config.build}`,
+        `#appVersion=${config.appVersion}`,
+        `#type=${config.type}`,
+        `#version=${config.version ?? '1.0.0'}`,
+    ]
+
+    // Find all files in directory
+    const filePaths = findAllFiles(fs, appOutputDir, appOutputDir)
+        .filter((f) => !f.endsWith('package_inventory.csv'))
+        .sort()
+
+    // Hash all files in parallel for better performance
+    const hashResults = await Promise.all(
+        filePaths.map(async (relativePath) => {
+            const fullPath = path.join(appOutputDir, relativePath)
+            const content = fs.readFileSync(fullPath)
+            const hash = await sha256(content)
+            return `${relativePath};${hash}`
+        })
+    )
+
+    return `${[...headerLines, ...hashResults].join('\n')}\n`
+}

package/src/plugins/context.ts

@@ -43,12 +43,12 @@ export interface Diagnostics {
 
 export interface Transform {
     toShape(node: ts.Node, ...plugins: Plugin[]): Promise<Result<Shape>>
-    recordToShape(record: Record, database: Database, ...plugins: Plugin[]): Promise<Result<Shape>>
-    toSubclass<const S extends Shape>(shape: S, ...plugins: Plugin[]): Promise<Result<S>>
+    toSubclass<const S extends Shape>(shape: S, ...plugins: Plugin[]): Promise<S>
     toRecord(node: ts.Node, ...plugins: Plugin[]): Promise<Result<Record>>
     toRecord(shape: Shape, ...plugins: Plugin[]): Promise<Result<Record>>
     toRecord(file: File, ...plugins: Plugin[]): Promise<Result<Record>>
     toRecord(source: ts.Node | Shape | File, ...plugins: Plugin[]): Promise<Result<Record>>
+    recordToShape(record: Record, database: Database, ...plugins: Plugin[]): Promise<Result<Shape>>
     getUpdateName(record: Record, ...plugins: Plugin[]): Promise<string>
 }
 

package/src/plugins/file.ts

@@ -22,4 +22,5 @@ export type OutputFile = {
     category: InstallCategory
     content: string
     ifDirectoryPackage?: string | undefined
+    hostedPluginDir?: string | undefined
 }

package/src/plugins/index.ts

@@ -7,5 +7,4 @@ export * from './product'
 export * from './project'
 export * from './database'
 export * from './time'
-export * from './usage'
 export * from './post-install'