@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/BusinessRulePlugin.ts

@@ -1,238 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import {
-    BusinessRule,
-    BusinessRuleSchema,
-    BusinessRuleSchemaInc,
-    getRolesArray,
-    localWhenSchemaTransformer,
-} from '@servicenow/sdk-core/runtime/app'
-import {
-    Plugin,
-    generateCallExpressionExportForDocument,
-    getSysUpdateName,
-    getCallExpressionName,
-    getOrCreateEntitySourceFile,
-    linkDocument,
-    removeNode,
-    stringify,
-    transformFunctionArguments,
-    writeArrayPropertyAsReference,
-    writeCustomProperty,
-    getOrCreatePropertyAssignment,
-    EntityData,
-    ObjectData,
-    StringData,
-    NumberData,
-    BooleanData,
-    Data,
-    UndefinedData,
-    transformCustomizedProperties,
-} from '@servicenow/sdk-build-core'
-import { additionalProperties } from '@servicenow/sdk-core/runtime/util'
-import { processScript } from './ScriptTemplatePlugin'
-import { extractCallExpressionAsRecord } from './db/RecordPlugin'
-import * as z from 'zod'
-import { Diagnostic, ts } from '@servicenow/sdk-project'
-import { Record, TableName } from '@servicenow/sdk-core/runtime/db'
-import { getRolesString } from './aclAndRole/RolePlugin'
-import { ModuleFunctionData } from './ServerModulePlugin'
-
-// Similar to lodash's groupBy, but simply stores the last element of each group
-function groupByExistence<T>(collection: T[] | undefined, keyProvider: (element: T) => string): { [key: string]: T } {
-    return (
-        collection?.reduce((groups, e) => {
-            groups[keyProvider(e)] = e
-            return groups
-        }, {}) ?? {}
-    )
-}
-
-function businessRuleAsRecord<const T extends TableName>(entity: EntityData<BusinessRule<T>>): ObjectData<Record> {
-    const node = entity.getNode()
-    const br = entity.getProperties()
-    const rest = additionalProperties(br, BusinessRuleSchema)
-
-    const scriptData = br.script
-    const script = new StringData(
-        ModuleFunctionData.getGlueCode(scriptData, (n) => `${n}(current, previous)`),
-        scriptData?.getNode() ?? node
-    )
-
-    const roleConditionsData = br.role_conditions
-    const roleConditions = new StringData(
-        roleConditionsData && Data.isArray(roleConditionsData) ? getRolesString(roleConditionsData) : '',
-        roleConditionsData?.getNode() ?? node
-    )
-
-    const { insertAction, updateAction, deleteAction, queryAction } = groupByExistence(
-        entity.getProperty('action', 'array')?.getElements(),
-        (action) => `${action.getValue()}Action`
-    )
-
-    const when = new StringData(localWhenSchemaTransformer(br.when.getValue()), br.when.getNode())
-
-    return new ObjectData(
-        {
-            $id: br.$id,
-            table: new StringData('sys_script', node),
-            data: new ObjectData(
-                {
-                    ...rest,
-                    name: br.name,
-                    collection: br.table,
-                    script,
-                    order: br.order ?? new NumberData(100, node),
-                    action_insert: new BooleanData(!!insertAction, insertAction?.getNode() ?? node),
-                    action_update: new BooleanData(!!updateAction, updateAction?.getNode() ?? node),
-                    action_query: new BooleanData(!!queryAction, queryAction?.getNode() ?? node),
-                    action_delete: new BooleanData(!!deleteAction, deleteAction?.getNode() ?? node),
-                    active: br.active ?? new BooleanData(true, node),
-                    when: br.when ? when : new StringData('before', node),
-                    message: br.message ?? new UndefinedData(node),
-                    add_message: br.add_message ?? new BooleanData(br.message ? true : false, node),
-                    condition: br.condition ?? new UndefinedData(node),
-                    filter_condition: br.filter_condition ?? new UndefinedData(node),
-                    template: br.set_field_value ?? new UndefinedData(node),
-                    description: br.description ?? new UndefinedData(node),
-                    role_conditions: roleConditions,
-                },
-                node
-            ),
-        },
-        node
-    )
-}
-
-export default Plugin({
-    name: 'BusinessRule',
-    ownedTables: {
-        sys_script: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression(node, context) {
-                    return extractCallExpressionAsRecord(
-                        BusinessRule,
-                        businessRuleAsRecord,
-                        (br) => context.registerExplicitId('sys_script', br.$id as string),
-                        node,
-                        context
-                    )
-                },
-            },
-        },
-    },
-    generators: {
-        record(document, context) {
-            const tableName = document.data!['table']
-            if (tableName !== 'sys_script') {
-                return undefined
-            }
-
-            return linkDocument(
-                document,
-                generateCallExpressionExportForDocument(
-                    context,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_script')),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                    },
-                    BusinessRule,
-                    { $id: document.guid }
-                ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-    },
-    transformers: {
-        record: {
-            CallExpression(document) {
-                if (getCallExpressionName(document.node) !== BusinessRule.name) {
-                    return false
-                }
-
-                if (document.action === 'DELETE') {
-                    removeNode(document.node)
-                    return true
-                }
-
-                const changedData = (document.changedData as any).data
-                const modified_properties = BusinessRuleSchemaInc.deepPartial().safeParse(changedData)
-                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 (!ts.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)
-                }
-
-                if (template) {
-                    writeCustomProperty(args, 'set_field_value', '', stringify(template))
-                }
-
-                const reqSchema = BusinessRuleSchemaInc.required()
-                transformCustomizedProperties(BusinessRule, document.node, changedData, modified_properties.data)
-                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

@@ -1,115 +0,0 @@
-import { CrossScopePrivilege, CrossScopePrivilegeSchema } from '@servicenow/sdk-core/runtime/app'
-import {
-    EntityData,
-    extractCallExpression,
-    generateCallExpressionExportForDocument,
-    getCallExpressionName,
-    getOrCreateEntitySourceFile,
-    getSysUpdateName,
-    linkDocument,
-    ObjectData,
-    Plugin,
-    removeNode,
-    transformFunctionArguments,
-} from '@servicenow/sdk-build-core'
-import { RecordPlugin } from './db/RecordPlugin'
-import { Diagnostic, ts } from '@servicenow/sdk-project'
-import { Record } from '@servicenow/sdk-core/runtime/db'
-import { except } from './scripts/scriptUtils'
-import z from 'zod'
-
-export default Plugin({
-    name: 'CrossScopePrivilege',
-    ownedTables: {
-        sys_scope_privilege: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            fluent: {
-                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.and(z.any()).safeParse(entity.getValue())
-                if (!privilege.success) {
-                    return Promise.resolve(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(),
-                            entity.getInstallMethod()
-                        ),
-                    ],
-                    [RecordPlugin]
-                )
-            },
-        },
-    },
-    generators: {
-        record(document, ctx) {
-            const tableName = document.data!['table']
-            if (tableName !== 'sys_scope_privilege') {
-                return undefined
-            }
-
-            return linkDocument(
-                document,
-                generateCallExpressionExportForDocument(
-                    ctx,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(ctx, getSysUpdateName(document, 'sys_scope_privilege')),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                    },
-                    CrossScopePrivilege,
-                    { $id: document.guid }
-                ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-    },
-
-    transformers: {
-        record: {
-            CallExpression(document) {
-                if (getCallExpressionName(document.node) !== CrossScopePrivilege.name) {
-                    return false
-                }
-
-                if (document.action === 'DELETE') {
-                    removeNode(document.node)
-                    return true
-                }
-
-                if (!document.changedData) {
-                    return false
-                }
-
-                const crossScopeData = (document.changedData as any).data
-                const cleanedData = except(crossScopeData, (key) => key.startsWith('sys_') || key === 'source_scope')
-                return transformFunctionArguments(document.node, CrossScopePrivilege, cleanedData)
-            },
-        },
-    },
-})

package/src/DefaultPlugin.ts

@@ -1,288 +0,0 @@
-import { isSupportedNode } from '@servicenow/sdk-project'
-import {
-    getValueDeclaration,
-    Plugin,
-    BooleanData,
-    FluentDiagnostic,
-    StringData,
-    NumberData,
-    Data,
-    ArrayData,
-    ObjectData,
-    getDirectiveDiagnostics,
-} from '@servicenow/sdk-build-core'
-import { ts } from '@servicenow/sdk-project'
-
-export default Plugin({
-    name: 'Default',
-    extractors: {
-        raw: {
-            any: {
-                TrueKeyword(node) {
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new BooleanData(true, node),
-                    }
-                },
-
-                FalseKeyword(node) {
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new BooleanData(false, node),
-                    }
-                },
-
-                StringLiteral(node) {
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new StringData(node.getLiteralValue(), node),
-                    }
-                },
-
-                NoSubstitutionTemplateLiteral(node) {
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new StringData(node.getLiteralValue(), node),
-                    }
-                },
-
-                NumericLiteral(node) {
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new NumberData(node.getLiteralValue(), node),
-                    }
-                },
-
-                AsExpression(node, context) {
-                    return context.extractAst(node.getExpression())
-                },
-
-                ExportAssignment(node, context) {
-                    return context.extractAst(node.getExpression())
-                },
-
-                ComputedPropertyName(node, context) {
-                    return context.extractAst(node.getExpression())
-                },
-
-                Identifier(node, context) {
-                    const extracted = context.extractAst(getValueDeclaration(node))
-
-                    const newDiagnostics: FluentDiagnostic[] = []
-                    if (extracted['diagnostics']) {
-                        extracted['diagnostics'].forEach((diagnostic) => {
-                            newDiagnostics.push(new FluentDiagnostic(node, diagnostic.message))
-                        })
-                    }
-                    return {
-                        handled: extracted.handled,
-                        data: extracted['data'],
-                        diagnostics: newDiagnostics,
-                    }
-                },
-
-                PropertyAccessExpression(node, context) {
-                    return context.extractAst(node.getNameNode())
-                },
-
-                ShorthandPropertyAssignment(node, context) {
-                    return context.extractAst(node.getNameNode())
-                },
-
-                VariableDeclaration(node, context) {
-                    const initializer = node.getInitializer()
-                    if (!initializer) {
-                        return {
-                            handled: true,
-                            diagnostics: [
-                                new FluentDiagnostic(
-                                    node,
-                                    `Expected variable declaration to have an initializer: ${node.getText()}`
-                                ),
-                            ],
-                        }
-                    }
-
-                    return context.extractAst(initializer)
-                },
-
-                PropertyAssignment(node, context) {
-                    const initializer = node.getInitializer()
-                    if (!initializer) {
-                        return {
-                            handled: true,
-                            diagnostics: [
-                                new FluentDiagnostic(
-                                    node,
-                                    `Expected property assignment to have an initializer: ${node.getText()}`
-                                ),
-                            ],
-                        }
-                    }
-
-                    return context.extractAst(initializer)
-                },
-
-                ArrayLiteralExpression(node, context) {
-                    const diagnostics: FluentDiagnostic[] = []
-                    const data: Data[] = []
-
-                    for (const element of node.getElements()) {
-                        const result = context.extractAst(element)
-                        if (!result.handled) {
-                            return {
-                                handled: true,
-                                diagnostics: [new FluentDiagnostic(element, 'Unsupported array element')],
-                            }
-                        }
-
-                        diagnostics.push(...result.diagnostics)
-                        if (result.data) {
-                            data.push(result.data)
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: new ArrayData(data, node),
-                    }
-                },
-
-                ObjectLiteralExpression(node, context) {
-                    const diagnostics: FluentDiagnostic[] = []
-                    const data: Record<string, Data> = {}
-
-                    for (const prop of node.getProperties()) {
-                        if (!ts.Node.isPropertyAssignment(prop) && !ts.Node.isShorthandPropertyAssignment(prop)) {
-                            diagnostics.push(new FluentDiagnostic(prop, 'Only property assignments are allowed'))
-                            continue
-                        }
-
-                        const nameNode = prop.getNameNode()
-                        const result = context.extractAst(prop)
-                        if (!result.handled) {
-                            return {
-                                handled: true,
-                                diagnostics: [new FluentDiagnostic(prop, 'Unsupported property assignment')],
-                            }
-                        }
-
-                        diagnostics.push(...result.diagnostics)
-                        if (!result.data) {
-                            diagnostics.push(
-                                new FluentDiagnostic(nameNode, `Property assignment has unsupported structure`)
-                            )
-                            continue
-                        }
-
-                        const name = ts.Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName()
-                        data[name] = result.data
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: new ObjectData(data, node),
-                    }
-                },
-
-                TemplateExpression(node, context) {
-                    const diagnostics: FluentDiagnostic[] = []
-                    const text =
-                        node.getHead().getLiteralText() +
-                        node
-                            .getTemplateSpans()
-                            .map((s) => {
-                                const result = context.extractAst(s.getExpression())
-                                if (!result.handled) {
-                                    diagnostics.push(new FluentDiagnostic(s, 'Unsupported expression in template'))
-                                    return undefined
-                                }
-
-                                if (!result.data) {
-                                    diagnostics.push(new FluentDiagnostic(s, `Unsupported expression in template`))
-                                    return undefined
-                                }
-
-                                diagnostics.push(...result.diagnostics)
-                                return `${result.data.getValue()}${s.getLiteral().getLiteralText()}`
-                            })
-                            .join('')
-
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: new StringData(text, node),
-                    }
-                },
-
-                //Added support for -ve number alone. Can be upgraded later to support other expressions as required.
-                PrefixUnaryExpression(node) {
-                    if (
-                        !ts.Node.isNumericLiteral(node.getOperand()) ||
-                        node.getOperatorToken() !== ts.SyntaxKind.MinusToken
-                    ) {
-                        return {
-                            handled: true,
-                            diagnostics: [new FluentDiagnostic(node, 'Unsupported prefix unary expression')],
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new NumberData(
-                            -node.getOperand().asKind(ts.SyntaxKind.NumericLiteral)!.getLiteralValue(),
-                            node
-                        ),
-                    }
-                },
-            },
-        },
-    },
-    diagnostics: {
-        Node(node) {
-            if (isSupportedNode(node)) {
-                return getDirectiveDiagnostics(node)
-            }
-
-            return [new FluentDiagnostic(node, `${getRawKindName(node)} is not allowed`)]
-        },
-    },
-})
-
-let rawKindNames: Record<ts.SyntaxKind, string> | undefined
-
-/**
- * This is a hack to get more accurate names for given syntax kinds. TypeScript's
- * `SyntaxKind` enum has a lot of reused numeric values, so when you try to index
- * it with a number, you might get a different name than you expect. For example,
- * `VariableStatement` and `FirstStatement` both have the same numeric value, and
- * you probably never would expect the latter. Thankfully, all the names that you
- * probably never want are towards the end, so this just grabs all the first ones
- * and ignores any duplicates that come after.
- */
-function getRawKindName(node: ts.Node): string | undefined {
-    if (!rawKindNames) {
-        rawKindNames = Object.entries(ts.SyntaxKind)
-            .filter(([k]) => isNaN(Number(k)))
-            .reduce(
-                (names, [name, value]) => {
-                    if (typeof value === 'number' && !names[value]) {
-                        names[value] = name // Only add if it hasn't been added already
-                    }
-
-                    return names
-                },
-                {} as Record<ts.SyntaxKind, string>
-            )
-    }
-
-    return rawKindNames[node.getKind()]
-}

package/src/HtmlTemplatePlugin.ts

@@ -1,31 +0,0 @@
-import { Plugin, StringData, UndefinedData } from '@servicenow/sdk-build-core'
-import { ts } from '@servicenow/sdk-project'
-
-const TEMPLATE_LITERAL_TAG = 'html'
-
-export default Plugin({
-    name: 'htmlTemplate',
-    extractors: {
-        raw: {
-            fluent: {
-                TaggedTemplateExpression: (node) => {
-                    if (node.getTag().getText() !== TEMPLATE_LITERAL_TAG) {
-                        return { handled: false }
-                    }
-
-                    const value = getTemplateLiteralValue(node)?.trim()
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: typeof value === 'string' ? new StringData(value, node) : new UndefinedData(node),
-                    }
-                },
-            },
-        },
-    },
-})
-
-function getTemplateLiteralValue(node: ts.TaggedTemplateExpression) {
-    return node?.getTemplate().asKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)?.getLiteralValue()
-}