@servicenow/sdk-build-plugins 4.1.1 → 4.2.0

package/src/acl-plugin.ts

@@ -54,7 +54,7 @@ export const AclPlugin = Plugin.create({
                 },
             },
             toShape(record, { descendants }) {
-                const type = reverseLookup(AclTypes, record.get('type').getValue()) || record.get('type')
+                const type = reverseLookup(AclTypes, record.get('type').getValue() as string) || record.get('type')
                 const roles = descendants.query('sys_security_acl_role').map((m2m) => m2m.get('sys_user_role'))
 
                 return {
@@ -75,14 +75,14 @@ export const AclPlugin = Plugin.create({
                                     appliesTo: $.from('applies_to').def(''),
                                     type: $.val(type),
                                     securityAttribute: $.from('security_attribute')
-                                        .map((v) => reverseLookup(AclAttributes, v.getValue()) || v)
+                                        .map((v) => reverseLookup(AclAttributes, v.getValue() as string) || v)
                                         .def(''),
-                                    operation: $.map((v) => reverseLookup(AclOperations, v.getValue()) || v),
+                                    operation: $.map((v) => reverseLookup(AclOperations, v.getValue() as string) || v),
                                     script: $.map((v) => v.ifString()?.getValue()).def(''),
                                     roles: $.val(roles.length > 0 ? roles : undefined),
                                     [merge]: $.from('type', 'name').map((type, name) =>
                                         getTableOrName(
-                                            type.pipe((t) => reverseLookup(AclTypes, t.getValue())),
+                                            type.pipe((t) => reverseLookup(AclTypes, t.getValue() as string)),
                                             name.asString().getValue()
                                         )
                                     ),
@@ -159,8 +159,14 @@ export const AclPlugin = Plugin.create({
                         name: $.from('name', 'table', 'field').map(
                             (n, t, f) => n.ifString() ?? (f.ifString() ? `${t.getValue()}.${f.getValue()}` : t)
                         ),
-                        type: $.map((type) => AclTypes[type.asString().getValue()] ?? type),
-                        operation: $.map((op) => AclOperations[op.asString().getValue()] ?? op),
+                        type: $.map((type) => {
+                            const typeKey = type.asString().getValue()
+                            return AclTypes[typeKey as keyof typeof AclTypes] ?? type
+                        }),
+                        operation: $.map((op) => {
+                            const opKey = op.asString().getValue()
+                            return AclOperations[opKey as keyof typeof AclOperations] ?? op
+                        }),
                         advanced: $.val(advanced),
                         script: $.map(
                             (v) =>
@@ -168,7 +174,11 @@ export const AclPlugin = Plugin.create({
                                 v
                         ).toCdata(),
                         security_attribute: $.from('securityAttribute').map(
-                            (v) => v.ifString()?.pipe((v) => AclAttributes[v.getValue()]) ?? v
+                            (v) =>
+                                v.ifString()?.pipe((v) => {
+                                    const attrKey = v.getValue()
+                                    return AclAttributes[attrKey as keyof typeof AclAttributes]
+                                }) ?? v
                         ),
                     })),
                 })
@@ -243,7 +253,7 @@ export const AclPlugin = Plugin.create({
 })
 
 function getTableOrName(type: keyof typeof AclTypes, name: string) {
-    if (AclNamedTypes[type]) {
+    if (type in AclNamedTypes) {
         return { name }
     }
     const split = name.indexOf('.')
@@ -253,7 +263,7 @@ function getTableOrName(type: keyof typeof AclTypes, name: string) {
     return { table, ...(field ? { field } : {}) }
 }
 
-function reverseLookup<T extends object>(obj: T, sysId): keyof T {
+function reverseLookup<T extends object>(obj: T, sysId: string): keyof T {
     return (Object.entries(obj)
         .filter(([_, id]) => id === sysId)
         .map(([key]) => key)[0] || '') as keyof T

package/src/application-menu-plugin.ts

@@ -51,6 +51,7 @@ export const ApplicationMenuPlugin = Plugin.create({
                     value: new CallExpressionShape({
                         source: record,
                         callee: 'ApplicationMenu',
+                        exportName: record.get('sys_name')?.ifString()?.getValue(),
                         args: [
                             record.transform(({ $ }) => ({
                                 $id: $.val(NowIdShape.from(record)),

package/src/atf/step-configs.ts

@@ -5,28 +5,30 @@ export type ATFVariableInfo = {
     inputVariableId: string
     type: string
     order: number
-    default?: any
+    default?: unknown
     mandatory?: boolean
 }
 
 export type Category = keyof ATFType
 
-type FunctionParameters<F> = F extends (inputs: infer P) => any
+type FunctionParameters<F> = F extends (inputs: infer P) => unknown
     ? P extends object
         ? Exclude<keyof P, keyof StandardStepValues>
         : never
     : never
 
-type ToRecordStepMetadata = {
+export type StepMetadata<T extends FunctionParameters<unknown> = FunctionParameters<unknown>> = {
+    name: string
+    stepConfigId: string
+    variables: {
+        [K in T]: ATFVariableInfo
+    }
+    defaultTimeout?: string
+}
+
+export type ToRecordStepMetadata = {
     [C in keyof ATFType]: {
-        [FunctionName in keyof ATFType[C]]: {
-            name: string
-            stepConfigId: string
-            variables: {
-                [K in FunctionParameters<ATFType[C][FunctionName]>]: ATFVariableInfo
-            }
-            defaultTimeout?: string
-        }
+        [FunctionName in keyof ATFType[C]]: StepMetadata<FunctionParameters<ATFType[C][FunctionName]>>
     }
 }
 
@@ -2355,7 +2357,7 @@ export type ToShapeStepMetadata = Record<
                 field: string
                 type: string
                 mandatory: boolean
-                default?: any
+                default?: unknown
             }
         >
     }

package/src/atf/test-plugin.ts

@@ -20,9 +20,15 @@ import { NowIdShape } from '../now-id-plugin'
 import { ArrowFunctionShape } from '../arrow-function-plugin'
 import { create } from 'xmlbuilder2'
 import { Test } from '@servicenow/sdk-core/runtime/app'
-import { type ATFVariableInfo, type Category, ToShapeStepConfigs, ToRecordStepConfigs } from './step-configs'
+import {
+    type ATFVariableInfo,
+    type Category,
+    ToShapeStepConfigs,
+    ToRecordStepConfigs,
+    type StepMetadata,
+} from './step-configs'
 import { durationFieldToXML, formatDateToPlatformFormat, parseGlideDuration } from '@servicenow/sdk-build-core'
-import type { TimeDuration } from '@servicenow/sdk/core'
+import type { Duration } from '@servicenow/sdk/core'
 
 export const TestPlugin = Plugin.create({
     name: 'TestPlugin',
@@ -381,7 +387,7 @@ function getFieldValuesFromElementMappingRecords(elementMappingRecords: RecordSh
 }
 
 function convertTimeoutToSystemFormat(timeoutShape: Shape) {
-    const timeoutDuration = timeoutShape.ifObject()?.getValue() as TimeDuration | undefined
+    const timeoutDuration = timeoutShape.ifObject()?.getValue() as Duration | undefined
     const timeoutDate = timeoutDuration && durationFieldToXML(timeoutDuration)
     return timeoutDate && formatDateToPlatformFormat(timeoutDate)
 }
@@ -389,8 +395,9 @@ function convertTimeoutToSystemFormat(timeoutShape: Shape) {
 function anyStepsAreUnknown(stepRecords: RecordShape[], testName: string) {
     return stepRecords.some((stepRecord) => {
         const stepConfigId = stepRecord.get('step_config').toString().getValue()
-        if (!ToShapeStepConfigs[stepConfigId]) {
-            const stepConfigName = UNSUPPORTED_STEP_CONFIGS[stepConfigId] ?? stepConfigId
+        if (!ToShapeStepConfigs[stepConfigId as keyof typeof ToShapeStepConfigs]) {
+            const stepConfigName =
+                UNSUPPORTED_STEP_CONFIGS[stepConfigId as keyof typeof UNSUPPORTED_STEP_CONFIGS] ?? stepConfigId
             console.error(
                 `Unable to transform ATF test '${testName}' because of unsupported step_config: '${stepConfigName}'`
             )
@@ -436,7 +443,11 @@ function propertyAccessToGemExpression(
     return `{{step['${stepId}']${suffix}}}`
 }
 
-function createGemExpressionsFromShape(shape: Shape, stepRecords: RecordShape[], diagnostics: Diagnostics) {
+function createGemExpressionsFromShape(
+    shape: Shape,
+    stepRecords: RecordShape[],
+    diagnostics: Diagnostics
+): string | Record<string, unknown> | undefined {
     if (shape instanceof PropertyAccessShape) {
         return propertyAccessToGemExpression(shape, stepRecords, diagnostics)
     }
@@ -452,7 +463,7 @@ function createGemExpressionsFromShape(shape: Shape, stepRecords: RecordShape[],
     }
 
     if (shape instanceof ObjectShape) {
-        const obj = {}
+        const obj: Record<string, unknown> = {}
         let gemExpressionFound = false
         for (const key in shape.properties()) {
             const value = createGemExpressionsFromShape(shape.get(key, false), stepRecords, diagnostics)
@@ -499,23 +510,26 @@ function getStepInfoFromAtfCallExpression(
         return undefined
     }
 
-    const [, category, funcName] = callExpression.getCallee().split('.')
+    const [, category, funcName] = callExpression.getCallee().split('.') as [never, Category?, string?]
+
     if (!category || !funcName) {
         diagnostics.info(callExpression, 'Invalid ATF step')
         return undefined
     }
 
-    if (!ToRecordStepConfigs[category]) {
+    const categoryKey = category
+    if (!ToRecordStepConfigs[categoryKey]) {
         diagnostics.warn(callExpression, `Unknown category: ${category}`)
         return undefined
     }
 
-    if (!ToRecordStepConfigs[category][funcName]) {
+    const categorySteps = ToRecordStepConfigs[categoryKey]
+    if (!(funcName in categorySteps)) {
         diagnostics.warn(callExpression, `Unknown step: ${funcName}`)
         return undefined
     }
 
-    const stepConfig = ToRecordStepConfigs[category as Category][funcName]!
+    const stepConfig = categorySteps[funcName as keyof typeof categorySteps] as StepMetadata
     const values = callExpression.getArgument(0).asObject()
     return {
         displayName: stepConfig.name,
@@ -524,7 +538,7 @@ function getStepInfoFromAtfCallExpression(
         table: values.get('table')?.ifString(),
         source: callExpression,
         identifier,
-        defaultTimeout: stepConfig.defaultTimeout,
+        defaultTimeout: stepConfig.defaultTimeout as string,
         values,
     }
 }
@@ -566,14 +580,19 @@ function variableElementPathToPropertyAccess(source: Source, propertyAccessPath:
     })
 }
 
-function getElementMappingValues(source: Source, value: any, stepIdToVarName: Map<string, string>) {
+function getElementMappingValues(
+    source: Source,
+    value: unknown,
+    stepIdToVarName: Map<string, string>
+): object | object[] | string | undefined {
     if (typeof value === 'object' && value !== null) {
         if (Array.isArray(value)) {
             return value.map((v) => getElementMappingValues(source, v, stepIdToVarName))
         } else {
-            const obj = {}
-            for (const key in value) {
-                obj[key] = getElementMappingValues(source, value[key], stepIdToVarName)
+            const obj: Record<string, unknown> = {}
+            const valueObj = value
+            for (const key in valueObj) {
+                obj[key] = getElementMappingValues(source, valueObj[key as keyof typeof valueObj], stepIdToVarName)
             }
             return obj
         }
@@ -581,13 +600,13 @@ function getElementMappingValues(source: Source, value: any, stepIdToVarName: Ma
 
     const potentialGemExpression = typeof value === 'string' ? value : undefined
     if (!potentialGemExpression) {
-        return value
+        return value as string
     }
 
     const [matched] = Array.from(potentialGemExpression.matchAll(GemRegex))
     const simpleGemExpression = matched && matched[0] === potentialGemExpression
     if (!matched) {
-        return value
+        return value as string
     }
 
     // If the GEM expression is simple, it only contains the GEM
@@ -643,7 +662,7 @@ function getElementMappingValues(source: Source, value: any, stepIdToVarName: Ma
     })
 }
 
-function objectToEncodedQuery(objectShape: Record<string, any>) {
+function objectToEncodedQuery(objectShape: Record<string, object | string | number | boolean>) {
     return Object.entries(objectShape)
         .map(([key, value]) => {
             const escapedValue = value.toString().replaceAll('^', '^^')
@@ -653,7 +672,7 @@ function objectToEncodedQuery(objectShape: Record<string, any>) {
         .join('^')
 }
 
-export function serializeValueToRecord(value: any, type: string, defaultValue: any) {
+export function serializeValueToRecord(value: unknown, type: string, defaultValue: unknown) {
     value = value === undefined ? defaultValue : value
 
     switch (type) {
@@ -670,7 +689,7 @@ export function serializeValueToRecord(value: any, type: string, defaultValue: a
             return JSON.stringify(value)
         }
         case 'template_value':
-            return value && objectToEncodedQuery(value)
+            return value && objectToEncodedQuery(value as Record<string, object | string | number | boolean>)
         case 'boolean':
             return value ? 1 : 0
         default:

package/src/basic-syntax-plugin.ts

@@ -24,7 +24,11 @@ import {
     remove,
     isFluentFile,
     path as pathModule,
+    Record as DBRecord,
+    asDataHelper,
 } from '@servicenow/sdk-build-core'
+import { isDataHelper } from './data-plugin'
+import { getCallExpressionName } from './utils'
 
 export const BasicSyntaxPlugin = Plugin.create({
     name: 'BasicSyntaxPlugin',
@@ -70,8 +74,26 @@ 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 (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 +189,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 +304,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 +312,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 +351,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

@@ -7,10 +7,13 @@ 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 }
+        ) ?? {}
     )
 }
 

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