@servicenow/sdk-build-plugins 2.0.1

package/src/db/TablePlugin.ts

@@ -0,0 +1,1581 @@
+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,
+} from '@servicenow/sdk-core/runtime/db'
+import {
+    Context,
+    EntityData,
+    LinkedDocument,
+    Plugin,
+    extractCallExpression,
+    getCallExpressionName,
+    getOrCreateEntitySourceFile,
+    getOrCreatePropertyAssignment,
+    linkDocument,
+    removeNode,
+    stringify,
+    transformFunctionArguments,
+    writeCustomProperty,
+    XmlData,
+    FluentDiagnostic,
+    PartialElements,
+    generateCallExpressionExport,
+    generateCallExpression,
+    createPropertyIdentifier,
+    XMLJsonBuilder,
+    XMLJsonElement,
+    ObjectData,
+} from '@servicenow/sdk-build-core'
+import { XMLBuilder } from 'fast-xml-parser'
+import { isArray, isEmpty, isObject, isString, 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 { Diagnostic } from '@servicenow/sdk-project'
+import { formatScript } from '../ScriptTemplatePlugin'
+import * as os from 'os'
+import * as path from 'path'
+
+/**
+ * The access levels are mapped to the following values on the platform
+ *
+ * - `none`: 0
+ * - `tracking`: 1
+ * - `restricted`: 2
+ *
+ */
+export const callerAccess = ['none', 'tracking', 'restricted'] as const
+
+// Basic info needed for table references
+export 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, cannot exceed 80 characters */
+    label: z.string().max(80, 'Cannot exceed 80 characters').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(),
+            })
+        )
+        .optional(),
+})
+
+const componentTables = ['sys_dictionary', 'sys_choice', 'sys_documentation']
+
+type IndexType = {
+    name: string
+    unique: boolean
+    element: 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>
+export const ColumnSchema = z.object({
+    entityKind: z.string().optional(),
+    column_type: z.string().optional(),
+    audit: z.boolean().optional().default(false),
+    label: z.string().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(),
+    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(),
+})
+
+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().default(true),
+    create_access: TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    update_access: TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    delete_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+
+    ws_access: TextBooleanSchema.or(BooleanFromString).optional().default(true),
+    caller_access: TextNumberSchema.or(IntFromString)
+        .transform((val) => {
+            if (val) {
+                return callerAccess[val]
+            }
+            return
+        })
+        .optional(),
+    alter_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    client_scripts_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    actions_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    //configuration_access: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+
+    is_extendable: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+    // live_feed_enabled: TextBooleanSchema.or(BooleanFromString).optional().default(false),
+
+    access: TextStringSchema.or(z.string()).optional(),
+})
+
+// Attributes in the element='collection' tag of bootstrap xml
+export const TableSchemaBootstrap = z.object({
+    name: z.string(),
+    extends: z.string().optional(),
+    label: z.string().max(80, 'Cannot exceed 80 characters').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),
+
+    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()),
+})
+
+export const Documentation = 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(),
+        url: TextStringSchema.optional(),
+        url_target: TextStringSchema.optional(),
+    }),
+})
+
+// Attributes from element=table in bootstrap.xml
+export const TableSchemaBootstrapAttributes = z
+    .object({
+        '@_name': z.string(),
+        '@_extends': z.string().optional(),
+        '@_label': z.string().optional(),
+        '@_max_length': z.coerce.number().optional(),
+
+        // From sys_dictionary
+        '@_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,
+
+        '@_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 IndexSchemaBootstrapAttributes = z.object({
+    '@_name': z.string(),
+    '@_unique': BooleanFromString,
+    element: z.object({
+        '@_name': z.string(),
+    }),
+})
+
+export 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(),
+        choice: z.object({ element: z.array(z.any()).or(z.record(z.any())).optional() }).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().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 })
+
+type ComposedTableData = {
+    data: {
+        bootstrapData: any
+        dbObjectData: any
+    }
+}
+
+function isSNScope(scopeName: string) {
+    return scopeName.startsWith('sn') || scopeName.startsWith('now')
+}
+
+export default Plugin({
+    name: 'Table',
+    ownedTables: {
+        sys_db_object: { diagnosticLevel: Diagnostic.Level.Warn },
+    },
+    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
+                }
+
+                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') {
+                        diagnostics.push(
+                            new FluentDiagnostic(
+                                tableName.getNode(),
+                                `'name' property must start with scope prefix '${scopeName}'`
+                            )
+                        )
+                    }
+                }
+
+                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 (!columnName.match(nameRegex)) {
+                        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(
+                            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] }
+            },
+        },
+        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.handledXmls[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.handledXmls[xml.filePath] = 'handled'
+                return new XmlData(
+                    dbObjectData,
+                    xml.filePath,
+                    'sys_db_object',
+                    db_object_inc.data.sys_db_object['@_action']
+                )
+            } else {
+                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 = Documentation.parse(record_update[table])
+                        return new XmlData(
+                            {
+                                table: table,
+                                id: record_update[table][table]['sys_id']['#text'],
+                                data: data.sys_documentation,
+                            },
+                            xml.filePath,
+                            'record',
+                            record_update[table][table]['@_action']
+                        )
+                    }
+
+                    context.handledXmls[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: idxData.data.element['@_name'],
+                            unique: idxData.data['@_unique'] ?? false,
+                        })
+                    }
+                })
+                bootstrapData['index'] = idxElements
+            }
+
+            return new XmlData(bootstrapData, xml.filePath, 'bootstrap')
+        },
+    },
+    composers: {
+        entity: {
+            table(entity, context) {
+                const node = entity.getNode()
+                const data = entity.getValue()
+                const table = TableSchemaFull.parse(data)
+
+                const composeData = compose(table)
+                composeData['columns'] = composeColumns(
+                    table.schema as Record<string, ColumnSchema>,
+                    context,
+                    table.display
+                )
+
+                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 = 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
+                }
+
+                composeData['index'] = table.index
+
+                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'] as string,
+                    data: { data: { dbObjectData: xml.data } },
+                    action: xml.action,
+                }
+            },
+        },
+    },
+    generators: {
+        bootstrap(document, context) {
+            const parsedBoostrapData = TableSchemaBootstrapIncoming.safeParse(
+                (document.data as ComposedTableData).data.bootstrapData
+            )
+            if (!parsedBoostrapData.success) {
+                return undefined
+            }
+
+            return linkDocument(
+                document,
+                generateCallExpressionExportForDocument(
+                    context,
+                    {
+                        sourceFile: getOrCreateEntitySourceFile(context, parsedBoostrapData.data.name),
+                        moduleSpecifier: '@servicenow/sdk/core',
+                        exportName: parsedBoostrapData.data.name,
+                    },
+                    Table,
+                    {}
+                ).getInitializerIfKindOrThrow(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 builder = new XMLJsonBuilder('1.0')
+            const databaseObj = builder.createRoot('database', undefined, undefined)
+            const composedAttributes = composeAttributes(attributes)
+            const collectionObj = databaseObj.addJsonObj(
+                'element',
+                undefined,
+                { ...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,
+                    }!
+                )
+
+                buildChoices(column as ColumnSchema, elementObj)
+            }
+
+            buildIndexes(index, collectionObj)
+
+            const bootstrapXmlJson = new XMLBuilder({
+                ignoreAttributes: false,
+                format: true,
+                suppressBooleanAttributes: false,
+                suppressEmptyNode: true,
+            }).build(builder.buildJsonObj())
+
+            return {
+                name: `${bootstrapData.name}.xml`,
+                directory: 'dictionary',
+                content: bootstrapXmlJson,
+                usedIds: [],
+            }
+        },
+    },
+    transformers: {
+        bootstrap: {
+            CallExpression(document) {
+                const expressionName = getCallExpressionName(document.node)
+                if (expressionName !== Table.name) {
+                    return false
+                }
+                const [args] = document.node.getArguments()
+                if (!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)) {
+                    const actions = getActionsArray({ create_access, delete_access, update_access, read_access })
+                    if (actions.length > 0) {
+                        writeCustomProperty(args, 'actions', '[]', stringify(actions))
+                    } else {
+                        const actionsProp = getOrCreatePropertyAssignment(args, 'actions', '[]')
+                        actionsProp.remove()
+                    }
+                }
+
+                if (!rest.attributes) {
+                    delete rest.attributes
+                }
+
+                if (xmlData.bootstrapData && xmlData.bootstrapData.index) {
+                    const indexProp = getOrCreatePropertyAssignment(args, 'index', '[]')
+                    indexProp.setInitializer(stringify(xmlData.bootstrapData.index))
+                    if (xmlData.bootstrapData.index.length === 0) {
+                        indexProp.remove()
+                    }
+                }
+
+                transformFunctionArguments(document.node, Table as any, rest)
+
+                // Handle columns
+                const incomingColumns = xmlData.bootstrapData ? xmlData.bootstrapData.columns : undefined
+
+                updateDisplayValue(document.node, columns, incomingColumns)
+                transformColumns(incomingColumns, args)
+                return true
+            },
+        },
+    },
+    postProcessors: {
+        entities(entities, context) {
+            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)
+                })
+        },
+    },
+})
+
+function generateCallExpressionExportForDocument<const A extends unknown[]>(
+    context: Context,
+    info: {
+        sourceFile: 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 composeAttributes(attributes: Record<string, any> | undefined) {
+    if (!attributes) {
+        return ''
+    }
+
+    return Object.entries(attributes)
+        .map(([key, value]) => `${key}=${value}`)
+        .join(',')
+}
+
+function updateDisplayValue(node: 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 composeColumns(columns: Record<string, ColumnSchema>, context: Context, display?: string) {
+    const composedColumns = {}
+    for (const [columnName, columnData] of Object.entries(columns)) {
+        const column = ColumnSchema.parse(columnData)
+        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,
+            audit: column.audit,
+            label: column.label ?? columnName,
+            max_length: column.maxLength,
+            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'
+                    ? getScriptInfo(column.dynamic_value_definitions!['calculated_value'], context)
+                    : 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,
+
+            use_dynamic_default: column.dynamic_value_definitions?.type === 'dynamic_default' || undefined,
+
+            default_value:
+                column.dynamic_value_definitions?.type === 'dynamic_default'
+                    ? getDynamicDefault(column.dynamic_value_definitions?.dynamic_default)
+                    : undefined,
+
+            default: column.default,
+
+            function_definition: column.function_definition,
+            function_field: column.function_definition ? true : false,
+        }
+
+        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 composedColumns
+}
+
+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: 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,
+
+        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
+}
+
+let schemaPosition = 4
+
+function transformColumns(incoming_schema: ColumnSchema, args: ObjectLiteralExpression) {
+    const schemaProperty = getOrCreatePropertyAssignment(args, 'schema', '{}')
+    const schemaLiteral = schemaProperty.getChildrenOfKind(ts.SyntaxKind.ObjectLiteralExpression)[0]
+    if (!schemaLiteral) {
+        return
+    }
+
+    const keys = Object.keys(incoming_schema ?? {})
+    if (keys.length === 0) {
+        return
+    }
+
+    //TODO:: need to come up with a way to format script more accurately
+    schemaPosition = schemaLiteral.getSourceFile().getLineAndColumnAtPos(schemaLiteral.getStart()).column
+    const assignments: ts.PropertyAssignment[] = []
+    keys.forEach((key) => {
+        const data = incoming_schema[key]
+        const callExpFromType = getCallExpressionFromType(data.type)
+        const transformedColumn = transformColumnData(data, callExpFromType)
+        const callExp = generateColumnExpression(callExpFromType, {
+            ...transformedColumn,
+            choices: data.choice_elements,
+        })
+        assignments.push(ts.factory.createPropertyAssignment(createPropertyIdentifier(data.name), callExp))
+    })
+
+    schemaLiteral.transform((traversal) => {
+        if (ts.isObjectLiteralExpression(traversal.currentNode)) {
+            return traversal.factory.updateObjectLiteralExpression(traversal.currentNode, assignments)
+        }
+        return traversal.currentNode
+    })
+}
+
+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 getDynamicDefault(val: string) {
+    return val.startsWith('javascript:') ? val : `javascript:${dynamic_value_mapping[val]}`
+}
+
+function buildIndexes(indexes: IndexType[] = [], collection: XMLJsonElement) {
+    indexes.forEach((index) => {
+        const indexElement = collection.addJsonObj('index', undefined, { name: index.name, unique: index.unique })
+        indexElement.addJsonObj('element', undefined, { name: index.element })
+    })
+}
+
+function buildChoices(column: ColumnSchema, element: XMLJsonElement) {
+    if (!column.choice_elements) {
+        return
+    }
+
+    const choices = element.addJsonObj('choice', undefined, undefined)
+    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, {
+                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.addJsonObj('element', undefined, {
+                    value: value[0],
+                    ...(value[1] as ChoiceConfig),
+                })
+            } else {
+                choices.addJsonObj('element', undefined, {
+                    value: value[1],
+                    label: value[0],
+                })
+            }
+        })
+    }
+}
+
+export function transformColumnData(col: any, callExpFromType: any) {
+    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,
+        function_field,
+        ...column
+    } = col
+
+    if (max_length) {
+        column.maxLength = max_length
+    }
+
+    if (internal_type && (callExpFromType.entityKind === 'generic' || callExpFromType.name === 'GenericColumn')) {
+        column.column_type = internal_type
+    }
+
+    if (choice !== undefined) {
+        column.dropdown = choiceDropdown[choice]
+    }
+
+    if (reference) {
+        column.referenceTable = reference
+    }
+
+    // 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.dynamic_value_definitions = {
+            type: 'dynamic_default',
+            dynamic_default: def,
+        }
+    }
+
+    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 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('@_')) {
+            obj[key.substring(2)] = value
+            delete obj[key]
+        }
+    })
+    return obj
+}
+
+export 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',
+        },
+    })
+}
+
+// TODO should this reference sys_filter_option_dynamic instead?
+export const dynamic_value_mapping = {
+    'Current Name': `current.name`,
+    'Next ECC Sequence Number': `GlideCounter.next('ecc:sequence');`,
+    'Get Module View': `var viewDefault='';if(current.device_type=='mobile') viewDefault='Mobile';else if(!current.application.nil() && current.application.device_type=='mobile' && current.device_type.nil()) viewDefault='Mobile';viewDefault`,
+    'Get Label Display Value': `gs.getDisplayValueFor(current.table, current.table_key, '')`,
+    'Get CMDB Item Category': `gs.include("CMDBItem");var item = new CMDBItem(current);item.setCategory();`,
+    'Parent Record Matcher Table': `if (typeof parent != "undefined") parent.matcher_table`,
+    'Next Cache Flush Number': `GlideCounter.next('sys_cache_flush');`,
+    'Get Next Number': `global.getNextObjNumber()`,
+    'Next Workflow Log Order Number': `GlideCounter.next('wf_log:order');`,
+    Subject: 'email.subject',
+    'Get Mobile Module View': `var viewDefault='';if(typeof parent != 'undefined')if(parent.device_type=='mobile') viewDefault='Mobile';viewDefault`,
+    'Parent Record Model Table': `if (typeof parent != "undefined") parent.model_table`,
+    'Get Label Table Display Value': `gs.getDisplayValueFor(current.table, current.table_key, 'sys_class_name')`,
+    'Parent Record Source Table': `if (typeof parent != "undefined") parent.source_table`,
+    'Get Next Padded Number': `global.getNextObjNumberPadded();`,
+    'My First Name': `gs.getUser().firstName`,
+    'My Last Name': `gs.getUser().lastName`,
+    'My Job Title': `gs.getUser().title`,
+}
+
+export function generateColumnExpression<Type extends (...args: any) => any>(
+    expression: Type,
+    args: Parameters<Type>[0],
+    argsSetIfDefined?: Undefined<Parameters<Type>[0]>
+): ts.CallExpression {
+    const setArgs = { ...args }
+    if (argsSetIfDefined) {
+        Object.keys(argsSetIfDefined).forEach((key) => {
+            if (argsSetIfDefined[key] !== undefined) {
+                setArgs[key] = argsSetIfDefined[key]
+            }
+        })
+    }
+
+    return ts.factory.createCallExpression(ts.factory.createIdentifier(expression.name), undefined, [
+        createObjectExpression(setArgs),
+    ])
+}
+
+export function createObjectExpression(firstArg: object): ts.Expression {
+    return ts.factory.createObjectLiteralExpression(
+        Object.entries(firstArg)
+            .filter(([_key, value]) => value !== undefined)
+            .map(([key, value]) => {
+                if (key === 'referenceTable') {
+                    return ts.factory.createPropertyAssignment(
+                        ts.factory.createIdentifier('referenceTable'),
+                        ts.factory.createStringLiteral(value)
+                    )
+                } else if (key === 'calculated_value') {
+                    const calVal = `${os.EOL}${formatScript(value, schemaPosition)}`
+                    return ts.factory.createPropertyAssignment(
+                        ts.factory.createIdentifier(key),
+                        ts.factory.createTaggedTemplateExpression(
+                            ts.factory.createIdentifier('script'),
+                            undefined,
+                            ts.factory.createNoSubstitutionTemplateLiteral(calVal, calVal)
+                        )
+                    )
+                }
+                return ts.factory.createPropertyAssignment(
+                    createPropertyIdentifier(key),
+                    factoryCreateValue(value, ts.factory)
+                )
+            })
+    )
+}
+
+export function factoryCreateValue(value: unknown, factory: ts.NodeFactory) {
+    if (typeof value === 'string') {
+        return factory.createStringLiteral(value)
+    }
+
+    if (typeof value === 'number') {
+        if (value >= 0) {
+            return factory.createNumericLiteral(value)
+        } else {
+            return factory.createPrefixUnaryExpression(
+                ts.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: ts.Expression[] = []
+
+            Object.values(value).forEach((v) => {
+                newvals.push(factoryCreateValue(v, factory))
+            })
+
+            return factory.createArrayLiteralExpression(newvals)
+        } else if (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
+}
+export function getCallExpressionFromType(internal_type: string) {
+    switch (internal_type) {
+        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 'string':
+            return StringColumn
+        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_list':
+        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 'image':
+        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
+    }
+}