@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/db/TablePlugin.ts

@@ -1,2072 +0,0 @@
-import {
-    ChoiceConfig,
-    Table,
-    Record as NowRecord,
-    TableName,
-    choiceDropdown,
-    DateColumn,
-    BasicDateTimeColumn,
-    GenericColumn,
-    BooleanColumn,
-    ChoiceColumn,
-    IntegerDateColumn,
-    ScheduleDateTimeColumn,
-    ConditionsColumn,
-    DateTimeColumn,
-    CalendarDateTimeColumn,
-    DueDateColumn,
-    OtherDateColumn,
-    DecimalColumn,
-    DocumentIdColumn,
-    DomainIdColumn,
-    DomainPathColumn,
-    FieldNameColumn,
-    IntegerColumn,
-    RadioColumn,
-    ReferenceColumn,
-    ScriptColumn,
-    SystemClassNameColumn,
-    TableNameColumn,
-    TranslatedFieldColumn,
-    TranslatedTextColumn,
-    UserRolesColumn,
-    VersionColumn,
-    StringColumn,
-    Documentation,
-    ListColumn,
-    BasicImageColumn,
-} from '@servicenow/sdk-core/runtime/db'
-import {
-    Context,
-    EntityData,
-    LinkedDocument,
-    Plugin,
-    extractCallExpression,
-    getCallExpressionName,
-    getOrCreateEntitySourceFile,
-    getOrCreatePropertyAssignment,
-    linkDocument,
-    removeNode,
-    stringify,
-    transformFunctionArguments,
-    XmlData,
-    FluentDiagnostic,
-    generateCallExpression,
-    createPropertyIdentifier,
-    ObjectData,
-    isSNScope,
-    GUID,
-    mergeDataIntoObjectLiteral,
-    getPropertyAssignment,
-    mergeDataIntoObjectLiteralArray,
-    addNamedImportIfAbsent,
-    generateCallExpressionExportForDocument,
-    Document,
-    generateCallExpressionExport,
-    PartialElements,
-    getObjectPropertyAssignmentName,
-} from '@servicenow/sdk-build-core'
-import { create } from 'xmlbuilder2'
-import { isArray, isEmpty, isObject, parseInt } from 'lodash'
-import { z } from 'zod'
-import { RecordPlugin, TextBooleanSchema, TextNumberSchema, TextStringSchema } from './RecordPlugin'
-import { Diagnostic, ts, tsc } from '@servicenow/sdk-project'
-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
- *
- * - `none`: 0
- * - `tracking`: 1
- * - `restricted`: 2
- *
- */
-const callerAccess = ['none', 'tracking', 'restricted'] as const
-
-// Basic info needed for table references
-const TableSchemaFull = z.object({
-    /** lowercase, one word name. Numbers, letters and underscores only */
-    name: z.string(),
-    /** Object literal of column names with <type>Column() calls as values.
-     * Ex. { column_name_1: StringColumn({...args}), column_name_2: IntegerColumn({...args}), }
-     * Import column definitions from `@servicenow/sdk-core/db`
-     */
-    schema: z.record(z.record(z.any())).default({}),
-    /** Table as a string, this table will inherit schema from extends table.
-     * Escape with `` (import from `@servicenow/sdk-core/global`)
-     * if table definition not present locally */
-    extends: z.string().optional(),
-    /** Will match name if not provided */
-    label: z.string().or(z.array(z.any())).optional(),
-    /** Must match column name */
-    display: z.string().optional(),
-
-    // Controls
-    extensible: z.boolean().optional().default(false),
-    live_feed: z.boolean().optional().default(false),
-
-    /** sys_number to create auto prefixing. Specify as Object literal */
-    auto_number: z
-        .object({
-            prefix: z.string().default('pre').optional(),
-            number: z.number().default(1000).optional(),
-            number_of_digits: z.number().default(7).optional(),
-        })
-
-        .optional(),
-
-    // Application Access
-    accessible_from: z
-        .union([z.literal('package_private'), z.literal('public')])
-        .optional()
-        .default('public'),
-    caller_access: z.enum(callerAccess).optional(),
-    /** Array of read, update, create, delete actions (['read', 'update',...])*/
-    actions: z
-        .array(z.union([z.literal('read'), z.literal('update'), z.literal('delete'), z.literal('create')]))
-        .optional(),
-
-    allow_web_service_access: z.boolean().optional().default(false),
-    allow_new_fields: z.boolean().optional().default(false),
-    allow_ui_actions: z.boolean().optional().default(false),
-    allow_client_scripts: z.boolean().optional().default(false),
-
-    // From sys_dictionary
-    audit: z.boolean().optional().default(false),
-    read_only: z.boolean().optional().default(false),
-    text_index: z.boolean().optional().default(false),
-
-    /** Object literal of key value pairs corresponding to attributes */
-    attributes: z.record(z.union([z.string(), z.number(), z.boolean()])).optional(),
-
-    /** Array of objects [{ { name: <columnName>, element: ...,}...}] */
-    index: z
-        .array(
-            z.object({
-                name: z.string(),
-                unique: z.boolean(),
-                element: z
-                    .string()
-                    .or(z.array(z.string()))
-                    .transform((el) => (isArray(el) ? el : [el])),
-            })
-        )
-        .optional(),
-
-    licensing_config: z.record(z.any()).optional(),
-    scriptable_table: z.boolean().default(false),
-})
-
-const componentTables = ['sys_dictionary', 'sys_choice', 'sys_documentation', 'ua_table_licensing_config']
-
-type IndexType = {
-    name: string
-    unique: boolean
-    element: string[] | string
-}
-
-// Everything that goes into a table
-// Everything which goes into a element with type='string/int/etc' in bootstrap.xml
-type ColumnSchema = z.infer<typeof ColumnSchema>
-const ColumnSchema = z.object({
-    entityKind: z.string().optional(),
-    column_type: z.string().optional(),
-    audit: z.boolean().optional().default(false),
-    label: z.string().or(z.array(z.any())).optional(),
-    maxLength: z.number().optional(),
-    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(),
-    display: z.boolean().default(false).optional(),
-    function_definition: z.string().optional(),
-    dynamic_value_definitions: z
-        .object({
-            type: z.union([
-                z.literal('dynamic_default'),
-                z.literal('choices_from_other_table'),
-                z.literal('calculated_value'),
-                z.literal('dependent_field'),
-            ]),
-        })
-        .and(z.any())
-        .optional(),
-    plural: z.string().optional(),
-    hint: z.string().optional(),
-    help: z.string().optional(),
-    widget: z.string().optional(),
-    table_reference: z.boolean().optional(),
-    reference_floats: z.boolean().optional(),
-    dynamic_creation: z.boolean().optional(),
-    dynamic_creation_script: z.string().optional(),
-    element_reference: z.boolean().optional(),
-    spell_check: z.boolean().optional(),
-    xml_view: z.boolean().optional(),
-    array: z.boolean().optional(),
-    text_index: z.boolean().optional(),
-    primary: z.boolean().optional(),
-    unique: z.boolean().optional(),
-    reference_key: z.string().optional(),
-    reference_qual: z.string().optional(),
-})
-
-const BooleanFromString = z
-    .string()
-    .transform((str) => str === 'true')
-    .or(z.boolean())
-    .optional()
-
-const IntFromString = z
-    .string()
-    .transform((str) => parseInt(str))
-    .or(z.number())
-    .optional()
-
-// These fields transform from sys_db_object only, not bootstrap. (Except name, which is needed to match)
-const DBObjectIncomingAttributes = z.object({
-    name: TextStringSchema.or(z.string()).optional(),
-
-    read_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    create_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    update_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    delete_access: TextBooleanSchema.or(BooleanFromString).optional(),
-
-    ws_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    caller_access: TextNumberSchema.or(IntFromString)
-        .transform((val) => {
-            if (val) {
-                return callerAccess[val]
-            }
-            return
-        })
-        .optional(),
-    alter_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    client_scripts_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    actions_access: TextBooleanSchema.or(BooleanFromString).optional(),
-    //configuration_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
-
-    is_extendable: TextBooleanSchema.or(BooleanFromString).optional(),
-    // live_feed_enabled: TextBooleanSchema.or(BooleanFromString).optional().default(false),
-
-    access: TextStringSchema.or(z.string()).optional(),
-
-    scriptable_table: TextBooleanSchema.or(BooleanFromString).optional(),
-})
-
-// Attributes in the element='collection' tag of bootstrap xml
-const TableSchemaBootstrap = z.object({
-    name: z.string(),
-    extends: z.string().optional(),
-    label: z.string().or(z.array(z.any())).optional(),
-
-    // Controls
-    extensible: z.boolean().optional().default(false),
-    live_feed: z.boolean().optional().default(false),
-
-    auto_number: z
-        .object({
-            prefix: z.string().default('pre').optional(),
-            number: z.number().default(1000).optional(),
-            number_of_digits: z.number().default(7).optional(),
-        })
-        .optional(),
-
-    number_ref: z.any().optional(),
-
-    // Application Access
-    accessible_from: z
-        .union([z.literal('public'), z.literal('package_private')])
-        .optional()
-        .default('public'),
-    caller_access: z.enum(callerAccess).default('none').optional(),
-
-    actions: z
-        .array(z.union([z.literal('read'), z.literal('update'), z.literal('delete'), z.literal('create')]))
-        .default(['read'])
-        .optional(),
-
-    allow_web_service_access: z.boolean().optional().default(true),
-    allow_new_fields: z.boolean().optional().default(false),
-    allow_ui_actions: z.boolean().optional().default(false),
-    allow_client_scripts: z.boolean().optional().default(false),
-
-    // From sys_dictionary
-    audit: z.boolean().optional().default(false),
-    read_only: z.boolean().optional().default(false),
-    text_index: z.boolean().optional().default(false),
-
-    scriptable_table: z.boolean().optional().default(false),
-
-    attributes: z
-        .record(z.union([z.string(), z.number(), z.boolean()]))
-        .default({})
-        .optional(),
-})
-
-const TableSchemaBootstrapIncoming = TableSchemaBootstrap.omit({ actions: true }).extend({
-    caller_access: z
-        .union([z.literal(0), z.literal(1), z.literal(2)])
-        .transform((val) => {
-            if (val) {
-                return callerAccess[val]
-            }
-            return
-        })
-        .optional(),
-    accessible_from: z.union([z.literal('public'), z.literal('package_private')]).optional(),
-    extends: z
-        .string()
-        .or(z.object({ name: z.string() }).transform((obj) => obj.name))
-        .optional(),
-    live_feed: z.boolean().optional().default(false),
-    index: z.any().optional(),
-    columns: z.any().optional(),
-})
-
-// Everything in side <database> in boostrap.xml
-const BootstrapDatabaseElement = z.object({
-    element: z.record(z.any()),
-})
-
-const DBObjectIncoming = z.object({
-    '@_table': z.literal('sys_db_object'),
-    sys_db_object: z.record(z.any()),
-})
-
-const SysDocumentation = z.object({
-    sys_documentation: z.object({
-        element: TextStringSchema.optional(),
-        label: TextStringSchema.optional(),
-        language: TextStringSchema.optional(),
-        hint: TextStringSchema.optional(),
-        help: TextStringSchema.optional(),
-        name: TextStringSchema.optional(),
-        plural: TextStringSchema.optional(),
-        sys_id: TextStringSchema.optional(),
-        url: TextStringSchema.optional(),
-        url_target: TextStringSchema.optional(),
-    }),
-})
-
-const LicensingConfig = z.object({
-    ua_table_licensing_config: z.object({
-        name: TextStringSchema.optional(),
-        op_insert: TextBooleanSchema.optional(),
-        op_update: TextBooleanSchema.optional(),
-        op_delete: TextBooleanSchema.optional(),
-        is_fulfillment: TextBooleanSchema.optional(),
-        license_model: TextStringSchema.optional(),
-        owner_condition: TextStringSchema.optional(),
-        license_condition: TextStringSchema.optional(),
-        license_roles: TextStringSchema.optional(),
-    }),
-})
-
-// Attributes from element=table in bootstrap.xml
-const TableSchemaBootstrapAttributes = z
-    .object({
-        '@_name': z.string(),
-        '@_extends': z.string().optional(),
-        '@_label': z.string().optional(),
-        '@_max_length': z.any().optional(),
-
-        // From sys_dictionary/sys_db_object
-        '@_audit': BooleanFromString,
-        '@_read_only': BooleanFromString,
-        '@_text_index': BooleanFromString,
-        '@_client_scripts_access': BooleanFromString,
-        '@_ws_access': BooleanFromString,
-        '@_alter_access': BooleanFromString,
-        '@_create_access': BooleanFromString,
-        '@_delete_access': BooleanFromString,
-        '@_update_access': BooleanFromString,
-        '@_query_access': BooleanFromString,
-        '@_actions_access': BooleanFromString,
-        '@_read_access': BooleanFromString,
-        '@_is_extendable': BooleanFromString,
-        '@_caller_access': IntFromString,
-        '@_scriptable_table': BooleanFromString,
-
-        '@_attributes': z
-            .string()
-            .transform((values) => {
-                const ret = {}
-                if (values === '') {
-                    return undefined
-                }
-                const entries = values.split(',')
-                entries.forEach((attr) => {
-                    const s = attr.split('=')
-                    if (s.length === 2 && s[0] && s[1]) {
-                        try {
-                            ret[s[0]] = JSON.parse(s[1])
-                        } catch (err) {
-                            ret[s[0]] = s[1]
-                        }
-                    }
-                })
-                return ret
-            })
-            .optional(),
-    })
-    .catchall(z.any())
-
-const DictionaryXmlSchema = z.object({
-    sys_dictionary: z
-        .object({
-            '@_action': z.union([z.literal('INSERT_OR_UPDATE'), z.literal('DELETE'), z.literal('delete_multiple')]),
-            sys_id: z
-                .object({
-                    '#text': z.string().min(32).max(32).or(z.number()),
-                })
-                .transform((val) => val['#text'])
-                .optional(),
-            '@_element': z.string(),
-            '@_table': z.string(),
-        })
-        .catchall(
-            z
-                .object({
-                    '#text': z.union([z.string(), z.boolean(), z.number(), z.undefined()]),
-                })
-                .transform((val) => val['#text'])
-        ),
-})
-
-const IndexSchemaBootstrapAttributes = z.object({
-    '@_name': z.string(),
-    '@_unique': BooleanFromString,
-    element: z.object({ '@_name': z.string() }).or(
-        z.array(
-            z.object({
-                '@_name': z.string(),
-            })
-        )
-    ),
-})
-
-const ColumnSchemaBootstrapAttributes = TableSchemaBootstrapAttributes.omit({ '@_extends': true })
-    .extend({
-        '@_choice': z.coerce.number().optional(),
-        '@_active': BooleanFromString,
-        '@_mandatory': BooleanFromString,
-        '@_display': BooleanFromString,
-        '@_type': z.string().optional(),
-        '@_use_dependent_field': BooleanFromString,
-        '@_use_dynamic_default': BooleanFromString,
-        '@_reference': z.string().optional(),
-        '@_virtual': BooleanFromString,
-        '@_default': z.string().optional(),
-        '@_calculation': z.string().optional(),
-        '@_choice_field': z.string().optional(),
-        '@_function_definition': z.string().optional(),
-        '@_reference_floats': BooleanFromString,
-        '@_reference_key': z.string().optional(),
-        '@_dynamic_creation_script': z.string().optional(),
-        '@_dynamic_creation': BooleanFromString,
-        '@_plural': z.string().optional(),
-        '@_hint': z.string().optional(),
-        '@_help': z.string().optional(),
-        '@_widget': z.string().optional(),
-        '@_table_reference': BooleanFromString,
-        '@_element_reference': BooleanFromString,
-        '@_unique': BooleanFromString,
-        '@_spell_check': BooleanFromString,
-        '@_xml_view': BooleanFromString,
-        '@_array': BooleanFromString,
-        '@_text_index': BooleanFromString,
-        '@_primary': BooleanFromString,
-        '@_reference_qual': z.string().optional(),
-        choice: z.object({ element: z.array(z.any()).or(z.record(z.any())).optional() }).optional(),
-        '@_attributes': z
-            .string()
-            .transform((values) => {
-                const ret = {}
-                if (values === '') {
-                    return undefined
-                }
-                const entries = values.split(',')
-                entries.forEach((attr) => {
-                    const s = attr.split('=')
-                    if (s.length === 2 && s[0] && s[1]) {
-                        try {
-                            ret[s[0]] = JSON.parse(s[1])
-                        } catch (err) {
-                            ret[s[0]] = s[1]
-                        }
-                    }
-                })
-                return ret
-            })
-            .optional(),
-    })
-    .catchall(z.any())
-
-const ChoiceSchema = z.object({
-    label: z.string().optional(),
-    value: z.string().optional(),
-    sequence: z.coerce.number().optional(),
-    dependent_value: z.coerce.number().or(z.string()).optional(),
-    hint: z.string().optional(),
-    inactive: BooleanFromString.default(false).optional(),
-    inactive_on_update: BooleanFromString.default(false).optional(),
-    language: z.string().optional(),
-})
-
-const ChoiceSchemaIncoming = ChoiceSchema.omit({ value: true })
-
-function composeLicenseConfig(tableName: string, config, node) {
-    return {
-        kind: 'ua_table_licensing_config',
-        guid: `${tableName}_license`,
-        data: {
-            table: 'ua_table_licensing_config',
-            $id: tableName,
-            data: {
-                name: tableName,
-                op_insert: config.op_insert ?? true,
-                op_update: config.op_update ?? true,
-                op_delete: config.op_delete ?? true,
-                is_fulfillment: config.is_fulfillment ?? false,
-                license_model: config.license_model ?? 'none',
-                owner_condition: config.owner_condition ?? '',
-                license_condition: config.license_condition ?? '',
-                license_roles: config.license_roles ? config.license_roles.join(',') : '',
-            },
-        },
-        node,
-    }
-}
-
-type ComposedTableData = {
-    data: {
-        bootstrapData: any
-        dbObjectData: any
-    }
-}
-
-const tableNameRegex = new RegExp(`^[a-z_][a-z0-9_]*[a-z0-9]$`)
-
-export default Plugin({
-    name: 'Table',
-    ownedTables: {
-        sys_db_object: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            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 || !result.data) {
-                        return result
-                    }
-
-                    const data = result.data
-                    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 tableName = data.getProperty('name')
-                    const scopeMatches = tableName.getValue().match(scopeRegex)
-                    let ignoreColumnNameCheck = false
-
-                    if (!tableName.getValue().match(tableNameRegex)) {
-                        diagnostics.push(
-                            new FluentDiagnostic(
-                                tableName.getNode(),
-                                `Table name must only contain lowercase letters, numbers, and underscores and end with a letter or number`
-                            )
-                        )
-                    }
-
-                    if (!scopeMatches) {
-                        const nameNode = tableName.getNode().asKindOrThrow(ts.SyntaxKind.StringLiteral)
-                        if (nameNode.getParent().getKindName() !== 'AsExpression') {
-                            diagnostics.push(
-                                new FluentDiagnostic(
-                                    tableName.getNode(),
-                                    `'name' property must start with scope prefix '${scopeName}'`
-                                )
-                            )
-                        } else {
-                            ignoreColumnNameCheck = true
-                        }
-                    }
-
-                    const schema = data.getProperty('schema')
-                    const schemaNode = schema.getNode().asKindOrThrow(ts.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(ts.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 }
-                            )
-                        )
-                    }
-
-                    diagnostics.push(...getLabelDiagnostics(data))
-                    const entityData = new EntityData(
-                        'table',
-                        tableName.getValue(),
-                        new ObjectData(data.getProperties(), data.getNode()),
-                        data.getNode(),
-                        data.getInstallMethod(),
-                        [tableName.getValue()]
-                    )
-                    return { handled: true, data: entityData, diagnostics }
-                },
-            },
-        },
-        xml(xml, context) {
-            const bootstrapData = {}
-            let dbObjectData = {}
-            const bootstrapDatabaseXML = BootstrapDatabaseElement.safeParse(xml.data['database'])
-            if (bootstrapDatabaseXML.success) {
-                const data = TableSchemaBootstrapAttributes.parse(bootstrapDatabaseXML.data.element)
-                Object.entries(data).forEach(([key, value]) => {
-                    if (key.startsWith('@_')) {
-                        bootstrapData[key.substring(2)] = value
-                    } else if (key === 'element') {
-                        //
-                    } else {
-                        bootstrapData[key] = value
-                    }
-                })
-                context.updateHandledXMLs(xml.filePath, 'handled')
-            }
-
-            const db_object_inc = DBObjectIncoming.safeParse(xml.data['record_update'])
-            if (db_object_inc.success) {
-                dbObjectData = DBObjectIncomingAttributes.parse(db_object_inc.data.sys_db_object)
-                context.updateHandledXMLs(xml.filePath, 'handled')
-                return new XmlData(
-                    dbObjectData,
-                    xml.filePath,
-                    'sys_db_object',
-                    db_object_inc.data.sys_db_object['@_action']
-                )
-            } else if (!bootstrapDatabaseXML.success) {
-                const record_update = xml.data['record_update']
-                if (record_update) {
-                    const table = Object.keys(record_update)[0]
-                    if (!table || !componentTables.includes(table)) {
-                        return
-                    }
-
-                    if (table === 'sys_documentation') {
-                        const data = SysDocumentation.parse(record_update[table]).sys_documentation
-                        return new XmlData(
-                            {
-                                table: table,
-                                id: record_update[table][table]['sys_id']?.['#text'] ?? GUID(),
-                                data,
-                            },
-                            xml.filePath,
-                            'sys_documentation',
-                            record_update[table]['@_action']
-                        )
-                    }
-
-                    if (table === 'ua_table_licensing_config') {
-                        const data = LicensingConfig.parse(record_update).ua_table_licensing_config
-                        return new XmlData(
-                            {
-                                table: table,
-                                id: record_update[table]['sys_id']?.['#text'] ?? GUID(),
-                                data,
-                            },
-                            xml.filePath,
-                            'ua_table_licensing_config',
-                            record_update[table]['@_action']
-                        )
-                    }
-
-                    const data = DictionaryXmlSchema.safeParse(record_update)
-                    if (data.success) {
-                        const {
-                            '@_action': action,
-                            '@_element': element,
-                            '@_table': dictTable,
-                            sys_id,
-                            ...dict
-                        } = data.data.sys_dictionary
-                        return new XmlData(
-                            {
-                                table: table,
-                                id: sys_id ?? `${dict['name']}_${dict['element'] !== '' ? dict['element'] : '_null'}`,
-                                data: dict,
-                            },
-                            xml.filePath,
-                            'sys_dictionary',
-                            action
-                        )
-                    }
-                    context.updateHandledXMLs(xml.filePath, 'ignored')
-                    return
-                }
-            }
-
-            // Columns and Indexes
-            const columns: z.infer<typeof ColumnSchemaBootstrapAttributes>[] = []
-            const idxElements: IndexType[] = []
-            if (bootstrapDatabaseXML.success && bootstrapDatabaseXML.data.element['element']) {
-                const element = bootstrapDatabaseXML.data.element['element']
-                const elementsArray = isArray(element) ? element : [element]
-                columns.push(...z.array(ColumnSchemaBootstrapAttributes).parse(elementsArray))
-
-                columns.forEach((element) => {
-                    if (element.choice && !isEmpty(element.choice)) {
-                        element['choice_elements'] = {}
-                        const choices = isArray(element.choice.element)
-                            ? element.choice.element
-                            : [element.choice.element]
-                        choices.forEach((choice) => {
-                            const obj = removeAttributeTag(choice)
-                            const choiceData = ChoiceSchemaIncoming.parse(obj)
-                            if (!choiceData.label) {
-                                choiceData.label = obj.value
-                            }
-                            element['choice_elements'][obj.value] = choiceData
-                        })
-                    }
-
-                    element = removeAttributeTag(element)
-                })
-                bootstrapData['columns'] = columns.reduce((map, obj) => ((map[obj['name']] = obj), map), {})
-
-                let elements = bootstrapDatabaseXML.data.element['index']
-                elements = isArray(elements) ? elements : [elements]
-                elements.forEach((element) => {
-                    const idxData = IndexSchemaBootstrapAttributes.safeParse(element)
-                    if (idxData.success) {
-                        idxElements.push({
-                            name: idxData.data['@_name'],
-                            element: isArray(idxData.data.element)
-                                ? idxData.data.element.reduce((arr, curr) => {
-                                      arr.push(curr['@_name'])
-                                      return arr
-                                  }, [] as string[])
-                                : idxData.data.element['@_name'],
-                            unique: idxData.data['@_unique'] ?? false,
-                        })
-                    }
-                })
-                bootstrapData['index'] = idxElements
-            }
-
-            return new XmlData(bootstrapData, xml.filePath, 'bootstrap')
-        },
-    },
-    composers: {
-        entity: {
-            async table(entity, context) {
-                const node = entity.getNode()
-                const data = entity.getValue()
-                const table = TableSchemaFull.parse(data)
-
-                const composeData = compose(table)
-                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
-
-                    const numberRecord = SysNumber(table.name, data.number_of_digits, data.number, data.prefix)
-
-                    const composedNumber = await RecordPlugin.composers.entity.record(
-                        new EntityData(
-                            'record',
-                            context.registerExplicitId(numberRecord.table, numberRecord.$id),
-                            ObjectData.fromObjectValue(numberRecord, node),
-                            node
-                        ),
-                        context
-                    )
-
-                    entities.push(composedNumber)
-
-                    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
-
-                if (table.licensing_config) {
-                    entities.push(composeLicenseConfig(composeData.name, table.licensing_config, node))
-                }
-
-                entities.push({
-                    kind: 'bootstrap',
-                    node,
-                    guid: composeData.name,
-                    data: { data: { bootstrapData: composeData, dbObjectData: composeData } },
-                })
-
-                return entities
-            },
-        },
-        xml: {
-            bootstrap(xml) {
-                return {
-                    kind: xml.kind,
-                    guid: xml.data['name'] as string,
-                    data: { data: { bootstrapData: xml.data } },
-                }
-            },
-            sys_db_object(xml) {
-                return {
-                    kind: 'bootstrap',
-                    guid: `${xml.data['name']}`,
-                    data: { data: { dbObjectData: xml.data } },
-                    action: xml.action,
-                }
-            },
-            sys_dictionary(xml) {
-                const data = xml.data['data']!
-                return {
-                    kind: 'sys_dictionary',
-                    guid:
-                        (xml.data['id'] as string) ??
-                        `${data['name']}_${data['element'] !== '' ? data['element'] : '_null'}`,
-                    data: xml.data,
-                    action: xml.action,
-                }
-            },
-        },
-    },
-    arrangers: {
-        bootstrap(_document: Document<any>) {
-            return { handled: false }
-        },
-        sys_dictionary(document: Document<any>) {
-            if ((document.data as any).table !== 'sys_dictionary') {
-                return { handled: false }
-            }
-            const tableName = (document.data as any).data.name
-            return {
-                handled: true,
-                result: tableName ? { kind: 'bootstrap', guid: tableName } : undefined,
-            }
-        },
-    },
-    generators: {
-        bootstrap(document, context) {
-            const parsedBoostrapData = TableSchemaBootstrapIncoming.safeParse(
-                (document.data as ComposedTableData).data.bootstrapData
-            )
-            if (!parsedBoostrapData.success) {
-                return undefined
-            }
-
-            return linkDocument(
-                document,
-                generateNamedCallExpressionExportForDocument(
-                    context,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(context, parsedBoostrapData.data.name),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                        exportName: parsedBoostrapData.data.name,
-                    },
-                    Table,
-                    {}
-                ).getInitializerIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-        sys_dictionary(document, context: Context, linkedDocuments) {
-            const data = (document.data as any).data
-            const updateName = data.sys_update_name
-            const table = linkedDocuments.find((doc) => doc.guid === data.name)
-            return table && table.node
-                ? { ...document, node: table.node }
-                : linkDocument(
-                      document,
-                      generateCallExpressionExportForDocument(
-                          context,
-                          {
-                              sourceFile: getOrCreateEntitySourceFile(
-                                  context,
-                                  updateName ?? `sys_dictionary_${document.guid}`
-                              ),
-                              moduleSpecifier: '@servicenow/sdk/core',
-                          },
-                          NowRecord,
-                          { $id: document.guid }
-                      ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-                  )
-        },
-        record(document, context) {
-            if (
-                document.data?.['table'] !== 'sys_documentation' &&
-                document.data?.['table'] !== 'ua_table_licensing_config'
-            ) {
-                return
-            }
-
-            return linkDocument(
-                document,
-                generateCallExpression(
-                    context,
-                    getOrCreateEntitySourceFile(context, `${document.data?.['data'].name}`),
-                    '@servicenow/sdk/core',
-                    NowRecord,
-                    { $id: document.guid }
-                )
-            )
-        },
-    },
-    serializers: {
-        bootstrap(document) {
-            const composedData = (document.data as ComposedTableData).data
-            const { columns, index, attributes, ...bootstrapData } = composedData.bootstrapData
-
-            if (bootstrapData.live_feed) {
-                // live_feed needs to be a table sys_dictionary attribute so it can be synced to sys_db_object by a startup process
-                attributes['live_feed'] = true
-            }
-
-            const root = create({ version: '1.0' }).ele('database')
-            const composedAttributes = composeAttributes(attributes)
-            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 element = collection.ele('element', { ...parsedColumn, attributes: columnAttributes }!)
-
-                buildChoices(column as ColumnSchema, element)
-            }
-
-            buildIndexes(index, collection)
-
-            return {
-                name: `${bootstrapData.name}.xml`,
-                directory: 'dictionary',
-                content: root.end({ prettyPrint: true }),
-                usedIds: [],
-            }
-        },
-        sys_dictionary(_document) {
-            // Don't serialize
-            return undefined
-        },
-    },
-    transformers: {
-        bootstrap: {
-            CallExpression(document, context) {
-                return transformTable(document, context)
-            },
-        },
-        sys_dictionary: {
-            CallExpression(document, context: Context) {
-                if (getCallExpressionName(document.node as ts.CallExpression) !== Table.name) {
-                    return RecordPlugin.transformers!.record!.CallExpression(document, context)
-                }
-
-                context.logger.info(
-                    `Deferring handling of sys_dictionary '${document.guid}' values to values in bootstrap.xml '${document.parent!.guid}'`
-                )
-                return true
-            },
-        },
-    },
-    postProcessors: {
-        entities(entities, context) {
-            const { interfaces, properties, imports, namedImports } = {
-                interfaces: [] as ts.OptionalKind<ts.InterfaceDeclarationStructure>[],
-                properties: [] as ts.OptionalKind<ts.PropertySignatureStructure>[],
-                imports: {} as Record<string, ts.OptionalKind<ts.ImportDeclarationStructure>>,
-                namedImports: [] as (ts.OptionalKind<ts.ImportSpecifierStructure> & {
-                    existingImport: ts.ImportDeclaration
-                })[],
-            }
-            const generatedTableFile: ts.SourceFile | undefined = context.compiler.getGeneratedTableFile()
-            entities
-                .filter((entity) => entity.getKind() === 'table')
-                .forEach((table) => {
-                    const tableName = table.getProperty('name')!.getValue() as string
-                    const extendsTable = table.getProperty('extends')?.getValue() as string
-                    if (tableName && tableName.trim().length > 0 && tableName.match(tableNameRegex)) {
-                        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 = table.getNode().getSourceFile().getFilePath()
-                        const resolvedModuleSpecifier = generatedTableFile?.getRelativePathAsModuleSpecifierTo(
-                            filePath
-                        ) as string
-                        const importExists = context.compiler.importExistsInGlobalDeclaration(resolvedModuleSpecifier)
-
-                        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,
-            })
-        },
-    },
-})
-
-function transformTable(document, context) {
-    const expressionName = getCallExpressionName(document.node)
-    if (expressionName !== Table.name) {
-        return false
-    }
-    const [args] = document.node.getArguments()
-    if (!ts.Node.isObjectLiteralExpression(args)) {
-        return false
-    }
-
-    if (document.action === 'DELETE') {
-        removeNode(document.node)
-        return true
-    }
-
-    if (!document.changedData) {
-        return true
-    }
-
-    const composedData = (document.changedData as ComposedTableData).data
-    const xmlData = (document.xmlData as ComposedTableData).data
-
-    let bootstrap_data = {}
-    let db_data = {}
-    if (!isEmpty(composedData.bootstrapData)) {
-        // sys_db_object or node without bootstrap.xml. Mark as handled and ignore
-        bootstrap_data = TableSchemaBootstrapIncoming.partial().parse(composedData.bootstrapData)
-    }
-    if (!isEmpty(composedData.dbObjectData)) {
-        db_data = DBObjectIncomingAttributes.partial().parse(composedData.dbObjectData)
-    }
-
-    const { auto_number, number_ref, extends: ext, index, columns, ...bootstrap_rest } = mapNames(bootstrap_data)
-    const { create_access, delete_access, update_access, read_access, caller_access, ...db_rest } = mapNames(db_data)
-    const rest = { ...bootstrap_rest, ...db_rest }
-
-    if (ext) {
-        rest['extends'] = ext
-    }
-
-    if (caller_access) {
-        rest['caller_access'] = callerAccess[caller_access]
-    }
-
-    if (!isEmpty(db_data)) {
-        rest.actions = getActionsArray(xmlData.dbObjectData)
-    }
-
-    if (!rest.attributes) {
-        delete rest.attributes
-    }
-
-    transformFunctionArguments(document.node, Table as any, rest)
-
-    // Handle columns
-    const incomingColumns = xmlData.bootstrapData ? xmlData.bootstrapData.columns : undefined
-
-    updateDisplayValue(document.node, columns, incomingColumns)
-    transformColumns(columns, incomingColumns, args, context)
-    transformIndexes(xmlData, args)
-    return true
-}
-
-function transformIndexes(xmlData, args) {
-    if (xmlData.bootstrapData?.index?.length > 0) {
-        // find the correct object literal
-        const indexProp = getPropertyAssignment(args, 'index')
-        if (indexProp) {
-            mergeDataIntoObjectLiteralArray(
-                indexProp.getFirstChildByKindOrThrow(ts.SyntaxKind.ArrayLiteralExpression),
-                Object.values(xmlData.bootstrapData?.index),
-                'name'
-            )
-        } else {
-            const newIndexProp = getOrCreatePropertyAssignment(args, 'index', '[]')
-            newIndexProp.setInitializer(stringify(xmlData.bootstrapData.index))
-        }
-    } else if (xmlData.bootstrapData) {
-        const indexProp = getPropertyAssignment(args, 'index')
-        if (indexProp) {
-            indexProp.remove()
-        }
-    }
-}
-
-function composeAttributes(attributes: Record<string, any> | undefined) {
-    if (!attributes) {
-        return ''
-    }
-
-    return Object.entries(attributes)
-        .map(([key, value]) => `${key}=${value}`)
-        .join(',')
-}
-
-function updateDisplayValue(node: ts.CallExpression, columns: ColumnSchema, incomingColumns: ColumnSchema) {
-    const display = Object.values(columns ?? {}).filter((col: any) => col.display)
-    if (display) {
-        const displayName = Object.values(incomingColumns ?? {}).find((c) => c.display)
-        if (displayName) {
-            transformFunctionArguments(node, Table as any, { display: displayName.name })
-        }
-    }
-}
-
-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
-}
-
-export function getDefaultMaxLength(column: ColumnSchema): number {
-    switch (column.entityKind) {
-        case 'conditions':
-        case 'glide_list':
-            return 4000
-        case 'decimal':
-            return 20
-        case 'domain_id':
-        case 'document_id':
-        case 'reference':
-            return 32
-        case 'domain_path':
-        case 'user_roles':
-            return 255
-        case 'script':
-            return 8000
-        case 'table_name':
-        case 'field_name':
-            return 80
-        default:
-            /**
-             * For types mentioned below it default to 40 on instance
-             * boolean | integer | image | choice | radio | sys_class_name | translated_field | translated_text | version | glide_date | glide_date_time | calendar_date_time
-             * datetime | due_date | integer_date | schedule_date_time | date | generic
-             *
-             * TODO::We need to request max_length from user for string column type because its mandatory on instance.
-             */
-            return 40
-    }
-}
-
-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 { 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: getLabel(column.label) ?? columnName,
-            max_length: maxLength ?? getDefaultMaxLength(column),
-            mandatory: column.mandatory,
-            read_only: column.read_only,
-            choice: choiceDropdown.indexOf(column.dropdown ?? (requiresDropdown ? 'dropdown_with_none' : 'none')),
-            display: display ? display === columnName : false,
-
-            // dynamic values
-            virtual: column.dynamic_value_definitions?.type === 'calculated_value' ? true : undefined,
-            calculation:
-                column.dynamic_value_definitions?.type === 'calculated_value'
-                    ? typeof column.dynamic_value_definitions!['calculated_value'] === 'string'
-                        ? column.dynamic_value_definitions!['calculated_value']
-                        : ModuleFunctionData.getGlueCode(
-                              column.dynamic_value_definitions!['calculated_value'],
-                              (n) => `${n}(current)`
-                          )
-                    : undefined,
-            choice_table:
-                column.dynamic_value_definitions?.type === 'choices_from_other_table'
-                    ? column.dynamic_value_definitions.table
-                    : undefined,
-            choice_field:
-                column.dynamic_value_definitions?.type === 'choices_from_other_table'
-                    ? column.dynamic_value_definitions.field
-                    : undefined,
-
-            use_dependent_field: column.dynamic_value_definitions?.type === 'dependent_field' || undefined,
-
-            dependent:
-                column.dynamic_value_definitions?.type === 'dependent_field'
-                    ? column.dynamic_value_definitions!['column_name']
-                    : undefined,
-
-            default: column.default,
-
-            function_definition: column.function_definition,
-            function_field: column.function_definition ? true : false,
-
-            plural: column.plural,
-            hint: column.hint,
-            help: column.help,
-            widget: column.widget,
-            table_reference: column.table_reference,
-            element_reference: column.element_reference,
-            reference_key: column.reference_key,
-            spell_check: column.spell_check,
-            xml_view: column.xml_view,
-            reference_floats: column.reference_floats,
-            dynamic_creation: column.dynamic_creation,
-            dynamic_creation_script: column.dynamic_creation_script,
-            array: column.array,
-            text_index: column.text_index,
-            primary: column.primary,
-            unique: column.unique,
-            reference_qual: column.reference_qual,
-        }
-
-        documentation.push(...composeDocumentation(columnName, tableName, column.label))
-
-        if (column.choices) {
-            Object.keys(column.choices).forEach((key) => {
-                if (isObject(column.choices![key])) {
-                    column.choices![key] = { value: key, ...column.choices![key] }
-                } else {
-                    column.choices![key] = { value: key, label: column.choices![key] }
-                }
-            })
-            element['choice_elements'] = z.record(ChoiceSchema).parse(column.choices)
-        }
-
-        composedColumns[columnName] = element
-    }
-    return { columnData: composedColumns, documentation }
-}
-
-function compose(bootstrapData: z.infer<typeof TableSchemaBootstrap>) {
-    if (bootstrapData.live_feed) {
-        bootstrapData.attributes = {
-            // live_feed needs to be a table sys_dictionary attribute so it can be synced to sys_db_object by a startup process
-            ...bootstrapData.attributes,
-            live_feed: true,
-        }
-    }
-
-    const composedData = {
-        // Generic data
-        name: bootstrapData.name,
-        type: 'collection',
-        extends: bootstrapData.extends,
-        label: getLabel(bootstrapData.label) ?? bootstrapData.name,
-
-        // Controls
-        is_extendable: bootstrapData.extensible,
-        text_index: bootstrapData.text_index,
-        read_only: bootstrapData.read_only,
-        audit: bootstrapData.audit,
-
-        access: bootstrapData.accessible_from,
-        caller_access: callerAccess.indexOf(bootstrapData.caller_access ?? 'none'),
-
-        read_access: bootstrapData.actions?.includes('read'),
-        update_access: bootstrapData.actions?.includes('update'),
-        create_access: bootstrapData.actions?.includes('create'),
-        delete_access: bootstrapData.actions?.includes('delete'),
-
-        ws_access: bootstrapData.allow_web_service_access,
-        alter_access: bootstrapData.allow_new_fields,
-        actions_access: bootstrapData.allow_ui_actions,
-        client_scripts_access: bootstrapData.allow_client_scripts,
-
-        scriptable_table: bootstrapData.scriptable_table,
-
-        attributes: bootstrapData.attributes,
-    }
-
-    return composedData
-}
-
-// API properties that are different in the bootstrap/sys_db_object file
-const property_name_mapping = {
-    client_scripts_access: 'allow_client_scripts',
-    alter_access: 'allow_new_fields',
-    actions_access: 'allow_ui_actions',
-    ws_access: 'allow_web_service_access',
-    is_extendable: 'extensible',
-    access: 'accessible_from',
-    live_feed_enabled: 'live_feed',
-}
-
-function mapNames(schema: any) {
-    Object.keys(schema).forEach((key) => {
-        if (property_name_mapping[key]) {
-            schema[property_name_mapping[key]] = schema[key]
-            delete schema[key]
-        }
-    })
-    return schema
-}
-
-function transformColumns(
-    columns: ColumnSchema,
-    incomingSchema: ColumnSchema,
-    args: ts.ObjectLiteralExpression,
-    context: Context
-) {
-    const schemaProperty = getOrCreatePropertyAssignment(args, 'schema', '{}')
-
-    if (!incomingSchema) {
-        return
-    }
-
-    const schemaLiteral = schemaProperty.getChildrenOfKind(ts.SyntaxKind.ObjectLiteralExpression)[0]
-    if (!schemaLiteral) {
-        return
-    }
-
-    const existingColumns = {}
-    schemaLiteral.getProperties().forEach((property) => {
-        const propertyAssignment = property.asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
-        const name = propertyAssignment.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier).getText()
-        const callExp = propertyAssignment.getFirstChildByKindOrThrow(ts.SyntaxKind.CallExpression)
-        const callExpType = callExp.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier).getText()
-        const objectLiteral = callExp.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-        existingColumns[name] = {
-            node: propertyAssignment,
-            type: callExpType,
-            objectLiteral,
-        }
-
-        if (!incomingSchema[name]) {
-            // Full bootstrap.xml does not have this existing column so remove it
-            removeNode(propertyAssignment)
-        }
-    })
-
-    if (!columns || isEmpty(columns)) {
-        return
-    }
-
-    Object.keys(incomingSchema).forEach((key) => {
-        const partialData = columns[key]
-        if (!existingColumns[key]) {
-            // This column doesn't exist so let's make it
-            const callExpFromType = getCallExpressionFromType(partialData.type)
-            createNewColumn(schemaLiteral, callExpFromType.name, partialData, context)
-        } else {
-            const existingColumn = existingColumns[key]
-            if (partialData) {
-                if (partialData.type && existingColumn.type !== partialData.type) {
-                    // Switching the column type so regenerate the CallExpression and add all incoming data
-                    removeNode(existingColumn.node)
-                    const callExpFromType = getCallExpressionFromType(partialData.type)
-                    createNewColumn(schemaLiteral, callExpFromType.name, incomingSchema[key], context)
-                } else {
-                    // Update the existing column with changed data only
-                    const transformedColumnData = transformColumnData(partialData, existingColumn.type)
-                    mergeDataIntoObjectLiteral(existingColumn.objectLiteral, {
-                        ...transformedColumnData,
-                        choices: partialData.choice_elements,
-                    })
-                }
-            }
-            if (existingColumn.node && !existingColumn.node.wasForgotten()) {
-                removeChoicesIfNecessary(existingColumn, incomingSchema[key])
-                removeAttributesIfNecessary(existingColumn, incomingSchema[key])
-            }
-        }
-    })
-}
-
-function removeChoicesIfNecessary(existingColumn: any, columnFromBootstrap: any) {
-    const existingProperties = existingColumn.objectLiteral
-        .getProperties()
-        .reduce((a, v) => ({ ...a, [getObjectPropertyAssignmentName(v)]: v }), {})
-
-    if (!existingProperties['choices']) {
-        return
-    }
-
-    if (!columnFromBootstrap['choice_elements']) {
-        removeNode(existingProperties['choices'])
-        return
-    }
-
-    const choicesFromBootstrap = Object.keys(columnFromBootstrap['choice_elements'])
-    const existingChoices = existingProperties['choices']
-        .getFirstChildByKind(ts.SyntaxKind.ObjectLiteralExpression)
-        .getProperties()
-        .reduce((a, v) => {
-            return {
-                ...a,
-                [getObjectPropertyAssignmentName(v)]: v,
-            }
-        }, {})
-    Object.keys(existingChoices).forEach((choice) => {
-        if (!choicesFromBootstrap.includes(choice)) {
-            removeNode(existingChoices[choice])
-        }
-    })
-}
-
-function removeAttributesIfNecessary(existingColumn: any, columnFromBootstrap: any) {
-    const existingProperties = existingColumn.objectLiteral
-        .getProperties()
-        .reduce((a, v) => ({ ...a, [getObjectPropertyAssignmentName(v)]: v }), {})
-
-    if (!existingProperties['attributes']) {
-        return
-    }
-
-    if (!columnFromBootstrap['attributes']) {
-        removeNode(existingProperties['attributes'])
-        return
-    }
-
-    const existingAttributes = existingProperties['attributes']
-        .getFirstChildByKind(ts.SyntaxKind.ObjectLiteralExpression)
-        .getProperties()
-        .reduce((a, v) => ({ ...a, [getObjectPropertyAssignmentName(v)]: v }), {})
-    Object.keys(existingAttributes).forEach((attr) => {
-        if (!(attr in columnFromBootstrap['attributes'])) {
-            removeNode(existingAttributes[attr])
-        }
-    })
-}
-
-function generateNamedCallExpressionExportForDocument<const A extends unknown[]>(
-    context: Context,
-    info: {
-        sourceFile: ts.SourceFile
-        moduleSpecifier: string
-        exportName: string
-    },
-    fn: (...args: A) => unknown,
-    ...args: PartialElements<A>
-) {
-    const { sourceFile, moduleSpecifier } = info
-    return generateCallExpressionExport(context, sourceFile, moduleSpecifier, info.exportName, fn, ...args)
-}
-
-function createNewColumn(schemaLiteral: ts.ObjectLiteralExpression, callExpName: string, data: any, context: Context) {
-    const propertyAssignment = schemaLiteral.addPropertyAssignment({
-        name: data.name,
-        initializer: `${callExpName}({})`,
-    })
-    const objectLiteral = propertyAssignment
-        .getInitializer()!
-        .getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-    const transformedColumnData = transformColumnData(data, callExpName)
-    mergeDataIntoObjectLiteral(objectLiteral, { ...transformedColumnData, choices: data.choice_elements })
-    addNamedImportIfAbsent(context, schemaLiteral.getSourceFile(), '@servicenow/sdk/core', {
-        name: callExpName,
-    })
-}
-
-type DB_ACTIONS = 'read' | 'delete' | 'create' | 'update'
-
-function getActionsArray(data) {
-    const actions: DB_ACTIONS[] = []
-    if (data.read_access) {
-        actions.push('read')
-    }
-    if (data.update_access) {
-        actions.push('update')
-    }
-    if (data.delete_access) {
-        actions.push('delete')
-    }
-    if (data.create_access) {
-        actions.push('create')
-    }
-
-    return actions
-}
-
-function buildIndexes(indexes: IndexType[] = [], collection: XMLBuilder) {
-    indexes.forEach((index) => {
-        const indexElement = collection.ele('index', { name: index.name, unique: index.unique })
-        if (isArray(index.element)) {
-            index.element.forEach((element) => {
-                indexElement.ele('element', { name: element })
-            })
-        } else {
-            indexElement.ele('element', { name: index.element })
-        }
-    })
-}
-
-function buildChoices(column: ColumnSchema, element: XMLBuilder) {
-    if (!column.choice_elements) {
-        return
-    }
-
-    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.ele('element', {
-                value: column.choices[choice],
-                label: column.choices[choice],
-            })
-        }
-    } else {
-        // Formatted - choices: { 1: { label: 'label' }, 2: { lable: label 2}, ...}
-        Object.entries(column.choice_elements).forEach((value) => {
-            if (isObject(value[1])) {
-                choices.ele('element', {
-                    value: value[0],
-                    ...(value[1] as ChoiceConfig),
-                })
-            } else {
-                choices.ele('element', {
-                    value: value[1],
-                    label: value[0],
-                })
-            }
-        })
-    }
-}
-
-function transformColumnData(col: any, callExpFromType: string) {
-    const {
-        type: internal_type,
-        choice,
-        name,
-        virtual,
-        display,
-        choice_table,
-        choice_field,
-        use_dependent_field,
-        dependent,
-        calculation,
-        use_dynamic_default,
-        default_value,
-        choice_elements,
-        table,
-        default: def,
-        max_length,
-        reference,
-        reference_cascade_rule,
-        function_field,
-        reference_qual_condition,
-        ...column
-    } = col
-
-    if (max_length !== undefined) {
-        column.maxLength = parseInt(max_length, 10)
-    }
-
-    if (internal_type && callExpFromType === 'GenericColumn') {
-        column.column_type = internal_type
-    }
-
-    if (choice !== undefined) {
-        column.dropdown = choiceDropdown[choice]
-    }
-
-    if (reference) {
-        column.referenceTable = reference
-    }
-    if (reference_cascade_rule) {
-        column.cascadeRule = reference_cascade_rule
-    }
-
-    // Handle dynamic values
-    if (calculation) {
-        column.dynamic_value_definitions = {
-            type: 'calculated_value',
-            calculated_value: calculation,
-        }
-    } else if (choice_table || choice_field) {
-        column.dynamic_value_definitions = {
-            type: 'choices_from_other_table',
-            table: choice_table,
-            field: choice_field,
-        }
-    } else if (dependent) {
-        column.dynamic_value_definitions = {
-            type: 'dependent_field',
-            column_name: dependent,
-        }
-    } else if (def) {
-        column.default = def
-    } else if (default_value) {
-        column.default = default_value
-    }
-
-    if (column.label && column.label === name) {
-        delete column.label
-    }
-
-    if (isEmpty(column.attributes)) {
-        delete column.attributes
-    } else if (isDefaultEdgeEncryptionAttribute(column.attributes)) {
-        delete column.attributes
-    }
-
-    return column
-}
-
-// The instance will sometimes add edge_encryption_enabled=true, this is a default so don't write it if it is the only one
-function isDefaultEdgeEncryptionAttribute(attributes: any) {
-    return (
-        attributes &&
-        Object.entries(attributes).length === 1 &&
-        attributes.edge_encryption_enabled !== undefined &&
-        attributes.edge_encryption_enabled
-    )
-}
-
-function removeAttributeTag(obj: any) {
-    Object.entries(obj).forEach(([key, value]) => {
-        if (key.startsWith('@_')) {
-            obj[key.substring(2)] = value
-            delete obj[key]
-        }
-    })
-    return obj
-}
-
-function SysNumber(
-    category: TableName,
-    maximum_digits: number | undefined,
-    number?: number | undefined,
-    prefix?: string | undefined
-) {
-    return NowRecord({
-        table: 'sys_number',
-        $id: `${category as string}_${prefix}`,
-        data: {
-            category,
-            maximum_digits: maximum_digits ?? 1000,
-            number: number ?? 7,
-            prefix: prefix ?? 'PRE',
-        },
-    })
-}
-
-export function generateColumnExpression<Type extends (...args: any) => any>(
-    expression: Type,
-    args: Parameters<Type>[0],
-    argsSetIfDefined?: Undefined<Parameters<Type>[0]>
-): tsc.CallExpression {
-    const setArgs = { ...args }
-    if (argsSetIfDefined) {
-        Object.keys(argsSetIfDefined).forEach((key) => {
-            if (argsSetIfDefined[key] !== undefined) {
-                setArgs[key] = argsSetIfDefined[key]
-            }
-        })
-    }
-
-    return tsc.factory.createCallExpression(tsc.factory.createIdentifier(expression.name), undefined, [
-        createObjectExpression(setArgs),
-    ])
-}
-
-export function createObjectExpression(firstArg: object): tsc.Expression {
-    return tsc.factory.createObjectLiteralExpression(
-        Object.entries(firstArg)
-            .filter(([_key, value]) => value !== undefined)
-            .map(([key, value]) => {
-                if (key === 'referenceTable') {
-                    return tsc.factory.createPropertyAssignment(
-                        tsc.factory.createIdentifier('referenceTable'),
-                        tsc.factory.createStringLiteral(value)
-                    )
-                } else if (key === 'calculated_value') {
-                    return tsc.factory.createPropertyAssignment(
-                        tsc.factory.createIdentifier(key),
-                        tsc.factory.createTaggedTemplateExpression(
-                            tsc.factory.createIdentifier('script'),
-                            undefined,
-                            tsc.factory.createNoSubstitutionTemplateLiteral(value, value)
-                        )
-                    )
-                } else if (key === 'maxLength') {
-                    if (isNaN(+value)) {
-                        return tsc.factory.createPropertyAssignment(
-                            tsc.factory.createIdentifier(key),
-                            tsc.factory.createAsExpression(
-                                tsc.factory.createStringLiteral(value),
-                                tsc.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
-                            )
-                        )
-                    }
-
-                    return tsc.factory.createPropertyAssignment(
-                        tsc.factory.createIdentifier(key),
-                        tsc.factory.createNumericLiteral(value)
-                    )
-                }
-                return tsc.factory.createPropertyAssignment(
-                    createPropertyIdentifier(key),
-                    factoryCreateValue(value, tsc.factory)
-                )
-            })
-    )
-}
-
-function factoryCreateValue(value: unknown, factory: tsc.NodeFactory) {
-    if (typeof value === 'string') {
-        return factory.createStringLiteral(value)
-    }
-
-    if (typeof value === 'number') {
-        if (value >= 0) {
-            return factory.createNumericLiteral(value)
-        } else {
-            return factory.createPrefixUnaryExpression(
-                tsc.SyntaxKind.MinusToken,
-                factory.createNumericLiteral(Math.abs(value))
-            )
-        }
-    }
-
-    if (typeof value === 'boolean') {
-        return value ? factory.createTrue() : factory.createFalse()
-    }
-
-    if (typeof value === 'object') {
-        if (value === null) {
-            return factory.createNull()
-        }
-        if (isArray(value)) {
-            const newvals: tsc.Expression[] = []
-
-            Object.values(value).forEach((v) => {
-                newvals.push(factoryCreateValue(v, factory))
-            })
-
-            return factory.createArrayLiteralExpression(newvals)
-        } else if (ts.Structure.isImportSpecifier(value)) {
-            return factory.createIdentifier(value['name'])
-        } else {
-            return createObjectExpression(value)
-        }
-    }
-
-    return factory.createNull()
-
-    // throw new Error(`Unsupported value type: ${typeof value}`)
-}
-
-type Undefined<T> = {
-    [P in keyof T]: T[P] | undefined
-}
-function getCallExpressionFromType(internal_type: string) {
-    switch (internal_type) {
-        case undefined:
-        case 'string':
-            return StringColumn
-        case 'boolean':
-            return BooleanColumn
-        case 'choice':
-            return ChoiceColumn
-        case 'conditions':
-            return ConditionsColumn
-        case 'date':
-            return OtherDateColumn
-        case 'calendar_date_time':
-            return CalendarDateTimeColumn
-        case 'datetime':
-            return BasicDateTimeColumn
-        case 'due_date':
-            return DueDateColumn
-        case 'glide_date':
-            return DateColumn
-        case 'glide_date_time':
-            return DateTimeColumn
-        case 'integer_date':
-            return IntegerDateColumn
-        case 'schedule_date_time':
-            return ScheduleDateTimeColumn
-        case 'decimal':
-            return DecimalColumn
-        case 'document_id':
-            return DocumentIdColumn
-        case 'domain_id':
-            return DomainIdColumn
-        case 'domain_path':
-            return DomainPathColumn
-        case 'field_name':
-            return FieldNameColumn
-        case 'integer':
-            return IntegerColumn
-        case 'radio':
-            return RadioColumn
-        case 'reference':
-            return ReferenceColumn
-        case 'script':
-            return ScriptColumn
-        case 'sys_class_name':
-            return SystemClassNameColumn
-        case 'table_name':
-            return TableNameColumn
-        case 'translated_field':
-            return TranslatedFieldColumn
-        case 'translated_text':
-            return TranslatedTextColumn
-        case 'user_roles':
-            return UserRolesColumn
-        case 'version':
-            return VersionColumn
-        case 'glide_list':
-            return ListColumn
-        case 'image':
-            return BasicImageColumn
-        case 'int':
-        case 'string_types':
-        case 'approval_rules':
-        case 'audio':
-        case 'auto_increment':
-        case 'auto_number':
-        case 'bootstrap_color':
-        case 'breakdown_element':
-        case 'catalog_preview':
-        case 'char':
-        case 'collection':
-        case 'color':
-        case 'color_display':
-        case 'composite_field':
-        case 'composite_name':
-        case 'compressed':
-        case 'condition_string':
-        case 'counter':
-        case 'css':
-        case 'currency':
-        case 'currency2':
-        case 'data_array':
-        case 'data_object':
-        case 'data_structure':
-        case 'days_of_week':
-        case 'day_of_week':
-        case 'documentation_field':
-        case 'dynamic_json':
-        case 'email':
-        case 'email_script':
-        case 'expression':
-        case 'external_names':
-        case 'field_list':
-        case 'file_attachment':
-        case 'float':
-        case 'formula':
-        case 'geo_point':
-        case 'glide_action_list':
-        case 'glide_duration':
-        case 'glide_precise_time':
-        case 'glide_time':
-        case 'glide_utc_time':
-        case 'glide_var':
-        case 'glyphicon':
-        case 'graphql_schema':
-        case 'GUID':
-        case 'html':
-        case 'html_script':
-        case 'html_template':
-        case 'icon':
-        case 'index_name':
-        case 'insert_timestamp':
-        case 'integer_time':
-        case 'internal_type':
-        case 'ip_addr':
-        case 'ip_address':
-        case 'journal':
-        case 'journal_input':
-        case 'journal_list':
-        case 'json':
-        case 'json_translations':
-        case 'language':
-        case 'long':
-        case 'longint':
-        case 'mask_code':
-        case 'metric_absolute':
-        case 'metric_counter':
-        case 'metric_derive':
-        case 'metric_gauge':
-        case 'mid_config':
-        case 'month_of_year':
-        case 'multi_small':
-        case 'multi_two_lines':
-        case 'name_values':
-        case 'nds_icon':
-        case 'nl_task_int1':
-        case 'order_index':
-        case 'password':
-        case 'password2':
-        case 'percent_complete':
-        case 'phone_number':
-        case 'phone_number_e164':
-        case 'ph_number':
-        case 'price':
-        case 'properties':
-        case 'records':
-        case 'reference_name':
-        case 'related_tags':
-        case 'reminder_field_name':
-        case 'repeat_count':
-        case 'repeat_type':
-        case 'replication_payload':
-        case 'schedule_interval_count':
-        case 'script_client':
-        case 'script_plain':
-        case 'script_server':
-        case 'short_field_name':
-        case 'short_table_name':
-        case 'simple_name_values':
-        case 'slushbucket':
-        case 'snapshot_template_value':
-        case 'source_id':
-        case 'source_name':
-        case 'source_table':
-        case 'string_boolean':
-        case 'string_full_utf8':
-        case 'structure':
-        case 'sysevent_name':
-        case 'sysrule_field_name':
-        case 'sys_class_path':
-        case 'template_value':
-        case 'time':
-        case 'timer':
-        case 'translated':
-        case 'translated_html':
-        case 'tree_code':
-        case 'tree_path':
-        case 'url':
-        case 'user_image':
-        case 'user_input':
-        case 'variables':
-        case 'variable_conditions':
-        case 'variable_template_value':
-        case 'video':
-        case 'week_of_month':
-        case 'wide_text':
-        case 'wiki_text':
-        case 'wms_job':
-        case 'workflow':
-        case 'workflow_conditions':
-        case 'xml':
-        default:
-            return GenericColumn
-    }
-}