@servicenow/sdk-build-core 2.2.9 → 3.0.1

package/src/IncludePaths.ts

@@ -0,0 +1,122 @@
+import { FileSystem, path } from '@servicenow/sdk-project'
+import { Context } from './plugins'
+
+export type IncludePaths = {
+    [table: string]: {
+        fields: { [field: string]: string }[]
+    }
+}
+
+type CustomizedFieldPaths = {
+    field: string
+    path: string
+}
+
+export type CustomizedIncludePathForTable = {
+    table: string
+    guid: string
+    fields: CustomizedFieldPaths[]
+}
+
+export type CustomizedIncludePaths = {
+    [table: string]: CustomizedIncludePathForTable[]
+}
+
+export const DefaultIncludePaths: IncludePaths = {
+    // Example of how to define include paths:
+    // sys_script_include: {
+    //     fields: [{ script: '{{name}}.server.js' }],
+    // },
+}
+
+export const getIncludePaths = (context: Context) => {
+    const mappingFileName = path.join(context.app.rootDir, 'now.includes-mapping.json')
+    const compilerSourceFile = context.compiler.getSourceFile(mappingFileName)
+    let fileText = ''
+    if (compilerSourceFile) {
+        fileText = compilerSourceFile.getFullText()
+    } else {
+        // now-sdk fetch doesn't load the file into the compiler, so
+        // for now we'll just read the file from the filesystem
+        fileText = FileSystem.existsSync(context.fs, mappingFileName)
+            ? context.fs.readFileSync(mappingFileName).toString()
+            : ''
+    }
+    return fileText ? (JSON.parse(fileText) as IncludePaths) : (DefaultIncludePaths as IncludePaths)
+}
+
+export const calculateCustomPathsFromDocs = (context: Context): CustomizedIncludePaths => {
+    const includePaths = getIncludePaths(context)
+    const customizedIncludePaths = context
+        .getAllDocuments()
+        .filter((doc) => doc.kind === 'record')
+        .map((doc) => ({ table: doc.data?.['table'], guid: doc.guid, data: doc.data?.['data'] }))
+        .filter((record) => includePaths[record.table])
+        .map((record) => ({
+            table: record.table,
+            guid: record.guid,
+            fields:
+                (includePaths[record.table]?.fields || []).flatMap(Object.entries).map(([field, path]) => ({
+                    field,
+                    path: replaceTemplate(path, { sys_id: record.guid, ...record.data }),
+                })) || [],
+        }))
+        .reduce((acc, record) => {
+            acc[record.table] = acc[record.table] || []
+            acc[record.table].push(record)
+            return acc
+        }, {})
+
+    return dedupeFilenames(customizedIncludePaths)
+}
+
+export function replaceTemplate(template: string, properties: Record<string, any>) {
+    let replacedString = template
+    const matches = template.matchAll(/{{([a-z_]+)}}/g)
+    for (const m of matches) {
+        const [, field] = m
+        if (field) {
+            const sanitizedValue = sanitizeForFilesystem(properties[field])
+            replacedString = replacedString.replaceAll(`{{${field}}}`, sanitizedValue)
+        }
+    }
+    return replacedString
+}
+
+const IllegalCharacters = /[/<>?\\:|*"]/g
+const Reserved = /^\.+$/
+const WindowsTrailing = /[. ]+$/
+
+function sanitizeForFilesystem(filename: string) {
+    return filename.replace(IllegalCharacters, '_').replace(Reserved, '').replace(WindowsTrailing, '')
+}
+
+function dedupeFilename(filePath: string, fixedCount: { [path: string]: number }) {
+    const parsedPath = path.parse(filePath)
+    fixedCount[filePath] = (fixedCount[filePath] || 0) + 1
+    const pathParts = parsedPath.base.split('.')
+    pathParts[0] = `${pathParts[0]}-${fixedCount[filePath]}`
+    return path.join(parsedPath.dir, pathParts.join('.'))
+}
+
+function dedupeFilenames(customizedFieldPaths: CustomizedIncludePaths) {
+    const pathCount = {}
+    for (const table in customizedFieldPaths) {
+        const paths = customizedFieldPaths[table]!.flatMap((record) => record.fields.map((f) => f.path))
+        paths.forEach((p) => (pathCount[p] = (pathCount[p] || 0) + 1))
+    }
+
+    const fixedCount = {}
+    for (const table in customizedFieldPaths) {
+        const pathForTable = customizedFieldPaths[table] || []
+        for (const includePathForTable of pathForTable) {
+            for (let i = 0; i < includePathForTable.fields.length; i++) {
+                const p = includePathForTable.fields[i]?.path
+                if (p && pathCount[p] > 1) {
+                    includePathForTable.fields[i]!.path = dedupeFilename(p, fixedCount)
+                }
+            }
+        }
+    }
+    return customizedFieldPaths
+}

package/src/Keys.ts

@@ -141,6 +141,10 @@ export class Keys implements Now.Internal.KeysRegistry {
         return !!this.explicit[key]
     }
 
+    getIdUsingExplicitKey(key: string | number) {
+        return this.explicit[key]?.id
+    }
+
     findExplicitKeyById(id: string) {
         return Object.entries(this.explicit).find(([, v]) => v.id === id)?.[0]
     }

package/src/XML.ts

@@ -1,6 +1,7 @@
 import { Action, type Context } from './plugins'
 import { create } from 'xmlbuilder2'
 import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
+import { maybeGetFieldToTagMap } from './util/RuntimeTableSchema'
 
 export type XmlValue = string | number | boolean
 
@@ -17,13 +18,22 @@ export function unloadBuilder(context: Context) {
         xml,
         end,
         record: (tableName: string, id: string | number, action: Action = 'INSERT_OR_UPDATE') => {
-            const rec = recordXml(xml, tableName, id, { attr: { action } })
+            const rec = recordXml(xml, tableName, id, { attr: { action }, context })
             rec.addSysScope(context)
             return rec
         },
     }
 }
 
+/**
+ * If the code contains the character sequence ']]>' it will be parsed as the end of
+ * the CDATA section. To avoid this, we need to split the sequence by dividing the
+ * content into two CDATA sections at that point.
+ */
+export function sanitizeNestedCdataTags(content: string): string {
+    return content.replace(/]]>/g, ']]]]><![CDATA[>')
+}
+
 export function recordXml(
     xml: XMLBuilder,
     tableName: string,
@@ -31,10 +41,12 @@ export function recordXml(
     options: {
         attr?: Record<string, string>
         excludeScopeElement?: boolean
+        context?: Context
     } = {}
 ) {
     const recordXml = xml.ele(tableName, options.attr || { action: 'INSERT_OR_UPDATE' })
     recordXml.ele('sys_id', undefined).txt(`${id}`)
+    const fieldToTagMap = maybeGetFieldToTagMap(tableName, options.context?.getAllDocuments() || [])
 
     // Record Builder
     return {
@@ -49,7 +61,15 @@ export function recordXml(
             }
 
             let fieldXml
-            if (columnName === 'script' || columnName === 'operation_script') {
+            const tag = fieldToTagMap[columnName]
+            if (
+                columnName === 'script' ||
+                columnName === 'operation_script' ||
+                tag === 'script' ||
+                tag === 'html' ||
+                tag === 'xml'
+            ) {
+                value = tag === 'xml' ? sanitizeNestedCdataTags(value as string) : value
                 fieldXml = recordXml.ele(columnName, attributes).dat(value as string)
             } else {
                 fieldXml = recordXml.ele(columnName, attributes).txt(`${value}`)

package/src/index.ts

@@ -4,4 +4,4 @@ export * from './XML'
 export * from './plugins'
 export * from './GUID'
 export * from './Keys'
-export * from './BuildOptions'
+export * from './IncludePaths'

package/src/plugins/Context.ts

@@ -13,7 +13,7 @@ import {
 import { Keys } from '../Keys'
 import { Plugin } from './Plugin'
 import { FluentDiagnostic } from './Diagnostic'
-import { ProjectContext, ts, type Diagnostic } from '@servicenow/sdk-project'
+import { ProjectContext, SupportedNode, ts, type Diagnostic } from '@servicenow/sdk-project'
 
 // These are only imported so they can be referenced in JS docs
 import type {
@@ -99,7 +99,7 @@ export type Context = ProjectContext & {
      * @param plugins An optional array of {@linkcode Plugin}s to use.
      * @returns a {@linkcode LinkedDocument} array.
      */
-    composeEntities(this: Context, data: EntityData[], plugins?: Plugin[]): LinkedDocument[]
+    composeEntities(this: Context, data: EntityData[], plugins?: Plugin[]): Promise<LinkedDocument[]>
 
     /**
      * Accepts an array of XML data and returns an {@linkcode UnlinkedDocument}
@@ -204,10 +204,11 @@ export type Context = ProjectContext & {
     usageCount: { [key: string]: number }
 
     /**
-     * An object of XML file names that was marked as handled or ignored by code transformation during the build process.
+     * Returns an object of XML file names that was marked as handled or ignored by code transformation during the build process.
      */
-    handledXmls: Record<string, HandledStates>
+    getHandledXmls: () => Record<string, HandledInfo>
 
+    updateHandledXMLs: (xml: string | undefined, status: HandledStates, info?: string, node?: SupportedNode) => void
     setAllDocuments: (documents: Document[]) => void
     getAllDocuments: () => Document[]
     getDocumentMap: () => DocumentMap
@@ -223,10 +224,16 @@ export type Context = ProjectContext & {
     keys: Keys
 
     explicitKeyExists: Keys['explicitKeyExists']
+    getIdUsingExplicitKey: Keys['getIdUsingExplicitKey']
     registerExplicitId: Keys['registerExplicitId']
     registerCompositeId: Keys['registerCompositeId']
     getDeletedAndUnusedIds: Keys['getDeletedAndUnusedIds']
     getKeysSourceFile(): ts.SourceFile
 }
 
-export type HandledStates = 'handled' | 'ignored' | 'skipped' | 'unchanged'
+export type HandledInfo = {
+    state: HandledStates
+    info?: string | undefined
+    node?: SupportedNode | undefined
+}
+export type HandledStates = 'handled' | 'handled as record' | 'ignored' | 'skipped' | 'unchanged'

package/src/plugins/behaviors/Composer.ts

@@ -37,6 +37,7 @@ export type Document<DocumentKind extends string = string, Node extends Supporte
     kind: DocumentKind
     data: unknown
     changedData?: unknown
+    xmlFilePath?: string
     xmlData?: unknown
     node?: Node
     action?: Action
@@ -80,7 +81,7 @@ export type DocumentMap<D extends Document = Document> = {
 export type EntityComposerFunction<Data extends Record<string, unknown> = Record<string, unknown>> = (
     entityData: EntityData<Data>,
     context: Context
-) => LinkedDocument | LinkedDocument[] | undefined
+) => Promise<LinkedDocument | LinkedDocument[] | undefined>
 
 /**
  * An XML composer function is a function that accepts a piece

package/src/plugins/behaviors/Serializer.ts

@@ -5,13 +5,14 @@ import { Context } from '../Context'
 /**
  * A file is a data structure with a name, a target directory, and content
  * as a string. The target directory must be the name of one of the magic
- * directories that exist within a ServiceNow deployable app package.
+ * directories that exist within a ServiceNow installable app package.
  */
 export type File = {
     name: `${string}.xml`
-    directory: 'dictionary' | 'unload' | 'unload.demo' | 'update' | 'apply_once' | 'scope' | ''
+    directory: Directories
     content: string
 }
+export type Directories = 'dictionary' | 'unload' | 'unload.demo' | 'update' | 'apply_once' | 'scope' | ''
 
 /**
  * A serializer function is a function which accepts a document of a known

package/src/plugins/behaviors/extractors/Data.ts

@@ -296,11 +296,17 @@ export class EntityData<const D extends Record<string, unknown> = Record<string,
         private readonly kind: string,
         private readonly guid: string,
         entity: ObjectData<D>,
-        node: SupportedNode
+        node: SupportedNode,
+        private installMethod?: string,
+        private explicitIds?: string[]
     ) {
         super(entity.getProperties(), node)
     }
 
+    getInstallMethod() {
+        return this.installMethod
+    }
+
     getKind() {
         return this.kind
     }
@@ -308,4 +314,8 @@ export class EntityData<const D extends Record<string, unknown> = Record<string,
     getGuid() {
         return this.guid
     }
+
+    getExplicitIds() {
+        return this.explicitIds ?? []
+    }
 }

package/src/plugins/index.ts

@@ -1,5 +1,5 @@
 export { Plugin } from './Plugin'
-export { type Context, type HandledStates } from './Context'
+export { type Context, type HandledStates, type HandledInfo } from './Context'
 export * from './behaviors'
 export * from './util'
 export * from './Diagnostic'

package/src/plugins/util/CallExpression.ts

@@ -82,6 +82,29 @@ export function extractCallExpression<
     return {
         handled: true,
         diagnostics,
-        data: new EntityData(kind, guid(entityValue), entity, node),
+        data: new EntityData(
+            kind,
+            guid(entityValue),
+            entity,
+            node,
+            extractInstallMethod(entity),
+            extractExplicitId(entity)
+        ),
     }
 }
+
+function extractInstallMethod<const D extends Record<string, unknown>>(entity: ObjectData<D>) {
+    const $meta = entity.getProperty('$meta')
+    if (!$meta) {
+        return
+    }
+    return $meta.getValue()['installMethod']
+}
+
+function extractExplicitId<const D extends Record<string, unknown>>(entity: ObjectData<D>) {
+    const $id = entity.getProperty('$id')
+    if (!$id) {
+        return []
+    }
+    return [`${$id.getValue()}`]
+}

package/src/plugins/util/CodeTransformation.ts

@@ -1,4 +1,4 @@
-import { NOW_FILE_EXTENSION, SupportedNode, path, ts, tsc } from '@servicenow/sdk-project'
+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'
@@ -6,10 +6,13 @@ import { isArray, isEmpty, isObject, isPlainObject } from 'lodash'
 import * as z from 'zod'
 import { Action, Document } from '../behaviors'
 import { isGUID } from '../../GUID'
-import { getPropertyAssignment } from './ObjectLiteral'
 import { noThrow } from '../../util'
+import { getPropertyAssignment } from './ObjectLiteral'
 
 export function stringify(val: unknown) {
+    if (typeof val === 'function') {
+        return val.toString()
+    }
     return JSON.stringify(val)
 }
 
@@ -28,8 +31,8 @@ export function formatSourceFileName(name: string) {
 }
 
 export function getSysUpdateName(document: Document & { xml?: string }, table: string) {
-    if (document.xml) {
-        return path.basename(document.xml, path.extname(document.xml))
+    if (document.xmlFilePath) {
+        return path.basename(document.xmlFilePath, path.extname(document.xmlFilePath))
     }
     return `${table}_${document.guid}`
 }
@@ -184,7 +187,7 @@ 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) ??
@@ -208,49 +211,6 @@ export function getOrCreatePropertyAssignment(
     return propOrErr
 }
 
-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) {
@@ -289,6 +249,7 @@ function isResolvablePropertyAssignment(args: ts.ObjectLiteralExpression, proper
 /** 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 (
@@ -357,7 +318,20 @@ export const recordSchema = z.object({
     table: z.string(),
 })
 
-export function writePropertyAsReference(arg: ts.ObjectLiteralExpression, name: string, def: string, value: unknown) {
+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
     }
@@ -381,7 +355,7 @@ export function writePropertyAsReference(arg: ts.ObjectLiteralExpression, name:
             if (isArray(value[property])) {
                 writeArrayPropertyAsReference(nestedArgs, property, '[]', value[property])
             } else {
-                writePropertyAsReference(nestedArgs, property, '{}', value[property])
+                writePropertyAsReference(logger, nestedArgs, property, '{}', value[property])
             }
         }
 
@@ -399,7 +373,7 @@ export function writePropertyAsReference(arg: ts.ObjectLiteralExpression, name:
 
     // 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
-    noThrow(() => {
+    const maybeError = noThrow(() => {
         propertyAssignment.setInitializer((writer) => {
             if (value === 'default') {
                 writer.write(stringify(value))
@@ -408,6 +382,11 @@ export function writePropertyAsReference(arg: ts.ObjectLiteralExpression, name:
             }
         })
     })
+    if (maybeError instanceof Error) {
+        logger.warn(
+            `Invalid reference value '${value}' for property '${name}' in file ${arg.getSourceFile().getFilePath()}`
+        )
+    }
     if (isResolvablePropertyAssignment(arg, name)) {
         return
     }
@@ -437,7 +416,7 @@ export function writeCustomProperty(arg: ts.ObjectLiteralExpression, name: strin
 export function mergeDataIntoObjectLiteral(node: ts.ObjectLiteralExpression, data: object) {
     const properties = node
         .getProperties()
-        .reduce((a, v) => ({ ...a, [(v as ts.PropertyAssignment).getName()]: v }), {})
+        .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))) {
@@ -455,6 +434,10 @@ export function mergeDataIntoObjectLiteral(node: ts.ObjectLiteralExpression, dat
         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 ? '[]' : '{}')
@@ -526,6 +509,21 @@ export function filterEmpty(data: any) {
     }, {})
 }
 
+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
@@ -550,9 +548,14 @@ export function setPropertyAssignmentValue(
     const taggedInitializer = property.getInitializerIfKind(ts.SyntaxKind.TaggedTemplateExpression)
     if (taggedInitializer) {
         const template = taggedInitializer.getTemplate()
-        template.setLiteralValue(value)
+
+        template.setLiteralValue(escapeStringLiteralValues(value))
     } else {
-        property.setInitializer(stringify(value))
+        const stringified =
+            typeof value !== 'string' || value.indexOf('\n') < 0
+                ? stringify(value)
+                : `\`${escapeStringLiteralValues(value)}\``
+        property.setInitializer(stringified)
     }
 }
 
@@ -674,3 +677,55 @@ export function removeNode(node: SupportedNode) {
     // 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()
+}

package/src/plugins/util/index.ts

@@ -1,4 +1,3 @@
 export * from './CallExpression'
 export * from './CodeTransformation'
 export * from './ObjectLiteral'
-export * from './ConfigurationFunction'

package/src/util/Debug.ts

@@ -1,5 +1,5 @@
 import { inspect as nodeInspect } from 'util'
-import { Data, Document, File } from '../plugins/behaviors'
+import { Document } from '../plugins/behaviors'
 import { Logger } from '@servicenow/sdk-project'
 
 export function inspect(val: unknown, depth = 2) {
@@ -10,21 +10,6 @@ export function inspect(val: unknown, depth = 2) {
     })
 }
 
-export function debugData(data: ({ data: unknown } | Data)[], logger: Logger, message = 'DATA:') {
-    logger.debug(
-        `${message} ${inspect(
-            data.map((d) => {
-                if (d instanceof Data) {
-                    return d.getValue()
-                } else {
-                    return d
-                }
-            }),
-            5
-        )}`
-    )
-}
-
 export function debugDocuments(documents: Document[], logger: Logger, message = 'DOCUMENTS:') {
     logger.debug(
         `${message} ${inspect(
@@ -37,7 +22,3 @@ export function debugDocuments(documents: Document[], logger: Logger, message =
         )}`
     )
 }
-
-export function debugFiles(files: File[], logger: Logger, message = 'FILES:') {
-    logger.debug(`${message}: ${inspect(files, 5)}`)
-}