@servicenow/sdk-build-plugins 2.2.9 → 3.0.1

package/src/aclAndRole/RolePlugin.ts

@@ -117,7 +117,7 @@ export default Plugin({
 
                 const role = roleSchema.safeParse(entity.getValue())
                 if (!role.success) {
-                    return undefined
+                    return Promise.resolve(undefined)
                 }
 
                 const { $id: _, name, contains_roles, ...rest } = role.data
@@ -158,7 +158,7 @@ export default Plugin({
                     },
                 }
 
-                return [roleDocument, ...roleMappingDocuments]
+                return Promise.resolve([roleDocument, ...roleMappingDocuments])
             },
         },
     },

package/src/aclAndRole/Util.ts

@@ -7,43 +7,52 @@ import {
     getOrCreatePropertyAssignment,
     ArrayIterator,
     stringify,
+    Data,
+    isGUID,
 } from '@servicenow/sdk-build-core'
 
-const getElementKey = (element: ts.Expression) => {
-    if (element.isKind(ts.SyntaxKind.StringLiteral)) {
-        return element.getLiteralValue()
+const getElementKey = (element: ts.Expression, context: Context): string => {
+    const result = context.extractAst(element)
+    if (result.handled && result.data) {
+        const data = result.data
+        if (Data.isString(data)) {
+            return data.getValue()
+        }
+        if (Data.isEntity(data) && data.getKind() === 'role') {
+            return data.getProperty('$id') ? `${data.getProperty('$id').getValue()}` : ''
+        }
     }
-    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
-          )!
-        : ''
+    return ''
 }
 
 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 primaryKey = 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'
+    const primaryKeyName = table === 'sys_security_acl_role' ? 'sys_security_acl' : 'role'
+    const secondaryKeyName = table === 'sys_security_acl_role' ? 'sys_user_role' : 'contains'
+
     while (rolesIterator.hasNext()) {
         const element = rolesIterator.next()
-        const secKey = getElementKey(element)
+        const secondaryKey = getElementKey(element, context)
+        const secondaryKeySysId =
+            secondaryKey && isGUID(secondaryKey) ? secondaryKey : context.getIdUsingExplicitKey(secondaryKey) || ''
+        if (secondaryKeySysId === roleId) {
+            return
+        }
 
         const foundIdx = context.keys.composite.findIndex((k) =>
             isEqual(k.key, {
-                [primaryKey]: argId,
-                [secondKey]: secKey,
+                [primaryKeyName]: primaryKey,
+                [secondaryKeyName]: secondaryKey,
             })
         )
-        if (foundIdx !== -1 && context.keys.composite[foundIdx]?.id === document.guid) {
-            if (context.keys.explicit[secKey]?.id === roleId || secKey === roleId) {
+        if (foundIdx !== -1 && context.keys.composite[foundIdx]?.id == document.guid) {
+            if (context.keys.explicit[secondaryKey]?.id === roleId || secondaryKey === roleId) {
                 return
             }
             element?.replaceWithText(stringify(roleId))
@@ -59,8 +68,8 @@ export function addObjectToArrayById(document: Document, name: string, roleId: s
     context.keys.registerCompositeId(
         table,
         {
-            [primaryKey]: argId!,
-            [secondKey]: roleId,
+            [primaryKeyName]: primaryKey!,
+            [secondaryKeyName]: roleId,
         },
         document.guid
     )
@@ -83,7 +92,7 @@ export function removeObjectFromArrayById(document: Document, name: string, cont
     const rolesIterator = new ArrayIterator(propertyAssignment)
     while (rolesIterator.hasNext()) {
         const element = rolesIterator.next()
-        const secKey = getElementKey(element)
+        const secKey = getElementKey(element, context)
         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) =>

package/src/app/ApplicationMenuPlugin.ts

@@ -11,9 +11,9 @@ import {
     removeNode,
     transformFunctionArguments,
     writeArrayPropertyAsReference,
-    writePropertyAsReference,
     EntityData,
     ObjectData,
+    transformCustomizedProperties,
 } from '@servicenow/sdk-build-core'
 import { RecordPlugin } from '../db/RecordPlugin'
 import { Record } from '@servicenow/sdk-core/runtime/db'
@@ -60,9 +60,9 @@ export default Plugin({
     composers: {
         entity: {
             appMenu(entity, context) {
-                const appMenuData = ApplicationMenuSchema.safeParse(entity.getValue())
+                const appMenuData = ApplicationMenuSchema.and(z.any()).safeParse(entity.getValue())
                 if (!appMenuData.success) {
-                    return undefined
+                    return Promise.resolve(undefined)
                 }
                 const { $id, category, ...props } = appMenuData.data
                 const roles = entity.getProperty('roles', 'array')
@@ -85,7 +85,8 @@ export default Plugin({
                             'record',
                             entity.getGuid(),
                             ObjectData.fromObjectValue(recordEntity, entity.getNode()),
-                            entity.getNode()
+                            entity.getNode(),
+                            entity.getInstallMethod()
                         ),
                     ],
                     [RecordPlugin]
@@ -119,7 +120,7 @@ export default Plugin({
     },
     transformers: {
         record: {
-            CallExpression(document) {
+            CallExpression(document, _context) {
                 if (getCallExpressionName(document.node) !== ApplicationMenu.name) {
                     return false
                 }
@@ -131,29 +132,32 @@ export default Plugin({
                 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 { roles } = (document.xmlData as AppMenuDocumentSchema).data
                 const [args] = document.node.getArguments()
                 if (!ts.Node.isObjectLiteralExpression(args)) {
                     return false
                 }
 
-                if (roles) {
+                if (roles && document.changedData?.['data']['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
+
+                transformCustomizedProperties(ApplicationMenu, document.node, (document.changedData as any).data, {
+                    roles: _roles,
+                    device_type: _device_type,
+                    ...data,
+                })
                 return transformFunctionArguments(document.node, ApplicationMenu, data as any)
             },
         },

package/src/db/DocumentationPlugin.ts

@@ -7,6 +7,9 @@ import {
     getOrCreatePropertyAssignment,
     mergeDataIntoObjectLiteralArray,
     filterEmpty,
+    generateCallExpressionExportForDocument,
+    getOrCreateEntitySourceFile,
+    linkDocument,
 } from '@servicenow/sdk-build-core'
 import { Documentation, Record, Table } from '@servicenow/sdk-core/runtime/db'
 import { createObjectExpression } from './TablePlugin'
@@ -47,17 +50,31 @@ export default Plugin({
         },
     },
     generators: {
-        sys_documentation(document, _context: Context, linkedDocuments) {
-            const table = linkedDocuments.find((doc) => doc.guid === (document.data as any).data.name)
-            return table && table.node ? { ...document, node: table.node } : undefined
+        sys_documentation(document, context: Context, linkedDocuments) {
+            const tableName = (document.data as any).data.name
+            const table = linkedDocuments.find((doc) => doc.guid === tableName)
+            return table && table.node
+                ? { ...document, node: table.node }
+                : linkDocument(
+                      document,
+                      generateCallExpressionExportForDocument(
+                          context,
+                          {
+                              sourceFile: getOrCreateEntitySourceFile(context, `${document.guid}`),
+                              moduleSpecifier: '@servicenow/sdk/core',
+                          },
+                          Record,
+                          { $id: document.guid }
+                      ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
+                  )
         },
     },
     transformers: {
         sys_documentation: {
-            CallExpression(document) {
+            CallExpression(document, context) {
                 const expressionName = getCallExpressionName(document.node)
                 if (expressionName !== Table.name) {
-                    return false
+                    return RecordPlugin.transformers!.record!.CallExpression(document, context)
                 }
 
                 const { element: column } = (document.data as any).data

package/src/db/LicensingPlugin.ts

@@ -0,0 +1,138 @@
+import {
+    getCallExpressionName,
+    Plugin,
+    Context,
+    getPropertyAssignment,
+    mergeDataIntoObjectLiteral,
+    linkDocument,
+    generateCallExpressionExportForDocument,
+    getOrCreateEntitySourceFile,
+    GUID,
+} from '@servicenow/sdk-build-core'
+import { Table, Record } from '@servicenow/sdk-core/runtime/db'
+import { RecordPlugin } from './RecordPlugin'
+import { ts } from '@servicenow/sdk-project'
+import { isEqual } from 'lodash'
+
+export const ua_table_licensing_config = 'ua_table_licensing_config'
+
+export default Plugin({
+    name: 'LicensingConfig',
+    composers: {
+        xml: {
+            ua_table_licensing_config(xml) {
+                return {
+                    kind: ua_table_licensing_config,
+                    guid: (xml.data['id'] as string) ?? GUID(),
+                    data: xml.data,
+                    action: xml.action,
+                }
+            },
+        },
+    },
+    serializers: {
+        ua_table_licensing_config(document, context) {
+            return RecordPlugin.serializers.record(document, context)
+        },
+    },
+    arrangers: {
+        ua_table_licensing_config(document) {
+            if ((document.data as any).table !== ua_table_licensing_config) {
+                return { handled: false }
+            }
+            const tableName = (document.data as any).data.name
+            return {
+                handled: true,
+                result: tableName ? { kind: 'bootstrap', guid: tableName } : undefined,
+            }
+        },
+    },
+    generators: {
+        ua_table_licensing_config(document, context: Context, linkedDocuments) {
+            const table = linkedDocuments.find((doc) => doc.guid === (document.data as any).data.name)
+            return table && table.node
+                ? { ...document, node: table.node }
+                : linkDocument(
+                      document,
+                      generateCallExpressionExportForDocument(
+                          context,
+                          {
+                              sourceFile: getOrCreateEntitySourceFile(context, `${document.kind}_${document.guid}`),
+                              moduleSpecifier: '@servicenow/sdk/core',
+                          },
+                          Record,
+                          { $id: document.guid }
+                      ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
+                  )
+        },
+    },
+    transformers: {
+        ua_table_licensing_config: {
+            CallExpression(document, context) {
+                const expressionName = getCallExpressionName(document.node)
+                if (expressionName !== Table.name) {
+                    return RecordPlugin.transformers!.record!.CallExpression(document, context)
+                }
+
+                const [baseArgs] = document.node.getArguments()
+                if (!baseArgs) {
+                    return false
+                }
+
+                const changedData = (document.changedData as any).data
+                const data = (document.data as any).data
+
+                let objLit, dataToMerge
+                const licensingProp = getPropertyAssignment(baseArgs, 'licensing_config')
+                if (!licensingProp) {
+                    if (isDefaultLicensingConfig(data)) {
+                        return true
+                    }
+                    const defaultValues = defaultLicensingConfigRecord(data.name).data
+                    dataToMerge = {}
+                    Object.entries(data)
+                        .filter(([prop]) => {
+                            return data[prop] !== defaultValues[prop]
+                        })
+                        .map(([k, v]) => {
+                            dataToMerge[k] = v
+                        })
+                    const callExpLit = document.node.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+                    const newProp = callExpLit.addPropertyAssignment({ name: 'licensing_config', initializer: '{}' })
+                    objLit = newProp!.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+                } else {
+                    dataToMerge = changedData
+                    objLit = licensingProp!.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+                }
+
+                if (dataToMerge.license_roles) {
+                    dataToMerge.license_roles = dataToMerge.license_roles.split(',')
+                }
+
+                mergeDataIntoObjectLiteral(objLit, dataToMerge)
+                return true
+            },
+        },
+    },
+})
+function isDefaultLicensingConfig(data) {
+    return isEqual(data, defaultLicensingConfigRecord(data.name).data)
+}
+
+function defaultLicensingConfigRecord(tableName: string) {
+    return Record({
+        table: ua_table_licensing_config,
+        $id: `${tableName}_license`,
+        data: {
+            name: tableName,
+            op_insert: true,
+            op_update: true,
+            op_delete: true,
+            is_fulfillment: false,
+            license_model: 'none',
+            owner_condition: '',
+            license_condition: '',
+            license_roles: '',
+        },
+    })
+}

package/src/db/RecordPlugin.ts

@@ -17,9 +17,13 @@ import {
     extractCallExpression,
     Data,
     ObjectData,
+    Document,
+    type Directories,
 } from '@servicenow/sdk-build-core'
 import { z } from 'zod'
 import { ts } from '@servicenow/sdk-project'
+import { except } from '../scripts/scriptUtils'
+import { fieldHasNowIncludeCallExpression } from '../IncludePlugin'
 
 // TODO: This schema should live with the Record entity function itself
 const RecordEntitySchema = z.object({
@@ -42,15 +46,7 @@ export const TextStringSchema = z.object({ '#text': z.string() }).transform((val
 export const TextBooleanSchema = z.object({ '#text': z.boolean() }).transform((val) => val['#text'])
 export const TextNumberSchema = z.object({ '#text': z.number().or(z.literal('')) }).transform((val) => val['#text'])
 
-const ignoreTables = [
-    'sys_metadata_link',
-    'sys_module',
-    'sys_ux_lib_asset',
-    'sys_app',
-    'sys_store_app',
-    'ua_table_licensing_config',
-    'sys_index',
-]
+const ignoreTables = ['sys_metadata_link', 'sys_module', 'sys_ux_lib_asset', 'sys_app', 'sys_store_app', 'sys_index']
 const ignoreFields = [
     'sys_created_by',
     'sys_created_on',
@@ -91,11 +87,45 @@ const RecordDocumentSchema = z.object({
     table: z.string(),
 })
 
+const InstallDir = z
+    .union([
+        z.literal('update'),
+        z.literal('dictionary'),
+        z.literal('scope'),
+        z.literal('demo'),
+        z.literal('first install'),
+    ])
+    .default('update')
+    .transform((directory) => {
+        if (directory === 'demo') {
+            return 'unload.demo'
+        } else if (directory === 'first install') {
+            return 'unload'
+        }
+        return directory
+    })
+
+export function getOutputDirectoryForDocument(document: Document, table: string): Directories {
+    if (table === 'sys_app') {
+        return 'scope'
+    }
+    return InstallDir.parse(document['directory'])
+}
+
 function cleanRecordUpdate(recordUpdate: globalThis.Record<string, unknown>) {
     ignoreXMLElement.forEach((element) => delete recordUpdate[element])
     return recordUpdate
 }
 
+export function propertyAssignmentIsInlineScript(pa: ts.PropertyAssignment) {
+    return (
+        pa.getInitializerIfKind(ts.SyntaxKind.StringLiteral) ||
+        pa.getInitializerIfKind(ts.SyntaxKind.TaggedTemplateExpression) ||
+        pa.getInitializerIfKind(ts.SyntaxKind.TemplateExpression) ||
+        pa.getInitializerIfKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)
+    )
+}
+
 export const RecordPlugin = Plugin({
     name: 'Record',
     extractors: {
@@ -244,29 +274,30 @@ export const RecordPlugin = Plugin({
             record(entity, _context) {
                 const $id = entity.getProperty('$id')
                 if (!Data.isString($id) && !Data.isNumber($id)) {
-                    throw new Error(`Record ID must be a string or number`)
+                    Promise.reject(`Record ID must be a string or number`)
                 }
 
                 const table = entity.getProperty('table')
                 if (!Data.isString(table)) {
-                    throw new Error(`Record table must be a string`)
+                    Promise.reject(`Record table must be a string`)
                 }
 
                 const data = entity.getProperty('data')
                 if (!Data.isObject(data)) {
-                    throw new Error(`Record data must be an object`)
+                    Promise.reject(`Record data must be an object`)
                 }
 
-                return {
+                return Promise.resolve({
                     kind: 'record',
                     guid: entity.getGuid(),
                     node: entity.getNode(),
+                    directory: entity.getInstallMethod(),
                     data: {
                         $id: $id.getValue(),
                         table: table.getValue(),
                         data: data.getValue(),
                     },
-                }
+                })
             },
         },
         xml: {
@@ -295,7 +326,7 @@ export const RecordPlugin = Plugin({
 
             return {
                 name: `${table}_${document.guid}.xml`,
-                directory: table === 'sys_app' ? 'scope' : 'update',
+                directory: getOutputDirectoryForDocument(document, table),
                 content: recordBuilder.end(),
             }
         },
@@ -335,6 +366,11 @@ export const RecordPlugin = Plugin({
                     return false
                 }
 
+                const [args] = document.node.getArguments()
+                if (!ts.Node.isObjectLiteralExpression(args)) {
+                    return false
+                }
+
                 const { table } = document.data as RecordData
                 const data = (document.changedData as any).data
 
@@ -350,9 +386,17 @@ export const RecordPlugin = Plugin({
                     return out
                 }, {} as Record)
 
+                const preexistingData = args
+                    .getProperty('data')
+                    ?.asKind(ts.SyntaxKind.PropertyAssignment)
+                    ?.getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
+
                 transformFunctionArguments(document.node, Record, {
                     table,
-                    data: properties,
+                    data: except(
+                        properties,
+                        (field) => !!preexistingData && fieldHasNowIncludeCallExpression(preexistingData, field)
+                    ),
                 })
 
                 context.argTypesToFix.push(document.node)
@@ -381,6 +425,15 @@ export function extractCallExpressionAsRecord<
     return {
         handled: true,
         diagnostics: result.diagnostics,
-        data: result.data ? new EntityData('record', result.data.getGuid(), asRecord(result.data), node) : undefined,
+        data: result.data
+            ? new EntityData(
+                  'record',
+                  result.data.getGuid(),
+                  asRecord(result.data),
+                  node,
+                  result.data.getInstallMethod(),
+                  result.data.getExplicitIds()
+              )
+            : undefined,
     }
 }