@servicenow/sdk-build-core 3.0.2 → 4.0.0

package/src/plugins/util/CodeTransformation.ts

@@ -1,731 +0,0 @@
-import { Logger, NOW_FILE_EXTENSION, SupportedNode, path, ts, tsc } from '@servicenow/sdk-project'
-const { format, resolve } = path
-import { Context } from '../Context'
-import { getCallExpressionName } from './CallExpression'
-import { isArray, isEmpty, isObject, isPlainObject } from 'lodash'
-import * as z from 'zod'
-import { Action, Document } from '../behaviors'
-import { isGUID } from '../../GUID'
-import { noThrow } from '../../util'
-import { getPropertyAssignment } from './ObjectLiteral'
-
-export function stringify(val: unknown) {
-    if (typeof val === 'function') {
-        return val.toString()
-    }
-    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.xmlFilePath) {
-        return path.basename(document.xmlFilePath, path.extname(document.xmlFilePath))
-    }
-    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.debug(
-        `Adding named import '${importName}' from module '${moduleSpecifier}' to source file: ${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'
-): ts.PropertyAssignment {
-    const stringifiedName = stringify(name)
-    const prop =
-        obj.getProperty(name)?.asKind(ts.SyntaxKind.PropertyAssignment) ??
-        obj.getProperty(stringifiedName)?.asKind(ts.SyntaxKind.PropertyAssignment)
-
-    if (prop) {
-        return prop
-    }
-
-    let propOrErr
-    /**
-     * Adding back the previous stringify regex check because property name with space when set without stringified works but later on throws error
-     */
-    if (/^[a-zA-Z0-9_$]*$/.test(name)) {
-        propOrErr = noThrow(() => obj.addPropertyAssignment({ name, initializer }))
-    }
-
-    if (!propOrErr || propOrErr instanceof Error) {
-        return obj.addPropertyAssignment({ name: stringifiedName, initializer })
-    }
-    return propOrErr
-}
-
-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<tsc.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 addCallExpressionToProperty(obj: ts.ObjectLiteralExpression, field: string, functionCall) {
-    const property = getOrCreatePropertyAssignment(obj, field, functionCall)
-    property.setInitializer((writer) => {
-        writer.write(functionCall)
-    })
-}
-
-export function writePropertyAsReference(
-    logger: Logger,
-    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(logger, nestedArgs, property, '{}', value[property])
-            }
-        }
-
-        return
-    }
-
-    const escapedPreTransform = isEscapedPropertyAssignment(arg, name)
-
-    if (isGUID(value as string)) {
-        propertyAssignment.setInitializer((writer) => {
-            writer.write(stringify(value))
-        })
-        return
-    }
-
-    // This first write is to check whether the value is a resolvable idenfifier
-    // We don't want to throw here if the property assignment would be malformed
-    const maybeError = noThrow(() => {
-        propertyAssignment.setInitializer((writer) => {
-            if (value === 'default') {
-                writer.write(stringify(value))
-            } else {
-                writer.write(value as string)
-            }
-        })
-    })
-    if (maybeError instanceof Error) {
-        logger.warn(
-            `Invalid reference value '${value}' for property '${name}' in file ${arg.getSourceFile().getFilePath()}`
-        )
-    }
-    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) {
-    const properties = node
-        .getProperties()
-        .reduce((a, v) => ({ ...a, [getObjectPropertyAssignmentName(v as ts.PropertyAssignment)]: v }), {})
-    for (const [key, value] of Object.entries(data)) {
-        const array = isArray(value)
-        if (!isEmpty(properties) && (value === '' || (array && value.length === 0))) {
-            const existingAssignment = properties[key]
-            if (existingAssignment) {
-                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 = properties[key]
-            if (propertyAssignment) {
-                if (isNowIncludeCall(propertyAssignment.getInitializerIfKind(ts.SyntaxKind.CallExpression))) {
-                    // Don't transform any updates to Now.includes calls
-                    continue
-                }
-                setPropertyAssignmentValue(propertyAssignment, value)
-            } else {
-                const newPropertyAssignment = getOrCreatePropertyAssignment(node, key, array ? '[]' : '{}')
-                setPropertyAssignmentValue(newPropertyAssignment, value)
-            }
-        }
-    }
-}
-
-/**
- * Merges an array of object literal data in to an existing array of object literal values
- * @param arrayNode Node with array to transform
- * @param data Array of object literals
- * @param comparisonProperty a property to be treated as the primary key of each object literal for comparison
- * @param action Should this item be deleted if found?
- */
-export function mergeDataIntoObjectLiteralArray(
-    arrayNode: ts.ArrayLiteralExpression,
-    data: any[],
-    comparisonProperty: string,
-    action?: Action
-) {
-    if (!data || data.length < 1) {
-        return
-    }
-
-    const mappedData = data.reduce((map, obj) => ((map[obj[`${comparisonProperty}`]] = obj), map), {})
-    arrayNode.getElements().forEach((element) => {
-        const existingProperty =
-            element
-                .asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                .getProperty(`${comparisonProperty}`)
-                ?.getFirstChildByKind(ts.SyntaxKind.StringLiteral)
-                ?.getLiteralValue() ?? undefined
-        if (existingProperty && !mappedData[existingProperty]) {
-            arrayNode.removeElement(element)
-        }
-    })
-    const existingElements = arrayNode.getElements()
-    data.forEach((obj) => {
-        const transformElement = existingElements.find((element) => {
-            const prop = element.asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-            const existingProperty = getPropertyAssignment(prop, `${comparisonProperty}`)?.getInitializerIfKind(
-                ts.SyntaxKind.StringLiteral
-            )
-            return obj[`${comparisonProperty}`] === existingProperty?.getLiteralValue()
-        })
-
-        // Found existing element in arrays
-        if (transformElement) {
-            if (action && action === 'DELETE') {
-                arrayNode.removeElement(transformElement)
-            } else {
-                mergeDataIntoObjectLiteral(transformElement.asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression), obj)
-            }
-        } else {
-            arrayNode.addElement(stringify(filterEmpty(obj)))
-        }
-    })
-}
-
-// Remove default empty values
-export function filterEmpty(data: any) {
-    return Object.entries(data).reduce((acc, [key, value]) => {
-        if (value !== '') {
-            acc[key] = value
-        }
-        return acc
-    }, {})
-}
-
-export function escapeStringLiteralValues(str: string) {
-    return str.replace(/[`\\]|\${/g, (char) => {
-        switch (char) {
-            case '`':
-                return '\\`'
-            case '\\':
-                return '\\' + char
-            case '${':
-                return '\\${'
-            default:
-                return char
-        }
-    })
-}
-
-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
-            )
-        }
-        return
-    }
-
-    //preserve any tagged template literals
-    const taggedInitializer = property.getInitializerIfKind(ts.SyntaxKind.TaggedTemplateExpression)
-    if (taggedInitializer) {
-        const template = taggedInitializer.getTemplate()
-
-        template.setLiteralValue(escapeStringLiteralValues(value))
-    } else {
-        const stringified =
-            typeof value !== 'string' || value.indexOf('\n') < 0
-                ? stringify(value)
-                : `\`${escapeStringLiteralValues(value)}\``
-        property.setInitializer(stringified)
-    }
-}
-
-export function fixFunctionArgumentTypes(context: Context, node: ts.CallExpression) {
-    if (node.wasForgotten()) {
-        return
-    }
-    const typeChecker = context.compiler.getTypeChecker()
-    const signature = typeChecker.getResolvedSignature(node)
-    if (signature) {
-        const callParams = signature.getParameters()
-        for (let i = 0; i < callParams.length; i++) {
-            const argType = callParams[i]?.getTypeAtLocation(node)
-            const argNode = node.getArguments()[i]?.asKind(ts.SyntaxKind.ObjectLiteralExpression)
-            if (!argType || !argNode) {
-                break
-            }
-            fixNodeArgumentType(node, argNode, argType)
-        }
-    }
-}
-
-function fixNodeArgumentType(
-    node: ts.CallExpression,
-    argNode: ts.ObjectLiteralExpression | ts.PropertyAssignment,
-    argType: ts.Type
-) {
-    if (argNode.getType().isObject()) {
-        argType.getApparentProperties().forEach((prop) => {
-            const propName = prop.getName()
-            const propType = prop.getTypeAtLocation(node)
-            let propNode: ts.PropertyAssignment | undefined
-            if (argNode.isKind(ts.SyntaxKind.ObjectLiteralExpression)) {
-                propNode = argNode.getProperty(propName)?.asKind(ts.SyntaxKind.PropertyAssignment)
-            } else {
-                propNode = argNode
-                    .getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-                    ?.getProperty(propName)
-                    ?.asKind(ts.SyntaxKind.PropertyAssignment)
-            }
-
-            if (!propNode) {
-                return
-            }
-            fixNodeArgumentType(node, propNode, propType)
-        })
-    } else if (argNode.isKind(ts.SyntaxKind.PropertyAssignment)) {
-        const nodeType = argNode.getType()
-        if (nodeType.isAssignableTo(argType)) {
-            return
-        }
-        // isAssignableTo doesnot play well with string literals in union types
-        if (
-            nodeType.isStringLiteral() &&
-            argType.isUnion() &&
-            argType.getUnionTypes().some((type) => type.getText() === nodeType.getText())
-        ) {
-            return
-        }
-
-        // fix types for string
-        if (isStringType(argType)) {
-            const argValue = argNode.getInitializer()?.getText()
-            argNode.setInitializer(`'${argValue}'`)
-            return
-        }
-
-        // cast 'as any' for other types
-        const argValue = argNode.getInitializer()?.getText()
-        argNode.setInitializer(`${argValue} as any`)
-    }
-}
-
-function isStringType(argType: ts.Type) {
-    if (argType.isUnion()) {
-        return argType.getUnionTypes().some((type) => type.isString())
-    }
-    return argType.isString()
-}
-
-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')
-}
-
-/**
- * Re-extracts CallExpression property names for transform to check for customized properties on Plugin APIs.
- * If CallExpression properties don't match don't match schema expected by fluent this function will tranform updates
- * only to those properties (not new properties)
- * @param fn type of CallExpression to extract
- * @param node Node
- * @param dataForTransform Document Data passed to a transformer function
- * @param cleanedData Document data cleaned/parsed by a Zod step that has filtered out properties not handled by fluent
- */
-export function transformCustomizedProperties<
-    const A extends unknown[],
-    const E extends A extends [infer T extends Record<string, unknown>] ? T : never,
->(fn: (...args: A) => E, node, dataForTransform, cleanedData) {
-    if (!dataForTransform || !cleanedData) {
-        return
-    }
-
-    const [arg] = node.getArguments()
-    const properties = arg?.asKind(ts.SyntaxKind.ObjectLiteralExpression)?.getProperties()
-
-    if (!properties) {
-        return
-    }
-
-    const customizedProperties = {}
-    Object.values(properties).forEach((prop) => {
-        const propName = getObjectPropertyAssignmentName(prop as ts.PropertyAssignment)
-        if (dataForTransform[propName] !== undefined && cleanedData[propName] === undefined) {
-            customizedProperties[propName] = dataForTransform[propName]
-        }
-    })
-
-    if (!isEmpty(customizedProperties)) {
-        transformFunctionArguments(node, fn, ...([customizedProperties] as PartialElements<A>))
-    }
-}
-
-export function isNowIncludeCall(callExpression?: ts.CallExpression) {
-    if (!callExpression) {
-        return false
-    }
-    const propertyAccessExp = callExpression.getExpressionIfKind(ts.SyntaxKind.PropertyAccessExpression)
-    const nowNamespace = propertyAccessExp?.getExpressionIfKind(ts.SyntaxKind.Identifier)?.getText()
-    const functionName = propertyAccessExp?.getName()
-    return nowNamespace === 'Now' && functionName === 'include'
-}
-
-export function getObjectPropertyAssignmentName(objectProperty: ts.PropertyAssignment) {
-    const nameNode = objectProperty.getNameNode()
-    return nameNode.isKind(ts.SyntaxKind.StringLiteral) ? nameNode.getLiteralValue() : objectProperty.getName()
-}