@servicenow/sdk-build-core 4.6.1 → 4.7.0

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

@@ -136,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
  */
@@ -248,6 +257,7 @@ const NowConfigSchema = z
         trustedModules: z.array(z.string()).default([]),
         tsconfigPath: z.string().optional(),
         scripts: z.record(z.string(), z.string()).default({}),
+        linter: LinterSchema,
         tableOutputFormat: z.enum(['bootstrap', 'component']).default('bootstrap').optional(),
         defaultLanguage: z
             .string()
@@ -334,6 +344,7 @@ const NowConfigSchema = z
                 | 'description'
                 | 'installedAsDependency'
                 | 'scripts'
+                | 'linter'
                 | 'tableOutputFormat'
                 | 'defaultLanguage'
                 | 'tableDefaultLanguage'

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/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'