@servicenow/sdk-build-core 3.0.3 → 4.0.0

package/src/plugins/util/ObjectLiteral.ts

@@ -1,37 +0,0 @@
-import { ts } from '@servicenow/sdk-project'
-
-/**
- * Retrieves the property assignment with the specified name and subpath from the given node.
- * @param node - The node to search for the property assignment.
- * @param property - The name of the property assignment to retrieve.
- * @param subPath - Optional subpath to navigate within the property assignment.
- * @returns The property assignment node if found, otherwise undefined.
- */
-export function getPropertyAssignment(node: ts.Node | undefined, property: string, ...subPath: string[]) {
-    let current = node
-        ?.asKind(ts.SyntaxKind.ObjectLiteralExpression)
-        // get the property assignment with the specified name
-        ?.getProperty((p) => hasPropertyAssignment(p, property))
-        ?.asKind(ts.SyntaxKind.PropertyAssignment)
-
-    for (const pathPart of subPath) {
-        current = current
-            ?.getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-            // get the property assignment with the specified name
-            ?.getProperty((p) => hasPropertyAssignment(p, pathPart))
-            ?.asKind(ts.SyntaxKind.PropertyAssignment)
-    }
-
-    return current
-}
-
-/**
- * Checks if the given property assignment has the specified path.
- * @param property - The property assignment to check.
- * @param path - The path to compare against.
- * @returns True if the property assignment has the specified path, otherwise false.
- */
-function hasPropertyAssignment(property: ts.ObjectLiteralElementLike | undefined, path: string): boolean {
-    const child = property?.getChildren().find((c) => ts.Node.isStringLiteral(c) || ts.Node.isIdentifier(c))
-    return child?.getSymbol()?.getEscapedName() === path
-}

package/src/plugins/util/index.ts

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

package/src/util/Debug.ts

@@ -1,24 +0,0 @@
-import { inspect as nodeInspect } from 'util'
-import { Document } from '../plugins/behaviors'
-import { Logger } from '@servicenow/sdk-project'
-
-export function inspect(val: unknown, depth = 2) {
-    return nodeInspect(val, {
-        colors: true,
-        compact: false,
-        depth,
-    })
-}
-
-export function debugDocuments(documents: Document[], logger: Logger, message = 'DOCUMENTS:') {
-    logger.debug(
-        `${message} ${inspect(
-            documents.map((d) => {
-                const { node, ...rest } = d
-                node
-                return rest
-            }),
-            5
-        )}`
-    )
-}

package/src/util/Directive.ts

@@ -1,123 +0,0 @@
-import { ts, tsc, Diagnostic } from '@servicenow/sdk-project'
-import { Context } from '../plugins/Context'
-import { FluentDiagnostic } from '../plugins'
-
-const FluentDisableSyncDirective = '@fluent-disable-sync'
-const FluentDisableSyncForFileDirective = '@fluent-disable-sync-for-file'
-const fluentCommentDirectiveRegEx = /^\/\/\/?\s*@fluent-ignore\b/
-
-enum FluentDirectiveType {
-    Ignore = 'ignore',
-}
-export type FluentDirective = {
-    filePath: string
-    start: number
-    type: FluentDirectiveType
-}
-
-function getDirectiveFromCommentText(text: string) {
-    const directiveRegex = /^.*(\/{2,}|\/\*{1,})*\s*(@fluent-[-_a-zA-Z0-9]+).*$/m
-    return text.match(directiveRegex)?.[2]
-}
-
-function getDirectivesFromAncestors(node: ts.Node) {
-    return [node].concat(node.getAncestors()).flatMap(
-        (ancestor) =>
-            ancestor
-                .getLeadingCommentRanges()
-                .map((comment) => getDirectiveFromCommentText(comment.getText()))
-                .filter((directive) => directive) as string[]
-    )
-}
-
-function isFluentDirective(text: string, kind: tsc.CommentKind) {
-    text = text.trim()
-    if (kind === tsc.SyntaxKind.SingleLineCommentTrivia) {
-        return fluentCommentDirectiveRegEx.test(text)
-    }
-    text = text.substring(2, text.length - 2).trim()
-    return /^@fluent-ignore\b/.test(text)
-}
-
-function parseFluentDirectives(filePath: string, context: Context) {
-    const fluentDirectives: FluentDirective[] = []
-    const visitedRange = new Set<number>()
-    const sourceFile = context.compiler.getSourceFile(filePath)
-    if (sourceFile) {
-        const sourceCode = sourceFile.getFullText()
-        context.compiler.visitNodeTree(sourceFile, (node) => {
-            ;[
-                ...(tsc.getLeadingCommentRanges(sourceCode, node.getFullStart()) ?? []),
-                ...(tsc.getTrailingCommentRanges(sourceCode, node.getFullStart()) ?? []),
-            ].forEach((range) => {
-                if (
-                    !visitedRange.has(range.pos) &&
-                    isFluentDirective(sourceCode.substring(range.pos, range.end), range.kind)
-                ) {
-                    fluentDirectives.push({
-                        filePath,
-                        start: range.pos,
-                        type: FluentDirectiveType.Ignore,
-                    })
-                    visitedRange.add(range.pos)
-                }
-            })
-        })
-    }
-    return fluentDirectives
-}
-
-export function syncDisabledForNode(node: ts.Node) {
-    return getDirectivesFromAncestors(node).some((directive) => directive === FluentDisableSyncDirective)
-}
-
-export function syncDisabledForFile(sourceFile: ts.SourceFile) {
-    return sourceFile
-        .getStatements()?.[0]
-        ?.getLeadingCommentRanges()
-        .map((comment) => getDirectiveFromCommentText(comment.getText()))
-        .some((directive) => directive === FluentDisableSyncForFileDirective)
-}
-
-export function applyFluentDirectives(context: Context, diagnostics: Diagnostic[]) {
-    const directiveCache = new Map<string, FluentDirective[]>()
-    const filteredDiagnostics = diagnostics.filter((diagnostic) => {
-        const filePath = diagnostic.file.getFilePath()
-        let fluentDirectives = directiveCache.get(filePath)
-        if (!fluentDirectives) {
-            fluentDirectives = parseFluentDirectives(filePath, context)
-            directiveCache.set(filePath, fluentDirectives)
-        }
-        let allowDiagnostic = true
-        for (const directive of fluentDirectives) {
-            const { line: direcLine } = diagnostic.file.getLineAndColumnAtPos(directive.start)
-            const { line: diagLine } = diagnostic.file.getLineAndColumnAtPos(diagnostic.position.start)
-            if (direcLine + 1 === diagLine) {
-                allowDiagnostic = false
-                break
-            }
-        }
-        return allowDiagnostic
-    })
-
-    return filteredDiagnostics
-}
-
-export function getDirectiveDiagnostics(node: ts.Node): FluentDiagnostic[] {
-    // Currently, the @fluent-disable-sync directive is only allowed before a CallExpression
-    // If we see it, within one (say, in a PropertyAssignment), we should flag it
-    if (node.isKind(ts.SyntaxKind.CallExpression)) {
-        return node
-            .getDescendantsOfKind(ts.SyntaxKind.SingleLineCommentTrivia)
-            .filter((commentNode) => getDirectiveFromCommentText(commentNode.getText()) === FluentDisableSyncDirective)
-            .map((n) => {
-                return new FluentDiagnostic(
-                    n,
-                    `${FluentDisableSyncDirective} directive only allowed before a call expression`,
-                    { level: Diagnostic.Level.Warn }
-                )
-            })
-    } else {
-        return []
-    }
-}

package/src/util/RuntimeTableSchema.ts

@@ -1,44 +0,0 @@
-import * as tables from '@servicenow/sdk-core/runtime/fluent'
-import { Document } from '../plugins'
-
-type Tag = 'html' | 'script' | 'css' | 'xml'
-
-export type FieldToTagMap = Record<string, Tag>
-
-const internalTypeToScriptTag: FieldToTagMap = {
-    html: 'html',
-    translated_html: 'html',
-    html_template: 'html',
-    message_html: 'html',
-    html_script: 'html',
-    script: 'script',
-    script_plain: 'script',
-    xml: 'xml',
-}
-
-export function maybeGetFieldToTagMap(table: string, documents: Document[]): FieldToTagMap {
-    return getTagsForColumnsFromSystemTables(table) || getTagsForColumnsFromBootstrapDocs(table, documents) || {}
-}
-
-function getTagsForColumnsFromSystemTables(table: string): FieldToTagMap | undefined {
-    const schema = (tables as any)[table]?.schema
-    return (
-        schema &&
-        Object.entries(schema)
-            .filter(([_, schema]) => internalTypeToScriptTag[(schema as any).column_type])
-            .map(([field, schema]) => ({ [field]: internalTypeToScriptTag[(schema as any).column_type] }))
-            .reduce((acc, val) => ({ ...acc, ...val }), {})
-    )
-}
-
-function getTagsForColumnsFromBootstrapDocs(table: string, documents: Document[]): FieldToTagMap | undefined {
-    const bootstrapDoc = documents.find((doc) => doc.kind === 'bootstrap' && doc.guid === table)
-    const columns = bootstrapDoc?.data?.['data']?.bootstrapData.columns
-    return (
-        columns &&
-        Object.entries(columns)
-            .filter(([, column]) => internalTypeToScriptTag[(column as any).type])
-            .map(([field, column]) => ({ [field]: internalTypeToScriptTag[(column as any).type] }))
-            .reduce((acc, val) => ({ ...acc, ...val }), {})
-    )
-}

package/src/util/Util.ts

@@ -1,7 +0,0 @@
-export function noThrow<T>(action: () => T) {
-    try {
-        return action()
-    } catch (error) {
-        return error as Error
-    }
-}

package/src/util/XMLUploadParser.ts

@@ -1,90 +0,0 @@
-import { XMLParser } from 'fast-xml-parser'
-
-enum Action {
-    INSERT_OR_UPDATE = 'INSERT_OR_UPDATE',
-    DELETE = 'DELETE',
-    DELETE_MULTIPLE = 'delete_multiple',
-}
-
-export type Record = {
-    table: string
-    action: Action
-    id: string
-    data: { [element: string]: string | undefined | boolean | number }
-}
-
-export class XMLUnloadParser {
-    readonly records: Record[] = []
-
-    static parse = (xml: string) => {
-        const parser = new XMLUnloadParser()
-        parser.parse(xml)
-
-        return parser
-    }
-
-    private parse = (xml: string) => {
-        const parsed = new XMLParser({
-            ignoreAttributes: false,
-            alwaysCreateTextNode: false,
-            ignoreDeclaration: true,
-        }).parse(xml, true)
-
-        this.processResult(parsed)
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    private processResult(result: RecordUpdateXmlJson | RecordUpdateXmlJson[]) {
-        const recordUpdate = result['record_update']
-
-        for (const tag in recordUpdate) {
-            if (!tag.startsWith('@') && typeof recordUpdate[tag] === 'object') {
-                const records = recordUpdate[tag]
-                if (Array.isArray(records)) {
-                    for (const record of records) {
-                        this.parseRecord(tag, record)
-                    }
-                } else {
-                    this.parseRecord(tag, recordUpdate[tag])
-                }
-            }
-        }
-    }
-
-    private parseRecord(table: string, record: RecordXmlJson[string]) {
-        const { '@_action': action, sys_id, ...data } = record
-
-        const parsedAction = this.parseAction(action)
-
-        this.records.push({
-            table,
-            action: parsedAction,
-            id: (sys_id as string) || 'unknown',
-            data,
-        })
-    }
-
-    private parseAction(actionStr: string): Action {
-        switch (actionStr) {
-            case 'INSERT_OR_UPDATE':
-                return Action.INSERT_OR_UPDATE
-            case 'DELETE':
-                return Action.DELETE
-            case 'delete_multiple':
-                return Action.DELETE_MULTIPLE
-            default:
-                throw new Error(`Invalid action string: ${actionStr}`)
-        }
-    }
-}
-
-type RecordUpdateXmlJson = {
-    record_update: RecordXmlJson | RecordXmlJson[]
-}
-
-type RecordXmlJson = {
-    [table: string]: {
-        '@_action': string
-        [field: string]: string | undefined | boolean | number
-    }
-}