@servicenow/sdk-build-plugins 4.1.1 → 4.3.0

package/src/basic-syntax-plugin.ts

@@ -24,7 +24,12 @@ import {
     remove,
     isFluentFile,
     path as pathModule,
+    Record as DBRecord,
+    asDataHelper,
+    isValidNode,
 } from '@servicenow/sdk-build-core'
+import { isDataHelper } from './data-plugin'
+import { getCallExpressionName } from './utils'
 
 export const BasicSyntaxPlugin = Plugin.create({
     name: 'BasicSyntaxPlugin',
@@ -61,7 +66,7 @@ export const BasicSyntaxPlugin = Plugin.create({
             shape: Shape,
             getTarget(shape, { compiler, project, config }) {
                 const source = shape.getOriginalSource()
-                if (ts.Node.isNode(source)) {
+                if (isValidNode(source)) {
                     return { success: true, value: source }
                 }
 
@@ -70,8 +75,34 @@ export const BasicSyntaxPlugin = Plugin.create({
                     return { success: false }
                 }
 
-                const name = pathModule.basename(source.path).replace(RegExp(`${pathModule.extname(source.path)}$`), '')
-                const file = compiler.getOrCreateSourceFile(project.resolvePath(config.generatedDir, `${name}.now.ts`))
+                const { generatedDir, taxonomy } = config
+                const tableName =
+                    shape.getSource() instanceof DBRecord ? (shape.getSource() as DBRecord).getTable() : undefined
+
+                const dir =
+                    tableName && taxonomy.mapping[tableName]
+                        ? pathModule.join(generatedDir, taxonomy.mapping[tableName])
+                        : generatedDir
+
+                let name = pathModule.basename(source.path).replace(RegExp(`${pathModule.extname(source.path)}$`), '')
+                if (!name) {
+                    const id =
+                        shape.getSource() instanceof DBRecord
+                            ? (shape.getSource() as DBRecord).getId().getValue()
+                            : undefined
+                    name = `${tableName}_${id}`
+                }
+
+                if (project.isTypesGenerationMode()) {
+                    // In types generation mode, use the exported variable name as the file name
+                    // Scope directory is already set via per-scope Project rootDir
+                    if (shape.is(VariableStatementShape) && shape.isExported()) {
+                        name = shape.getVariableName().getName()
+                    }
+                }
+                const file = compiler.getOrCreateSourceFile(
+                    project.resolvePath(project.getRootDir(), dir, `${name}.now.ts`)
+                )
                 const statement = project
                     .addFile(file.getFilePath(), { resolveDependencies: false })
                     .addStatement(shape.getCode())
@@ -167,6 +198,16 @@ export const BasicSyntaxPlugin = Plugin.create({
                             // Turn the number back into a string and compare with the original string to avoid
                             // lossy conversions due to floating point precision or other factors
                             return number.getValue().toString() === shape.getValue() ? number : undefined
+                        } else if (isDataHelper(target)) {
+                            if (!ts.Node.isCallExpression(target)) {
+                                return undefined
+                            }
+                            const helperName = getCallExpressionName(target)
+                            const timeZone = target
+                                .getArguments()[1]
+                                ?.asKind(ts.SyntaxKind.StringLiteral)
+                                ?.getLiteralValue()
+                            return asDataHelper(helperName, shape, timeZone)
                         } else {
                             return undefined
                         }
@@ -272,7 +313,7 @@ export const BasicSyntaxPlugin = Plugin.create({
                     const existingPropKey = [...shape.getAliases(name), name].find((aliasedKey) =>
                         existingNames.has(aliasedKey)
                     )
-                    if (existingPropKey) {
+                    if (existingPropKey !== undefined) {
                         if (existingPropKey !== name) {
                             target
                                 .getPropertyOrThrow(existingPropKey)
@@ -280,6 +321,7 @@ export const BasicSyntaxPlugin = Plugin.create({
                                 .getNameNode()
                                 .replaceWithText(name)
                         }
+
                         await commit(value, existingNames.get(existingPropKey) as ts.Expression)
                     } else if (!value.equals(shape.getDefault(name))) {
                         propsToAdd.push({
@@ -318,35 +360,50 @@ export const BasicSyntaxPlugin = Plugin.create({
         {
             shape: VariableStatementShape,
             async commit(shape, target, { commit }) {
-                if (!ts.Node.isVariableStatement(target)) {
-                    const parentStatement = target.getParentIfKind(ts.SyntaxKind.ExpressionStatement)
-                    if (ts.Node.isCallExpression(target) && parentStatement) {
-                        parentStatement.replaceWithText(shape.getCode())
-                        return { success: true }
-                    }
+                // If target is ExpressionStatement, replace it directly
+                if (ts.Node.isExpressionStatement(target)) {
                     target.replaceWithText(shape.getCode())
                     return { success: true }
                 }
 
-                if (target.isExported() !== shape.isExported()) {
-                    target.setIsExported(shape.isExported())
+                // If target is CallExpression, check parent type
+                if (ts.Node.isCallExpression(target)) {
+                    const expressionStatement = target.getParentIfKind(ts.SyntaxKind.ExpressionStatement)
+                    if (expressionStatement) {
+                        expressionStatement.replaceWithText(shape.getCode())
+                        return { success: true }
+                    }
+                }
+
+                // Get VariableStatement for in-place updates (either from CallExpression ancestor or target itself)
+                const variableStatement = ts.Node.isVariableStatement(target)
+                    ? target
+                    : target.getFirstAncestorByKindOrThrow(ts.SyntaxKind.VariableStatement)
+
+                // Update export modifier if needed
+                if (variableStatement.isExported() !== shape.isExported()) {
+                    variableStatement.setIsExported(shape.isExported())
                 }
 
-                const [declaration, otherDeclaration] = target.getDeclarations()
+                // Get the variable declaration
+                const [declaration, otherDeclaration] = variableStatement.getDeclarations()
                 if (!declaration) {
-                    throw new Error(`Variable statement is missing a declaration: ${target.getFullText()}`)
+                    throw new Error(`Variable statement is missing a declaration: ${variableStatement.getFullText()}`)
                 }
 
+                // Remove duplicate declarations
                 if (otherDeclaration) {
                     removeReferences(otherDeclaration)
                     remove(otherDeclaration)
                 }
 
+                // Update variable name if changed
                 const variableName = shape.getVariableName()
                 if (declaration.getName() !== variableName.getName()) {
                     await commit(variableName, declaration.getNameNode())
                 }
 
+                // Update initializer
                 await commit(shape.getInitializer(), declaration.getInitializerOrThrow())
                 return { success: true }
             },

package/src/business-rule-plugin.ts

@@ -1,16 +1,19 @@
 import { CallExpressionShape, type ObjectShape, Plugin, type ArrayShape, type Shape } from '@servicenow/sdk-build-core'
 import { ModuleFunctionShape } from './server-module-plugin'
 import { NowIdShape } from './now-id-plugin'
-import { generateDeprecatedDiagnostics } from './utils'
+import { createSdkDocEntry, generateDeprecatedDiagnostics } from './utils'
 import { NowIncludeShape } from './now-include-plugin'
 
 // 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
-        }, {}) ?? {}
+        collection?.reduce(
+            (groups, e) => {
+                groups[keyProvider(e)] = e
+                return groups
+            },
+            {} as { [key: string]: T }
+        ) ?? {}
     )
 }
 
@@ -42,6 +45,7 @@ const brAliases = {
 
 export const BusinessRulePlugin = Plugin.create({
     name: 'BusinessRulePlugin',
+    docs: [createSdkDocEntry('BusinessRule', ['sys_script'])],
     records: {
         sys_script: {
             async toShape(record, { transform }) {

package/src/call-expression-plugin.ts

@@ -1,5 +1,4 @@
-import { ts, Plugin, CallExpressionShape, type Shape, type Compiler } from '@servicenow/sdk-build-core'
-import { Record } from '@servicenow/sdk-core/runtime/db'
+import { ts, Plugin, CallExpressionShape, type Shape } from '@servicenow/sdk-build-core'
 import { getCallExpressionName } from './utils'
 
 export const CallExpressionPlugin = Plugin.create({
@@ -34,7 +33,7 @@ export const CallExpressionPlugin = Plugin.create({
     shapes: [
         {
             shape: CallExpressionShape,
-            async commit(shape, target, { commit, compiler }) {
+            async commit(shape, target, { commit }) {
                 if (target.isKind(ts.SyntaxKind.ExpressionStatement)) {
                     target = target.getExpression()
                 }
@@ -68,135 +67,8 @@ export const CallExpressionPlugin = Plugin.create({
                     target.addArguments(argumentsToAdd)
                 }
 
-                if (shape.getCallee() === Record.name) {
-                    fixCallExpressionArgTypes(compiler, target)
-                }
-
                 return { success: true }
             },
         },
     ],
 })
-
-function fixCallExpressionArgTypes(compiler: Compiler, node: ts.CallExpression) {
-    if (node.wasForgotten()) {
-        return
-    }
-
-    node.getSourceFile().fixMissingImports()
-    const signature = compiler.getTypeChecker().getResolvedSignature(node)
-    if (!signature) {
-        return
-    }
-
-    signature.getParameters().forEach((param, idx) => {
-        const argType = param.getTypeAtLocation(node)
-        const argNode = node.getArguments()[idx]?.asKind(ts.SyntaxKind.ObjectLiteralExpression)
-        if (!argType || !argNode) {
-            return
-        }
-        fixCallExpressionArgType(node, argNode, argType)
-    })
-}
-
-function fixCallExpressionArgType(
-    node: ts.CallExpression,
-    argNode: ts.ObjectLiteralExpression | ts.PropertyAssignment,
-    argType: ts.Type
-) {
-    if (argNode.getType().isObject()) {
-        const objectLiteral = argNode.isKind(ts.SyntaxKind.ObjectLiteralExpression)
-            ? argNode
-            : argNode.getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-        argType.getApparentProperties().forEach((prop) => {
-            const propNode = objectLiteral?.getProperty(prop.getName())?.asKind(ts.SyntaxKind.PropertyAssignment)
-            if (!propNode) {
-                return
-            }
-            fixCallExpressionArgType(node, propNode, prop.getTypeAtLocation(node))
-        })
-    } else if (argNode.isKind(ts.SyntaxKind.PropertyAssignment)) {
-        const nodeType = argNode.getType()
-        if (
-            nodeType.isAssignableTo(argType) ||
-            canAssignString(argNode, argType) ||
-            canCastAndAssignBoolean(argNode, argType) ||
-            canCastAndAssignNumber(argNode, argType)
-        ) {
-            return
-        }
-
-        // cast 'as any' for other types
-        const argValue = argNode.getInitializer()?.getText()
-        argNode.setInitializer(`${argValue} as any`)
-    }
-}
-
-function canCastAndAssignBoolean(argNode: ts.PropertyAssignment, argType: ts.Type): boolean {
-    const booleanTypes = getBooleanTypes(argType)
-    const booleanValue = getBooleanValue(argNode)
-    if (booleanValue && booleanTypes.length > 0) {
-        const isAssignable = booleanTypes.some((type) => {
-            return (
-                (type.isBoolean() && (booleanValue === 'true' || booleanValue === 'false')) ||
-                type.getText() === booleanValue
-            )
-        })
-        if (isAssignable) {
-            argNode.setInitializer(`${booleanValue}`)
-            return true
-        }
-    }
-    return false
-}
-
-function canCastAndAssignNumber(argNode: ts.PropertyAssignment, argType: ts.Type): boolean {
-    const numberTypes = getNumberTypes(argType)
-    const numberValue = getNumberValue(argNode)
-    if (numberValue && numberTypes.length > 0) {
-        const isAssignable = numberTypes.some((type) => {
-            return type.isNumber() || `${type.getLiteralValue()}` === numberValue
-        })
-        if (isAssignable) {
-            argNode.setInitializer(`${numberValue}`)
-            return true
-        }
-    }
-    return false
-}
-
-function canAssignString(argNode: ts.PropertyAssignment, argType: ts.Type): boolean {
-    const stringTypes = getStringTypes(argType)
-    const stringValue = getStringValue(argNode)
-    return stringTypes.some((type) => {
-        return type.isString() || type.getLiteralValue() === stringValue
-    })
-}
-
-function getBooleanValue(argNode: ts.PropertyAssignment): string | undefined {
-    return argNode.getInitializerIfKind(ts.SyntaxKind.StringLiteral)?.getLiteralValue()
-}
-
-function getBooleanTypes(argType: ts.Type) {
-    const type = argType.isUnion() ? argType.getUnionTypes() : [argType]
-    return type.filter((type) => type.isBoolean() || type.isBooleanLiteral())
-}
-
-function getNumberValue(argNode: ts.PropertyAssignment): string | undefined {
-    const numStrVal = argNode.getInitializerIfKind(ts.SyntaxKind.StringLiteral)?.getLiteralValue()
-    return numStrVal && !isNaN(Number(numStrVal)) ? `${numStrVal}` : undefined
-}
-
-function getNumberTypes(argType: ts.Type) {
-    const type = argType.isUnion() ? argType.getUnionTypes() : [argType]
-    return type.filter((type) => type.isNumber() || type.isNumberLiteral())
-}
-
-function getStringValue(argNode: ts.PropertyAssignment): string | undefined {
-    return argNode.getInitializerIfKind(ts.SyntaxKind.StringLiteral)?.getLiteralValue()
-}
-
-function getStringTypes(argType: ts.Type) {
-    const type = argType.isUnion() ? argType.getUnionTypes() : [argType]
-    return type.filter((type) => type.isString() || type.isStringLiteral())
-}

package/src/claims-plugin.ts

@@ -59,7 +59,7 @@ export const ClaimsPlugin = Plugin.create({
                     return { success: false }
                 }
 
-                const allClaims = file.getJson()
+                const allClaims = file.getJson().asObject()
                 const records: Record[] = []
                 for (const [updateName, claims] of allClaims.entries()) {
                     for (const claim of claims

package/src/client-script-plugin.ts

@@ -1,6 +1,7 @@
-import { type Compiler, ts, CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
+import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
 import { NowIdShape } from './now-id-plugin'
-import { generateDeprecatedDiagnostics } from './utils'
+import { generateDeprecatedDiagnostics, validateClientSideScript } from './utils'
+import { NowIncludeShape } from './now-include-plugin'
 
 enum UITypeMapping {
     desktop = 0,
@@ -45,7 +46,8 @@ export const ClientScriptPlugin = Plugin.create({
     name: 'ClientScriptPlugin',
     records: {
         sys_script_client: {
-            toShape(record) {
+            async toShape(record, { transform }) {
+                const script = await NowIncludeShape.fromRecord(record, record.get('script'), transform)
                 return {
                     success: true,
                     value: new CallExpressionShape({
@@ -59,7 +61,7 @@ export const ClientScriptPlugin = Plugin.create({
                                     table: $,
                                     appliesExtended: $.from('applies_extended').toBoolean().def(false),
                                     isolateScript: $.from('isolate_script').toBoolean().def(false),
-                                    script: $,
+                                    script: $.val(script),
                                     name: $,
                                     description: $.def(''),
                                     messages: $.def(''),
@@ -110,7 +112,7 @@ export const ClientScriptPlugin = Plugin.create({
                     )
                 }
 
-                if (script && !validateClientSideScripts(script, compiler)) {
+                if (script && !validateClientSideScript(script, compiler)) {
                     diagnostics.error(
                         clientScript.get('script'),
                         `Client side scripts cannot import or require modules.`
@@ -147,17 +149,6 @@ export const ClientScriptPlugin = Plugin.create({
     ],
 })
 
-function validateClientSideScripts(script: string, compiler: Compiler) {
-    const source = compiler.createSourceFile('tmp-file.ts', script)
-    const importDeclarations = source.getDescendantsOfKind(ts.SyntaxKind.ImportDeclaration)
-    const requireCalls = source.getDescendantsOfKind(ts.SyntaxKind.CallExpression).filter((callExpression) => {
-        return isRequire(callExpression)
-    })
-    const isValid = !(importDeclarations.length > 0 || requireCalls.length > 0)
-    compiler.removeSourceFile(source)
-    return isValid
-}
-
 function getUITypeFromId(id: number) {
     const type = UITypeMapping[id]
     if (!type) {
@@ -168,12 +159,7 @@ function getUITypeFromId(id: number) {
 
 function getUITypeId(value: string) {
     if (value in UITypeMapping) {
-        return UITypeMapping[value]
+        return UITypeMapping[value as keyof typeof UITypeMapping]
     }
     throw Error('Invalid ui_type found in xml')
 }
-
-function isRequire(callExpression: ts.CallExpression): boolean {
-    const expression = callExpression.getExpression()
-    return ts.Node.isIdentifier(expression) && expression.getText() === 'require'
-}

package/src/column/column-helper.ts

@@ -1,5 +1,6 @@
 import { CallExpressionShape, Shape } from '@servicenow/sdk-build-core'
 import {
+    ApprovalRulesColumn,
     BasicDateTimeColumn,
     BasicImageColumn,
     BooleanColumn,
@@ -8,25 +9,42 @@ import {
     ConditionsColumn,
     DateColumn,
     DateTimeColumn,
+    DayOfWeekColumn,
+    DaysOfWeekColumn,
     DecimalColumn,
     DocumentIdColumn,
     DomainIdColumn,
     DomainPathColumn,
     DueDateColumn,
+    DurationColumn,
+    EmailColumn,
+    FieldListColumn,
     FieldNameColumn,
+    FloatColumn,
+    GuidColumn,
+    HtmlColumn,
     IntegerColumn,
     IntegerDateColumn,
+    JsonColumn,
     ListColumn,
+    MultiLineTextColumn,
+    NameValuePairsColumn,
     OtherDateColumn,
+    Password2Column,
     RadioColumn,
+    RecordsColumn,
     ReferenceColumn,
     ScheduleDateTimeColumn,
     ScriptColumn,
+    SlushBucketColumn,
     StringColumn,
     SystemClassNameColumn,
     TableNameColumn,
+    TemplateValueColumn,
+    TimeColumn,
     TranslatedFieldColumn,
     TranslatedTextColumn,
+    UrlColumn,
     UserRolesColumn,
     VersionColumn,
 } from '@servicenow/sdk-core/runtime/db'
@@ -61,6 +79,25 @@ export const COLUMN_TYPE_TO_API: Record<string, string> = {
     version: VersionColumn.name,
     glide_list: ListColumn.name,
     image: BasicImageColumn.name,
+    // New column types
+    GUID: GuidColumn.name,
+    password2: Password2Column.name,
+    json: JsonColumn.name,
+    url: UrlColumn.name,
+    email: EmailColumn.name,
+    html: HtmlColumn.name,
+    float: FloatColumn.name,
+    glide_duration: DurationColumn.name,
+    glide_time: TimeColumn.name,
+    field_list: FieldListColumn.name,
+    records: RecordsColumn.name,
+    slushbucket: SlushBucketColumn.name,
+    name_values: NameValuePairsColumn.name,
+    approval_rules: ApprovalRulesColumn.name,
+    multi_two_lines: MultiLineTextColumn.name,
+    template_value: TemplateValueColumn.name,
+    day_of_week: DayOfWeekColumn.name,
+    days_of_week: DaysOfWeekColumn.name,
 }
 
 export const COLUMN_API_TO_TYPE = Object.fromEntries(
@@ -87,25 +124,50 @@ export function addFieldsToColumn(
     })
 }
 
-export function getDefaultMaxLength(columnType: string): number {
+export function getDefaultMaxLength(columnType: string | undefined): number {
     switch (columnType) {
         case 'conditions':
         case 'glide_list':
+        case 'json':
+        case 'name_values':
+        case 'multi_two_lines':
             return 4000
+        case 'template_value':
+            return 65000
+        case 'script':
+            return 8000
+        case 'html':
+            return 65536
         case 'decimal':
             return 20
+        case 'float':
+            return 15
         case 'domain_id':
         case 'document_id':
         case 'reference':
+        case 'GUID':
             return 32
+        case 'string_full_utf8':
         case 'domain_path':
         case 'user_roles':
+        case 'password2':
+        case 'email':
             return 255
-        case 'script':
-            return 8000
+        case 'url':
+        case 'records':
+            return 1024
         case 'table_name':
         case 'field_name':
             return 80
+        case 'glide_duration':
+            return 20
+        case 'glide_time':
+            return 8
+        case 'field_list':
+        case 'approval_rules':
+            return 1024
+        case 'slushbucket':
+            return 4000
         default:
             /**
              * For types mentioned below it default to 40 on instance

package/src/column/column-to-record.ts

@@ -28,6 +28,7 @@ export async function getDocumentationRecords(
                     name: $.from('table'),
                     element: $.val(columnName),
                     language: $.def('en'),
+                    hint: $.def(''),
                     label: $.val(documentation.ifDefined() ?? columnName),
                     plural: $.val(
                         generatePlural(
@@ -52,7 +53,7 @@ export async function getDocumentationRecords(
                         name: $.val(column.get('table')),
                         element: $.val(column.get('name')),
                         language: $,
-                        hint: $,
+                        hint: $.def(''),
                         help: $,
                         label: $,
                         plural: $,
@@ -78,6 +79,7 @@ export async function getDocumentationRecords(
                 name: $.from('table'),
                 element: $.val(columnName),
                 language: $.def('en'),
+                hint: $.def(''),
                 label: $.val(documentation.ifDefined() ?? columnName),
                 plural: $.val(
                     generatePlural(documentation.ifDefined()?.asString().getValue() ?? columnName.asString().getValue())
@@ -100,9 +102,7 @@ export async function getChoiceRecords(
     }
 
     const records: Record[] = []
-    for (const choiceValue of Object.keys(choiceArg.getValue())) {
-        // TODO Should have proper type here
-        const choice = choiceArg.get(choiceValue)
+    for (const [idx, [choiceValue, choice]] of Object.entries(choiceArg.properties()).entries()) {
         if (choice.isObject()) {
             generateDeprecatedDiagnostics(choice.withAliasedKeys(aliasedKeys), diagnostics)
         }
@@ -116,6 +116,8 @@ export async function getChoiceRecords(
                           element: column.get('name').asString().getValue(),
                           label: choice,
                           value: choiceValue,
+                          sequence: idx + 1,
+                          language: 'en',
                       }
                     : choice.asObject().transform(({ $ }) => ({
                           name: $.val(column.get('table')),