@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/src/table-plugin.ts

@@ -0,0 +1,1698 @@
+import {
+    type Compiler,
+    ts,
+    CallExpressionShape,
+    type OutputFile,
+    Plugin,
+    unloadBuilder,
+    isSNScope,
+    type Record,
+    type RecordId,
+    type Shape,
+    VariableStatementShape,
+    IdentifierShape,
+    type ObjectShape,
+} from '@servicenow/sdk-build-core'
+import { XMLParser } from 'fast-xml-parser'
+import { z } from 'zod'
+import { columnToCallExpression, generatePlural, isDefaultDocumentation } from './column-plugin'
+import { create } from 'xmlbuilder2'
+import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
+import { addFieldsToColumn } from './column/column-helper'
+import { generateDeprecatedDiagnostics } from './utils'
+import isEqual from 'lodash/isEqual'
+
+type GlobalRecord<T extends string | number | symbol, U> = globalThis.Record<T, U>
+
+// Bootstrap XML schema
+const BooleanFromString = z
+    .string()
+    .transform((str) => str === 'true')
+    .or(z.boolean())
+    .optional()
+
+const ChoiceElementSchema = 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.optional(),
+    '@_inactive_on_update': BooleanFromString.optional(),
+    '@_language': z.string().optional(),
+})
+
+const IndexElementSchema = z.object({
+    '@_name': z.string(),
+})
+
+const IndexSchema = z.object({
+    '@_name': z.string(),
+    '@_unique': BooleanFromString.optional(),
+    element: z.array(IndexElementSchema).or(IndexElementSchema),
+})
+
+const ColumnSchema = z
+    .object({
+        '@_name': z.string(),
+        '@_type': z.string().optional(),
+        '@_internal_type': z.string().optional(),
+        '@_default': z.string().optional(),
+        '@_default_value': z.string().optional(),
+        '@_max_length': z.coerce.number().or(z.string()).optional(),
+        '@_mandatory': BooleanFromString.optional(),
+        '@_read_only': BooleanFromString.optional(),
+        '@_reference_table': z.string().optional(),
+        '@_reference_qual': z.string().optional(),
+        '@_label': z.string().optional(),
+        '@_choice': z.coerce.number().optional(),
+        '@_active': BooleanFromString.optional(),
+        '@_display': BooleanFromString.optional(),
+        '@_use_dependent_field': BooleanFromString.optional(),
+        '@_use_dynamic_default': BooleanFromString.optional(),
+        '@_reference': z.string().optional(),
+        '@_virtual': BooleanFromString.optional(),
+        '@_calculation': z.string().optional(),
+        '@_choice_field': z.string().optional(),
+        '@_function_definition': z.string().optional(),
+        '@_reference_floats': BooleanFromString.optional(),
+        '@_reference_key': z.string().optional(),
+        '@_dynamic_creation_script': z.string().optional(),
+        '@_dynamic_creation': BooleanFromString.optional(),
+        '@_plural': z.string().optional(),
+        '@_hint': z.string().optional(),
+        '@_help': z.string().optional(),
+        '@_widget': z.string().optional(),
+        '@_table_reference': BooleanFromString.optional(),
+        '@_element_reference': BooleanFromString.optional(),
+        '@_unique': BooleanFromString.optional(),
+        '@_spell_check': BooleanFromString.optional(),
+        '@_xml_view': BooleanFromString.optional(),
+        '@_array': BooleanFromString.optional(),
+        '@_text_index': BooleanFromString.optional(),
+        '@_primary': BooleanFromString.optional(),
+        '@_attributes': z.string().optional(),
+        '@_audit': BooleanFromString.optional(),
+        choice: z
+            .object({
+                element: z.array(ChoiceElementSchema).or(ChoiceElementSchema).optional(),
+            })
+            .optional(),
+    })
+    .catchall(z.any())
+
+const TableSchema = z
+    .object({
+        '@_name': z.string(),
+        '@_extends': z.string().optional(),
+        '@_label': z.string().optional(),
+        '@_plural': z.string().optional(),
+        '@_audit': BooleanFromString.optional(),
+        '@_read_only': BooleanFromString.optional(),
+        '@_text_index': BooleanFromString.optional(),
+        '@_client_scripts_access': BooleanFromString.optional().default(true),
+        '@_ws_access': BooleanFromString.optional().default(true),
+        '@_alter_access': BooleanFromString.optional().default(true),
+        '@_create_access': BooleanFromString.optional().default(true),
+        '@_delete_access': BooleanFromString.optional().default(false),
+        '@_update_access': BooleanFromString.optional().default(true),
+        '@_actions_access': BooleanFromString.optional().default(true),
+        '@_read_access': BooleanFromString.optional().default(true),
+        '@_is_extendable': BooleanFromString.optional().default(false),
+        '@_scriptable_table': BooleanFromString.optional().default(false),
+        '@_attributes': z.string().optional(),
+        element: z.array(ColumnSchema).or(ColumnSchema).optional(),
+        index: z.array(IndexSchema).or(IndexSchema).optional(),
+    })
+    .catchall(z.any())
+
+const BootstrapDatabaseSchema = z.object({
+    element: TableSchema,
+})
+
+// Parsed table definitions
+type ChoiceDefinition = {
+    label: string | undefined
+    value: string
+    sequence: number | undefined
+    dependentValue: string | number | undefined
+    hint: string | undefined
+    inactive: boolean | undefined
+    inactiveOnUpdate: boolean | undefined
+    language: string | undefined
+}
+
+type ColumnDefinition = {
+    name: string
+    type: string | undefined
+    defaultValue: string | undefined
+    maxLength: number | string | undefined
+    isMandatory: boolean | undefined
+    isReadOnly: boolean | undefined
+    referenceTable: string | undefined
+    referenceQual: string | undefined
+    columnLabel: string | undefined
+    choices: ChoiceDefinition[] | undefined
+    isActive: boolean | undefined
+    display: boolean | undefined
+    useDependentField: boolean | undefined
+    useDynamicDefault: boolean | undefined
+    reference: string | undefined
+    isVirtual: boolean | undefined
+    calculation: string | undefined
+    choiceField: string | undefined
+    functionDefinition: string | undefined
+    referenceFloats: boolean | undefined
+    referenceKey: string | undefined
+    dynamicCreationScript: string | undefined
+    dynamicCreation: boolean | undefined
+    plural: string | undefined
+    hint: string | undefined
+    help: string | undefined
+    widget: string | undefined
+    tableReference: boolean | undefined
+    elementReference: boolean | undefined
+    unique: boolean | undefined
+    spellCheck: boolean | undefined
+    xmlView: boolean | undefined
+    isArray: boolean | undefined
+    textIndex: boolean | undefined
+    isPrimary: boolean | undefined
+    attributes: string | undefined
+    referenceCascadeRule: string | undefined
+    choiceValue: number | undefined
+    choiceTable: string | undefined
+    dependent: string | undefined
+    audit: boolean | undefined
+}
+
+type IndexDefinition = {
+    name: string
+    unique: boolean | undefined
+    columns: string[]
+}
+
+type TableDefinition = {
+    name: string
+    label: string | undefined
+    plural: string | undefined
+    extends: string | undefined
+    columns: ColumnDefinition[]
+    indexes: IndexDefinition[]
+    audit: boolean | undefined
+    readOnly: boolean | undefined
+    textIndex: boolean | undefined
+    clientScriptsAccess: boolean | undefined
+    wsAccess: boolean | undefined
+    alterAccess: boolean | undefined
+    createAccess: boolean | undefined
+    deleteAccess: boolean | undefined
+    updateAccess: boolean | undefined
+    callerAccess: number | undefined
+    actionsAccess: boolean | undefined
+    readAccess: boolean | undefined
+    isExtendable: boolean | undefined
+    scriptableTable: boolean | undefined
+    attributes: string | undefined
+    display: string | undefined
+}
+
+// sys_db_object & related record properties
+type SysDbObjectProperties = {
+    name: string
+    label: string | undefined
+    super_class: string | undefined
+    is_extendable: boolean | undefined
+    scriptable_table: boolean | undefined
+    client_scripts_access: boolean | undefined
+    ws_access: boolean | undefined
+    alter_access: boolean | undefined
+    create_access: boolean | undefined
+    delete_access: boolean | undefined
+    update_access: boolean | undefined
+    caller_access: number | undefined
+    actions_access: boolean | undefined
+    read_access: boolean | undefined
+}
+
+type SysDictionaryProperties = {
+    name: string
+    internal_type: string
+    element: string | undefined
+    default_value: string | undefined
+    audit: boolean | undefined
+    max_length: number | string | undefined
+    mandatory: boolean | undefined
+    read_only: boolean | undefined
+    reference_table: string | undefined
+    reference_qual: string | undefined
+    column_label: string | undefined
+    active: boolean | undefined
+    display: boolean | undefined
+    use_dependent_field: boolean | undefined
+    use_dynamic_default: boolean | undefined
+    reference: string | undefined
+    virtual: boolean | undefined
+    default: string | undefined
+    calculation: string | undefined
+    choice_field: string | undefined
+    function_definition: string | undefined
+    reference_floats: boolean | undefined
+    reference_key: string | undefined
+    dynamic_creation_script: string | undefined
+    dynamic_creation: boolean | undefined
+    plural: string | undefined
+    hint: string | undefined
+    help: string | undefined
+    widget: string | undefined
+    table_reference: boolean | undefined
+    element_reference: boolean | undefined
+    unique: boolean | undefined
+    spell_check: boolean | undefined
+    xml_view: boolean | undefined
+    array: boolean | undefined
+    text_index: boolean | undefined
+    primary: boolean | undefined
+    attributes: string | undefined
+    reference_cascade_rule: string | undefined
+    choice: number | undefined
+    choice_table: string | undefined
+    dependent: string | undefined
+    function_field: boolean | undefined
+}
+
+type SysChoiceProperties = {
+    name: string
+    element: string
+    label: string
+    value: string
+    sequence: number | undefined
+    dependent_value: string | number | undefined
+    hint: string | undefined
+    inactive: boolean | undefined
+    inactive_on_update: boolean | undefined
+    language: string | undefined
+}
+
+type SysIndexProperties = {
+    index_name: string
+    col_name_string: string
+    unique_index: boolean | undefined
+    logical_table_name: string
+}
+
+type SysDocumentationProperties = {
+    name: string
+    element: string | undefined
+    label: string | undefined
+    plural: string | undefined
+    language: string
+    hint: string | undefined
+    help: string | undefined
+}
+
+/**
+ * The access levels are mapped to the following values on the platform
+ *
+ * - `none`: 0
+ * - `tracking`: 1
+ * - `restricted`: 2
+ *
+ */
+const callerAccessLevels = ['none', 'tracking', 'restricted'] as const
+
+const tableNameRegex = /^[a-z_][a-z0-9_]*[a-z0-9]$/
+const columnNameRegex = /^[a-z_][a-z0-9_]*$/
+
+const tableAliases = {
+    readOnly: ['read_only'],
+    textIndex: ['text_index'],
+    allowWebServiceAccess: ['allow_web_service_access'],
+    allowNewFields: ['allow_new_fields'],
+    allowUiActions: ['allow_ui_actions'],
+    allowClientScripts: ['allow_client_scripts'],
+    licensingConfig: ['licensing_config'],
+    liveFeed: ['live_feed'],
+    accessibleFrom: ['accessible_from'],
+    callerAccess: ['caller_access'],
+    scriptableTable: ['scriptable_table'],
+    autoNumber: ['auto_number'],
+}
+
+const documentationAliases = {
+    urlTarget: ['url_target'],
+}
+
+const autoNumberAliases = {
+    numberOfDigits: ['number_of_digits'],
+}
+
+const licensingAliases = {
+    licenseModel: ['license_model'],
+    ownerCondition: ['owner_condition'],
+    licenseCondition: ['license_condition'],
+    isFulfillment: ['is_fulfillment'],
+    opDelete: ['op_delete'],
+    opUpdate: ['op_update'],
+    opInsert: ['op_insert'],
+    licenseRoles: ['license_roles'],
+}
+
+export const TablePlugin = Plugin.create({
+    name: 'TablePlugin',
+    files: [
+        {
+            matcher: /\.xml$/,
+            toRecord(file, { factory }) {
+                const xml = new XMLParser({
+                    ignoreAttributes: false,
+                    alwaysCreateTextNode: true,
+                    htmlEntities: true,
+                }).parse(file.content).database
+
+                if (!xml) {
+                    return { success: false }
+                }
+
+                const tableDef = parseTableBootstrapXml(xml)
+                if (!tableDef) {
+                    return { success: false }
+                }
+
+                const recordDefs = tableDefToRecordProperties(tableDef)
+                const [sysDbRecord, ...relatedRecords] = (
+                    [
+                        ['sysDbObject', 'sys_db_object'],
+                        ['sysDictionary', 'sys_dictionary'],
+                        ['sysChoice', 'sys_choice'],
+                        ['sysIndex', 'sys_index'],
+                        ['sysDocumentation', 'sys_documentation'],
+                    ] as const
+                ).flatMap(([key, table]) => {
+                    return [recordDefs[key]].flat().map((rec) =>
+                        factory.createRecord({
+                            source: file,
+                            table,
+                            properties: filterUndefinedProperties(rec),
+                        })
+                    )
+                })
+
+                return {
+                    success: true,
+                    value: sysDbRecord!.with(...relatedRecords),
+                }
+            },
+        },
+    ],
+    records: {
+        sys_db_object: {
+            coalesce: ['name'],
+            relationships: {
+                sys_dictionary: {
+                    via: { name: 'name' },
+                    descendant: true,
+                    relationships: {
+                        sys_documentation: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                        sys_choice: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                        sys_choice_set: {
+                            descendant: true,
+                            via: {
+                                name: 'name',
+                                element: 'element',
+                            },
+                        },
+                    },
+                },
+                ua_table_licensing_config: {
+                    descendant: true,
+                    via: { name: 'name' },
+                },
+                sys_documentation: {
+                    descendant: true,
+                    via: { name: 'name' },
+                },
+                sys_number: {
+                    descendant: true,
+                    via: { category: 'name' },
+                },
+                sys_index: {
+                    descendant: true,
+                    via: { logical_table_name: 'name' },
+                },
+                sys_db_object: {
+                    descendant: false,
+                    via: 'super_class',
+                },
+            },
+            toShape(record, { descendants }) {
+                const schema = {}
+                let displayColumn: string | undefined
+                const columns = descendants.query('sys_dictionary')
+                let collectionRecord: Record
+                const choices = descendants.query('sys_choice')
+                const documentation = descendants.query('sys_documentation')
+                for (const column of columns) {
+                    if (column.get('internal_type').getValue() === 'collection') {
+                        // 'collection' sys_dictionary record only has table properties
+                        collectionRecord = column
+                        continue
+                    }
+                    const columnName = column.get('element').asString().getValue()
+                    schema[columnName] = columnToCallExpression(column, {
+                        choices: choices.filter((choice) => choice.get('element').asString().getValue() === columnName),
+                        documentation: documentation.filter(
+                            (d) => d.get('element').ifString()?.getValue() === columnName
+                        ),
+                    })
+                    if (column.get('display').ifDefined()?.toBoolean().getValue()) {
+                        displayColumn = columnName
+                    }
+                }
+
+                const tableDocumentation = documentation.filter((d) => !d.get('element').getValue())
+                const licensing = descendants.query('ua_table_licensing_config')
+                const autoNumber = descendants.query('sys_number')
+                const indexes = descendants.query('sys_index')
+                const originalSource = record.getOriginalSource()
+
+                // Avoid replacing call expressions with variable statements
+                const writeAsCallExpression =
+                    ts.Node.isNode(originalSource) && originalSource.isKind(ts.SyntaxKind.CallExpression)
+                const callExpression = new CallExpressionShape({
+                    source: record,
+                    callee: 'Table',
+                    args: [
+                        record
+                            .transform(({ $ }) => ({
+                                accessibleFrom: $.from('access')
+                                    .map((access) => (access.ifString()?.getValue() === '' ? undefined : access))
+                                    .def('public'),
+                                actions: $.from('read_access', 'update_access', 'delete_access', 'create_access')
+                                    .map((readAccess, updateAccess, deleteAccess, createAccess) => {
+                                        // TODO Add framework solution so these don't come in as strings
+                                        const isTrueString = (value: string | undefined): boolean => value === 'true'
+                                        const actions: ('read' | 'update' | 'delete' | 'create')[] = []
+                                        if (
+                                            readAccess.ifBoolean()?.getValue() ||
+                                            isTrueString(readAccess.ifString()?.getValue())
+                                        ) {
+                                            actions.push('read')
+                                        }
+                                        if (
+                                            updateAccess.ifBoolean()?.getValue() ||
+                                            isTrueString(updateAccess.ifString()?.getValue())
+                                        ) {
+                                            actions.push('update')
+                                        }
+                                        if (
+                                            deleteAccess.ifBoolean()?.getValue() ||
+                                            isTrueString(deleteAccess.ifString()?.getValue())
+                                        ) {
+                                            actions.push('delete')
+                                        }
+                                        if (
+                                            createAccess.ifBoolean()?.getValue() ||
+                                            isTrueString(createAccess.ifString()?.getValue())
+                                        ) {
+                                            actions.push('create')
+                                        }
+                                        return actions.length ? actions : undefined
+                                    })
+                                    .def(['read']),
+                                allowClientScripts: $.from('client_scripts_access').toBoolean().def(false),
+                                allowNewFields: $.from('alter_access').toBoolean().def(false),
+                                allowUiActions: $.from('actions_access').toBoolean().def(false),
+                                allowWebServiceAccess: $.from('ws_access').toBoolean().def(false),
+                                attributes: $.val(
+                                    (() => {
+                                        const attributes = collectionRecord?.get('attributes')
+                                        if (!attributes?.isString()) {
+                                            return undefined
+                                        }
+                                        const result = {}
+                                        attributes
+                                            .toString()
+                                            .getValue()
+                                            .split(',')
+                                            .forEach((attr) => {
+                                                if (attr === '') {
+                                                    return
+                                                }
+                                                const [key, value] = attr.split('=').map((s) => s.trim())
+                                                if (value === 'true') {
+                                                    result[key!] = true
+                                                } else if (value === 'false') {
+                                                    result[key!] = false
+                                                } else {
+                                                    result[key!] = value
+                                                }
+                                            })
+                                        return result
+                                    })()
+                                ).def({ edgeEncryptionEnabled: true }),
+                                audit: $.val(collectionRecord?.get('audit')).toBoolean().def(false),
+                                autoNumber: $.val(
+                                    autoNumber[0]
+                                        ?.transform(({ $ }) => ({
+                                            number: $.toNumber().def(1000),
+                                            numberOfDigits: $.from('maximum_digits').toNumber().def(7),
+                                            prefix: $.def('PRE'),
+                                        }))
+                                        .withAliasedKeys(autoNumberAliases)
+                                ),
+                                callerAccess: $.from('caller_access')
+                                    .map((callerAccess) => {
+                                        if (callerAccess.isNumber()) {
+                                            return callerAccessLevels[callerAccess.getValue()]
+                                        }
+                                        if (callerAccess.isString()) {
+                                            const callerAccessString = callerAccess.getValue()
+                                            if (!isNaN(Number(callerAccessString))) {
+                                                return callerAccessLevels[Number(callerAccessString)]
+                                            }
+                                        }
+                                        return 'none'
+                                    })
+                                    .def('none'),
+                                display: displayColumn ? $.val(displayColumn) : undefined,
+                                extends: $.from('super_class').def(''),
+                                extensible: $.from('is_extendable').toBoolean().def(false),
+                                index: $.val(
+                                    indexes.map((idx) => {
+                                        return idx.transform(({ $ }) => ({
+                                            // TODO Find actual home of 'index_name' instead of using a fake property here
+                                            name: $.from('index_name'),
+                                            unique: $.from('unique_index').map(
+                                                (uniqueIndex) => uniqueIndex.ifBoolean() ?? false
+                                            ),
+                                            element: $.from('col_name_string').map((colNamesString) => {
+                                                const colNames = colNamesString.asString().getValue().split(',')
+                                                return colNames.length > 1 ? colNames : colNames[0]
+                                            }),
+                                        }))
+                                    })
+                                ).def([]),
+                                label: $.map(
+                                    (label) =>
+                                        label.ifString() ??
+                                        (tableDocumentation.length && !isDefaultDocumentation('', tableDocumentation)
+                                            ? tableDocumentation.map((doc) =>
+                                                  doc
+                                                      .transform(({ $ }) => ({
+                                                          label: $.def(''),
+                                                          help: $.def(''),
+                                                          hint: $.def(''),
+                                                          language: $.def(''),
+                                                          plural: $.def(''),
+                                                          url: $.def(''),
+                                                          urlTarget: $.from('url_target').def(''),
+                                                      }))
+                                                      .withAliasedKeys(documentationAliases)
+                                              )
+                                            : undefined)
+                                ),
+                                licensingConfig: licensing.length
+                                    ? $.val(
+                                          licensing[0]!
+                                              .transform(({ $ }) => ({
+                                                  licenseModel: $.from('license_model').def('none'),
+                                                  ownerCondition: $.from('owner_condition').def(''),
+                                                  licenseCondition: $.from('license_condition').def(''),
+                                                  isFulfillment: $.from('is_fulfillment').toBoolean().def(false),
+                                                  opDelete: $.from('op_delete').toBoolean().def(true),
+                                                  opUpdate: $.from('op_update').toBoolean().def(true),
+                                                  opInsert: $.from('op_insert').toBoolean().def(true),
+                                                  licenseRoles: $.from('license_roles')
+                                                      .map((v) => {
+                                                          return v.isString() && !v.isEmpty()
+                                                              ? v
+                                                                    .asString()
+                                                                    .getValue()
+                                                                    .split(',')
+                                                                    .map((role) => role.trim())
+                                                              : []
+                                                      })
+                                                      .def([]),
+                                              }))
+                                              .withAliasedKeys(licensingAliases)
+                                      ).def({
+                                          licenseModel: 'none',
+                                          ownerCondition: '',
+                                          licenseCondition: '',
+                                          isFulfillment: false,
+                                          opDelete: true,
+                                          opUpdate: true,
+                                          opInsert: true,
+                                          licenseRoles: [],
+                                      })
+                                    : undefined,
+                                liveFeed: $.from('live_feed_enabled').toBoolean().def(false),
+                                name: $,
+                                readOnly: $.val(collectionRecord?.get('read_only')).toBoolean().def(false),
+                                schema: $.val(schema),
+                                scriptableTable: $.from('scriptable_table').toBoolean().def(false),
+                                textIndex: $.val(collectionRecord?.get('text_index')).toBoolean().def(false),
+                            }))
+                            .withAliasedKeys(tableAliases),
+                    ],
+                })
+                return {
+                    success: true,
+                    value: writeAsCallExpression
+                        ? callExpression
+                        : new VariableStatementShape({
+                              source: record,
+                              isExported: true,
+                              variableName: new IdentifierShape({
+                                  source: record,
+                                  name: record.get('name').asString().getValue(),
+                              }),
+                              initializer: callExpression,
+                          }),
+                }
+            },
+            toFile(record, { descendants, config }) {
+                if (config.tableOutputFormat !== 'bootstrap' || record.isDeleted()) {
+                    // Defer to record plugin
+                    return { success: false }
+                }
+
+                const tableName = record.get('name').asString().getValue()
+                const columns = descendants.query('sys_dictionary')
+                const choices = descendants.query('sys_choice')
+                const indexes = descendants.query('sys_index')
+                const documentation = descendants.query('sys_documentation')
+                const licensing = descendants.query('ua_table_licensing_config')
+                const autoNumber = descendants.query('sys_number')
+                let collectionRecord: Record | undefined
+                let displayColumn: string | undefined
+                const elements: XMLBuilder[] = []
+                for (const column of columns) {
+                    const displayValue = column.get('display').ifBoolean()?.getValue()
+                    if (displayValue) {
+                        displayColumn = column.get('element').asString().getValue()
+                    }
+                    if (column.get('internal_type').asString().getValue() === 'collection') {
+                        // collection element has only table properties
+                        collectionRecord = column
+                        continue
+                    }
+
+                    const defaultValue = column.get('default_value')
+                    const maxLength = column.get('max_length')
+                    const dependentOnField = column.get('dependent_on_field').ifString()
+                    const columnAttributes: [string, string | undefined][] = [
+                        ['name', column.get('element').asString().getValue()],
+                        ['type', column.get('internal_type').asString().getValue()],
+                        ['active', column.get('active').ifBoolean()?.getValue().toString()],
+                        ['array', column.get('array').ifBoolean()?.getValue().toString()],
+                        ['audit', column.get('audit').ifBoolean()?.getValue().toString()],
+                        [
+                            'default_value',
+                            defaultValue.ifString()?.getValue() ??
+                                defaultValue.ifNumber()?.toString().getValue() ??
+                                defaultValue.ifBoolean()?.toString().getValue() ??
+                                defaultValue
+                                    .ifArray()
+                                    ?.getElements()
+                                    .map((v) => v.asString().getValue())
+                                    .join(', '),
+                        ],
+                        ['unique', column.get('unique').ifBoolean()?.getValue().toString()],
+                        ['label', column.get('column_label').ifString()?.getValue()],
+                        ['max_length', maxLength.ifNumber()?.getValue().toString() ?? maxLength.ifString()?.getValue()],
+                        ['mandatory', column.get('mandatory').ifBoolean()?.getValue().toString()],
+                        ['read_only', column.get('read_only').ifBoolean()?.getValue().toString()],
+                        ['reference_cascade_rule', column.get('reference_cascade_rule').ifString()?.getValue()],
+                        ['calculation', column.get('calculation').ifString()?.getValue()],
+                        ['choice', column.get('choice').ifNumber()?.getValue().toString()],
+                        ['choice_table', column.get('choice_table').ifString()?.getValue()],
+                        ['choice_field', column.get('choice_field').ifString()?.getValue()],
+                        ['display', displayValue?.toString()],
+                        ['function_field', column.get('function_field').ifBoolean()?.getValue().toString()],
+                        ['attributes', column.get('attributes').ifString()?.getValue()],
+                        ['inactive', column.get('inactive').ifBoolean()?.getValue().toString()],
+                        ['dynamic_default', column.get('dynamic_default').ifString()?.getValue()],
+                        ['spell_check', column.get('spell_check').ifBoolean()?.getValue().toString()],
+                        ['xml_view', column.get('xml_view').ifBoolean()?.getValue().toString()],
+                        ['table_reference', column.get('table_reference').ifBoolean()?.getValue().toString()],
+                        ['text_index', column?.get('text_index').ifBoolean()?.getValue().toString()],
+                        ['element_reference', column.get('element_reference').ifBoolean()?.getValue().toString()],
+                        ['primary', column.get('primary').ifBoolean()?.getValue().toString()],
+                        ['dependent', column.get('dependent').ifString()?.getValue().toString()],
+                        ['dependent_on_field', dependentOnField?.getValue()],
+                        [
+                            'use_dependent_field',
+                            dependentOnField ? (!!dependentOnField.getValue()).toString() : undefined,
+                        ],
+                        ['use_dynamic_default', column.get('use_dynamic_default').ifBoolean()?.getValue().toString()],
+                        ['reference', column.get('reference').ifString()?.getValue()],
+                        ['function_definition', column.get('function_definition').ifString()?.getValue()],
+                        ['reference_floats', column.get('reference_floats').ifBoolean()?.getValue().toString()],
+                        ['reference_key', column.get('reference_key').ifString()?.getValue()],
+                        ['dynamic_creation_script', column.get('dynamic_creation_script').ifString()?.getValue()],
+                        ['dynamic_creation', column.get('dynamic_creation').ifBoolean()?.getValue().toString()],
+                        ['plural', column.get('plural').ifString()?.getValue()],
+                        ['hint', column.get('hint').ifString()?.getValue()],
+                        ['help', column.get('help').ifString()?.getValue()],
+                        ['virtual', column.get('virtual').ifBoolean()?.getValue().toString()],
+                        ['widget', column.get('widget').ifString()?.getValue()],
+                        ['reference_qual', column.get('reference_qual').ifString()?.getValue()],
+                        ['reference_qual_condition', column.get('reference_qual_condition').ifString()?.getValue()],
+                    ]
+
+                    const choiceElements = choices
+                        .filter(
+                            (choice) =>
+                                choice.get('element').asString().getValue() ===
+                                column.get('element').asString().getValue()
+                        )
+                        .map((choice) =>
+                            createElement(
+                                'element',
+                                filterUndefinedAttributes([
+                                    ['value', choice.get('value').ifString()?.getValue()],
+                                    ['label', choice.get('label').ifString()?.getValue()],
+                                    [
+                                        'dependent_value',
+                                        choice.get('dependent_value').ifNumber()?.getValue().toString() ??
+                                            choice.get('dependent_value').ifString()?.asString().getValue(),
+                                    ],
+                                    ['inactive', choice.get('inactive').ifBoolean()?.getValue().toString()],
+                                    [
+                                        'inactive_on_update',
+                                        choice.get('inactive_on_update').ifBoolean()?.getValue().toString(),
+                                    ],
+                                    ['sequence', choice.get('sequence').ifNumber()?.getValue().toString()],
+                                ])
+                            )
+                        )
+
+                    elements.push(
+                        createElement(
+                            'element',
+                            filterUndefinedAttributes(columnAttributes),
+                            choiceElements.length ? [createElement('choice', [], choiceElements)] : []
+                        )
+                    )
+                }
+
+                const indexElements = indexes.map((index) => {
+                    const indexAttributes: [string, string | undefined][] = [
+                        ['name', index.get('index_name').ifString()?.getValue()],
+                        ['unique', index.get('unique_index').ifBoolean()?.getValue().toString()],
+                    ]
+
+                    const indexColumns = index
+                        .get('col_name_string')
+                        .asString()
+                        .getValue()
+                        .split(',')
+                        .map((col) => createElement('element', [['name', col.trim()]]))
+
+                    return createElement('index', filterUndefinedAttributes(indexAttributes), indexColumns)
+                })
+
+                const tableAttributes: [string, string | undefined][] = [
+                    ['name', tableName],
+                    ['type', 'collection'],
+                    ['label', record.get('label').ifString()?.getValue()],
+                    ['extends', record.get('super_class').ifRecordId()?.getPrimaryKey()],
+                    ['is_extendable', record.get('is_extendable').ifBoolean()?.getValue().toString()],
+                    ['text_index', collectionRecord?.get('text_index').ifBoolean()?.getValue().toString()],
+                    ['read_only', collectionRecord?.get('read_only').ifBoolean()?.getValue().toString()],
+                    ['audit', collectionRecord?.get('audit').ifBoolean()?.getValue().toString()],
+                    ['display', displayColumn],
+                    ['access', record.get('access').ifString()?.getValue()],
+                    ['caller_access', record.get('caller_access').ifNumber()?.getValue().toString()],
+                    ['ws_access', record.get('ws_access').ifBoolean()?.getValue().toString()],
+                    ['read_access', record.get('read_access').ifBoolean()?.getValue().toString()],
+                    ['alter_access', record.get('alter_access').ifBoolean()?.getValue().toString()],
+                    ['create_access', record.get('create_access').ifBoolean()?.getValue().toString()],
+                    ['update_access', record.get('update_access').ifBoolean()?.getValue().toString()],
+                    ['delete_access', record.get('delete_access').ifBoolean()?.getValue().toString()],
+                    ['actions_access', record.get('actions_access').ifBoolean()?.getValue().toString()],
+                    ['client_scripts_access', record.get('client_scripts_access').ifBoolean()?.getValue().toString()],
+                    ['scriptable_table', record.get('scriptable_table').ifBoolean()?.getValue().toString()],
+                    ['attributes', collectionRecord?.get('attributes').ifString()?.getValue()],
+                ]
+
+                const tableXml = createElement(
+                    'database',
+                    [],
+                    [
+                        createElement('element', filterUndefinedAttributes(tableAttributes), [
+                            ...elements,
+                            ...indexElements,
+                        ]),
+                    ]
+                ).end({ prettyPrint: true })
+
+                const documentationFiles = generateRecordXml(
+                    documentation.filter(
+                        (doc) => !isDefaultDocumentation(doc.get('element')?.toString().getValue(), [doc])
+                    ),
+                    config,
+                    (doc) =>
+                        `sys_documentation_${tableName}${doc.get('element').isDefined() ? `_${doc.get('element').asString().getValue()}` : ''}_${doc.get('language').isDefined() ? doc.get('language').asString().getValue() : 'en'}.xml`
+                )
+
+                const licensingFiles = generateRecordXml(
+                    licensing.filter((licensing) => !isDefaultLicenseConfig(tableName, licensing)),
+                    config,
+                    (record) => `ua_table_licensing_config_${record.getId().getValue()}.xml`
+                )
+
+                const autoNumberFiles = generateRecordXml(
+                    autoNumber,
+                    config,
+                    (record) => `sys_number_${record.getId().getValue()}.xml`
+                )
+
+                return {
+                    success: true,
+                    value: [
+                        {
+                            name: `${tableName}.xml`,
+                            category: 'dictionary',
+                            content: tableXml,
+                        },
+                        ...documentationFiles,
+                        ...licensingFiles,
+                        ...autoNumberFiles,
+                    ],
+                }
+            },
+        },
+        sys_dictionary: {
+            coalesce: ['name', 'element'],
+        },
+        sys_documentation: {
+            coalesce: ['name', 'element', 'language'],
+        },
+        ua_table_licensing_config: {
+            coalesce: ['name'],
+        },
+        sys_index: {
+            coalesce: ['logical_table_name', 'col_name_string'],
+        },
+        sys_number: {
+            coalesce: ['category', 'prefix'],
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { config, factory, transform, diagnostics, compiler }) {
+                if (callExpression.getCallee() !== 'Table') {
+                    return { success: false }
+                }
+
+                const statement = callExpression
+                    .getOriginalNode()
+                    .getFirstAncestorByKind(ts.SyntaxKind.VariableStatement)
+                const table = callExpression.getArgument(0).asObject().withAliasedKeys(tableAliases)
+                generateDeprecatedDiagnostics(table, diagnostics)
+                const relatedRecords: Record[] = []
+                const tableName = table.get('name').asString()
+                if (!tableName.getValue().match(tableNameRegex)) {
+                    diagnostics.error(
+                        table.get('name'),
+                        'Table name must only contain lowercase letters, numbers, and underscores and end with a letter or number'
+                    )
+                }
+
+                let ignoreColumnNameCheck = false
+                const scopeName = config.scope
+                const scopeRegex = new RegExp(`^${scopeName}_`)
+                const tableNameMatch = tableName.getValue().match(scopeRegex)
+                if (!tableNameMatch && !isSNScope(scopeName) && scopeName !== 'global') {
+                    const nameNode = tableName.getOriginalNode()
+                    if (nameNode && !nameNode.isKind(ts.SyntaxKind.AsExpression)) {
+                        // 'sn' and 'now' scoped apps ignore this validation
+                        diagnostics.error(
+                            table.get('name'),
+                            `'name' property should start with scope prefix '${scopeName}_'`
+                        )
+                    } else {
+                        ignoreColumnNameCheck = true
+                    }
+                }
+
+                const declaration = callExpression.getOriginalNode().getParent()
+                const exportedByName =
+                    declaration?.isKind(ts.SyntaxKind.VariableDeclaration) &&
+                    declaration.isNamedExport() &&
+                    declaration.getName() === tableName.getValue()
+                if (!exportedByName) {
+                    diagnostics.error(
+                        callExpression,
+                        `Table definition should be exported as a named export with the name '${tableName.getValue()}'`
+                    )
+                }
+
+                // sys_dictionary
+                const schema = table.get('schema').asObject()
+                for (const [name, column] of schema.entries()) {
+                    if (!name.match(columnNameRegex)) {
+                        diagnostics.error(
+                            column.getOriginalNode().getParentIfKind(ts.SyntaxKind.PropertyAssignment) ?? column,
+                            'Column name must only contain lowercase letters, numbers, and underscores'
+                        )
+                    }
+                    if (
+                        !ignoreColumnNameCheck &&
+                        !tableNameMatch &&
+                        !isSNScope(scopeName) &&
+                        scopeName !== 'global' &&
+                        !name.match(scopeRegex)
+                    ) {
+                        // 'sn' and 'now' scoped apps ignore this validation
+                        diagnostics.error(
+                            column.getOriginalNode().getParentIfKind(ts.SyntaxKind.PropertyAssignment) ?? column,
+                            `Column name should be prefixed with scope '${scopeName}_' if table name does not contain prefix`
+                        )
+                    }
+                    const display = table.get('display').ifString()?.getValue() === name
+                    const result = await transform.toRecord(
+                        addFieldsToColumn(
+                            { name, table: tableName.getValue(), display },
+                            column.as(CallExpressionShape)
+                        )
+                    )
+                    if (!result.success) {
+                        diagnostics.error(column, 'Invalid column in table schema')
+                        return { success: false }
+                    }
+                    relatedRecords.push(result.value)
+                }
+
+                // sys_index
+                if (table.get('index').isArray()) {
+                    for (const index of table.get('index').asArray().getElements()) {
+                        const indexObject = index.asObject().getValue()
+                        const colNames = Array.isArray(indexObject['element'])
+                            ? indexObject['element'].join(',')
+                            : (indexObject['element'] as string)
+
+                        relatedRecords.push(
+                            factory.createRecord({
+                                source: statement ?? callExpression,
+                                table: 'sys_index',
+                                properties: {
+                                    index_name: indexObject['name'],
+                                    col_name_string: colNames,
+                                    unique_index: indexObject['unique'] === true,
+                                    logical_table_name: table.get('name').asString().getValue(),
+                                },
+                            })
+                        )
+                    }
+                }
+
+                // ua_table_licensing_config
+                if (table.get('licensingConfig').isObject()) {
+                    const licenseObj = table.get('licensingConfig').asObject().withAliasedKeys(licensingAliases)
+                    generateDeprecatedDiagnostics(licenseObj, diagnostics)
+                    const licenseRecord = factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'ua_table_licensing_config',
+                        properties: licenseObj.transform(({ $ }) => ({
+                            name: $.val(table.get('name')),
+                            license_model: $.from('licenseModel').def('none'),
+                            owner_condition: $.from('ownerCondition'),
+                            license_condition: $.from('licenseCondition'),
+                            is_fulfillment: $.from('isFulfillment').def(false),
+                            op_delete: $.from('opDelete').def(true),
+                            op_update: $.from('opUpdate').def(true),
+                            license_roles: $.from('licenseRoles')
+                                .map((licenseRoles) => {
+                                    return (
+                                        licenseRoles
+                                            .ifArray()
+                                            ?.getElements()
+                                            .map((e) => e.asString().getValue())
+                                            .join(',') ?? []
+                                    )
+                                })
+                                .def([]),
+                            op_insert: $.from('opInsert').def(true),
+                        })),
+                    })
+                    relatedRecords.push(licenseRecord)
+                } else {
+                    relatedRecords.push(
+                        factory.createRecord({
+                            source: statement ?? callExpression,
+                            table: 'ua_table_licensing_config',
+                            properties: {
+                                name: tableName,
+                                license_model: 'none',
+                                is_fulfillment: false,
+                                op_delete: true,
+                                op_insert: true,
+                                op_update: true,
+                            },
+                        })
+                    )
+                }
+
+                // sys_documentation
+                if (table.get('label').isArray()) {
+                    const documentation = table.get('label').asArray().getElements()
+                    const languages = new Set<string>()
+                    for (const doc of documentation) {
+                        const docObject = doc.asObject().withAliasedKeys(documentationAliases)
+                        generateDeprecatedDiagnostics(docObject, diagnostics)
+                        const language = docObject.get('language').ifString()?.getValue()
+                        if (language) {
+                            if (language.length !== 2) {
+                                diagnostics.error(
+                                    doc.getOriginalNode(),
+                                    `'language' must be a 2 character identifier (Ex. 'en', 'es')`
+                                )
+                            }
+                            if (languages.has(language)) {
+                                diagnostics.error(doc.getOriginalNode(), `'language' must be unique per table/column`)
+                            }
+                            languages.add(language)
+                        }
+                        relatedRecords.push(
+                            factory.createRecord({
+                                source: statement ?? callExpression,
+                                table: 'sys_documentation',
+                                properties: docObject.transform(({ $ }) => ({
+                                    name: $.val(table.get('name').asString().getValue()),
+                                    element: $.val(undefined),
+                                    label: $,
+                                    help: $,
+                                    hint: $,
+                                    language: $,
+                                    plural: $,
+                                    url: $,
+                                    url_target: $.from('urlTarget'),
+                                })),
+                            })
+                        )
+                    }
+                } else {
+                    relatedRecords.push(
+                        factory.createRecord({
+                            source: statement ?? callExpression,
+                            table: 'sys_documentation',
+                            properties: {
+                                name: tableName,
+                                element: undefined,
+                                language: 'en',
+                                label: table.get('label').ifString() ?? tableName,
+                                plural: generatePlural(
+                                    table.get('label')?.ifString()?.getValue() ?? tableName.getValue()
+                                ),
+                            },
+                        })
+                    )
+                }
+
+                // sys-number
+                let numberRef: RecordId | undefined
+                if (table.get('autoNumber').isObject()) {
+                    const autoNumber = table.get('autoNumber').asObject().withAliasedKeys(autoNumberAliases)
+                    const sysNumberRecord = factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'sys_number',
+                        properties: autoNumber.transform(({ $ }) => ({
+                            category: $.val(table.get('name').getValue()),
+                            maximum_digits: $.from('numberOfDigits').toNumber().def(7),
+                            number: $.def(1000),
+                            prefix: $.from('prefix').def('PRE'),
+                        })),
+                    })
+                    numberRef = sysNumberRecord.getId()
+                    relatedRecords.push(sysNumberRecord)
+                }
+
+                // sys_dictionary (collection)
+                relatedRecords.push(
+                    factory.createRecord({
+                        source: statement ?? callExpression,
+                        table: 'sys_dictionary',
+                        properties: table.transform(({ $ }) => ({
+                            name: $,
+                            element: $.val(undefined),
+                            internal_type: $.def('collection'),
+                            attributes: $.map((attributes) => {
+                                if (!attributes.isObject()) {
+                                    return undefined
+                                }
+                                const attributesObj = attributes.asObject().getValue()
+                                return Object.entries(attributesObj)
+                                    .map(([key, value]) => `${key}=${value}`)
+                                    .join(',')
+                            }).def(''),
+                            audit: $.def(false),
+                            read_only: $.from('readOnly').def(false),
+                            text_index: $.from('textIndex').def(false),
+                        })),
+                    })
+                )
+
+                const hasAction = (actionName: string, actions: Shape): boolean | undefined => {
+                    return actions
+                        .ifArray()
+                        ?.getElements()
+                        .some((action) => action.isString() && action.getValue() === actionName)
+                }
+
+                // sys_db_object
+                const tableRecord = factory.createRecord({
+                    source: statement ?? callExpression,
+                    table: 'sys_db_object',
+                    properties: table.transform(({ $ }) => ({
+                        client_scripts_access: $.from('allowClientScripts').toBoolean().def(false),
+                        alter_access: $.from('allowNewFields').toBoolean().def(false),
+                        actions_access: $.from('allowUiActions').toBoolean().def(false),
+                        ws_access: $.from('allowWebServiceAccess').toBoolean().def(false),
+                        number_ref: $.val(numberRef),
+                        access: $.from('accessibleFrom').def('public'),
+                        caller_access: $.from('callerAccess').map((callerAccess) =>
+                            callerAccessLevels.indexOf(
+                                (callerAccess.ifString()?.getValue() ?? 'none') as 'none' | 'tracking' | 'restricted'
+                            )
+                        ),
+                        super_class: $.from('extends').map(
+                            (v) =>
+                                v.ifString()?.pipe((parent) =>
+                                    factory.createReference({
+                                        source: parent,
+                                        table: 'sys_db_object',
+                                        keys: { name: parent.getValue() },
+                                    })
+                                ) ?? v.ifDefined()?.toRecordId()
+                        ),
+                        read_access: $.from('actions')
+                            .map((actions) => hasAction('read', actions))
+                            .def(true),
+                        update_access: $.from('actions')
+                            .map((actions) => hasAction('update', actions))
+                            .def(false),
+                        delete_access: $.from('actions')
+                            .map((actions) => hasAction('delete', actions))
+                            .def(false),
+                        create_access: $.from('actions')
+                            .map((actions) => hasAction('create', actions))
+                            .def(false),
+                        is_extendable: $.from('extensible').toBoolean().def(false),
+                        label: $.map((label) => (label.isString() ? label.asString() : undefined)),
+                        live_feed_enabled: $.from('liveFeed').toBoolean().def(false),
+                        name: $,
+                        scriptable_table: $.from('scriptableTable').toBoolean().def(false),
+                    })),
+                })
+
+                if (exportedByName) {
+                    addTableToGlobalGeneratedFile(table, callExpression.getOriginalFilePath(), compiler)
+                }
+                return {
+                    success: true,
+                    value: tableRecord.with(...relatedRecords),
+                }
+            },
+        },
+    ],
+    nodes: [
+        {
+            node: 'VariableStatement',
+            fileTypes: ['fluent'],
+            entryPoint: true,
+        },
+        {
+            node: 'ExportAssignment',
+            fileTypes: ['fluent'],
+            entryPoint: true,
+            toShape(node, { diagnostics }) {
+                const expression = node.getExpression().asKind(ts.SyntaxKind.CallExpression)?.getExpression()
+                if (expression && expression.getText() === 'Table') {
+                    diagnostics.error(expression, 'Export assignments are not supported for Table definitions')
+                }
+                return { success: false }
+            },
+        },
+    ],
+})
+
+function parseTableBootstrapXml(xml: unknown): TableDefinition | null {
+    const parsedXml = BootstrapDatabaseSchema.safeParse(xml)
+    if (!parsedXml.success) {
+        return null
+    }
+
+    const table = parsedXml.data.element
+    const columns: ColumnDefinition[] = []
+    if (table.element) {
+        const mapColumnToDefinition = (column: z.infer<typeof ColumnSchema>): ColumnDefinition => ({
+            name: column['@_name'],
+            type: column['@_internal_type'] ?? column['@_type'],
+            defaultValue: column['@_default'] ?? column['@_default_value'],
+            audit: column['@_audit'],
+            maxLength: column['@_max_length'],
+            isMandatory: column['@_mandatory'],
+            isReadOnly: column['@_read_only'],
+            referenceTable: column['@_reference_table'],
+            referenceQual: column['@_reference_qual'],
+            columnLabel: column['@_label'],
+            choices: column.choice?.element
+                ? Array.isArray(column.choice.element)
+                    ? column.choice.element.map((choice) => ({
+                          label: choice['@_label'],
+                          value: choice['@_value'] ?? '',
+                          sequence: choice['@_sequence'],
+                          dependentValue: choice['@_dependent_value'],
+                          hint: choice['@_hint'],
+                          inactive: choice['@_inactive'],
+                          inactiveOnUpdate: choice['@_inactive_on_update'],
+                          language: choice['@_language'],
+                      }))
+                    : [
+                          {
+                              label: column.choice.element['@_label'],
+                              value: column.choice.element['@_value'] ?? '',
+                              sequence: column.choice.element['@_sequence'],
+                              dependentValue: column.choice.element['@_dependent_value'],
+                              hint: column.choice.element['@_hint'],
+                              inactive: column.choice.element['@_inactive'],
+                              inactiveOnUpdate: column.choice.element['@_inactive_on_update'],
+                              language: column.choice.element['@_language'],
+                          },
+                      ]
+                : undefined,
+            isActive: column['@_active'],
+            display: column['@_display'],
+            useDependentField: column['@_use_dependent_field'],
+            useDynamicDefault: column['@_use_dynamic_default'],
+            reference: column['@_reference'],
+            isVirtual: column['@_virtual'],
+            calculation: column['@_calculation'],
+            choiceField: column['@_choice_field'],
+            functionDefinition: column['@_function_definition'],
+            referenceFloats: column['@_reference_floats'],
+            referenceKey: column['@_reference_key'],
+            dynamicCreationScript: column['@_dynamic_creation_script'],
+            dynamicCreation: column['@_dynamic_creation'],
+            plural: column['@_plural'],
+            hint: column['@_hint'],
+            help: column['@_help'],
+            widget: column['@_widget'],
+            tableReference: column['@_table_reference'],
+            elementReference: column['@_element_reference'],
+            unique: column['@_unique'],
+            spellCheck: column['@_spell_check'],
+            xmlView: column['@_xml_view'],
+            isArray: column['@_array'],
+            textIndex: column['@_text_index'],
+            isPrimary: column['@_primary'],
+            attributes: column['@_attributes'],
+            referenceCascadeRule: column['@_reference_cascade_rule'],
+            choiceValue: column['@_choice'],
+            choiceTable: column['@_choice_table'],
+            dependent: column['@_dependent'],
+        })
+
+        if (Array.isArray(table.element)) {
+            columns.push(...table.element.map(mapColumnToDefinition))
+        } else {
+            columns.push(mapColumnToDefinition(table.element))
+        }
+    }
+
+    const indexes: IndexDefinition[] = []
+    if (table.index) {
+        const mapIndexToDefinition = (index: z.infer<typeof IndexSchema>): IndexDefinition => ({
+            name: index['@_name'],
+            unique: index['@_unique'],
+            columns: index.element
+                ? Array.isArray(index.element)
+                    ? index.element.map((element) => element['@_name'])
+                    : [index.element['@_name']]
+                : [],
+        })
+
+        if (Array.isArray(table.index)) {
+            indexes.push(...table.index.map(mapIndexToDefinition))
+        } else {
+            indexes.push(mapIndexToDefinition(table.index))
+        }
+    }
+
+    return {
+        name: table['@_name'],
+        label: table['@_label'],
+        plural: table['@_plural'],
+        extends: table['@_extends'],
+        columns,
+        indexes,
+        audit: table['@_audit'],
+        readOnly: table['@_read_only'],
+        textIndex: table['@_text_index'],
+        clientScriptsAccess: table['@_client_scripts_access'],
+        wsAccess: table['@_ws_access'],
+        display: table['@_display'],
+        alterAccess: table['@_alter_access'],
+        createAccess: table['@_create_access'],
+        deleteAccess: table['@_delete_access'],
+        updateAccess: table['@_update_access'],
+        callerAccess: table['@_caller_access'],
+        actionsAccess: table['@_actions_access'],
+        readAccess: table['@_read_access'],
+        isExtendable: table['@_is_extendable'],
+        scriptableTable: table['@_scriptable_table'],
+        attributes: table['@_attributes'],
+    }
+}
+
+function tableDefToRecordProperties(tableDef: TableDefinition): {
+    sysDbObject: SysDbObjectProperties
+    sysDictionary: SysDictionaryProperties[]
+    sysChoice: SysChoiceProperties[]
+    sysIndex: SysIndexProperties[]
+    sysDocumentation: SysDocumentationProperties[]
+} {
+    const sysDbObject: SysDbObjectProperties = {
+        name: tableDef.name,
+        label: tableDef.label,
+        super_class: tableDef.extends,
+        is_extendable: tableDef.isExtendable,
+        scriptable_table: tableDef.scriptableTable,
+        client_scripts_access: tableDef.clientScriptsAccess,
+        ws_access: tableDef.wsAccess,
+        alter_access: tableDef.alterAccess,
+        create_access: tableDef.createAccess,
+        delete_access: tableDef.deleteAccess,
+        update_access: tableDef.updateAccess,
+        caller_access: tableDef.callerAccess,
+        actions_access: tableDef.actionsAccess,
+        read_access: tableDef.readAccess,
+    }
+
+    const sysDictionary: SysDictionaryProperties[] = []
+    const sysChoice: SysChoiceProperties[] = []
+    const sysDocumentation: SysDocumentationProperties[] = []
+
+    // table documentation
+    if (tableDef.label && tableDef.plural) {
+        sysDocumentation.push({
+            name: tableDef.name,
+            element: undefined,
+            label: tableDef.label,
+            plural: tableDef.plural,
+            language: 'en',
+            hint: undefined,
+            help: undefined,
+        })
+    }
+
+    for (const column of tableDef.columns) {
+        sysDictionary.push({
+            name: tableDef.name,
+            element: column.name,
+            internal_type: column.type || 'string',
+            default_value: column.defaultValue,
+            max_length: column.maxLength,
+            mandatory: column.isMandatory,
+            read_only: column.isReadOnly,
+            reference_table: column.referenceTable,
+            reference_qual: column.referenceQual,
+            column_label: column.columnLabel,
+            active: column.isActive,
+            display: tableDef.display === column.name || column.display,
+            use_dependent_field: column.useDependentField,
+            use_dynamic_default: column.useDynamicDefault,
+            reference: column.reference,
+            virtual: column.isVirtual,
+            default: column.defaultValue,
+            calculation: column.calculation,
+            choice_field: column.choiceField,
+            function_definition: column.functionDefinition,
+            reference_floats: column.referenceFloats,
+            reference_key: column.referenceKey,
+            dynamic_creation_script: column.dynamicCreationScript,
+            dynamic_creation: column.dynamicCreation,
+            plural: column.plural,
+            hint: column.hint,
+            help: column.help,
+            widget: column.widget,
+            table_reference: column.tableReference,
+            element_reference: column.elementReference,
+            unique: column.unique,
+            spell_check: column.spellCheck,
+            xml_view: column.xmlView,
+            array: column.isArray,
+            text_index: column.textIndex,
+            primary: column.isPrimary,
+            attributes: column.attributes,
+            reference_cascade_rule: column.referenceCascadeRule,
+            choice: column.choiceValue,
+            choice_table: column.choiceTable,
+            dependent: column.dependent,
+            function_field: column.functionDefinition ? true : undefined,
+            audit: column.audit,
+        })
+
+        if (column.choices?.length) {
+            for (const choice of column.choices) {
+                sysChoice.push({
+                    name: tableDef.name,
+                    element: column.name,
+                    label: choice.label || choice.value,
+                    value: choice.value,
+                    sequence: choice.sequence,
+                    dependent_value: choice.dependentValue,
+                    hint: choice.hint,
+                    inactive: choice.inactive,
+                    inactive_on_update: choice.inactiveOnUpdate,
+                    language: choice.language,
+                })
+            }
+        }
+
+        // Add column documentation
+        sysDocumentation.push({
+            name: tableDef.name,
+            element: column.name,
+            label: column.columnLabel || column.name,
+            plural: column.plural || generatePlural(column.columnLabel || column.name),
+            language: 'en',
+            hint: column.hint,
+            help: column.help,
+        })
+    }
+
+    // sys_dictionary collection record
+    sysDictionary.push({
+        name: tableDef.name,
+        internal_type: 'collection',
+        // table properties
+        attributes: tableDef.attributes,
+        audit: tableDef.audit,
+        text_index: tableDef.textIndex,
+        read_only: tableDef.readOnly,
+        // column properties left undefined
+        element: undefined,
+        default_value: undefined,
+        max_length: undefined,
+        mandatory: undefined,
+        reference_table: undefined,
+        reference_qual: undefined,
+        column_label: undefined,
+        active: undefined,
+        display: undefined,
+        use_dependent_field: undefined,
+        use_dynamic_default: undefined,
+        reference: undefined,
+        virtual: undefined,
+        default: undefined,
+        calculation: undefined,
+        choice_field: undefined,
+        function_definition: undefined,
+        reference_floats: undefined,
+        reference_key: undefined,
+        dynamic_creation_script: undefined,
+        dynamic_creation: undefined,
+        plural: undefined,
+        hint: undefined,
+        help: undefined,
+        widget: undefined,
+        table_reference: undefined,
+        element_reference: undefined,
+        unique: undefined,
+        spell_check: undefined,
+        xml_view: undefined,
+        array: undefined,
+        primary: undefined,
+        reference_cascade_rule: undefined,
+        choice: undefined,
+        choice_table: undefined,
+        dependent: undefined,
+        function_field: undefined,
+    })
+
+    const sysIndex: SysIndexProperties[] = []
+    for (const index of tableDef.indexes) {
+        sysIndex.push({
+            index_name: index.name,
+            col_name_string: index.columns.join(','),
+            unique_index: index.unique,
+            logical_table_name: tableDef.name,
+        })
+    }
+
+    return {
+        sysDbObject,
+        sysDictionary,
+        sysChoice,
+        sysIndex,
+        sysDocumentation,
+    }
+}
+
+function addTableToGlobalGeneratedFile(tableArg: ObjectShape, sourceFilePath: string, compiler: Compiler): void {
+    const { interfaces, properties, imports, namedImports } = {
+        interfaces: [] as ts.OptionalKind<ts.InterfaceDeclarationStructure>[],
+        properties: [] as ts.OptionalKind<ts.PropertySignatureStructure>[],
+        imports: {} as GlobalRecord<string, ts.OptionalKind<ts.ImportDeclarationStructure>>,
+        namedImports: [] as Array<
+            ts.OptionalKind<ts.ImportSpecifierStructure> & {
+                existingImport: ts.ImportDeclaration
+            }
+        >,
+    }
+    const generatedTableFile: ts.SourceFile | undefined = compiler.getGeneratedTableFile()
+    const tableName = tableArg.get('name').asString().getValue()
+    if (!(tableName.trim().length > 0 && tableName.match(tableNameRegex))) {
+        return
+    }
+    const extendsTable = tableArg.get('extends').ifString()?.getValue()
+    if (!compiler.interfaceExistsInGlobalDeclaration(tableName)) {
+        interfaces.push({
+            name: tableName,
+            extends: [`Helper<typeof ${tableName}>`],
+        })
+    }
+    if (!compiler.propertyExistsInGlobalDeclaration(tableName)) {
+        const interfaceType = extendsTable
+            ? `Table<TableSchemas.${tableName}, "${extendsTable}">`
+            : `Table<TableSchemas.${tableName}>`
+
+        properties.push({
+            name: tableName,
+            type: interfaceType,
+        })
+    }
+    if (generatedTableFile) {
+        const resolvedModuleSpecifier = generatedTableFile.getRelativePathAsModuleSpecifierTo(sourceFilePath)
+        if (resolvedModuleSpecifier) {
+            const importExists = compiler.importExistsInGlobalDeclaration(resolvedModuleSpecifier)
+            if (!importExists) {
+                if (imports[sourceFilePath]) {
+                    const existingImport = imports[sourceFilePath]
+                    if (Array.isArray(existingImport.namedImports)) {
+                        ;(existingImport.namedImports as string[]).push(tableName)
+                    }
+                } else {
+                    imports[sourceFilePath] = {
+                        namedImports: [tableName],
+                        moduleSpecifier: resolvedModuleSpecifier,
+                    }
+                }
+            } else {
+                const namedImportExists = importExists?.getNamedImports().some((value) => value.getName() === tableName)
+                if (!namedImportExists) {
+                    namedImports.push({
+                        existingImport: importExists,
+                        name: tableName,
+                    })
+                }
+            }
+        }
+    }
+    if (interfaces.length > 0 || properties.length > 0 || Object.keys(imports).length > 0 || namedImports.length > 0) {
+        compiler.addTableInterfacesToGlobalDeclaration({
+            interfaces,
+            properties,
+            imports,
+            namedImports,
+        })
+    }
+}
+
+function filterUndefinedProperties<T extends object>(obj: T): T {
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined)) as T
+}
+
+function filterUndefinedAttributes<T>(attributes: [string, T | undefined][]): [string, T][] {
+    return attributes.filter((pair): pair is [string, T] => pair[1] !== undefined)
+}
+
+function createElement(name: string, attributes: [string, string][] = [], children: XMLBuilder[] = []): XMLBuilder {
+    const element = create().ele(name)
+    for (const [key, value] of attributes) {
+        const sanitizedValue = value.replaceAll('\n', '&#10;').replaceAll('\r', '&#13;')
+        element.att(key, sanitizedValue)
+    }
+    for (const child of children) {
+        element.import(child)
+    }
+    return element
+}
+
+function generateRecordXml(
+    records: Record[],
+    config: { scope: string; scopeId: string },
+    getFileName: (record: Record) => string
+): OutputFile[] {
+    return records.map((record) => {
+        const recordBuilder = unloadBuilder({ scope: config.scope, scopeId: config.scopeId })
+        const builder = recordBuilder.record(record)
+        record
+            .entries()
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([prop, shape]) => builder.field(prop, shape))
+        return {
+            name: getFileName(record),
+            category: record.getInstallCategory(),
+            content: recordBuilder.end(),
+        }
+    })
+}
+
+export function isDefaultLicenseConfig(tableName: string, licenseRecord: Record): boolean {
+    const license = licenseRecord!.asObject().getValue() as globalThis.Record<string, unknown>
+    const defaultRecord: globalThis.Record<string, unknown> = {
+        name: tableName,
+        license_model: 'none',
+        is_fulfillment: false,
+        op_delete: true,
+        op_insert: true,
+        op_update: true,
+    }
+    const optionalFields = ['owner_condition', 'license_condition', 'license_roles'] as const
+    optionalFields.forEach((field) => {
+        if (field in license) {
+            defaultRecord[field] = ''
+        }
+    })
+    return isEqual(defaultRecord, license)
+}