@servicenow/sdk-build-plugins 2.0.1

package/src/aclAndRole/Util.ts

@@ -0,0 +1,104 @@
+import { isEqual } from 'lodash'
+import * as ts from 'ts-morph'
+import {
+    Document,
+    Context,
+    getNodeId,
+    getOrCreatePropertyAssignment,
+    ArrayIterator,
+    stringify,
+} from '@servicenow/sdk-build-core'
+
+const getElementKey = (element: ts.Expression) => {
+    if (element.isKind(ts.SyntaxKind.StringLiteral)) {
+        return element.getLiteralValue()
+    }
+    const varDec = (element.getSymbol()?.getValueDeclaration() ??
+        element.getSymbol()?.getAliasedSymbol()?.getValueDeclaration()) as ts.VariableDeclaration
+    return varDec
+        ? getNodeId(
+              varDec.getInitializerIfKind(ts.SyntaxKind.CallExpression)?.getArguments()[0] as ts.ObjectLiteralExpression
+          )!
+        : ''
+}
+
+export function addObjectToArrayById(document: Document, name: string, roleId: string, context: Context) {
+    const arg = document.node?.asKind(ts.SyntaxKind.CallExpression)?.getArguments()[0] as ts.ObjectLiteralExpression
+    const table = document.data!['table']
+    const argId = getNodeId(arg)
+    const propertyAssignment = getOrCreatePropertyAssignment(arg, name, '[]')
+
+    let handled = false
+    const rolesIterator = new ArrayIterator(propertyAssignment)
+    const primaryKey = table === 'sys_security_acl_role' ? 'sys_security_acl' : 'role'
+    const secondKey = table === 'sys_security_acl_role' ? 'sys_user_role' : 'contains'
+    while (rolesIterator.hasNext()) {
+        const element = rolesIterator.next()
+        const secKey = getElementKey(element)
+
+        const foundIdx = context.keys.composite.findIndex((k) =>
+            isEqual(k.key, {
+                [primaryKey]: argId,
+                [secondKey]: secKey,
+            })
+        )
+        if (foundIdx !== -1 && context.keys.composite[foundIdx]?.id === document.guid) {
+            if (context.keys.explicit[secKey]?.id === roleId || secKey === roleId) {
+                return
+            }
+            element?.replaceWithText(stringify(roleId))
+            context.keys.composite.splice(foundIdx, 1)
+            handled = true
+        }
+    }
+
+    if (!handled) {
+        const stringValue = stringify(roleId)
+        rolesIterator.getExpression().addElement(stringValue)
+    }
+    context.keys.registerCompositeId(
+        table,
+        {
+            [primaryKey]: argId!,
+            [secondKey]: roleId,
+        },
+        document.guid
+    )
+}
+
+export function removeObjectFromArrayById(document: Document, name: string, context: Context) {
+    const arg = document.node?.asKind(ts.SyntaxKind.CallExpression)?.getArguments()[0] as ts.ObjectLiteralExpression
+    const table = document.data!['table']
+    const argId = getNodeId(arg)
+    const property = arg.getProperty(name)
+    if (!property) {
+        return
+    }
+
+    const propertyAssignment = property.asKind(ts.ts.SyntaxKind.PropertyAssignment)
+    if (!propertyAssignment) {
+        return
+    }
+
+    const rolesIterator = new ArrayIterator(propertyAssignment)
+    while (rolesIterator.hasNext()) {
+        const element = rolesIterator.next()
+        const secKey = getElementKey(element)
+        const primaryKey = table === 'sys_security_acl_role' ? 'sys_security_acl' : 'role'
+        const secondKey = table === 'sys_security_acl_role' ? 'sys_user_role' : 'contains'
+        const foundIdx = context.keys.composite.findIndex((k) =>
+            isEqual(k.key, {
+                [primaryKey]: argId,
+                [secondKey]: secKey,
+            })
+        )
+        if (foundIdx !== -1 && context.keys.composite[foundIdx]?.id === document.guid) {
+            rolesIterator.getExpression().removeElement(element)
+        }
+
+        if (!element.wasForgotten() && element.asKind(ts.SyntaxKind.Identifier) && !element.getSymbol()) {
+            //remove if the identifier doesn't have symbol, happens when the identifier declaration is removed prior to this
+            rolesIterator.getExpression().removeElement(element)
+        }
+    }
+}

package/src/app/ApplicationMenuPlugin.ts

@@ -0,0 +1,158 @@
+import { z } from 'zod'
+import { Node, SyntaxKind } from 'ts-morph'
+import { ApplicationMenu, ApplicationMenuSchema, getRolesString, getRolesArray } from '@servicenow/sdk-core/runtime/app'
+import {
+    Plugin,
+    extractCallExpression,
+    generateCallExpressionExportForDocument,
+    getSysUpdateName,
+    getCallExpressionName,
+    getOrCreateEntitySourceFile,
+    linkDocument,
+    removeNode,
+    transformFunctionArguments,
+    writeArrayPropertyAsReference,
+    writePropertyAsReference,
+    EntityData,
+    ObjectData,
+} from '@servicenow/sdk-build-core'
+import { RecordPlugin } from '../db/RecordPlugin'
+import { Record } from '@servicenow/sdk-core/runtime/db'
+import { Diagnostic } from '@servicenow/sdk-project'
+
+type AppMenuDocumentSchema = z.output<typeof AppMenuDocumentSchema>
+
+const AppMenuDocumentSchema = z.object({
+    table: z.literal('sys_app_application'),
+    data: ApplicationMenuSchema.omit({ roles: true, category: true, $id: true }).extend({
+        roles: z.string().optional(),
+        category: z.string().optional(),
+        device_type: z.string().optional(),
+        view_name: z.string().optional(),
+    }),
+})
+
+const AppMenuDocumentTransformer = AppMenuDocumentSchema.transform(
+    ({ data: data }): Partial<typeof ApplicationMenuSchema> => {
+        const { roles, category, device_type, view_name, ...rest } = data
+
+        return {
+            ...rest,
+        }
+    }
+)
+
+export default Plugin({
+    name: 'ApplicationMenu',
+    ownedTables: {
+        sys_app_application: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    extractors: {
+        entity: {
+            CallExpression: (node, context) =>
+                extractCallExpression(ApplicationMenu, 'appMenu', node, context, (menu) =>
+                    context.registerExplicitId('sys_app_application', menu.$id as string)
+                ),
+        },
+    },
+    composers: {
+        entity: {
+            appMenu(entity, context) {
+                const appMenuData = ApplicationMenuSchema.safeParse(entity.getValue())
+                if (!appMenuData.success) {
+                    return undefined
+                }
+                const { $id, roles, category, ...props } = appMenuData.data
+                const rolesString = roles ? getRolesString(roles) : ''
+
+                const recordEntity = Record({
+                    $id,
+                    table: 'sys_app_application',
+                    data: {
+                        ...props,
+                        roles: rolesString,
+                        category: (category as string) ?? '',
+                        device_type: 'browser',
+                        view_name: '',
+                    },
+                })
+                return context.composeEntities(
+                    [
+                        new EntityData(
+                            'record',
+                            entity.getGuid(),
+                            ObjectData.fromObjectValue(recordEntity, entity.getNode()),
+                            entity.getNode()
+                        ),
+                    ],
+                    [RecordPlugin]
+                )
+            },
+        },
+    },
+
+    generators: {
+        record(document, context) {
+            if (!AppMenuDocumentSchema.safeParse(document.data).success) {
+                return undefined
+            }
+
+            return linkDocument(
+                document,
+                generateCallExpressionExportForDocument(
+                    context,
+                    {
+                        sourceFile: getOrCreateEntitySourceFile(
+                            context,
+                            getSysUpdateName(document, 'sys_app_application')
+                        ),
+                        moduleSpecifier: '@servicenow/sdk/core',
+                    },
+                    ApplicationMenu,
+                    { $id: document.guid }
+                ).getExpressionIfKindOrThrow(SyntaxKind.CallExpression)
+            )
+        },
+    },
+    transformers: {
+        record: {
+            CallExpression(document) {
+                if (getCallExpressionName(document.node) !== ApplicationMenu.name) {
+                    return false
+                }
+
+                if (document.action === 'DELETE') {
+                    removeNode(document.node)
+                    return true
+                }
+                if (!document.changedData) {
+                    return false
+                }
+                const menu = AppMenuDocumentTransformer.safeParse(document.data)
+                if (!menu.success) {
+                    return false
+                }
+                const { roles, category } = (document.xmlData as AppMenuDocumentSchema).data
+                const [args] = document.node.getArguments()
+                if (!Node.isObjectLiteralExpression(args)) {
+                    return false
+                }
+
+                if (roles) {
+                    writeArrayPropertyAsReference(args, 'roles', '[]', getRolesArray(roles))
+                }
+                if (category) {
+                    writePropertyAsReference(args, 'category', '{}', category)
+                }
+
+                const {
+                    roles: _roles,
+                    category: _category,
+                    device_type: _device_type,
+                    ...data
+                } = (AppMenuDocumentSchema.deepPartial().parse(document.changedData) as AppMenuDocumentSchema).data
+                return transformFunctionArguments(document.node, ApplicationMenu, data as any)
+            },
+        },
+    },
+})