@servicenow/sdk-build-plugins 2.0.1 → 2.1.1

package/src/aclAndRole/RolePlugin.ts

@@ -6,11 +6,12 @@ import {
     extractCallExpression,
     FluentDiagnostic,
     findObjectPropertyValue,
-    EntityData,
-    ObjectData,
     Data,
+    isSNScope,
+    LinkedDocument,
+    ArrayData,
+    fixFunctionArgumentTypes,
 } from '@servicenow/sdk-build-core'
-import { Record } from '@servicenow/sdk-core/runtime/db'
 import {
     generateCallExpressionExportForDocument,
     getOrCreateEntitySourceFile,
@@ -21,22 +22,39 @@ import {
 import { addObjectToArrayById, removeObjectFromArrayById } from './Util'
 import { SyntaxKind, Node } from 'ts-morph'
 import { except } from '../scripts/scriptUtils'
-import { RecordPlugin } from '../db/RecordPlugin'
-import { Diagnostic } from '@servicenow/sdk-project'
+import { Diagnostic, SupportedNode } from '@servicenow/sdk-project'
+
+export function getRolesString(roles: ArrayData<unknown[]>): string {
+    const uniqueRoles = [
+        ...new Set(
+            roles.getElements().map((role) => {
+                return Data.isEntity(role) ? role.getPropertyOrThrow('name', 'string').getValue() : role.getValue()
+            })
+        ),
+    ]
+
+    return uniqueRoles.join(',')
+}
 
-function mapRoleToRole(context, roleId, containedRoleId) {
-    const m2mId = context.keys.registerCompositeId('sys_user_role_contains', {
+function mapRoleToRole(context: Context, roleId: string, containedRoleId: string, node: SupportedNode): LinkedDocument {
+    const mappingId = context.keys.registerCompositeId('sys_user_role_contains', {
         role: roleId,
         contains: containedRoleId,
     })
-    return Record({
-        table: 'sys_user_role_contains',
-        $id: m2mId,
+
+    return {
+        kind: 'record',
+        guid: mappingId,
+        node,
         data: {
-            contains: containedRoleId,
-            role: roleId,
+            $id: mappingId,
+            table: 'sys_user_role_contains',
+            data: {
+                contains: containedRoleId,
+                role: roleId,
+            },
         },
-    })
+    }
 }
 
 type RoleDoc = {
@@ -61,33 +79,35 @@ export default Plugin({
     },
     extractors: {
         entity: {
-            CallExpression: (node, context) => {
-                const result = extractCallExpression(
-                    Role as (role: RoleConfig) => RoleConfig,
-                    'role',
-                    node,
-                    context,
-                    ({ $id }) => context.registerExplicitId('sys_user_role', $id as string)
-                )
-
-                if (!result.handled || !(0 in result.data)) {
-                    return result
-                }
+            fluent: {
+                CallExpression: (node, context) => {
+                    const result = extractCallExpression(
+                        Role as (role: RoleConfig) => RoleConfig,
+                        'role',
+                        node,
+                        context,
+                        ({ $id }) => context.registerExplicitId('sys_user_role', $id as string)
+                    )
+
+                    if (!result.handled || !(0 in result.data)) {
+                        return result
+                    }
 
-                const role = result.data[0]
-                const diagnostics = result.diagnostics
-                const scope = context.app?.config?.scope
-                const name = role.getProperty('name').getValue()
-                if (!name.startsWith(`${scope}.`)) {
-                    const nameValue = findObjectPropertyValue(node, 'name')
-                    diagnostics.push(new FluentDiagnostic(nameValue, `Role name must begin with '${scope}.'`))
-                }
+                    const role = result.data[0]
+                    const diagnostics = result.diagnostics
+                    const scope = context.app?.config?.scope
+                    const name = role.getProperty('name').getValue()
+                    if (!isSNScope(scope) && !name.startsWith(`${scope}.`)) {
+                        const nameValue = findObjectPropertyValue(node, 'name')
+                        diagnostics.push(new FluentDiagnostic(nameValue, `Role name must begin with '${scope}.'`))
+                    }
 
-                return {
-                    handled: true,
-                    diagnostics,
-                    data: [role],
-                }
+                    return {
+                        handled: true,
+                        diagnostics,
+                        data: [role],
+                    }
+                },
             },
         },
     },
@@ -96,7 +116,6 @@ export default Plugin({
             role(entity, context) {
                 const scope = context.app?.config?.scope
                 const guid = entity.getGuid()
-                const node = entity.getNode()
 
                 const role = roleSchema.safeParse(entity.getValue())
                 if (!role.success) {
@@ -105,36 +124,43 @@ export default Plugin({
 
                 const { $id: _, name, contains_roles, ...rest } = role.data
 
-                const roleToRoles: Record<'sys_user_role_contains'>[] = []
+                const roleMappingDocuments: LinkedDocument[] = []
                 const containsRoles = entity.getProperty('contains_roles')
                 if (Data.isArray(containsRoles)) {
                     for (const containedRole of containsRoles.getElements()) {
                         const containedRoleSysId = Data.isEntity(containedRole)
                             ? containedRole.getGuid()
-                            : containedRole.getValue() // Should be a string
+                            : Data.isString(containedRole)
+                              ? containedRole.getValue()
+                              : undefined
 
-                        roleToRoles.push(mapRoleToRole(context, guid, containedRoleSysId))
+                        if (!containedRoleSysId) {
+                            throw new Error(`Invalid contained role value: ${containedRole.getValue()}`)
+                        }
+
+                        roleMappingDocuments.push(
+                            mapRoleToRole(context, guid, containedRoleSysId, containedRole.getNode())
+                        )
                     }
                 }
 
                 const suffix = name.replace(new RegExp(`^${scope}\\.`), '')
-
-                const roleRecord = Record({
-                    table: 'sys_user_role',
-                    $id: guid,
+                const roleDocument = {
+                    kind: 'record',
+                    guid,
+                    node: entity.getNode(),
                     data: {
-                        name,
-                        suffix,
-                        ...rest,
+                        $id: guid,
+                        table: 'sys_user_role',
+                        data: {
+                            name,
+                            suffix,
+                            ...rest,
+                        },
                     },
-                })
+                }
 
-                return context.composeEntities(
-                    [roleRecord, ...roleToRoles].map(
-                        (r) => new EntityData('record', r.$id.toString(), ObjectData.fromObjectValue(r, node), node)
-                    ),
-                    [RecordPlugin]
-                )
+                return [roleDocument, ...roleMappingDocuments]
             },
         },
     },
@@ -217,8 +243,9 @@ export default Plugin({
                         key === 'suffix' ||
                         key === 'includes_roles'
                 )
-
-                return transformFunctionArguments(document.node, Role, roleData)
+                transformFunctionArguments(document.node, Role, roleData)
+                fixFunctionArgumentTypes(context, document.node)
+                return true
             },
         },
     },

package/src/app/ApplicationMenuPlugin.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { Node, SyntaxKind } from 'ts-morph'
-import { ApplicationMenu, ApplicationMenuSchema, getRolesString, getRolesArray } from '@servicenow/sdk-core/runtime/app'
+import { ApplicationMenu, ApplicationMenuSchema, getRolesArray } from '@servicenow/sdk-core/runtime/app'
 import {
     Plugin,
     extractCallExpression,
@@ -19,6 +19,7 @@ import {
 import { RecordPlugin } from '../db/RecordPlugin'
 import { Record } from '@servicenow/sdk-core/runtime/db'
 import { Diagnostic } from '@servicenow/sdk-project'
+import { getRolesString } from '../aclAndRole/RolePlugin'
 
 type AppMenuDocumentSchema = z.output<typeof AppMenuDocumentSchema>
 
@@ -26,9 +27,9 @@ 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(),
+        category: z.coerce.string().optional(),
+        device_type: z.coerce.string().optional(),
+        view_name: z.coerce.string().optional(),
     }),
 })
 
@@ -49,10 +50,12 @@ export default Plugin({
     },
     extractors: {
         entity: {
-            CallExpression: (node, context) =>
-                extractCallExpression(ApplicationMenu, 'appMenu', node, context, (menu) =>
-                    context.registerExplicitId('sys_app_application', menu.$id as string)
-                ),
+            fluent: {
+                CallExpression: (node, context) =>
+                    extractCallExpression(ApplicationMenu, 'appMenu', node, context, (menu) =>
+                        context.registerExplicitId('sys_app_application', menu.$id as string)
+                    ),
+            },
         },
     },
     composers: {
@@ -62,7 +65,8 @@ export default Plugin({
                 if (!appMenuData.success) {
                     return undefined
                 }
-                const { $id, roles, category, ...props } = appMenuData.data
+                const { $id, category, ...props } = appMenuData.data
+                const roles = entity.getProperty('roles', 'array')
                 const rolesString = roles ? getRolesString(roles) : ''
 
                 const recordEntity = Record({
@@ -93,10 +97,10 @@ export default Plugin({
 
     generators: {
         record(document, context) {
-            if (!AppMenuDocumentSchema.safeParse(document.data).success) {
+            const tableName = document.data!['table']
+            if (tableName !== 'sys_app_application') {
                 return undefined
             }
-
             return linkDocument(
                 document,
                 generateCallExpressionExportForDocument(

package/src/atf/ATFComposer.ts

@@ -1,6 +1,6 @@
 import { Data, Record, TableName } from '@servicenow/sdk-core/runtime/db'
 import type { Role } from '@servicenow/sdk-core/runtime/app'
-import { StepConfig, Variables } from '@servicenow/sdk-core/runtime/tables'
+import { StepConfig, Variables } from '@servicenow/sdk-core/runtime/fluent'
 import { Context, InputObject } from '@servicenow/sdk-build-core'
 import * as atf from '@servicenow/sdk-core/runtime/atf'
 

package/src/atf/TestPlugin.ts

@@ -18,19 +18,21 @@ export default Plugin({
     name: 'Test',
     extractors: {
         entity: {
-            CallExpression: (node: CallExpression, context: Context) => {
-                // This constructs an entity of kind 'test' and returns it. This entity is then parsed by the composer
-                const configExtractor = new ConfigurationFunctionExtractor(node, context, ATF)
-                const result = configExtractor.extractConfigFunction('test', context.logger)
-                if (!result) {
-                    return { handled: false }
-                }
+            fluent: {
+                CallExpression: (node: CallExpression, context: Context) => {
+                    // This constructs an entity of kind 'test' and returns it. This entity is then parsed by the composer
+                    const configExtractor = new ConfigurationFunctionExtractor(node, context, ATF)
+                    const result = configExtractor.extractConfigFunction('test', context.logger)
+                    if (!result) {
+                        return { handled: false }
+                    }
 
-                return {
-                    handled: true,
-                    diagnostics: [],
-                    data: [result],
-                }
+                    return {
+                        handled: true,
+                        diagnostics: [],
+                        data: [result],
+                    }
+                },
             },
         },
     },

package/src/db/ColumnPlugins.ts

@@ -1,5 +1,6 @@
 import * as db from '@servicenow/sdk-core/runtime/db'
-import { EntityData, FluentDiagnostic, ObjectData, Plugin, extractCallExpression } from '@servicenow/sdk-build-core'
+import { FluentDiagnostic, ObjectData, Plugin, extractCallExpression } from '@servicenow/sdk-build-core'
+import { getLabelDiagnostics } from './DBUtils'
 
 const validFunctions = [
     'add',
@@ -28,42 +29,41 @@ function ColumnPlugin<
     return Plugin({
         name: `${entityKind}Column`,
         extractors: {
-            entity: {
-                CallExpression(node, context) {
-                    const result = extractCallExpression(
-                        fn,
-                        `${entityKind}Column`,
-                        node,
-                        context,
-                        () => 'NO_GUID_GENERATED' // TODO: We shouldn't need to generate any GUID here but maybe should provide something unique to be on the safe side
-                    )
-                    if (!result.handled || !(0 in result.data)) {
-                        return result
-                    }
+            raw: {
+                fluent: {
+                    CallExpression(node, context) {
+                        const result = extractCallExpression(
+                            fn,
+                            `${entityKind}Column`,
+                            node,
+                            context,
+                            () => 'NO_GUID_GENERATED' // TODO: We shouldn't need to generate any GUID here but maybe should provide something unique to be on the safe side
+                        )
+                        if (!result.handled || !(0 in result.data)) {
+                            return result
+                        }
 
-                    const entity = result.data[0]
-                    const diagnostics = result.diagnostics
-                    const functionDefinition = entity.getProperty('function_definition')?.getValue()
-                    if (functionDefinition) {
-                        if (typeof functionDefinition !== 'string' || !functionDefinition.match(regExp)) {
-                            diagnostics.push(
-                                new FluentDiagnostic(
-                                    node,
-                                    `'function_definition' must start with 'glidefunction:' and include a single function call to a predefined function:\n${validFunctions.join(
-                                        '\n'
-                                    )}`
+                        const entity = result.data[0]
+                        const diagnostics = result.diagnostics
+                        diagnostics.push(...getLabelDiagnostics(entity))
+                        const functionDefinition = entity.getProperty('function_definition')?.getValue()
+                        if (functionDefinition) {
+                            if (typeof functionDefinition !== 'string' || !functionDefinition.match(regExp)) {
+                                diagnostics.push(
+                                    new FluentDiagnostic(
+                                        node,
+                                        `'function_definition' must start with 'glidefunction:' and include a single function call to a predefined function:\n${validFunctions.join(
+                                            '\n'
+                                        )}`
+                                    )
                                 )
-                            )
+                            }
                         }
-                    }
 
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: [
-                            new EntityData(
-                                entity.getKind(),
-                                entity.getGuid(),
+                        return {
+                            handled: true,
+                            diagnostics,
+                            data: [
                                 ObjectData.fromObjectValue(
                                     {
                                         ...entity.getValue(),
@@ -71,10 +71,9 @@ function ColumnPlugin<
                                     },
                                     entity.getNode()
                                 ),
-                                entity.getNode()
-                            ),
-                        ],
-                    }
+                            ],
+                        }
+                    },
                 },
             },
         },

package/src/db/DBUtils.ts

@@ -0,0 +1,36 @@
+import { FluentDiagnostic } from '@servicenow/sdk-build-core'
+import { isArray } from 'lodash'
+import { Diagnostic } from '@servicenow/sdk-project'
+
+export function getLabelDiagnostics(entity) {
+    const diagnostics: FluentDiagnostic[] = []
+    const label = entity.getProperty('label')?.getValue()
+    if (label && isArray(label)) {
+        const languages = {}
+        label.forEach((l, i) => {
+            const language = l.language
+            if (languages[language] !== undefined) {
+                diagnostics.push(
+                    new FluentDiagnostic(
+                        entity.getProperty('label')!.getNode().getChildrenOfKind(210)![i]?.getProperty('language') ??
+                            entity.getProperty('label')!.getNode(),
+                        `'language' must be unique per table/column`,
+                        { level: Diagnostic.Level.Error }
+                    )
+                )
+            }
+            languages[language] = i
+            if (language === '' || (language && language.length !== 2)) {
+                diagnostics.push(
+                    new FluentDiagnostic(
+                        entity.getProperty('label')!.getNode().getChildrenOfKind(210)![i]?.getProperty('language') ??
+                            entity.getProperty('label')!.getNode(),
+                        `'language' must be a 2 character identifier (Ex. 'en', 'es')`,
+                        { level: Diagnostic.Level.Error }
+                    )
+                )
+            }
+        })
+    }
+    return diagnostics
+}