@servicenow/sdk-build-plugins 2.0.1

package/src/AttachmentPlugin.ts

@@ -0,0 +1,262 @@
+import {
+    Plugin,
+    extractCallExpression,
+    generateCallExpression,
+    getSysUpdateName,
+    getCallExpressionName,
+    getOrCreateEntitySourceFile,
+    linkDocument,
+    recordXml,
+    removeNode,
+    transformFunctionArguments,
+    unloadBuilder,
+} from '@servicenow/sdk-build-core'
+import * as zlib from 'node:zlib'
+import * as path from 'path'
+import * as crypto from 'crypto'
+import { RecordXmlSchema } from './db/RecordPlugin'
+import * as z from 'zod'
+import { SysAttachment, SysAttachmentConfig } from '@servicenow/sdk-core/runtime/sys'
+import { SourceFile } from 'ts-morph'
+import { Diagnostic, FileSystem } from '@servicenow/sdk-project'
+
+export const AttachmentPlugin = Plugin({
+    name: 'Attachment',
+    ownedTables: {
+        sys_attachment: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) => {
+                return extractCallExpression(SysAttachment, 'attachment', node, context, (attachment) => attachment.id)
+            },
+        },
+    },
+
+    composers: {
+        entity: {
+            attachment(entity) {
+                return {
+                    kind: 'attachment',
+                    node: entity.getNode(),
+                    guid: entity.getGuid(),
+                    data: entity.getValue() as SysAttachmentConfig,
+                }
+            },
+        },
+
+        xml: {
+            record(xml) {
+                const parseResult = AttachmentXmlSchema.safeParse(xml.data['record_update'])
+                if (!parseResult.success) {
+                    return undefined
+                }
+
+                const { sys_attachment, sys_attachment_doc } = parseResult.data
+
+                const data: AttachmentEntityData = {
+                    attachment: sys_attachment,
+                    attachmentDocs: Array.isArray(sys_attachment_doc) ? sys_attachment_doc : [sys_attachment_doc],
+                }
+
+                return {
+                    action: sys_attachment['@_action'],
+                    kind: 'attachment',
+                    guid: sys_attachment.sys_id,
+                    data,
+                }
+            },
+        },
+    },
+
+    generators: {
+        attachment(document, context) {
+            return linkDocument(
+                document,
+                generateCallExpression(
+                    context,
+                    getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_attachment')),
+                    '@servicenow/sdk/core',
+                    SysAttachment,
+                    {}
+                )
+            )
+        },
+    },
+
+    transformers: {
+        attachment: {
+            CallExpression(document, context) {
+                const expressionName = getCallExpressionName(document.node)
+                if (expressionName !== SysAttachment.name) {
+                    return false
+                }
+
+                if (document.action === 'DELETE') {
+                    removeNode(document.node)
+                    return true
+                }
+
+                if (document.action !== 'INSERT_OR_UPDATE') {
+                    return false
+                }
+
+                const { attachment, attachmentDocs } = document.data as AttachmentEntityData
+
+                transformFunctionArguments(document.node, SysAttachment, {
+                    id: document.guid,
+                    fileName: attachment.file_name,
+                    contentType: attachment.content_type,
+                    filePath: `./${attachment.file_name}`,
+                    tableName: attachment.table_name as SysAttachmentConfig['tableName'],
+                    tableSysId: attachment.table_sys_id,
+                })
+
+                /**
+                 * Attachments are gzip compressed and base64 encoded into multiple sys_attachment_doc chunks
+                 * Rebuild the archive and decompress it to disk
+                 */
+
+                const dataBuffer = Buffer.alloc(attachment.size_compressed)
+
+                let position = 0
+
+                attachmentDocs
+                    .sort((a, b) => a.position - b.position)
+                    .forEach((doc) => {
+                        position += dataBuffer.write(doc.data, position, 'base64')
+                    })
+
+                const filePath = getSourceFileDirectory(document.node.getSourceFile())
+
+                if (!FileSystem.existsSync(context.fs, filePath)) {
+                    context.fs.mkdirSync(filePath, { recursive: true })
+                }
+
+                context.fs.writeFileSync(path.join(filePath, attachment.file_name), zlib.gunzipSync(dataBuffer), {
+                    encoding: 'binary',
+                })
+
+                return true
+            },
+        },
+    },
+
+    serializers: {
+        attachment(document, context) {
+            /**
+             <unload>
+                <sys_attachment/>
+                <sys_attachment_doc/>
+                <sys_attachment_doc/>
+             </unload>
+             */
+            const data = document.data as SysAttachmentConfig
+
+            const xmlBuilder = unloadBuilder(context)
+
+            const CHUNK_SIZE = 4 * 1024
+
+            const attachmentEle = recordXml(xmlBuilder.xml, 'sys_attachment', document.guid)
+            attachmentEle.addSysScope(context)
+            attachmentEle.fields({
+                compressed: true,
+                content_type: data.contentType,
+                file_name: data.fileName,
+                table_name: data.tableName,
+                table_sys_id: data.tableSysId,
+                chunk_size: CHUNK_SIZE,
+            })
+
+            const directoryPath = getSourceFileDirectory(document.node!.getSourceFile())
+            const contentFilePath = path.join(directoryPath, data.filePath)
+            if (!FileSystem.existsSync(context.fs, contentFilePath)) {
+                throw new Error(`Attachment file not found for attachment ${document.guid}: ${contentFilePath}`)
+            }
+
+            // Compress the file with gzip, then break into chuncks and base64 encode for each sys_attachment_doc
+            const hash = crypto.createHash('md5')
+
+            const contents = context.fs.readFileSync(contentFilePath, { flag: 'r' })
+
+            attachmentEle.field('size_bites', contents.length)
+
+            const zipEncoded = zlib.gzipSync(contents)
+            attachmentEle.field('size_compressed', zipEncoded.length)
+
+            hash.update(zipEncoded)
+            attachmentEle.field('hash', hash.digest('hex'))
+
+            const dataArray = Uint8Array.from(zipEncoded)
+
+            let position = 0
+            let readOffset = position * CHUNK_SIZE
+            while (readOffset < dataArray.length) {
+                const dataChunk = dataArray.slice(readOffset, readOffset + CHUNK_SIZE)
+
+                const dataChunkBase64 = Buffer.from(dataChunk).toString('base64')
+                const attachmentDoc = recordXml(
+                    xmlBuilder.xml,
+                    'sys_attachment_doc',
+                    context.keys.registerCompositeId('sys_attachment_doc', {
+                        attachment: document.guid,
+                        data: dataChunkBase64,
+                    })
+                )
+
+                attachmentDoc.fields({
+                    data: dataChunkBase64,
+                    length: dataChunkBase64.length,
+                    position,
+                    sys_attachment: document.guid,
+                })
+
+                position++
+
+                readOffset = position * CHUNK_SIZE
+            }
+
+            return {
+                name: `sys_attachment_${document.guid}.xml`,
+                directory: 'update',
+                content: xmlBuilder.end(),
+            }
+        },
+    },
+})
+
+function getSourceFileDirectory(sourceFile: SourceFile): string {
+    const parsedPath = path.parse(path.normalize(sourceFile.getFilePath()))
+    return parsedPath.dir
+}
+
+const TextStringSchema = z.object({ '#text': z.string() }).transform((val) => val['#text'])
+const TextIntSchema = z.object({ '#text': z.number() }).transform((val) => val['#text'])
+
+const SysAttachmentSchema = RecordXmlSchema.extend({
+    sys_id: TextStringSchema,
+    content_type: TextStringSchema,
+    file_name: TextStringSchema,
+    hash: TextStringSchema,
+    table_name: TextStringSchema,
+    table_sys_id: TextStringSchema,
+    size_bytes: TextIntSchema,
+    size_compressed: TextIntSchema,
+})
+
+const SysAttachmentDocSchema = RecordXmlSchema.extend({
+    data: TextStringSchema,
+    length: TextIntSchema,
+    position: TextIntSchema,
+    sys_attachment: TextStringSchema,
+})
+
+const AttachmentXmlSchema = z.object({
+    sys_attachment: SysAttachmentSchema,
+    sys_attachment_doc: z.union([z.array(SysAttachmentDocSchema), SysAttachmentDocSchema]),
+})
+
+type AttachmentEntityData = {
+    attachment: z.infer<typeof SysAttachmentSchema>
+    attachmentDocs: Array<z.infer<typeof SysAttachmentDocSchema>>
+}

package/src/BusinessRulePlugin.ts

@@ -0,0 +1,251 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+    BusinessRule,
+    BusinessRuleSchemaInc,
+    getRolesString,
+    getRolesArray,
+    BusinessRuleSchema,
+} from '@servicenow/sdk-core/runtime/app'
+import {
+    Plugin,
+    generateCallExpressionExportForDocument,
+    getSysUpdateName,
+    getCallExpressionName,
+    getOrCreateEntitySourceFile,
+    linkDocument,
+    removeNode,
+    stringify,
+    transformFunctionArguments,
+    writeArrayPropertyAsReference,
+    writeCustomProperty,
+    getOrCreatePropertyAssignment,
+    EntityData,
+    ObjectData,
+} from '@servicenow/sdk-build-core'
+import { processScript } from './ScriptTemplatePlugin'
+import { scriptInfo, type ScriptInfo, buildScriptImport } from './scripts/scriptUtils'
+import { extractCallExpressionAsRecord } from './db/RecordPlugin'
+import { merge } from 'lodash'
+import { SyntaxKind, Node } from 'ts-morph'
+import * as z from 'zod'
+import { Diagnostic } from '@servicenow/sdk-project'
+import { Record, TableName } from '@servicenow/sdk-core/runtime/db'
+
+function businessRuleAsRecord<const T extends TableName>(config: BusinessRule<T>) {
+    const br = BusinessRuleSchema.parse(config)
+    return Record({
+        $id: br.$id,
+        table: 'sys_script',
+        data: {
+            name: br.name,
+            collection: br.table,
+            script: br.script,
+            order: br.order ?? 100,
+            action_insert: br?.action?.includes('insert') ?? false,
+            action_update: br?.action?.includes('update') ?? false,
+            action_query: br?.action?.includes('query') ?? false,
+            action_delete: br?.action?.includes('delete') ?? false,
+            active: br.active ?? true,
+            when: br.when ?? 'before',
+            message: br.message!,
+            add_message: br.add_message ?? br.message ? true : false,
+            condition: br.condition,
+            filter_condition: br.filter_condition,
+            template: br.set_field_value,
+            description: br.description,
+        },
+    })
+}
+
+export default Plugin({
+    name: 'BusinessRule',
+    ownedTables: {
+        sys_script: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression(node, context) {
+                const result = extractCallExpressionAsRecord(
+                    BusinessRule,
+                    businessRuleAsRecord,
+                    (br) => context.registerExplicitId('sys_script', br.$id as string),
+                    node,
+                    context
+                )
+
+                if (!result.handled || !(0 in result.data)) {
+                    return result
+                }
+
+                const record = result.data[0]
+                const recordData = record.getProperty('data').getValue()
+                const scriptData = recordData.script as unknown as ScriptInfo
+                const role_conditions = recordData.role_conditions as unknown as any[]
+                let scriptVal: string
+                if (scriptData && scriptData.filePath) {
+                    const { filePath, functionName, isDefault } = scriptData
+                    scriptVal = buildScriptImport(
+                        filePath,
+                        functionName,
+                        isDefault,
+                        context,
+                        (funcName: string) => `${funcName}(current, previous)\n`
+                    )
+                } else {
+                    scriptVal = recordData.script as unknown as string
+                }
+
+                return {
+                    handled: true,
+                    diagnostics: result.diagnostics,
+                    data: [
+                        new EntityData(
+                            record.getKind(),
+                            record.getGuid(),
+                            ObjectData.fromObjectValue(
+                                merge(record.getValue(), {
+                                    data: {
+                                        script: scriptVal,
+                                        role_conditions: role_conditions ? getRolesString(role_conditions) : '',
+                                    },
+                                }),
+                                record.getNode()
+                            ),
+                            record.getNode()
+                        ),
+                    ],
+                }
+            },
+        },
+        raw: {
+            FunctionDeclaration(node, context) {
+                const info = scriptInfo(node, context, BusinessRule.name)
+                if (!info) {
+                    return { handled: false }
+                }
+
+                return { handled: true, diagnostics: [], data: [info] }
+            },
+
+            FunctionExpression(node, context) {
+                const info = scriptInfo(node, context, BusinessRule.name)
+                if (!info) {
+                    return { handled: false }
+                }
+
+                return { handled: true, diagnostics: [], data: [info] }
+            },
+        },
+    },
+    generators: {
+        record(document, context) {
+            if (!BusinessRuleSchemaInc.safeParse(document.data!['data']).success) {
+                return undefined
+            }
+
+            return linkDocument(
+                document,
+                generateCallExpressionExportForDocument(
+                    context,
+                    {
+                        sourceFile: getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_script')),
+                        moduleSpecifier: '@servicenow/sdk/core',
+                    },
+                    BusinessRule,
+                    { $id: document.guid }
+                ).getExpressionIfKindOrThrow(SyntaxKind.CallExpression)
+            )
+        },
+    },
+    transformers: {
+        record: {
+            CallExpression(document, context) {
+                if (getCallExpressionName(document.node) !== BusinessRule.name) {
+                    return false
+                }
+
+                if (document.action === 'DELETE') {
+                    removeNode(document.node)
+                    return true
+                }
+
+                const modified_properties = BusinessRuleSchemaInc.deepPartial().safeParse(
+                    (document.changedData as any).data
+                )
+                const merged_properties = BusinessRuleSchemaInc.safeParse((document.data as any).data)
+                const incoming_properties = BusinessRuleSchemaInc.safeParse((document.xmlData as any).data)
+                if (!modified_properties.success || !merged_properties.success || !incoming_properties.success) {
+                    return false
+                }
+
+                const [args] = document.node.getArguments()
+                if (!Node.isObjectLiteralExpression(args)) {
+                    return false
+                }
+                const {
+                    role_conditions: roles,
+                    filter_condition: filters,
+                    collection,
+                    script,
+                    template,
+                    action_delete,
+                    action_insert,
+                    action_query,
+                    action_update,
+                    ...rest
+                } = modified_properties.data
+
+                const xml_actions = getActionsArray(incoming_properties.data)
+                if (xml_actions.length > 0 || getActionsArray(merged_properties.data).length > 0) {
+                    writeCustomProperty(args, 'action', '[]', stringify(xml_actions))
+                } else {
+                    const actionsProp = getOrCreatePropertyAssignment(args, 'action', '[]')
+                    actionsProp.remove()
+                }
+
+                if (roles) {
+                    writeArrayPropertyAsReference(args, 'role_conditions', '[]', getRolesArray(roles))
+                }
+
+                if (filters) {
+                    writeCustomProperty(args, 'filter_condition', '', `\`${filters}\``)
+                }
+
+                if (script !== undefined) {
+                    processScript(args, 'script', script, document.guid, 'sys_script', context)
+                }
+
+                if (template) {
+                    writeCustomProperty(args, 'set_field_value', '', stringify(template))
+                }
+
+                const reqSchema = BusinessRuleSchemaInc.required()
+                const result = transformFunctionArguments(document.node, BusinessRule, {
+                    table: collection,
+                    ...(rest as Partial<z.infer<typeof reqSchema>>),
+                })
+                return result
+            },
+        },
+    },
+})
+
+function getActionsArray(data) {
+    const actions: BR_ACTIONS[] = []
+    if (data.action_update) {
+        actions.push('update')
+    }
+    if (data.action_delete) {
+        actions.push('delete')
+    }
+    if (data.action_insert) {
+        actions.push('insert')
+    }
+    if (data.action_query) {
+        actions.push('query')
+    }
+
+    return actions
+}
+
+type BR_ACTIONS = 'insert' | 'update' | 'delete' | 'query'

package/src/CrossScopePrivilegePlugin.ts

@@ -0,0 +1,54 @@
+import { CrossScopePrivilege, CrossScopePrivilegeSchema } from '@servicenow/sdk-core/runtime/app'
+import { EntityData, extractCallExpression, ObjectData, Plugin } from '@servicenow/sdk-build-core'
+import { RecordPlugin } from './db/RecordPlugin'
+import { Diagnostic } from '@servicenow/sdk-project'
+import { Record } from '@servicenow/sdk-core/runtime/db'
+
+export default Plugin({
+    name: 'CrossScopePrivilege',
+    ownedTables: {
+        sys_scope_privilege: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) =>
+                extractCallExpression(CrossScopePrivilege, 'sys_scope_privilege', node, context, (privilege) =>
+                    context.registerExplicitId('sys_scope_privilege', privilege.$id as string)
+                ),
+        },
+    },
+    composers: {
+        entity: {
+            sys_scope_privilege(entity, context) {
+                const scopeId = context.app.config.scopeId
+                const privilege = CrossScopePrivilegeSchema.safeParse(entity.getValue())
+                if (!privilege.success) {
+                    return undefined
+                }
+
+                const { $id, ...rest } = privilege.data
+
+                const privilegeRecord = Record({
+                    table: 'sys_scope_privilege',
+                    $id,
+                    data: {
+                        source_scope: scopeId,
+                        ...rest,
+                    },
+                })
+
+                return context.composeEntities(
+                    [
+                        new EntityData(
+                            'record',
+                            entity.getGuid(),
+                            ObjectData.fromObjectValue(privilegeRecord, entity.getNode()),
+                            entity.getNode()
+                        ),
+                    ],
+                    [RecordPlugin]
+                )
+            },
+        },
+    },
+})