@servicenow/sdk-build-plugins 2.0.1 → 2.1.0

package/src/db/TablePlugin.ts

@@ -32,6 +32,7 @@ import {
     UserRolesColumn,
     VersionColumn,
     StringColumn,
+    Documentation,
 } from '@servicenow/sdk-core/runtime/db'
 import {
     Context,
@@ -53,20 +54,36 @@ import {
     generateCallExpressionExport,
     generateCallExpression,
     createPropertyIdentifier,
-    XMLJsonBuilder,
-    XMLJsonElement,
     ObjectData,
+    isSNScope,
+    GUID,
 } from '@servicenow/sdk-build-core'
-import { XMLBuilder } from 'fast-xml-parser'
-import { isArray, isEmpty, isObject, isString, parseInt } from 'lodash'
+import { create } from 'xmlbuilder2'
+import { isArray, isEmpty, isObject, parseInt } from 'lodash'
 import { z } from 'zod'
 import { RecordPlugin, TextBooleanSchema, TextNumberSchema, TextStringSchema } from './RecordPlugin'
-import { ScriptInfo, buildScriptImport, scriptInfo } from '../scripts/scriptUtils'
-import { SyntaxKind, Node, ts, ObjectLiteralExpression, CallExpression, Structure, SourceFile } from 'ts-morph'
+import {
+    SyntaxKind,
+    Node,
+    ts,
+    ObjectLiteralExpression,
+    CallExpression,
+    Structure,
+    SourceFile,
+    ImportDeclarationStructure,
+    PropertySignatureStructure,
+    InterfaceDeclarationStructure,
+    ImportSpecifierStructure,
+    OptionalKind,
+    ImportDeclaration,
+} from 'ts-morph'
 import { Diagnostic } from '@servicenow/sdk-project'
 import { formatScript } from '../ScriptTemplatePlugin'
 import * as os from 'os'
 import * as path from 'path'
+import { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
+import { getLabelDiagnostics } from './DBUtils'
+import { ModuleFunctionData } from '../ServerModulePlugin'
 
 /**
  * The access levels are mapped to the following values on the platform
@@ -92,7 +109,7 @@ export const TableSchemaFull = z.object({
      * if table definition not present locally */
     extends: z.string().optional(),
     /** Will match name if not provided, cannot exceed 80 characters */
-    label: z.string().max(80, 'Cannot exceed 80 characters').optional(),
+    label: z.string().max(80, 'Cannot exceed 80 characters').or(z.array(z.any())).optional(),
     /** Must match column name */
     display: z.string().optional(),
 
@@ -158,17 +175,18 @@ type IndexType = {
 
 // Everything which goes into a element with type='string/int/etc' in bootstrap.xml
 type ColumnSchema = z.infer<typeof ColumnSchema>
-export const ColumnSchema = z.object({
+const ColumnSchema = z.object({
     entityKind: z.string().optional(),
     column_type: z.string().optional(),
     audit: z.boolean().optional().default(false),
-    label: z.string().optional(),
+    label: z.string().or(z.array(z.any())).optional(),
     maxLength: z.number().optional().default(40),
     mandatory: z.boolean().optional().default(false),
     read_only: z.boolean().optional().default(false),
     default: z.any().optional(),
     attributes: z.record(z.string(), z.union([z.string(), z.boolean(), z.number()])).optional(),
     referenceTable: z.string().optional(),
+    cascadeRule: z.string().optional(),
     dropdown: z.enum(choiceDropdown).default('none').optional(),
     choices: z.record(z.any()).or(z.array(z.any())).optional(),
     choice_elements: z.record(z.any()).or(z.array(z.any())).optional(),
@@ -232,7 +250,7 @@ const DBObjectIncomingAttributes = z.object({
 export const TableSchemaBootstrap = z.object({
     name: z.string(),
     extends: z.string().optional(),
-    label: z.string().max(80, 'Cannot exceed 80 characters').optional(),
+    label: z.string().max(80, 'Cannot exceed 80 characters').or(z.array(z.any())).optional(),
 
     // Controls
     extensible: z.boolean().optional().default(false),
@@ -306,7 +324,7 @@ const DBObjectIncoming = z.object({
     sys_db_object: z.record(z.any()),
 })
 
-export const Documentation = z.object({
+export const SysDocumentation = z.object({
     sys_documentation: z.object({
         element: TextStringSchema.optional(),
         label: TextStringSchema.optional(),
@@ -315,6 +333,7 @@ export const Documentation = z.object({
         help: TextStringSchema.optional(),
         name: TextStringSchema.optional(),
         plural: TextStringSchema.optional(),
+        sys_id: TextStringSchema.optional(),
         url: TextStringSchema.optional(),
         url_target: TextStringSchema.optional(),
     }),
@@ -326,7 +345,7 @@ export const TableSchemaBootstrapAttributes = z
         '@_name': z.string(),
         '@_extends': z.string().optional(),
         '@_label': z.string().optional(),
-        '@_max_length': z.coerce.number().optional(),
+        '@_max_length': z.any().optional(),
 
         // From sys_dictionary
         '@_audit': BooleanFromString,
@@ -415,10 +434,6 @@ type ComposedTableData = {
     }
 }
 
-function isSNScope(scopeName: string) {
-    return scopeName.startsWith('sn') || scopeName.startsWith('now')
-}
-
 export default Plugin({
     name: 'Table',
     ownedTables: {
@@ -426,92 +441,94 @@ export default Plugin({
     },
     extractors: {
         entity: {
-            // TODO: Cast to `any` is temporary workaround for the circular nature of Table entities
-            CallExpression: (node, context) => {
-                const result = extractCallExpression(Table, 'table', node, context, (table) => table.name)
-                if (!result.handled || !(0 in result.data)) {
-                    return result
-                }
+            fluent: {
+                // TODO: Cast to `any` is temporary workaround for the circular nature of Table entities
+                CallExpression: (node, context) => {
+                    const result = extractCallExpression(Table, 'table', node, context, (table) => table.name)
+                    if (!result.handled || !(0 in result.data)) {
+                        return result
+                    }
 
-                const data = result.data[0]
-                const diagnostics = result.diagnostics
-                const scopeName = context.app.config.scope
-                const scopeRegex = new RegExp(`^${scopeName}_`)
-                const nameRegex = new RegExp(`^[a-z_][a-z0-9_]`)
-                const tableName = data.getProperty('name')
-                const scopeMatches = tableName.getValue().match(scopeRegex)
-
-                if (!scopeMatches) {
-                    const nameNode = tableName.getNode().asKindOrThrow(SyntaxKind.StringLiteral)
-                    if (nameNode.getParent().getKindName() !== 'AsExpression') {
+                    const data = result.data[0]
+                    const diagnostics = result.diagnostics
+                    const scopeName = context.app.config.scope
+                    const scopeRegex = new RegExp(`^${scopeName}_`)
+                    const columnNameRegex = new RegExp(`^[a-z_][a-z0-9_]*$`)
+                    const tableNameRegex = new RegExp(`^[a-z_][a-z0-9_]*[a-z0-9]$`)
+                    const tableName = data.getProperty('name')
+                    const scopeMatches = tableName.getValue().match(scopeRegex)
+                    let ignoreColumnNameCheck = false
+
+                    if (!tableName.getValue().match(tableNameRegex)) {
                         diagnostics.push(
                             new FluentDiagnostic(
                                 tableName.getNode(),
-                                `'name' property must start with scope prefix '${scopeName}'`
+                                `Table name must only contain lowercase letters, numbers, and underscores and end with a letter or number`
                             )
                         )
                     }
-                }
 
-                const schema = data.getProperty('schema')
-                const schemaNode = schema.getNode().asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
-                for (const columnName in schema.getValue()) {
-                    const columnNode = schemaNode.getPropertyOrThrow(columnName)
-                    if (!scopeMatches && !isSNScope(scopeName) && !columnName.match(scopeRegex)) {
-                        diagnostics.push(
-                            new FluentDiagnostic(
-                                columnNode,
-                                `Column name must be prefixed with scope '${scopeName}' if table name does not contain prefix`
+                    if (!scopeMatches) {
+                        const nameNode = tableName.getNode().asKindOrThrow(SyntaxKind.StringLiteral)
+                        if (nameNode.getParent().getKindName() !== 'AsExpression') {
+                            diagnostics.push(
+                                new FluentDiagnostic(
+                                    tableName.getNode(),
+                                    `'name' property must start with scope prefix '${scopeName}'`
+                                )
                             )
-                        )
+                        } else {
+                            ignoreColumnNameCheck = true
+                        }
                     }
 
-                    if (!columnName.match(nameRegex)) {
+                    const schema = data.getProperty('schema')
+                    const schemaNode = schema.getNode().asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                    for (const columnName in schema.getValue()) {
+                        const columnNode = schemaNode.getPropertyOrThrow(columnName)
+                        if (
+                            !ignoreColumnNameCheck &&
+                            !scopeMatches &&
+                            !isSNScope(scopeName) &&
+                            !columnName.match(scopeRegex)
+                        ) {
+                            diagnostics.push(
+                                new FluentDiagnostic(
+                                    columnNode,
+                                    `Column name must be prefixed with scope '${scopeName}' if table name does not contain prefix`
+                                )
+                            )
+                        }
+
+                        if (!columnName.match(columnNameRegex)) {
+                            diagnostics.push(
+                                new FluentDiagnostic(
+                                    columnNode,
+                                    `Column name must only contain lowercase letters, numbers, and underscores`
+                                )
+                            )
+                        }
+                    }
+
+                    const declaration = node.getParentIfKind(SyntaxKind.VariableDeclaration)
+                    if (
+                        !declaration ||
+                        !declaration.isExported() ||
+                        !declaration.isNamedExport() ||
+                        declaration.getName() !== tableName.getValue()
+                    ) {
                         diagnostics.push(
                             new FluentDiagnostic(
-                                columnNode,
-                                `Column name must only contain lowercase letters, numbers, and underscores`
+                                node,
+                                `Table definition should be exported as a named export with the name '${tableName.getValue()}'`,
+                                { level: Diagnostic.Level.Warn }
                             )
                         )
                     }
-                }
-
-                const declaration = node.getParentIfKind(SyntaxKind.VariableDeclaration)
-                if (
-                    !declaration ||
-                    !declaration.isExported() ||
-                    !declaration.isNamedExport() ||
-                    declaration.getName() !== tableName.getValue()
-                ) {
-                    diagnostics.push(
-                        new FluentDiagnostic(
-                            node,
-                            `Table definition should be exported as a named export with the name '${tableName.getValue()}'`,
-                            { level: Diagnostic.Level.Warn }
-                        )
-                    )
-                }
 
-                return { handled: true, data: [data], diagnostics }
-            },
-        },
-        raw: {
-            FunctionDeclaration(node, context) {
-                const info = scriptInfo(node, context, Table.name)
-                if (!info) {
-                    return { handled: false }
-                }
-
-                return { handled: true, diagnostics: [], data: [info] }
-            },
-
-            FunctionExpression(node, context) {
-                const info = scriptInfo(node, context, Table.name)
-                if (!info) {
-                    return { handled: false }
-                }
-
-                return { handled: true, diagnostics: [], data: [info] }
+                    diagnostics.push(...getLabelDiagnostics(data))
+                    return { handled: true, data: [data], diagnostics }
+                },
             },
         },
         xml(xml, context) {
@@ -551,16 +568,16 @@ export default Plugin({
                     }
 
                     if (table === 'sys_documentation') {
-                        const data = Documentation.parse(record_update[table])
+                        const data = SysDocumentation.parse(record_update[table]).sys_documentation
                         return new XmlData(
                             {
                                 table: table,
-                                id: record_update[table][table]['sys_id']['#text'],
-                                data: data.sys_documentation,
+                                id: record_update[table][table]['sys_id']?.['#text'] ?? GUID(),
+                                data,
                             },
                             xml.filePath,
-                            'record',
-                            record_update[table][table]['@_action']
+                            'sys_documentation',
+                            record_update[table]['@_action']
                         )
                     }
 
@@ -623,12 +640,15 @@ export default Plugin({
                 const table = TableSchemaFull.parse(data)
 
                 const composeData = compose(table)
-                composeData['columns'] = composeColumns(
+                const { columnData, documentation } = composeColumns(
                     table.schema as Record<string, ColumnSchema>,
                     context,
+                    table.name,
                     table.display
                 )
 
+                composeData['columns'] = columnData
+
                 const entities: LinkedDocument[] = []
                 if (table.auto_number) {
                     const data = table.auto_number
@@ -650,6 +670,25 @@ export default Plugin({
                     composeData['number_ref'] = composedNumber.guid
                 }
 
+                documentation.forEach((doc) => {
+                    entities.push({
+                        kind: 'sys_documentation',
+                        node: node,
+                        data: doc,
+                        guid: doc.$id as string,
+                    })
+                })
+
+                const docs = composeDocumentation('', table.name, table.label)
+                docs.forEach((doc) => {
+                    entities.push({
+                        kind: 'sys_documentation',
+                        node: node,
+                        data: doc,
+                        guid: doc.$id as string,
+                    })
+                })
+
                 composeData['index'] = table.index
 
                 entities.push({
@@ -734,42 +773,23 @@ export default Plugin({
                 attributes['live_feed'] = true
             }
 
-            const builder = new XMLJsonBuilder('1.0')
-            const databaseObj = builder.createRoot('database', undefined, undefined)
+            const root = create({ version: '1.0' }).ele('database')
             const composedAttributes = composeAttributes(attributes)
-            const collectionObj = databaseObj.addJsonObj(
-                'element',
-                undefined,
-                { ...bootstrapData, attributes: composedAttributes }!
-            )
+            const collection = root.ele('element', { ...bootstrapData, attributes: composedAttributes }!)
             for (const column of Object.values(columns)) {
                 const { choice_elements, attributes, ...parsedColumn } = column as ColumnSchema
                 const columnAttributes = composeAttributes(attributes)
-                const elementObj = collectionObj.addJsonObj(
-                    'element',
-                    undefined,
-                    {
-                        ...(parsedColumn as any),
-                        attributes: columnAttributes,
-                    }!
-                )
+                const element = collection.ele('element', { ...parsedColumn, attributes: columnAttributes }!)
 
-                buildChoices(column as ColumnSchema, elementObj)
+                buildChoices(column as ColumnSchema, element)
             }
 
-            buildIndexes(index, collectionObj)
-
-            const bootstrapXmlJson = new XMLBuilder({
-                ignoreAttributes: false,
-                format: true,
-                suppressBooleanAttributes: false,
-                suppressEmptyNode: true,
-            }).build(builder.buildJsonObj())
+            buildIndexes(index, collection)
 
             return {
                 name: `${bootstrapData.name}.xml`,
                 directory: 'dictionary',
-                content: bootstrapXmlJson,
+                content: root.end({ prettyPrint: true }),
                 usedIds: [],
             }
         },
@@ -863,13 +883,72 @@ export default Plugin({
     },
     postProcessors: {
         entities(entities, context) {
+            const { interfaces, properties, imports, namedImports } = {
+                interfaces: [] as OptionalKind<InterfaceDeclarationStructure>[],
+                properties: [] as OptionalKind<PropertySignatureStructure>[],
+                imports: {} as Record<string, OptionalKind<ImportDeclarationStructure>>,
+                namedImports: [] as (OptionalKind<ImportSpecifierStructure> & {
+                    existingImport: ImportDeclaration
+                })[],
+            }
+            const generatedTableFile: SourceFile | undefined = context.compiler.getGeneratedTableFile()
             entities
                 .filter((entity) => entity.getKind() === 'table')
                 .forEach((table) => {
                     const tableName = table.getProperty('name')!.getValue() as string
-                    const originalSourceFilePath = path.normalize(table.getNode().getSourceFile().getFilePath())
-                    context.compiler.addTableInterfaceToGlobalDeclaration(originalSourceFilePath, tableName)
+                    const extendsTable = table.getProperty('extends')?.getValue() as string
+                    if (tableName && tableName.trim().length > 0) {
+                        if (!context.compiler.interfaceExistsInGlobalDeclaration(tableName)) {
+                            interfaces.push({
+                                name: tableName,
+                                extends: [`Helper<typeof ${tableName}>`],
+                            })
+                        }
+                        if (!context.compiler.propertyExistsInGlobalDeclaration(tableName)) {
+                            let interfaceType = `Table<TableSchemas.${tableName}>`
+                            if (extendsTable) {
+                                interfaceType = `Table<TableSchemas.${tableName}, "${extendsTable}">`
+                            }
+                            properties.push({
+                                name: tableName,
+                                type: interfaceType,
+                            })
+                        }
+
+                        const filePath = path.normalize(table.getNode().getSourceFile().getFilePath())
+                        const resolvedModuleSpecifier = generatedTableFile?.getRelativePathAsModuleSpecifierTo(
+                            filePath
+                        ) as string
+                        const importExists = context.compiler.importExistsInGlobalDeclaration(tableName)
+
+                        if (!importExists) {
+                            if (imports[filePath]) {
+                                ;(imports[filePath].namedImports! as string[]).push(tableName)
+                            } else {
+                                imports[filePath] = {
+                                    namedImports: [tableName],
+                                    moduleSpecifier: resolvedModuleSpecifier,
+                                }
+                            }
+                        } else {
+                            const namedImportExists = importExists
+                                ?.getNamedImports()
+                                .find((value) => value.getName() === tableName)
+                            if (!namedImportExists) {
+                                namedImports.push({
+                                    existingImport: importExists,
+                                    name: tableName,
+                                })
+                            }
+                        }
+                    }
                 })
+            context.compiler.addTableInterfacesToGlobalDeclaration({
+                interfaces,
+                properties,
+                imports,
+                namedImports,
+            })
         },
     },
 })
@@ -908,19 +987,52 @@ function updateDisplayValue(node: CallExpression, columns: ColumnSchema, incomin
     }
 }
 
-function composeColumns(columns: Record<string, ColumnSchema>, context: Context, display?: string) {
+function composeDocumentation(columnName: string, tableName: string, labels?: string | Documentation[]): NowRecord[] {
+    const labelData: NowRecord[] = []
+
+    if (!labels || !isArray(labels)) {
+        return labelData
+    }
+
+    labels.forEach((label) => {
+        const labelValue = label.label ?? columnName !== '' ? columnName : tableName
+        labelData.push(
+            NowRecord({
+                table: 'sys_documentation',
+                $id: `${tableName}_${columnName ? columnName + '_' : ''}${label.language}`,
+                data: { label: labelValue, element: columnName, name: tableName, ...label },
+            })
+        )
+    })
+    return labelData
+}
+
+function getLabel(label?: string | Documentation[]): string | undefined {
+    if (!label || isArray(label)) {
+        // use column name if no label specified
+        return
+    }
+
+    // label is an explicit string value
+    return label
+}
+
+function composeColumns(columns: Record<string, ColumnSchema>, _context: Context, tableName: string, display?: string) {
     const composedColumns = {}
+    const documentation: NowRecord[] = []
     for (const [columnName, columnData] of Object.entries(columns)) {
-        const column = ColumnSchema.parse(columnData)
+        const { maxLength, ...rest } = columnData
+        const column = ColumnSchema.parse(rest)
         const requiresDropdown = column.dynamic_value_definitions || column.choices
         const element = {
             name: columnName,
             type: column.entityKind === 'generic' ? column.column_type : column.entityKind,
             attributes: column.attributes ?? undefined,
             reference: column.referenceTable,
+            reference_cascade_rule: column.referenceTable ? column.cascadeRule : undefined,
             audit: column.audit,
-            label: column.label ?? columnName,
-            max_length: column.maxLength,
+            label: getLabel(column.label) ?? columnName,
+            max_length: maxLength ?? column.maxLength,
             mandatory: column.mandatory,
             read_only: column.read_only,
             choice: choiceDropdown.indexOf(column.dropdown ?? requiresDropdown ? 'dropdown_with_none' : 'none'),
@@ -930,7 +1042,10 @@ function composeColumns(columns: Record<string, ColumnSchema>, context: Context,
             virtual: column.dynamic_value_definitions?.type === 'calculated_value' ? true : undefined,
             calculation:
                 column.dynamic_value_definitions?.type === 'calculated_value'
-                    ? getScriptInfo(column.dynamic_value_definitions!['calculated_value'], context)
+                    ? ModuleFunctionData.getGlueCode(
+                          column.dynamic_value_definitions!['calculated_value'],
+                          (n) => `${n}(current)`
+                      )
                     : undefined,
             choice_table:
                 column.dynamic_value_definitions?.type === 'choices_from_other_table'
@@ -961,6 +1076,8 @@ function composeColumns(columns: Record<string, ColumnSchema>, context: Context,
             function_field: column.function_definition ? true : false,
         }
 
+        documentation.push(...composeDocumentation(columnName, tableName, column.label))
+
         if (column.choices) {
             Object.keys(column.choices).forEach((key) => {
                 if (isObject(column.choices![key])) {
@@ -974,7 +1091,7 @@ function composeColumns(columns: Record<string, ColumnSchema>, context: Context,
 
         composedColumns[columnName] = element
     }
-    return composedColumns
+    return { columnData: composedColumns, documentation }
 }
 
 function compose(bootstrapData: z.infer<typeof TableSchemaBootstrap>) {
@@ -991,7 +1108,7 @@ function compose(bootstrapData: z.infer<typeof TableSchemaBootstrap>) {
         name: bootstrapData.name,
         type: 'collection',
         extends: bootstrapData.extends,
-        label: bootstrapData.label ?? bootstrapData.name,
+        label: getLabel(bootstrapData.label) ?? bootstrapData.name,
 
         // Controls
         is_extendable: bootstrapData.extensible,
@@ -1095,27 +1212,30 @@ function getActionsArray(data) {
     return actions
 }
 
-function getDynamicDefault(val: string) {
+function getDynamicDefault(val: string | undefined) {
+    if (!val) {
+        return
+    }
     return val.startsWith('javascript:') ? val : `javascript:${dynamic_value_mapping[val]}`
 }
 
-function buildIndexes(indexes: IndexType[] = [], collection: XMLJsonElement) {
+function buildIndexes(indexes: IndexType[] = [], collection: XMLBuilder) {
     indexes.forEach((index) => {
-        const indexElement = collection.addJsonObj('index', undefined, { name: index.name, unique: index.unique })
-        indexElement.addJsonObj('element', undefined, { name: index.element })
+        const indexElement = collection.ele('index', { name: index.name, unique: index.unique })
+        indexElement.ele('element', { name: index.element })
     })
 }
 
-function buildChoices(column: ColumnSchema, element: XMLJsonElement) {
+function buildChoices(column: ColumnSchema, element: XMLBuilder) {
     if (!column.choice_elements) {
         return
     }
 
-    const choices = element.addJsonObj('choice', undefined, undefined)
+    const choices = element.ele('choice')
     if (Array.isArray(column.choices) && column.choices.length > 0) {
         // Formatted - choices: [1, 2, 3, 4]
         for (const choice in column.choices) {
-            choices.addJsonObj('element', undefined, {
+            choices.ele('element', {
                 value: column.choices[choice],
                 label: column.choices[choice],
             })
@@ -1124,12 +1244,12 @@ function buildChoices(column: ColumnSchema, element: XMLJsonElement) {
         // Formatted - choices: { 1: { label: 'label' }, 2: { lable: label 2}, ...}
         Object.entries(column.choice_elements).forEach((value) => {
             if (isObject(value[1])) {
-                choices.addJsonObj('element', undefined, {
+                choices.ele('element', {
                     value: value[0],
                     ...(value[1] as ChoiceConfig),
                 })
             } else {
-                choices.addJsonObj('element', undefined, {
+                choices.ele('element', {
                     value: value[1],
                     label: value[0],
                 })
@@ -1157,11 +1277,12 @@ export function transformColumnData(col: any, callExpFromType: any) {
         default: def,
         max_length,
         reference,
+        reference_cascade_rule,
         function_field,
         ...column
     } = col
 
-    if (max_length) {
+    if (max_length !== undefined) {
         column.maxLength = max_length
     }
 
@@ -1175,6 +1296,10 @@ export function transformColumnData(col: any, callExpFromType: any) {
 
     if (reference) {
         column.referenceTable = reference
+
+        if (reference_cascade_rule) {
+            column.cascadeRule = reference_cascade_rule
+        }
     }
 
     // Handle dynamic values
@@ -1226,21 +1351,6 @@ function isDefaultEdgeEncryptionAttribute(attributes: any) {
     )
 }
 
-function getScriptInfo(scriptInfo: ScriptInfo | string, context: Context) {
-    if (isString(scriptInfo)) {
-        return scriptInfo
-    }
-    const { filePath, functionName, isDefault } = scriptInfo
-    const script = buildScriptImport(
-        filePath,
-        functionName,
-        isDefault,
-        context,
-        (funcName: string) => `;${funcName}(current)`
-    )
-    return script.replaceAll('\n', '')
-}
-
 function removeAttributeTag(obj: any) {
     Object.entries(obj).forEach(([key, value]) => {
         if (key.startsWith('@_')) {
@@ -1330,6 +1440,21 @@ export function createObjectExpression(firstArg: object): ts.Expression {
                             ts.factory.createNoSubstitutionTemplateLiteral(calVal, calVal)
                         )
                     )
+                } else if (key === 'maxLength') {
+                    if (isNaN(+value)) {
+                        return ts.factory.createPropertyAssignment(
+                            ts.factory.createIdentifier(key),
+                            ts.factory.createAsExpression(
+                                ts.factory.createStringLiteral(value),
+                                ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                            )
+                        )
+                    }
+
+                    return ts.factory.createPropertyAssignment(
+                        ts.factory.createIdentifier(key),
+                        ts.factory.createNumericLiteral(value)
+                    )
                 }
                 return ts.factory.createPropertyAssignment(
                     createPropertyIdentifier(key),
@@ -1388,6 +1513,9 @@ type Undefined<T> = {
 }
 export function getCallExpressionFromType(internal_type: string) {
     switch (internal_type) {
+        case undefined:
+        case 'string':
+            return StringColumn
         case 'boolean':
             return BooleanColumn
         case 'choice':
@@ -1440,8 +1568,6 @@ export function getCallExpressionFromType(internal_type: string) {
             return UserRolesColumn
         case 'version':
             return VersionColumn
-        case 'string':
-            return StringColumn
         case 'int':
         case 'string_types':
         case 'approval_rules':