@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/src/IdPlugin.ts

@@ -1,74 +0,0 @@
-import { isSupportedNode, ts } from '@servicenow/sdk-project'
-import { Plugin, FluentDiagnostic, StringData, Data } from '@servicenow/sdk-build-core'
-
-export default Plugin({
-    name: 'NowID',
-    extractors: {
-        raw: {
-            fluent: {
-                ElementAccessExpression(node, context) {
-                    const nowIdExpression = node.getExpressionIfKind(ts.SyntaxKind.PropertyAccessExpression)
-                    if (!nowIdExpression || nowIdExpression.getText() !== 'Now.ID') {
-                        return {
-                            handled: false,
-                        }
-                    }
-
-                    const argExpression = node.getArgumentExpression()
-                    if (!argExpression || !isSupportedNode(argExpression)) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(node, 'Now.ID must have an argument')],
-                        }
-                    }
-
-                    const result = context.extractRaw(argExpression)
-                    if (!result.handled) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(node, 'Unsupported Now.ID argument')],
-                        }
-                    }
-
-                    if (!result.data) {
-                        return {
-                            handled: true,
-                            diagnostics: [
-                                ...result.diagnostics,
-                                new FluentDiagnostic(node, 'Unsupported Now.ID argument'),
-                            ],
-                        }
-                    }
-
-                    return result
-                },
-                PropertyAccessExpression(node, context) {
-                    if (node.getName() !== '$id') {
-                        return { handled: false }
-                    }
-
-                    const identifier = node.getExpressionIfKind(ts.SyntaxKind.Identifier)
-                    if (!identifier) {
-                        return { handled: false }
-                    }
-
-                    const extraction = context.extractAst(identifier)
-                    if (!extraction.handled) {
-                        return { handled: false }
-                    }
-
-                    const entity = extraction.data
-                    if (!Data.isEntity(entity)) {
-                        return { handled: false }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new StringData(entity.getGuid(), node),
-                    }
-                },
-            },
-        },
-    },
-})

package/src/IncludePlugin.ts

@@ -1,206 +0,0 @@
-import { Compiler, FileSystem, FluentScriptKinds, ts } from '@servicenow/sdk-project'
-import {
-    addCallExpressionToProperty,
-    FluentDiagnostic,
-    getCallExpressionName,
-    Plugin,
-    StringData,
-    getIncludePaths,
-    calculateCustomPathsFromDocs,
-    getOrCreatePropertyAssignment,
-    isNowIncludeCall,
-    Context,
-} from '@servicenow/sdk-build-core'
-import { path } from '@servicenow/sdk-project'
-import { Record } from '@servicenow/sdk-core/runtime/db'
-
-export default Plugin({
-    name: 'Include',
-    extractors: {
-        raw: {
-            fluent: {
-                CallExpression(node, context) {
-                    if (!isNowIncludeCall(node)) {
-                        return { handled: false }
-                    }
-
-                    const args = node.getArguments()
-                    const isStringLiteral = args[0]?.isKind(ts.SyntaxKind.StringLiteral)
-                    if (args[0] && !isStringLiteral) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(args[0]!, 'Invalid argument, String literal expected')],
-                            data: new StringData('', node),
-                        }
-                    }
-
-                    const filePath = args[0]?.asKind(ts.SyntaxKind.StringLiteral)?.getLiteralText()
-                    if (!filePath) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(args[0]!, 'File path cannot be empty')],
-                            data: new StringData('', node),
-                        }
-                    }
-
-                    const thisDir = path.dirname(node.getSourceFile().getFilePath())
-                    const resolvedPath = path.resolve(thisDir, filePath)
-
-                    if (!FileSystem.existsSync(context.fs, resolvedPath)) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(args[0]!, 'File not found')],
-                            data: new StringData('', node),
-                        }
-                    }
-
-                    const rootDir = path.resolve(context.app.rootDir)
-                    const relativePath = path.relative(rootDir, resolvedPath)
-                    if (relativePath.startsWith('..')) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(args[0]!, 'File not within project')],
-                            data: new StringData('', node),
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new StringData(context.fs.readFileSync(resolvedPath).toString(), node, {
-                            needsCDATA: true,
-                        }),
-                    }
-                },
-            },
-        },
-    },
-    transformers: {
-        record: {
-            CallExpression(document, context: Context) {
-                if (document.action === 'DELETE') {
-                    return false
-                }
-
-                const { table } = document.data as any
-
-                const [args] = document.node.getArguments()
-                if (!ts.Node.isObjectLiteralExpression(args)) {
-                    return false
-                }
-
-                if (!document.changedData) {
-                    // If we aren't changing anything, no need to update Now.include
-                    // The root Plugin for the CallExpression should handle this
-                    return false
-                }
-
-                const fluentFilePath = document.node.getSourceFile().getDirectory().getPath()
-                args.getDescendantsOfKind(ts.SyntaxKind.CallExpression)
-                    .filter(isNowIncludeCall)
-                    .map((callExpression) => ({
-                        field: callExpression.getParentIfKind(ts.SyntaxKind.PropertyAssignment)?.getName(),
-                        path: callExpression?.getArguments()[0]?.asKind(ts.SyntaxKind.StringLiteral)?.getLiteralText(),
-                    }))
-                    .filter((includeData) => includeData.field && includeData.path)
-                    .forEach((includeData) => {
-                        const script = (document.changedData as any).data?.[includeData.field!]
-                        if (script) {
-                            const absolutePath = path.resolve(fluentFilePath, includeData.path!)
-                            writeScriptToFile(context.compiler, absolutePath, script)
-                        }
-                    })
-
-                const includePaths = getIncludePaths(context)
-
-                // Only create a Now.include call on an initial fetch for certain tables
-                if (!includePaths[table]) {
-                    return false
-                }
-
-                let propertyObjectLiteral
-                if (getCallExpressionName(document.node) !== Record.name) {
-                    // Treat this as a root level property
-                    propertyObjectLiteral = args
-                } else {
-                    propertyObjectLiteral = getOrCreatePropertyAssignment(
-                        args,
-                        'data',
-                        '{}'
-                    ).getInitializer() as ts.ObjectLiteralExpression
-                }
-
-                const customIncludes =
-                    calculateCustomPathsFromDocs(context)[table]?.find((r) => r.guid === document.guid)?.fields || []
-                const propertyAssignments = getScriptFieldPropertyAssignments(
-                    customIncludes.map((i) => i.field),
-                    propertyObjectLiteral
-                )
-                for (const customInclude of customIncludes) {
-                    const script = (document.changedData as any).data?.[customInclude.field]
-                    if (typeof script !== 'string') {
-                        continue
-                    }
-
-                    if (path.parse(customInclude.path).base !== customInclude.path) {
-                        context.logger.error(
-                            `Custom include name for table ${table} and field ${customInclude.field} must be for filename only. Record ${document.guid}.`
-                        )
-                        continue
-                    }
-
-                    const pa = propertyAssignments[customInclude.field]
-                    if (!pa) {
-                        const scriptFilePath = path.resolve(
-                            context.app.rootDir,
-                            context.app.config.generatedDir,
-                            customInclude.path
-                        )
-
-                        const relativeScriptDir = path.relative(fluentFilePath, scriptFilePath)
-                        addCallExpressionToProperty(
-                            propertyObjectLiteral,
-                            customInclude.field,
-                            `Now.include('${relativeScriptDir}')`
-                        )
-                        writeScriptToFile(context.compiler, scriptFilePath, script)
-                    }
-                }
-
-                return false
-            },
-        },
-    },
-})
-
-function writeScriptToFile(compiler: Compiler, scriptFilePath, script) {
-    const scriptDir = path.parse(scriptFilePath).dir
-    if (!compiler.getDirectory(scriptDir)) {
-        compiler.addDirectoryAtPath(scriptDir, { recursive: true })
-    }
-
-    compiler.createSourceFile(scriptFilePath, script, {
-        overwrite: true,
-        scriptKind: FluentScriptKinds.IncludeFile,
-    } as any)
-}
-
-function getScriptFieldPropertyAssignments(
-    fields: string[],
-    dataObjectLiteral: ts.ObjectLiteralExpression
-): { [field: string]: ts.PropertyAssignment | undefined } {
-    return fields
-        .map((field) => ({
-            [field]: dataObjectLiteral.getProperty(field)?.asKind(ts.SyntaxKind.PropertyAssignment),
-        }))
-        .reduce((acc, field) => ({ ...acc, ...field }), {})
-}
-
-export function fieldHasNowIncludeCallExpression(objectLiteralExpression: ts.ObjectLiteralExpression, field: string) {
-    const callExpression = objectLiteralExpression
-        .getProperty(field)
-        ?.asKind(ts.SyntaxKind.PropertyAssignment)
-        ?.getInitializerIfKind(ts.SyntaxKind.CallExpression)
-
-    return !!callExpression && isNowIncludeCall(callExpression)
-}

package/src/JsonPlugin.ts

@@ -1,76 +0,0 @@
-import { isSupportedNode, ts } from '@servicenow/sdk-project'
-import { Plugin, FluentDiagnostic, Data, StringData } from '@servicenow/sdk-build-core'
-
-export default Plugin({
-    name: 'JSON',
-    extractors: {
-        raw: {
-            json: {
-                SourceFile(node, context) {
-                    const objectLiteral = node
-                        .getFirstChildIfKind(ts.SyntaxKind.SyntaxList)
-                        ?.getFirstChildIfKind(ts.SyntaxKind.ExpressionStatement)
-                        ?.getFirstChildIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-
-                    return objectLiteral ? context.extractAst(objectLiteral) : { handled: false }
-                },
-            },
-            fluent: {
-                CallExpression(node, context) {
-                    const expression = node.getExpressionIfKind(ts.SyntaxKind.PropertyAccessExpression)
-                    if (!expression || expression.getText() !== 'JSON.stringify') {
-                        return {
-                            handled: false,
-                        }
-                    }
-
-                    const argument = node.getArguments()[0]
-                    if (!argument || !isSupportedNode(argument)) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(node, 'JSON.stringify must have an argument')],
-                        }
-                    }
-
-                    const secondArgument = node.getArguments()[1]
-                    if (secondArgument) {
-                        return {
-                            handled: true,
-                            diagnostics: [
-                                new FluentDiagnostic(
-                                    secondArgument,
-                                    'Additional arguments to JSON.stringify are not supported'
-                                ),
-                            ],
-                        }
-                    }
-
-                    const result = context.extractRaw(argument)
-                    if (!result.handled) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(argument, 'Unsupported JSON.stringify argument')],
-                        }
-                    }
-
-                    const data = result.data
-                    if (!Data.isObject(data)) {
-                        return {
-                            handled: true,
-                            diagnostics: [
-                                ...result.diagnostics,
-                                new FluentDiagnostic(argument, 'Unsupported JSON.stringify argument'),
-                            ],
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: result.diagnostics,
-                        data: new StringData(JSON.stringify(data.getValue()), node),
-                    }
-                },
-            },
-        },
-    },
-})