@servicenow/sdk-build-core 2.0.1

package/src/plugins/util/CallExpression.ts

@@ -0,0 +1,83 @@
+import * as ts from 'ts-morph'
+import { Context } from '../Context'
+import { EntityData, ExtractionResult, ObjectData } from '../behaviors'
+import { FluentDiagnostic } from '../Diagnostic'
+
+export const CURRENT_CALL_EXPRESSION = 'current_call_expression'
+
+export function getCallExpressionName(node: ts.CallExpression) {
+    const expression = node.getExpression()
+    if (ts.Node.isIdentifier(expression)) {
+        return expression.getText()
+    } else if (ts.Node.isPropertyAccessExpression(expression)) {
+        return expression.getName()
+    } else {
+        throw `CallExpression does not have an identifier: ${expression.getText()}`
+    }
+}
+
+export function extractCallExpression<
+    const A extends unknown[],
+    const E extends A extends [infer T extends Record<string, unknown>] ? T : never,
+    const K extends string,
+>(
+    fn: (...args: A) => E,
+    kind: K,
+    node: ts.CallExpression,
+    context: Context,
+    guid: (entity: E) => string,
+    validate: (entity: unknown) => entity is E = (_): _ is E => true
+): ExtractionResult<EntityData<E>> {
+    const name = getCallExpressionName(node)
+    if (name !== fn.name) {
+        return { handled: false }
+    }
+
+    //Needed to perform specific parsing and handling of nodes based on call expression
+    const oldNodeValue = context.store[CURRENT_CALL_EXPRESSION]
+    context.store[CURRENT_CALL_EXPRESSION] = fn.name
+    const diagnostics: FluentDiagnostic[] = []
+    const args = node.getArguments().map((a) => {
+        const result = context.extractAst(a)
+        if (!result.handled) {
+            diagnostics.push(new FluentDiagnostic(a, `Unsupported argument in ${fn.name} call`))
+            return undefined
+        }
+
+        diagnostics.push(...result.diagnostics)
+        if (!(0 in result.data) || result.data.length !== 1) {
+            diagnostics.push(new FluentDiagnostic(a, `Unsupported argument in ${fn.name} call`))
+            return undefined
+        }
+
+        return result.data[0]
+    })
+    context.store[CURRENT_CALL_EXPRESSION] = oldNodeValue
+
+    if (!(0 in args) || args.length !== 1) {
+        return {
+            handled: true,
+            data: [],
+            diagnostics: [
+                ...diagnostics,
+                new FluentDiagnostic(node, `Expected ${fn.name} call to have exactly one argument`),
+            ],
+        }
+    }
+
+    const entity = args[0] as ObjectData<E>
+    const entityValue = entity.getValue()
+    if (!validate(entityValue)) {
+        return {
+            handled: true,
+            data: [],
+            diagnostics: [...diagnostics, new FluentDiagnostic(node, `Invalid ${fn.name} call argument`)],
+        }
+    }
+
+    return {
+        handled: true,
+        diagnostics,
+        data: [new EntityData(kind, guid(entityValue), entity, node)],
+    }
+}

package/src/plugins/util/CodeTransformation.ts

@@ -0,0 +1,500 @@
+import { NOW_FILE_EXTENSION, SupportedNode } from '@servicenow/sdk-project'
+import { format, resolve } from 'path'
+import { Context } from '../Context'
+import { getCallExpressionName } from './CallExpression'
+import { isArray, isEmpty, isObject, isPlainObject } from 'lodash'
+import * as ts from 'ts-morph'
+import * as z from 'zod'
+import * as path from 'path'
+import { Document } from '../behaviors'
+import { getPropertyAssignment } from './ObjectLiteral'
+import { isGUID } from '../../GUID'
+
+export function stringify(val: unknown) {
+    return JSON.stringify(val)
+}
+
+export type PartialElements<A extends unknown[]> = {
+    [I in keyof A]: Partial<A[I]>
+}
+
+/**
+ * Formats a source file name with the .now.ts extension.
+ */
+export function formatSourceFileName(name: string) {
+    return format({
+        name,
+        ext: NOW_FILE_EXTENSION,
+    })
+}
+
+export function getSysUpdateName(document: Document & { xml?: string }, table: string) {
+    if (document.xml) {
+        return path.basename(document.xml, path.extname(document.xml))
+    }
+    return `${table}_${document.guid}`
+}
+
+export function getOrCreateEntitySourceFile(context: Context, sysUpdateName: string) {
+    const fullPath = resolve(context.app.rootDir, context.app.config.generatedDir, formatSourceFileName(sysUpdateName))
+    const sourceFile = context.compiler.getSourceFile(fullPath)
+    if (sourceFile) {
+        return sourceFile
+    }
+
+    context.logger.info(`Generating new source file: ${fullPath}`)
+    return context.compiler.createSourceFile(fullPath)
+}
+
+export function addDefaultImportIfAbsent(sourceFile: ts.SourceFile, moduleSpecifier: string, module: string) {
+    const importDeclaration = sourceFile.getImportDeclaration((d) => d.getModuleSpecifierValue() === moduleSpecifier)
+    if (!importDeclaration) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            defaultImport: module,
+        })
+        return
+    }
+
+    const defaultImport = importDeclaration.getDefaultImport()?.getText()
+    if (defaultImport && defaultImport === module) {
+        return
+    }
+    importDeclaration.setDefaultImport(module)
+}
+
+export function addNamedImportIfAbsent(
+    context: Context,
+    sourceFile: ts.SourceFile,
+    moduleSpecifier: string,
+    module: { name: string } | string
+): ts.ImportSpecifier {
+    let importDeclaration = sourceFile.getImportDeclaration(
+        (d) => d.getModuleSpecifierValue() === moduleSpecifier && !d.getNamespaceImport() // If it's a namespace import we cannot add named imports, so we have to create a new one
+    )
+
+    const importName = typeof module === 'string' ? module : module.name
+    if (!importDeclaration) {
+        importDeclaration = sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            namedImports: [importName],
+        })
+    }
+
+    const namedImports = importDeclaration.getNamedImports().find((n) => n.getName() === importName)
+    if (namedImports) {
+        return namedImports
+    }
+
+    context.logger.info(
+        `Adding named import '${importName}' from module '${moduleSpecifier}' to source file: ${path.normalize(sourceFile.getFilePath())}`
+    )
+
+    return importDeclaration.addNamedImport(importName)
+}
+
+/**
+ * Generate an exported variable assignment initialized by a function call with
+ * the provided arguments.
+ */
+export function generateCallExpressionDefaultExport<const A extends unknown[]>(
+    context: Context,
+    sourceFile: ts.SourceFile,
+    moduleSpecifier: string,
+    fn: (...args: A) => unknown,
+    ...args: PartialElements<A>
+) {
+    addNamedImportIfAbsent(context, sourceFile, moduleSpecifier, fn)
+    const exportAssignment = sourceFile.addExportAssignment({
+        isExportEquals: false,
+        expression: `${fn.name}()`,
+    })
+
+    const callExpression = exportAssignment.getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
+    transformFunctionArguments(callExpression, fn, ...args)
+
+    return exportAssignment
+}
+
+export function generateCallExpressionExport<const A extends unknown[]>(
+    context: Context,
+    sourceFile: ts.SourceFile,
+    moduleSpecifier: string,
+    exportName: string,
+    fn: (...args: A) => unknown,
+    ...args: PartialElements<A>
+) {
+    addNamedImportIfAbsent(context, sourceFile, moduleSpecifier, fn)
+    const variableDeclaration = sourceFile
+        .addVariableStatement({
+            isExported: true,
+            declarationKind: ts.VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    name: exportName,
+                    initializer: `${fn.name}()`, // Generate empty function call since we will add arguments later
+                },
+            ],
+        })
+        .getDeclarations()[0]!
+
+    // Transform function call to add arguments
+    const callExpression = variableDeclaration.getInitializerIfKindOrThrow(ts.SyntaxKind.CallExpression)
+    transformFunctionArguments(callExpression, fn, ...args)
+
+    return variableDeclaration
+}
+
+export function generateCallExpression<const A extends unknown[]>(
+    context: Context,
+    sourceFile: ts.SourceFile,
+    moduleSpecifier: string,
+    fn: (...args: A) => unknown,
+    ...args: PartialElements<A>
+) {
+    addNamedImportIfAbsent(context, sourceFile, moduleSpecifier, fn)
+    sourceFile.addStatements((writer) => writer.newLine())
+    const [statement] = sourceFile.addStatements(`${fn.name}()`)
+
+    const expression = statement!.getChildAtIndexIfKindOrThrow(0, ts.SyntaxKind.CallExpression)
+
+    transformFunctionArguments(expression, fn, ...args)
+
+    return expression
+}
+
+/**
+ * Generate an exported variable assignment initialized by a function call with the
+ * provided arguments. The exported variable name will be automatically determined
+ * based on the function's name and the document's ID.
+ */
+export function generateCallExpressionExportForDocument<const A extends unknown[]>(
+    context: Context,
+    info: {
+        sourceFile: ts.SourceFile
+        moduleSpecifier: string
+    },
+    fn: (...args: A) => unknown,
+    ...args: PartialElements<A>
+) {
+    const { sourceFile, moduleSpecifier } = info
+    return generateCallExpressionDefaultExport(context, sourceFile, moduleSpecifier, fn, ...args)
+}
+
+export function getOrCreatePropertyAssignment(
+    obj: ts.ObjectLiteralExpression,
+    name: string,
+    initializer: string = 'undefined'
+) {
+    return (
+        obj.getProperty(name)?.asKind(ts.SyntaxKind.PropertyAssignment) ??
+        obj.addPropertyAssignment({ name, initializer })
+    )
+}
+
+export function createOrUpdateScriptProperty(obj: ts.ObjectLiteralExpression, name: string, value: string) {
+    if (!value) {
+        return
+    }
+
+    const property = obj.getProperty(name)?.asKind(ts.SyntaxKind.PropertyAssignment)
+    if (property) {
+        property.remove()
+    }
+    value = value.replaceAll('`', '\\`').replaceAll('${', '\\${').trim()
+
+    return createOrUpdateStringLiteralProperty(obj, name, value, '`')
+}
+
+export function createOrUpdateStringLiteralProperty(
+    obj: ts.ObjectLiteralExpression,
+    name: string,
+    value: string | undefined,
+    valueQuoteStyle: "'" | '"' | '`' = "'"
+) {
+    if (value === undefined) {
+        return
+    }
+
+    let property = obj.getProperty(name)?.asKind(ts.SyntaxKind.PropertyAssignment)
+
+    if (!property) {
+        property = obj.addPropertyAssignment({ name, initializer: `${valueQuoteStyle}${value}${valueQuoteStyle}` })
+    } else {
+        const valueNode = property.getChildAtIndexIfKind(2, ts.SyntaxKind.StringLiteral)
+        if (valueNode) {
+            valueNode.setLiteralValue(value || 'undefined')
+        } else {
+            const valueNode = property.getChildAtIndexIfKind(2, ts.SyntaxKind.NoSubstitutionTemplateLiteral)
+            if (valueNode) {
+                valueNode.setLiteralValue(value || 'undefined')
+            }
+        }
+    }
+
+    return property
+}
+
+export function isEscapedPropertyAssignment(args: ts.ObjectLiteralExpression, name: string) {
+    const prop = args.getProperty(name)
+    if (!prop) {
+        return false
+    }
+
+    const asExpression = prop.getChildAtIndexIfKind(2, ts.SyntaxKind.AsExpression)
+    if (asExpression && asExpression.getFullText().indexOf('any') !== -1) {
+        return true
+    }
+
+    return false
+}
+
+function isResolvablePropertyAssignment(args: ts.ObjectLiteralExpression, propertyName: string) {
+    const prop = args.getProperty(propertyName)
+    if (!prop) {
+        return false
+    }
+
+    const identifierExp = prop.getChildAtIndexIfKind(2, ts.SyntaxKind.Identifier)
+    if (!identifierExp) {
+        return false
+    }
+
+    // Variable definition may be from other file
+    identifierExp.getSourceFile().fixMissingImports()
+
+    const definitions = identifierExp.getDefinitionNodes()
+    if (definitions && definitions.length > 0) {
+        return true
+    }
+    return false
+}
+
+/** utility function to get the $id value in a object literal node */
+export const getNodeId = (node: ts.ObjectLiteralExpression) => {
+    const prop = node.getPropertyOrThrow('$id').asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
+    if (prop.getInitializerIfKind(ts.SyntaxKind.ElementAccessExpression)) {
+        const expression = prop.getInitializerIfKind(ts.SyntaxKind.ElementAccessExpression)?.getArgumentExpression()
+        return (
+            expression?.asKind(ts.SyntaxKind.StringLiteral)?.getLiteralValue() ??
+            expression?.asKind(ts.SyntaxKind.NumericLiteral)?.getLiteralValue().toString()
+        )
+    } else if (prop.getInitializerIfKind(ts.SyntaxKind.StringLiteral)) {
+        return prop.getInitializerIfKind(ts.SyntaxKind.StringLiteral)?.getLiteralValue()
+    }
+    return `${prop.getInitializerIfKind(ts.SyntaxKind.NumericLiteral)?.getLiteralValue()}`
+}
+
+/** utility iterator for iterating array structures in rest api*/
+export class ArrayIterator {
+    arrayExpression: ts.ArrayLiteralExpression
+    elements: ts.Expression<ts.ts.Expression>[]
+    idx: number
+
+    constructor(private prop: ts.PropertyAssignment) {
+        this.arrayExpression = this.prop.getInitializerIfKindOrThrow(ts.SyntaxKind.ArrayLiteralExpression)!
+        this.elements = this.arrayExpression.getElements()
+        this.idx = 0
+    }
+
+    hasNext() {
+        return this.idx < this.elements.length
+    }
+
+    next() {
+        return this.elements[this.idx++]!
+    }
+
+    getExpression() {
+        return this.arrayExpression
+    }
+}
+
+export function writeArrayPropertyAsReference(
+    arg: ts.ObjectLiteralExpression,
+    name: string,
+    def: string,
+    value: string[]
+) {
+    if (!value || !isArray(value)) {
+        return
+    }
+
+    const propertyAssignment = getOrCreatePropertyAssignment(arg, name, def)
+
+    const newValues = value.map((val) => {
+        propertyAssignment.setInitializer((writer) => {
+            writer.write(val)
+        })
+
+        return isResolvablePropertyAssignment(arg, name) ? val : `'${val}' as any`
+    })
+
+    propertyAssignment.setInitializer((writer) => {
+        writer.write(`[${newValues}]`)
+    })
+}
+
+export const recordSchema = z.object({
+    $id: z.union([z.string(), z.number()]),
+    data: z.record(z.any()),
+    table: z.string(),
+})
+
+export function writePropertyAsReference(arg: ts.ObjectLiteralExpression, name: string, def: string, value: unknown) {
+    if (!value || isArray(value)) {
+        return
+    }
+
+    // This value is already a reference that we shouldn't attempt to resolve
+    if (recordSchema.safeParse(value).success) {
+        return
+    }
+
+    const propertyAssignment = getOrCreatePropertyAssignment(arg, name, def)
+
+    if (isEmpty(value)) {
+        propertyAssignment.setInitializer((writer) => {
+            writer.write(stringify(value))
+        })
+    }
+
+    if (isPlainObject(value)) {
+        const nestedArgs = propertyAssignment.getInitializerIfKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+        for (const property in value) {
+            if (isArray(value[property])) {
+                writeArrayPropertyAsReference(nestedArgs, property, '[]', value[property])
+            } else {
+                writePropertyAsReference(nestedArgs, property, '{}', value[property])
+            }
+        }
+
+        return
+    }
+
+    const escapedPreTransform = isEscapedPropertyAssignment(arg, name)
+
+    if (isGUID(value as string)) {
+        propertyAssignment.setInitializer((writer) => {
+            writer.write(stringify(value))
+        })
+        return
+    }
+
+    propertyAssignment.setInitializer((writer) => {
+        writer.write(value as string)
+    })
+
+    if (isResolvablePropertyAssignment(arg, name)) {
+        return
+    }
+
+    value = `${stringify(value)} as any`
+    if (!escapedPreTransform) {
+        // Generate comment
+        value = `${value} /*Generated*/` // comment like this '//comment' breaks the code in some occasion
+    }
+
+    propertyAssignment.setInitializer((writer) => {
+        writer.write(value as string)
+    })
+}
+
+export function writeCustomProperty(arg: ts.ObjectLiteralExpression, name: string, def: string, value: string) {
+    if (!value) {
+        return
+    }
+
+    const propertyAssignment = getOrCreatePropertyAssignment(arg, name, def)
+    propertyAssignment.setInitializer((writer) => {
+        writer.write(value)
+    })
+}
+
+export function mergeDataIntoObjectLiteral(node: ts.ObjectLiteralExpression, data: object) {
+    for (const [key, value] of Object.entries(data)) {
+        const existingAssignment = getPropertyAssignment(node, key)
+        const array = isArray(value)
+        if (existingAssignment) {
+            if (value === '') {
+                removeNode(existingAssignment)
+            } else if (array && value.length === 0) {
+                removeNode(existingAssignment)
+            }
+        }
+
+        if (isObject(value) && !Object.values(value).some((value) => value !== undefined)) {
+            // Don't write an empty object literal
+            continue
+        }
+
+        if (value !== '' && value !== undefined && !(array && value.length === 0)) {
+            const propertyAssignment = getOrCreatePropertyAssignment(node, key, array ? '[]' : '{}')
+            setPropertyAssignmentValue(propertyAssignment, value)
+        }
+    }
+}
+
+export function setPropertyAssignmentValue(
+    property: ts.PropertyAssignment,
+    value: string | ts.PropertyAssignmentStructure | ts.ImportSpecifierStructure | object
+) {
+    if (typeof value === 'object') {
+        if (ts.Structure.isPropertyAssignment(value)) {
+            property.setInitializer(value.initializer)
+        } else if (ts.Structure.isImportSpecifier(value)) {
+            property.setInitializer(value.name)
+        } else if (isArray(value)) {
+            property.setInitializer(stringify(value))
+        } else {
+            mergeDataIntoObjectLiteral(
+                property.getInitializerIfKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression),
+                value
+            )
+        }
+    } else {
+        property.setInitializer(stringify(value))
+    }
+}
+
+export function transformFunctionArguments<const A extends unknown[]>(
+    node: ts.CallExpression,
+    fn: (...args: A) => unknown,
+    ...args: PartialElements<A>
+) {
+    if (getCallExpressionName(node) !== fn.name) {
+        return false
+    }
+
+    for (let i = 0; i < args.length; i++) {
+        const argValue = args[i]
+        const argNode = node.getArguments()[i] ?? node.insertArgument(i, '{}')
+
+        if (argValue && typeof argValue === 'object') {
+            mergeDataIntoObjectLiteral(argNode.asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression), argValue)
+        } else {
+            argNode.replaceWithText(stringify(argValue))
+        }
+    }
+
+    return true
+}
+
+export function removeNode(node: SupportedNode) {
+    if ('remove' in node) {
+        return node.remove()
+    } else if (ts.Node.isCallExpression(node)) {
+        const parent = node.getParent()
+        if (ts.Node.isExpressionStatement(parent) || ts.Node.isVariableDeclaration(parent)) {
+            return removeNode(parent)
+        }
+    } else if (ts.Node.isStatement(node)) {
+        removeNode(node)
+    }
+
+    // TODO: Nodes that aren't complete statements can't be arbitrarily removed because it
+    // will almost always result in broken code. Replacing with 'undefined' works pretty
+    // much anywhere, but isn't very elegant. We should revisit this and perhaps make the
+    // behavior configurable.
+    node.replaceWithText('undefined')
+}