@servicenow/sdk-build-plugins 2.0.1

package/src/PropertyPlugin.ts

@@ -0,0 +1,218 @@
+import { Property, getRolesString, getRolesArray, roleSchema } from '@servicenow/sdk-core/runtime/app'
+import { Record } from '@servicenow/sdk-core/runtime/db'
+import { PropertyType } from '@servicenow/sdk-core/runtime/tables'
+import {
+    EntityData,
+    FluentDiagnostic,
+    ObjectData,
+    Plugin,
+    extractCallExpression,
+    generateCallExpressionExportForDocument,
+    getCallExpressionName,
+    getOrCreateEntitySourceFile,
+    getSysUpdateName,
+    linkDocument,
+    removeNode,
+    transformFunctionArguments,
+    writePropertyAsReference,
+} from '@servicenow/sdk-build-core'
+import { RecordPlugin } from './db/RecordPlugin'
+import { z } from 'zod'
+import { SyntaxKind, Node } from 'ts-morph'
+import { pickBy } from 'lodash'
+import { Diagnostic } from '@servicenow/sdk-project'
+
+const PropertySchema = z.object({
+    $id: z.string().or(z.number()),
+    name: z.string(),
+    type: PropertyType.or(z.literal('')).default(''),
+    value: z.union([z.string(), z.number(), z.boolean()]).default(''),
+    description: z.string().default(''),
+    ignoreCache: z.boolean().default(false),
+    isPrivate: z.boolean().default(false),
+    choices: z.array(z.string()).default([]),
+    roles: z
+        .record(z.union([z.literal('read'), z.literal('write')]), z.array(z.union([roleSchema, z.string()])).optional())
+        .default({ read: [], write: [] }),
+})
+
+const PropertyConfigSchema = z.object({
+    name: PropertySchema.shape.name,
+    type: z.string().default(''),
+    value: PropertySchema.shape.value.optional(),
+    description: PropertySchema.shape.description,
+    is_private: PropertySchema.shape.isPrivate,
+    ignore_cache: PropertySchema.shape.ignoreCache,
+    read_roles: z.string().optional(),
+    write_roles: z.string().optional(),
+})
+
+export const PropertyDocumentSchema = z.object({
+    table: z.literal('sys_properties'),
+    data: PropertyConfigSchema,
+})
+
+type PropertyConfig = z.output<typeof PropertyConfigSchema>
+
+export const transformProperties = (
+    data: PropertyConfig,
+    xmlRoles: { read_roles: string; write_roles: string }
+): Partial<Property> => {
+    const { read_roles, write_roles, ...rest } = data
+
+    let roles
+    if (read_roles || write_roles) {
+        roles = {
+            ...(xmlRoles.read_roles && { read: getRolesArray(xmlRoles.read_roles) }),
+            ...(xmlRoles.write_roles && { write: getRolesArray(xmlRoles.write_roles) }),
+        }
+    }
+    const result = {
+        name: rest.name,
+        type: rest.type,
+        value: rest.value,
+        description: rest.description,
+        ignoreCache: rest.ignore_cache,
+        isPrivate: rest.is_private,
+        roles: roles,
+    }
+    return pickBy(result, (v) => v !== undefined)
+}
+
+export default Plugin({
+    name: 'Property',
+    ownedTables: {
+        sys_properties: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) => {
+                const result = extractCallExpression(Property, 'property', node, context, (prop) =>
+                    context.registerExplicitId('sys_properties', prop.$id as string)
+                )
+
+                if (!result.handled || !(0 in result.data)) {
+                    return result
+                }
+
+                const propertyData = result.data[0]
+                const diagnostics = result.diagnostics
+                const scope = context.app.config.scope
+                const nameData = propertyData.getProperty('name')
+                const nameNode = nameData.getNode()
+
+                if (!nameData.getValue().startsWith(`${scope}.`)) {
+                    diagnostics.push(new FluentDiagnostic(nameNode, `Property name must begin with '${scope}.'`))
+                }
+
+                return {
+                    handled: true,
+                    diagnostics,
+                    data: [propertyData],
+                }
+            },
+        },
+    },
+    composers: {
+        entity: {
+            property(entity, context) {
+                const scope = context.app.config.scope
+                const property = PropertySchema.safeParse(entity.getValue())
+                if (!property.success) {
+                    return undefined
+                }
+
+                const { $id, name, roles, value, isPrivate, ignoreCache, choices, type, ...rest } = property.data
+
+                const readRoles = roles.read ? getRolesString(roles.read) : ''
+                const writeRoles = roles.write ? getRolesString(roles.write) : ''
+
+                const suffix = name.replace(new RegExp(`^${scope}\\.`), '')
+                const propertyRecord = Record({
+                    table: 'sys_properties',
+                    $id,
+                    data: {
+                        name,
+                        suffix,
+                        ...rest,
+                        ...(type === '' ? {} : { type }),
+                        value: `${value}`, // TODO: Should be allowed to assign non-strings to string columns
+                        is_private: isPrivate,
+                        ignore_cache: ignoreCache,
+                        choices: choices.join('\n'),
+                        read_roles: readRoles,
+                        write_roles: writeRoles,
+                    },
+                })
+
+                return context.composeEntities(
+                    [
+                        new EntityData(
+                            'record',
+                            entity.getGuid(),
+                            ObjectData.fromObjectValue(propertyRecord, entity.getNode()),
+                            entity.getNode()
+                        ),
+                    ],
+                    [RecordPlugin]
+                )
+            },
+        },
+    },
+
+    generators: {
+        record(document, context) {
+            if (!PropertyDocumentSchema.safeParse(document.data).success) {
+                return undefined
+            }
+
+            return linkDocument(
+                document,
+                generateCallExpressionExportForDocument(
+                    context,
+                    {
+                        sourceFile: getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_properties')),
+                        moduleSpecifier: '@servicenow/sdk/core',
+                    },
+                    Property,
+                    { $id: document.guid }
+                ).getExpressionIfKindOrThrow(SyntaxKind.CallExpression)
+            )
+        },
+    },
+    transformers: {
+        record: {
+            CallExpression(document) {
+                if (getCallExpressionName(document.node) !== Property.name) {
+                    return false
+                }
+
+                if (document.action === 'DELETE') {
+                    removeNode(document.node)
+                    return true
+                }
+
+                if (!document.changedData) {
+                    return false
+                }
+                const { read_roles, write_roles } = (document.xmlData as any).data
+                const data = transformProperties(document.changedData!['data'] as PropertyConfig, {
+                    read_roles,
+                    write_roles,
+                })
+
+                const [args] = document.node.getArguments()
+                if (!Node.isObjectLiteralExpression(args)) {
+                    return false
+                }
+                transformFunctionArguments(document.node, Property, data)
+
+                if (data.roles) {
+                    writePropertyAsReference(args, 'roles', '{}', data.roles)
+                }
+
+                return true
+            },
+        },
+    },
+})

package/src/ScriptTemplatePlugin.ts

@@ -0,0 +1,223 @@
+import { Plugin, Context, addDefaultImportIfAbsent, StringData, UndefinedData } from '@servicenow/sdk-build-core'
+import * as ts from 'ts-morph'
+import * as path from 'path'
+import { FileSystem } from '@servicenow/sdk-project'
+import * as os from 'os'
+
+export const UNIQUE_SCRIPT_FILES = 'unique_script_files'
+
+export default Plugin({
+    name: 'scriptTemplate',
+    extractors: {
+        raw: {
+            TaggedTemplateExpression: (node) => {
+                if (node.getTag().getText() !== 'script') {
+                    return { handled: false }
+                }
+
+                const value = getTemplateLiteralValue(node)?.trim()
+
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [typeof value === 'string' ? new StringData(value, node) : new UndefinedData(node)],
+                }
+            },
+
+            ExportAssignment: (node, context) => {
+                const expression = node.getExpression()
+                if (
+                    !expression ||
+                    expression.getKind() !== ts.SyntaxKind.TaggedTemplateExpression ||
+                    expression.asKind(ts.SyntaxKind.TaggedTemplateExpression)!.getTag().getText() !== 'script'
+                ) {
+                    return { handled: false }
+                }
+
+                validateScriptFile(node, context)
+                const value = getTemplateLiteralValue(
+                    node.getExpression().asKind(ts.SyntaxKind.TaggedTemplateExpression)!
+                )
+
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [typeof value === 'string' ? new StringData(value, node) : new UndefinedData(node)],
+                }
+            },
+        },
+    },
+})
+
+function validateScriptFile(node: ts.ExportAssignment, context: Context) {
+    const filePath = path.normalize(node.getSourceFile().getFilePath())
+    const uniqueScriptFiles = (context.store[UNIQUE_SCRIPT_FILES] as Set<string>) ?? new Set<string>()
+    if (uniqueScriptFiles.has(filePath)) {
+        throw Error(
+            `Tagged template script files should be unique per entity but expression in ${filePath.replace(
+                context.app.rootDir,
+                ''
+            )} is referenced in multiple nodes.`
+        )
+    }
+    uniqueScriptFiles.add(filePath)
+    context.store[UNIQUE_SCRIPT_FILES] = uniqueScriptFiles
+}
+
+export function processScript(
+    args: ts.ObjectLiteralExpression,
+    argName: string,
+    script: string,
+    docId: string,
+    tableName: string,
+    context: Context
+) {
+    if (!args.getProperty(argName)) {
+        createNewScriptTemplate(args, argName, script, docId, tableName, context)
+    } else {
+        const prop = args.getProperty(argName)!.asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
+        const kind = prop.getInitializer()?.getKind()
+        if (kind === ts.SyntaxKind.TaggedTemplateExpression) {
+            if (shouldCreateScriptFile(script, context)) {
+                args.getProperty(argName)?.remove()
+                createNewScriptTemplate(args, argName, script, docId, tableName, context)
+            } else {
+                const taggedTempExp = prop.getInitializer()?.asKind(ts.SyntaxKind.TaggedTemplateExpression)
+                updateTaggedTempExpWithScript(taggedTempExp!, script)
+            }
+        } else if (kind === ts.SyntaxKind.Identifier && checkIfItsScriptTemplate(prop)) {
+            const taggedTempExp = getTaggedTemplate(prop)
+            updateTaggedTempExpWithScript(taggedTempExp!, script)
+        } else {
+            args.getProperty(argName)?.remove()
+            createNewScriptTemplate(args, argName, script, docId, tableName, context)
+        }
+    }
+}
+
+function getTemplateLiteralValue(node: ts.TaggedTemplateExpression) {
+    return node?.getTemplate().asKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)?.getLiteralValue()
+}
+
+function shouldCreateScriptFile(script: string, context: Context) {
+    return script.replaceAll(/\r\n/g, '\n').split('\n').length > context.app.config.maxInlineScriptLines
+}
+
+export function formatScript(script: string, spacing: number = 4) {
+    const indent = ' '.repeat(spacing)
+    return script
+        .trim()
+        .replaceAll(/\r\n/g, '\n')
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join(os.EOL)
+        .replaceAll('`', '\\`')
+        .replaceAll('${', '\\${')
+}
+
+function templateScript(script: string) {
+    script = formatScript(script)
+    return `${os.EOL}export default script\`${os.EOL}${script}${os.EOL}\``
+}
+
+function getUniqueScriptModuleName(sourceFile: ts.SourceFile) {
+    let uniqueScriptName = 'genScript0'
+    let i = 1
+    const usedIdentifiers = new Set<string>()
+    sourceFile.getDescendantsOfKind(ts.SyntaxKind.Identifier).forEach((node) => {
+        usedIdentifiers.add(node.getText().trim())
+    })
+    while (usedIdentifiers.has(uniqueScriptName)) {
+        uniqueScriptName = `genScript${i}`
+        i += 1
+    }
+    return uniqueScriptName
+}
+
+function createNewScriptTemplate(
+    args: ts.ObjectLiteralExpression,
+    argName: string,
+    script: string,
+    docId: string,
+    tableName: string,
+    context: Context
+) {
+    if (shouldCreateScriptFile(script, context)) {
+        const { filePath } = createScriptFile(script, `${tableName}_${docId}`, context)
+        const nodeFileDir = path.dirname(path.normalize(args.getSourceFile().getFilePath()))
+        let relativePath = path.relative(nodeFileDir, filePath).split(path.sep).join(path.posix.sep)
+        relativePath = relativePath.replace(path.extname(relativePath), '')
+        relativePath = relativePath.startsWith('.') ? relativePath : `./${relativePath}`
+        const uniqueScriptName = getUniqueScriptModuleName(args.getSourceFile())
+        args.addPropertyAssignment({ name: argName, initializer: uniqueScriptName })
+        addDefaultImportIfAbsent(args.getSourceFile(), relativePath, uniqueScriptName)
+    } else {
+        const prop = args.addPropertyAssignment({ name: argName, initializer: '"place_holder"' })
+        const startPos = prop.getInitializer()!.getStart()
+        const lAndCol = args.getSourceFile().getLineAndColumnAtPos(startPos)
+        script = formatScript(script, lAndCol.column)
+        prop.setInitializer((writer) => {
+            writer.writeLine('script`')
+            writer.write(script)
+            writer.write('`')
+        })
+    }
+}
+
+function updateTaggedTempExpWithScript(node: ts.TaggedTemplateExpression, script: string) {
+    const literal = node!.getTemplate().asKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)!
+    const lAndCol = literal.getSourceFile().getLineAndColumnAtPos(node.getStart())
+    literal.setLiteralValue(`${os.EOL}${formatScript(script, lAndCol.column)}`)
+}
+
+function checkIfItsScriptTemplate(node: ts.PropertyAssignment) {
+    const taggedTemp = getTaggedTemplate(node)
+    if (!taggedTemp) {
+        return false
+    }
+
+    const identifer = taggedTemp.getTag()
+    if (!identifer || identifer.getText() !== 'script') {
+        return false
+    }
+
+    return true
+}
+
+function getTaggedTemplate(node: ts.PropertyAssignment) {
+    const definitions = node.getInitializer()?.asKind(ts.SyntaxKind.Identifier)?.getDefinitions()
+    if (!definitions || definitions.length > 1) {
+        return undefined
+    }
+
+    const exportAssignments = definitions[0]?.getSourceFile().getDescendantsOfKind(ts.SyntaxKind.ExportAssignment)
+    if (!exportAssignments || exportAssignments.length > 1) {
+        return undefined
+    }
+
+    return exportAssignments[0]?.getExpression()?.asKind(ts.SyntaxKind.TaggedTemplateExpression)
+}
+
+const getGeneratedFilePath = (context: Context, fileName: string) => {
+    const resolvedDirPath = path.resolve(context.app.rootDir, context.app.config.generatedDir)
+    return path.join(resolvedDirPath, fileName)
+}
+
+function createScriptFile(script: string, fileName: string, context: Context) {
+    let uniqueFileName = `${fileName}_script.now.ts`
+    let filePath = getGeneratedFilePath(context, uniqueFileName)
+    let i = 0
+    while (FileSystem.existsSync(context.fs, filePath)) {
+        uniqueFileName = `${fileName}_script${i}.now.ts`
+        filePath = getGeneratedFilePath(context, uniqueFileName)
+        i++
+    }
+
+    const directory = path.dirname(filePath)
+    if (!FileSystem.existsSync(context.fs, directory)) {
+        context.fs.mkdirSync(directory, { recursive: true })
+    }
+
+    context.fs.writeFileSync(filePath, templateScript(script), { encoding: 'utf-8' })
+    return { filePath }
+}

package/src/UserPreferencePlugin.ts

@@ -0,0 +1,36 @@
+import { UserPreference, UserPreferenceConfig, UserPreferenceSchema } from '@servicenow/sdk-core/runtime/app'
+import { Plugin } 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(config: UserPreferenceConfig) {
+    const { $id, value, ...rest } = UserPreferenceSchema.parse(config)
+    return Record({
+        table: 'sys_user_preference',
+        $id,
+        data: {
+            ...rest,
+            value: `${value}`, // TODO: Should be allowed to assign non-strings to string columns
+        },
+    })
+}
+
+export default Plugin({
+    name: 'UserPreference',
+    ownedTables: {
+        sys_user_preference: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) =>
+                extractCallExpressionAsRecord(
+                    UserPreference,
+                    asRecord,
+                    (pref) => context.registerExplicitId('sys_user_preference', pref.$id as string),
+                    node,
+                    context
+                ),
+        },
+    },
+})