@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/src/ServerModulePlugin.ts

@@ -1,480 +0,0 @@
-import {
-    BooleanData,
-    Context,
-    Data,
-    EntityData,
-    ExtractionResult,
-    FluentDiagnostic,
-    LinkedDocument,
-    ObjectData,
-    Plugin,
-    StringData,
-    sanitizeNestedCdataTags,
-} from '@servicenow/sdk-build-core'
-import {
-    Diagnostic,
-    FileSystem,
-    TsMorphFileSystemWrapper,
-    TypeScriptDiagnostic,
-    path,
-    path as pathModule,
-    ts,
-    SupportedNode,
-} from '@servicenow/sdk-project'
-
-import type { DependencyNode } from '@servicenow/sdk-repack'
-
-type DependencyData = {
-    name: string
-    version: string
-    file: string
-    fileContent: string
-}
-
-export class ModuleEntityData extends EntityData {
-    constructor(path: string, content: string, node: SupportedNode, context: Context) {
-        const { scope } = context.app.config
-        const { name: packageName, version } = context.app.package
-        const relativePath = pathModule.relative(context.app.rootDir, path)
-
-        // Module resolution at runtime requires this format
-        const modulePath = pathModule.join(scope, packageName, version, relativePath)
-
-        super(
-            'module',
-            context.registerExplicitId('sys_module', relativePath.replaceAll(/[./\\]/g, '_')),
-            new ObjectData(
-                {
-                    path: new StringData(modulePath, node),
-                    content: new StringData(content, node),
-                },
-                node
-            ),
-            node
-        )
-    }
-}
-
-export class ModuleFunctionData extends ObjectData<{ exportName: string; modulePath: string; isDefault: boolean }> {
-    constructor(name: string, module: ModuleEntityData, node: ts.FunctionDeclaration | ts.VariableDeclaration) {
-        super(
-            {
-                exportName: new StringData(name, node),
-                modulePath: new StringData(module.getPropertyOrThrow('path', 'string').getValue(), node),
-                isDefault: new BooleanData(node.isDefaultExport(), node),
-            },
-            node
-        )
-    }
-
-    getGlueCode(callExpressionProvider: (functionName: string) => string): string {
-        return ModuleFunctionData.getGlueCode(this, callExpressionProvider)
-    }
-
-    static getGlueCode(
-        scriptData: Data | ReturnType<ModuleFunctionData['getValue']> | undefined,
-        callExpressionProvider: (functionName: string) => string
-    ): string {
-        if (Data.isString(scriptData)) {
-            return scriptData.getValue()
-        } else if (!scriptData) {
-            return ''
-        }
-
-        scriptData = scriptData instanceof ModuleFunctionData ? scriptData.getValue() : scriptData
-        if (scriptData instanceof Data) {
-            throw new Error(`Unsupported script data type: ${scriptData.getNode().getText()}`)
-        }
-
-        const { exportName, modulePath, isDefault } = scriptData
-        return isDefault
-            ? `const ${exportName} = require('${modulePath}').default;\n${callExpressionProvider(exportName)};`
-            : `const { ${exportName} } = require('${modulePath}');\n${callExpressionProvider(exportName)};`
-    }
-}
-
-function applyModulePathMappings(path: string, context: Context) {
-    const { modulePaths } = context.app.config
-    if (!modulePaths) {
-        return path
-    }
-    const relativePath = pathModule.relative(context.app.rootDir, path)
-
-    // TODO: Naive implementation for now that just supports simple patterns. We can explore supporting more complex patterns later.
-    for (const [source, target] of Object.entries(modulePaths)) {
-        const match = relativePath.match(`${source.replace(/\./, '\\.').replace(/\*+/, '(.*)')}$`)?.[1]
-        if (match !== undefined) {
-            return pathModule.join(context.app.rootDir, target.replace(/\*+/, match))
-        }
-    }
-
-    return path
-}
-
-/**
- * Removes invalid control characters that would cause XML parsing errors.
- * Regex taken from: https://github.com/oozcitak/xmlbuilder-js/blob/b20136cd1591d0f17ab2f184053c7150150428b2/src/XMLStringifier.coffee#L119C15-L119C127
- */
-function removeInvalidControlCharacters(content: string): string {
-    return content.replace(
-        // eslint-disable-next-line no-control-regex
-        /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/g,
-        ''
-    )
-}
-
-function sanitizeModuleContent(content: string): string {
-    return sanitizeNestedCdataTags(removeInvalidControlCharacters(content))
-}
-
-function extractFunctionDeclaration(
-    node: ts.FunctionDeclaration | ts.VariableDeclaration,
-    context: Context
-): ExtractionResult<ModuleFunctionData> {
-    const result = context.extractEntities(node.getSourceFile())
-
-    if (!result.handled) {
-        const path = node.getSourceFile().getFilePath()
-        const dir = `${context.app.config.tsconfigPath ? 'tsconfig.rootDir' : 'serverModulesDir'}`
-        return {
-            handled: true,
-            diagnostics: [
-                new FluentDiagnostic(
-                    node,
-                    `File ${path} is not under ${dir}. ${dir} is expected to contain all source files.`
-                ),
-            ],
-            data: new ModuleFunctionData('name', new ModuleEntityData('', '', node, context), node),
-        }
-    }
-
-    const module = result.data
-    if (!(module instanceof ModuleEntityData)) {
-        return { handled: false }
-    }
-
-    const name = node.getName() ?? 'functionModule'
-    if (!name) {
-        return {
-            handled: true,
-            diagnostics: [new FluentDiagnostic(node, 'Function declaration must have a name')],
-        }
-    }
-
-    return {
-        handled: true,
-        diagnostics: [],
-        data: new ModuleFunctionData(name, module, node),
-    }
-}
-
-function getEmitOutput(file: ts.SourceFile, fs: FileSystem, context: Context): string | Diagnostic[] {
-    const path = file.getFilePath()
-    if (!path.endsWith('.ts')) {
-        return file.getFullText()
-    }
-
-    let project
-    let sourceFile
-    if (context.app.config.tsconfigPath) {
-        project = new ts.Project({
-            fileSystem: new TsMorphFileSystemWrapper(fs),
-            tsConfigFilePath: pathModule.join(context.app.rootDir, context.app.config.tsconfigPath),
-        })
-        sourceFile = project.getSourceFile(path)
-        if (!sourceFile) {
-            return [new FluentDiagnostic(file, `Failed to get emit output for module: ${path}`)]
-        }
-    } else {
-        project = new ts.Project({
-            fileSystem: new TsMorphFileSystemWrapper(fs),
-            compilerOptions: {
-                target: ts.ScriptTarget.ES2022,
-                module: ts.ModuleKind.ES2022,
-                declaration: false,
-                sourceMap: false,
-            },
-        })
-        sourceFile = project.createSourceFile('module.ts', file.getFullText(), {
-            overwrite: true,
-            scriptKind: ts.ScriptKind.TS,
-        })
-    }
-
-    const emitResult = sourceFile.getEmitOutput()
-
-    const diagnostics = emitResult
-        .getDiagnostics()
-        .map((d) => new TypeScriptDiagnostic(d))
-        .filter((d) => d.level === Diagnostic.Level.Error)
-
-    if (diagnostics.length > 0) {
-        return diagnostics
-    }
-
-    const output = emitResult.getOutputFiles()[0]
-    if (!output) {
-        return [new FluentDiagnostic(file, `Failed to get emit output for module: ${path}`)]
-    }
-
-    return output.getText()
-}
-
-function isValidRequireCall(callExpression: ts.CallExpression, requirePath: ts.StringLiteral): boolean {
-    const expression = callExpression.getExpression()
-    const isRequire = ts.Node.isIdentifier(expression) && expression.getText() === 'require'
-    const isRelativePath =
-        requirePath.getLiteralText().startsWith('../') || requirePath.getLiteralText().startsWith('./')
-    return isRequire && !isRelativePath
-}
-
-const dependencyIgnoreList = ['@servicenow/glide', '@servicenow/sdk']
-function ignoreDependency(name: string): boolean {
-    return dependencyIgnoreList.some((dependency) => name.startsWith(dependency))
-}
-
-function isKeysFile(path, context): boolean {
-    return path === context.getKeysSourceFile().getFilePath()
-}
-
-function validateAndGetModuleSpecifier(name: string): { name: string; entry?: string } {
-    const scopedRegex = /@[a-z\d][\w\-.]+\/[a-z\d][\w\-.]*/gi
-    scopedRegex.test(name)
-    const idx = scopedRegex.lastIndex
-
-    const isSubPathImport = name.indexOf('/', idx)
-    if (isSubPathImport > 0) {
-        return { name: name.slice(0, isSubPathImport), entry: name.slice(isSubPathImport + 1) }
-    }
-    return { name }
-}
-
-function extractDependency(
-    node: ts.ImportDeclaration | ts.ExportDeclaration | ts.CallExpression,
-    context: Context
-): ExtractionResult<EntityData<{ name: string; version: string; [entry: string]: string }>> {
-    const path = node.getSourceFile().getFilePath()
-    if (isKeysFile(path, context)) {
-        return { handled: false }
-    }
-
-    let moduleName: string | undefined
-    if (ts.Node.isImportDeclaration(node) && !node.isModuleSpecifierRelative()) {
-        moduleName = node.getModuleSpecifierValue()
-    }
-    if (ts.Node.isExportDeclaration(node) && node.hasModuleSpecifier() && !node.isModuleSpecifierRelative()) {
-        moduleName = node.getModuleSpecifierValue()
-    }
-
-    if (ts.Node.isCallExpression(node)) {
-        const args = node.getArguments()
-        const requirePath = args[0]
-        if (!ts.Node.isStringLiteral(requirePath) || !isValidRequireCall(node, requirePath)) {
-            return { handled: false }
-        }
-
-        moduleName = requirePath.getLiteralValue()
-    }
-
-    if (!moduleName || ignoreDependency(moduleName)) {
-        return { handled: false }
-    }
-    const dependencies = context.app.package.dependencies ?? {}
-    const { name, entry } = validateAndGetModuleSpecifier(moduleName)
-
-    if (!(name in dependencies)) {
-        return {
-            handled: true,
-            diagnostics: [new FluentDiagnostic(node, `Dependency ${name} is not found in package.json`)],
-        }
-    }
-    const entryPoint = entry ?? '.'
-    const entityData = new EntityData(
-        'dependency',
-        name,
-        new ObjectData(
-            {
-                name: new StringData(name, node),
-                [entryPoint]: new StringData(entryPoint, node),
-                version: new StringData(dependencies[name]!, node),
-            },
-            node
-        ),
-        node
-    )
-
-    return {
-        handled: true,
-        diagnostics: [],
-        data: entityData,
-    }
-}
-
-export default Plugin({
-    name: 'ServerModule',
-    extractors: {
-        raw: {
-            module: {
-                FunctionDeclaration: extractFunctionDeclaration,
-                FunctionExpression(node, context) {
-                    const parent = node.getParentIfKind(ts.SyntaxKind.VariableDeclaration)
-                    if (!parent) {
-                        return { handled: false }
-                    }
-
-                    return extractFunctionDeclaration(parent, context)
-                },
-            },
-        },
-        entity: {
-            module: {
-                SourceFile(file, context) {
-                    const path = file.getFilePath()
-                    if (isKeysFile(path, context)) {
-                        return { handled: false }
-                    }
-
-                    const mappedPath = applyModulePathMappings(path, context)
-                    const mappedFile =
-                        context.compiler.getSourceFile(mappedPath) ??
-                        context.compiler.addSourceFileAtPathIfExists(mappedPath)
-
-                    if (!mappedFile) {
-                        context.logger.debug(
-                            `Module path was mapped from '${path}' to '${mappedPath}' but no file exists at the mapped location.`
-                        )
-                        return { handled: false }
-                    }
-
-                    const content = getEmitOutput(mappedFile, context.fs, context)
-                    if (Array.isArray(content)) {
-                        return {
-                            handled: false,
-                            diagnostics: content,
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new ModuleEntityData(mappedPath, content, file, context),
-                    }
-                },
-                ImportDeclaration: extractDependency,
-                ExportDeclaration: extractDependency,
-                CallExpression: extractDependency,
-            },
-        },
-    },
-    composers: {
-        entity: {
-            module(module) {
-                if (module.getProperty('path', 'string')?.getValue().endsWith('package.json')) {
-                    return Promise.resolve(undefined)
-                }
-
-                return Promise.resolve({
-                    kind: 'module',
-                    guid: module.getGuid(),
-                    node: module.getNode(),
-                    data: module.getValue(),
-                })
-            },
-            async dependency(module, context) {
-                const { Lint } = await import('./repack/lint/index.js')
-                const { RepackService } = await import('./repack/index.js')
-                const { name, version, ...entry } = module.getProperties()
-
-                const id = `${name?.getValue()}@${version?.getValue()}`
-                const repack = await RepackService.create(context.logger, context.fs, context.app.rootDir)
-                const buildResult = await repack.execute({
-                    id,
-                    entry: Object.keys(entry),
-                })
-                if (!buildResult) {
-                    throw new Error(`Failed to build dependency ${id}`)
-                }
-
-                const builtEntities: LinkedDocument[] = []
-
-                for (const currentDep of buildResult) {
-                    const { packagePath, files, updatedManifest } = currentDep as DependencyNode
-                    const { name, version } = updatedManifest
-                    const currentId = `${name}@${version}`
-
-                    for (const file of files) {
-                        const guid = context.registerCompositeId('sys_module', {
-                            module: currentId,
-                            file: file,
-                        })
-                        const lint = new Lint()
-                        const fileExt = path.extname(file)
-                        const fileContent = context.fs.readFileSync(path.join(packagePath, file)).toString('utf-8')
-                        if (/(.js|.cjs|.mjs)$/.test(fileExt)) {
-                            const result = await lint.check(fileContent)
-
-                            if (result) {
-                                context.logger.warn(`Use of unsupported APIs detected in npm dependency ${name}`)
-                                context.logger.warn(result)
-                            }
-                        }
-
-                        builtEntities.push({
-                            kind: 'dependency',
-                            guid: guid,
-                            node: module.getNode(),
-                            data: {
-                                name,
-                                version,
-                                packagePath,
-                                file,
-                                fileContent,
-                            },
-                        })
-                    }
-                }
-
-                return builtEntities
-            },
-        },
-    },
-    serializers: {
-        module(module, context) {
-            const { path, content } = module.data as any
-
-            return {
-                name: `sys_module_${module.guid}.xml`,
-                directory: 'update',
-                content: `<?xml version="1.0"?>
-<record_update>
-  <sys_module action="INSERT_OR_UPDATE">
-    <sys_scope>${context.app.config.scopeId}</sys_scope>
-    <sys_id>${module.guid}</sys_id>
-    <path>${path}</path>
-    <external_source>false</external_source>
-    <content><![CDATA[${sanitizeModuleContent(content)}]]></content>
-  </sys_module>
-</record_update>`,
-            }
-        },
-        dependency(module, context) {
-            const { name, version, file, fileContent } = module.data as DependencyData
-            const modulePath = path.join(context.app.config.scope, name, version, file)
-
-            return {
-                name: `sys_module_${module.guid}.xml`,
-                directory: 'update',
-                content: `<?xml version="1.0"?>
-<record_update>
-<sys_module action="INSERT_OR_UPDATE">
-<sys_scope>${context.app.config.scopeId}</sys_scope>
-<sys_id>${module.guid}</sys_id>
-<path>${modulePath}</path>
-<external_source>true</external_source>
-<content><![CDATA[${sanitizeModuleContent(fileContent)}]]></content>
-</sys_module>
-</record_update>`,
-            }
-        },
-    },
-})

package/src/UserPreferencePlugin.ts

@@ -1,45 +0,0 @@
-import { UserPreference, UserPreferenceConfig } from '@servicenow/sdk-core/runtime/app'
-import { EntityData, ObjectData, Plugin, StringData } from '@servicenow/sdk-build-core'
-import { extractCallExpressionAsRecord } from './db/RecordPlugin'
-import { Diagnostic } from '@servicenow/sdk-project'
-import { Record } from '@servicenow/sdk-core/runtime/db'
-
-function asRecord(entity: EntityData<UserPreferenceConfig>): ObjectData<Record> {
-    const node = entity.getNode()
-    const { $id, value, ...rest } = entity.getProperties()
-    return new ObjectData(
-        {
-            table: new StringData('sys_user_preference', node),
-            $id,
-            data: new ObjectData(
-                {
-                    ...rest,
-                    value: new StringData(value.getValue().toString(), value.getNode()),
-                },
-                node
-            ),
-        },
-        node
-    )
-}
-
-export default Plugin({
-    name: 'UserPreference',
-    ownedTables: {
-        sys_user_preference: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression: (node, context) =>
-                    extractCallExpressionAsRecord(
-                        UserPreference,
-                        asRecord,
-                        (pref) => context.registerExplicitId('sys_user_preference', pref.$id as string),
-                        node,
-                        context
-                    ),
-            },
-        },
-    },
-})