@servicenow/sdk-build-plugins 4.6.0 → 4.7.0

package/src/table-plugin.ts

@@ -26,7 +26,7 @@ import { create } from 'xmlbuilder2'
 import type { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
 import { addFieldsToColumn } from './column/column-helper'
 import { getLabelForDefaultLanguage } from './column/column-to-record'
-import { createSdkDocEntry, generateDeprecatedDiagnostics } from './utils'
+import { generateDeprecatedDiagnostics, generateChoiceSetFile } from './utils'
 import isEqual from 'lodash/isEqual'
 
 type GlobalRecord<T extends string | number | symbol, U> = globalThis.Record<T, U>
@@ -80,6 +80,10 @@ const ColumnSchema = z
         '@_use_dynamic_default': BooleanFromString.optional(),
         '@_reference': z.string().optional(),
         '@_virtual': BooleanFromString.optional(),
+        '@_formula': z.string().optional(),
+        '@_virtual_type': z.string().optional(),
+        '@_use_reference_qualifier': z.string().optional(),
+        '@_dynamic_ref_qual': z.string().optional(),
         '@_calculation': z.string().optional(),
         '@_choice_field': z.string().optional(),
         '@_function_definition': z.string().optional(),
@@ -168,6 +172,10 @@ type ColumnDefinition = {
     useDynamicDefault: boolean | undefined
     reference: string | undefined
     isVirtual: boolean | undefined
+    formula: string | undefined
+    virtualType: 'script' | 'formula' | undefined
+    useReferenceQualifier: 'simple' | 'dynamic' | 'advanced' | undefined
+    dynamicRefQual: string | undefined
     calculation: string | undefined
     choiceField: string | undefined
     functionDefinition: string | undefined
@@ -221,6 +229,8 @@ type TableDefinition = {
     actionsAccess: boolean | undefined
     readAccess: boolean | undefined
     isExtendable: boolean | undefined
+    createAccessControls: boolean | undefined
+    userRole: string | undefined
     scriptableTable: boolean | undefined
     attributes: string | undefined
     display: string | undefined
@@ -232,6 +242,8 @@ type SysDbObjectProperties = {
     label: string | undefined
     super_class: string | undefined
     is_extendable: boolean | undefined
+    create_access_controls: boolean | undefined
+    user_role: string | undefined
     scriptable_table: boolean | undefined
     client_scripts_access: boolean | undefined
     ws_access: boolean | undefined
@@ -263,6 +275,10 @@ type SysDictionaryProperties = {
     use_dynamic_default: boolean | undefined
     reference: string | undefined
     virtual: boolean | undefined
+    formula: string | undefined
+    virtual_type: 'script' | 'formula' | undefined
+    use_reference_qualifier: 'simple' | 'dynamic' | 'advanced' | undefined
+    dynamic_ref_qual: string | undefined
     default: string | undefined
     calculation: string | undefined
     choice_field: string | undefined
@@ -384,7 +400,6 @@ const licensingAliases = {
 
 export const TablePlugin = Plugin.create({
     name: 'TablePlugin',
-    docs: [createSdkDocEntry('Table', ['sys_db_object'])],
     files: [
         {
             matcher: /\.xml$/,
@@ -419,7 +434,11 @@ export const TablePlugin = Plugin.create({
                             await factory.createRecord({
                                 source: file,
                                 table,
-                                properties: filterUndefinedProperties(rec),
+                                properties: {
+                                    ...filterUndefinedProperties(rec),
+                                    // Decorate generated sys_db_object
+                                    ...(key === 'sysDbObject' || key === 'sysDictionary' ? { _bootstrap: true } : {}),
+                                },
                             })
                         )
                     }
@@ -489,7 +508,7 @@ export const TablePlugin = Plugin.create({
                     via: 'super_class',
                 },
             },
-            toShape(record, { descendants, config }) {
+            toShape(record, { descendants, config, compiler }) {
                 const schema: { [key: string]: CallExpressionShape } = {}
                 let displayColumn: string | undefined
                 const columns = descendants.query('sys_dictionary')
@@ -528,29 +547,41 @@ export const TablePlugin = Plugin.create({
                             override.transform(({ $ }) => ({
                                 baseTable: $.from('base_table'),
                                 default: $.from('default_value_override', 'default_value').map((flag, value) => {
-                                    return flag.toBoolean()?.getValue() ? value.ifString()?.getValue() : undefined
+                                    return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                        ? value.ifString()?.getValue()
+                                        : undefined
                                 }),
                                 calculation: $.from('calculation_override', 'calculation').map((flag, value) => {
-                                    return flag.toBoolean()?.getValue() ? value.ifString()?.getValue() : undefined
+                                    return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                        ? value.ifString()?.getValue()
+                                        : undefined
                                 }),
                                 referenceQualifier: $.from('reference_qual_override', 'reference_qual').map(
                                     (flag, value) => {
-                                        return flag.toBoolean()?.getValue() ? value.ifString()?.getValue() : undefined
+                                        return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                            ? value.ifString()?.getValue()
+                                            : undefined
                                     }
                                 ),
                                 readOnlyOption: $.from('read_only_option_override', 'read_only_option').map(
                                     (flag, value) => {
-                                        return flag.toBoolean()?.getValue() ? value.ifString()?.getValue() : undefined
+                                        return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                            ? value.ifString()?.getValue()
+                                            : undefined
                                     }
                                 ),
                                 dependent: $.from('dependent_override', 'dependent').map((flag, value) => {
-                                    return flag.toBoolean()?.getValue() ? value.ifString()?.getValue() : undefined
+                                    return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                        ? value.ifString()?.getValue()
+                                        : undefined
                                 }),
                                 mandatory: $.from('mandatory_override', 'mandatory').map((flag, value) => {
-                                    return flag.toBoolean()?.getValue() ? value.toBoolean()?.getValue() : undefined
+                                    return flag.ifDefined() && flag.toBoolean()?.getValue()
+                                        ? value.toBoolean()?.getValue()
+                                        : undefined
                                 }),
                                 attributes: $.from('attributes_override', 'attributes').map((flag, attrs) => {
-                                    if (!flag.toBoolean()?.getValue() || !attrs.isString()) {
+                                    if (!flag.ifDefined() || !flag.toBoolean()?.getValue() || !attrs.isString()) {
                                         return undefined
                                     }
                                     const result: { [key: string]: string | number | boolean } = {}
@@ -603,6 +634,44 @@ export const TablePlugin = Plugin.create({
                 // Avoid replacing call expressions with variable statements
                 const writeAsCallExpression =
                     ts.Node.isNode(originalSource) && originalSource.isKind(ts.SyntaxKind.CallExpression)
+
+                const tableName = record.get('name').asString().getValue()
+                const isBootstrapDbObject = record.get('_bootstrap').ifBoolean()?.getValue() === true
+                const nonBootstrapColumns = columns.filter(
+                    (col) => col.get('_bootstrap').ifBoolean()?.getValue() !== true
+                )
+
+                // Write as augmentation if we have sys_db_object from bootstrap and columns from elsewhere
+                const isAugmentation = isBootstrapDbObject && nonBootstrapColumns.length > 0
+                if (isAugmentation) {
+                    const augmentsExpression = new CallExpressionShape({
+                        source: record,
+                        callee: 'Table',
+                        exportName: tableName,
+                        args: [
+                            record.transform(({ $ }) => ({
+                                augments: $.val(tableName),
+                                schema: $.val(schema),
+                            })),
+                        ],
+                    })
+                    registerBootstrappedTable(augmentsExpression, schema, compiler)
+                    return {
+                        success: true,
+                        value: writeAsCallExpression
+                            ? augmentsExpression
+                            : new VariableStatementShape({
+                                  source: record,
+                                  isExported: true,
+                                  variableName: new IdentifierShape({
+                                      source: record,
+                                      name: tableName,
+                                  }),
+                                  initializer: augmentsExpression,
+                              }),
+                    }
+                }
+
                 const callExpression = new CallExpressionShape({
                     source: record,
                     callee: 'Table',
@@ -693,18 +762,24 @@ export const TablePlugin = Plugin.create({
                                 ),
                                 callerAccess: $.from('caller_access')
                                     .map((callerAccess) => {
+                                        // An empty <caller_access/> element arrives as '', not 0 — guard before
+                                        // '' and 0 both mean "none" on the platform — omit from generated Fluent.
+                                        if (callerAccess.isString() && callerAccess.getValue() === '') {
+                                            return ''
+                                        }
                                         if (callerAccess.isNumber()) {
-                                            return callerAccessLevels[callerAccess.getValue()]
+                                            const value = callerAccess.getValue()
+                                            return value === 0 ? '' : callerAccessLevels[value]
                                         }
                                         if (callerAccess.isString()) {
-                                            const callerAccessString = callerAccess.getValue()
-                                            if (!isNaN(Number(callerAccessString))) {
-                                                return callerAccessLevels[Number(callerAccessString)]
+                                            const parsed = Number(callerAccess.getValue())
+                                            if (!isNaN(parsed)) {
+                                                return parsed === 0 ? '' : callerAccessLevels[parsed]
                                             }
                                         }
-                                        return 'none'
+                                        return ''
                                     })
-                                    .def('none'),
+                                    .def(''),
                                 display: displayColumn ? $.val(displayColumn) : undefined,
                                 extends: $.from('super_class').def(''),
                                 extensible: $.from('is_extendable').toBoolean().def(false),
@@ -725,7 +800,7 @@ export const TablePlugin = Plugin.create({
                                 ).def([]),
                                 label: $.map(
                                     (label) =>
-                                        label.ifString() ??
+                                        label.ifString()?.ifNotEmpty() ??
                                         (tableDocumentation.length &&
                                         !isDefaultDocumentation('', tableDocumentation, config.defaultLanguage)
                                             ? tableDocumentation.map((doc) =>
@@ -782,12 +857,24 @@ export const TablePlugin = Plugin.create({
                                 name: $,
                                 readOnly: $.val(collectionRecord?.get('read_only')).toBoolean().def(false),
                                 schema: $.val(schema),
+                                // create_access_controls and user_role only ever arrive here from the
+                                // sys_db_object record. The platform's bootstrap XML pipeline does not
+                                // touch either field (no references in /glide/db/bootstrap/xml/ or
+                                // TableDescriptorProvider.createTableLevelMetaData), and the SDK's own
+                                // bootstrap output is always paired with sys_db_object_<id>.xml that
+                                // carries the record values. So the bootstrap-only string path through
+                                // tableDefToRecordProperties is unreachable for these two fields.
+                                createAccessControls: $.from('create_access_controls').toBoolean().def(false),
+                                userRole: $.from('user_role')
+                                    .map((v) => v.ifRecordId()?.getPrimaryKey())
+                                    .def(''),
                                 scriptableTable: $.from('scriptable_table').toBoolean().def(false),
                                 textIndex: $.val(collectionRecord?.get('text_index')).toBoolean().def(false),
                             }))
                             .withAliasedKeys(tableAliases),
                     ],
                 })
+                registerBootstrappedTable(callExpression, schema, compiler)
                 return {
                     success: true,
                     value: writeAsCallExpression
@@ -804,12 +891,13 @@ export const TablePlugin = Plugin.create({
                 }
             },
             async toFile(record, { descendants, config, transform }) {
-                if (config.tableOutputFormat !== 'bootstrap' || config.type === 'configuration' || record.isDeleted()) {
-                    // Defer to record plugin
+                if (record.isDeleted()) {
                     return { success: false }
                 }
 
-                const tableName = record.get('name').asString().getValue()
+                const augmentsValue = record.get('augments').ifString()?.getValue()
+                const isAugmentation = augmentsValue !== undefined
+                const tableName = augmentsValue ?? record.get('name').asString().getValue()
                 const columns = descendants.query('sys_dictionary')
                 const choices = descendants.query('sys_choice')
                 const indexes = descendants.query('sys_index')
@@ -817,6 +905,71 @@ export const TablePlugin = Plugin.create({
                 const licensing = descendants.query('ua_table_licensing_config')
                 const autoNumber = descendants.query('sys_number')
                 const overrides = descendants.query('sys_dictionary_override')
+
+                const [
+                    documentationFiles,
+                    licensingFiles,
+                    autoNumberFiles,
+                    overrideFiles,
+                    sysDictionaryFiles,
+                    sysDbObjectFiles,
+                ] = await Promise.all([
+                    generateRecordXml(
+                        documentation.filter(
+                            (doc) =>
+                                !isDefaultDocumentation(
+                                    doc.get('element')?.toString().getValue(),
+                                    [doc],
+                                    config.defaultLanguage
+                                )
+                        ),
+                        config,
+                        transform
+                    ),
+                    generateRecordXml(
+                        licensing.filter((l) => !isDefaultLicenseConfig(tableName, l)),
+                        config,
+                        transform
+                    ),
+                    generateRecordXml(autoNumber, config, transform),
+                    generateRecordXml(overrides, config, transform),
+                    generateRecordXml(columns, config, transform, ['_bootstrap']),
+                    isAugmentation
+                        ? Promise.resolve([])
+                        : generateRecordXml([record], config, transform, ['augments', '_bootstrap']),
+                ])
+
+                if (config.type === 'configuration') {
+                    // No bootstrap XML for configuration projects, just write independent record XML
+                    const choiceSets = descendants.query('sys_choice_set')
+                    const [choiceSetFiles, indexFiles] = await Promise.all([
+                        Promise.all(
+                            choiceSets.map((cs) => {
+                                const csChoices = choices.filter(
+                                    (c) =>
+                                        c.get('name').toString().getValue() === cs.get('name').toString().getValue() &&
+                                        c.get('element').toString().getValue() ===
+                                            cs.get('element').toString().getValue()
+                                )
+                                return generateChoiceSetFile(cs, csChoices, config, transform)
+                            })
+                        ),
+                        generateRecordXml(indexes, config, transform),
+                    ])
+                    return {
+                        success: true,
+                        value: [
+                            ...sysDictionaryFiles,
+                            ...choiceSetFiles,
+                            ...indexFiles,
+                            ...sysDbObjectFiles,
+                            ...documentationFiles,
+                            ...licensingFiles,
+                            ...autoNumberFiles,
+                            ...overrideFiles,
+                        ],
+                    }
+                }
                 let displayColumn: string | undefined
                 let collectionRecord: Record | undefined
                 const elements: XMLBuilder[] = []
@@ -859,7 +1012,10 @@ export const TablePlugin = Plugin.create({
                         ['read_only_option', column.get('read_only_option').ifString()?.getValue()],
                         ['reference_cascade_rule', column.get('reference_cascade_rule').ifString()?.getValue()],
                         ['calculation', column.get('calculation').ifString()?.getValue()],
-                        ['choice', column.get('choice').ifNumber()?.getValue().toString()],
+                        // Bootstrap convention: emit `choice="0"` for the platform default ("none").
+                        // The component (install) path uses an empty `<choice/>` element instead, but
+                        // bootstrap files conventionally include the literal "0" attribute.
+                        ['choice', (column.get('choice').ifNumber()?.getValue() ?? 0).toString()],
                         ['choice_table', column.get('choice_table').ifString()?.getValue()],
                         ['choice_field', column.get('choice_field').ifString()?.getValue()],
                         ['display', displayValue?.toString()],
@@ -890,6 +1046,23 @@ export const TablePlugin = Plugin.create({
                         ['hint', column.get('hint').ifString()?.getValue()],
                         ['help', column.get('help').ifString()?.getValue()],
                         ['virtual', column.get('virtual').ifBoolean()?.getValue().toString()],
+                        ['formula', column.get('formula').ifString()?.getValue() || undefined],
+                        [
+                            'virtual_type',
+                            column.get('virtual_type').ifString()?.getValue() === 'script'
+                                ? undefined
+                                : column.get('virtual_type').ifString()?.getValue(),
+                        ],
+                        [
+                            'use_reference_qualifier',
+                            column.get('use_reference_qualifier').ifString()?.getValue() === 'simple'
+                                ? undefined
+                                : column.get('use_reference_qualifier').ifString()?.getValue(),
+                        ],
+                        [
+                            'dynamic_ref_qual',
+                            column.get('dynamic_ref_qual').ifDefined()?.toString().getValue() || undefined,
+                        ],
                         ['widget', column.get('widget').ifString()?.getValue()],
                         ['reference_qual', column.get('reference_qual').ifString()?.getValue()],
                         ['reference_qual_condition', column.get('reference_qual_condition').ifString()?.getValue()],
@@ -958,7 +1131,9 @@ export const TablePlugin = Plugin.create({
                     ['audit', collectionRecord?.get('audit').ifBoolean()?.getValue().toString()],
                     ['display', displayColumn],
                     ['access', record.get('access').ifString()?.getValue()],
-                    ['caller_access', record.get('caller_access').ifNumber()?.getValue().toString()],
+                    // Bootstrap convention: emit `caller_access="0"` for the platform default ("none").
+                    // The component (install) path uses an empty `<caller_access/>` element instead.
+                    ['caller_access', (record.get('caller_access').ifNumber()?.getValue() ?? 0).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()],
@@ -967,6 +1142,8 @@ export const TablePlugin = Plugin.create({
                     ['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()],
+                    // create_access_controls and user_role are omitted: the platform's bootstrap
+                    // pipeline doesn't read them. They're carried by the paired sys_db_object_<id>.xml.
                     ['scriptable_table', record.get('scriptable_table').ifBoolean()?.getValue().toString()],
                     ['attributes', collectionRecord?.get('attributes').ifString()?.getValue()],
                 ]
@@ -982,28 +1159,6 @@ export const TablePlugin = Plugin.create({
                     ]
                 ).end({ prettyPrint: true })
 
-                const documentationFiles = await generateRecordXml(
-                    documentation.filter(
-                        (doc) =>
-                            !isDefaultDocumentation(
-                                doc.get('element')?.toString().getValue(),
-                                [doc],
-                                config.defaultLanguage
-                            )
-                    ),
-                    config,
-                    transform
-                )
-
-                const licensingFiles = await generateRecordXml(
-                    licensing.filter((licensing) => !isDefaultLicenseConfig(tableName, licensing)),
-                    config,
-                    transform
-                )
-
-                const autoNumberFiles = await generateRecordXml(autoNumber, config, transform)
-                const overrideFiles = await generateRecordXml(overrides, config, transform)
-
                 return {
                     success: true,
                     value: [
@@ -1017,6 +1172,8 @@ export const TablePlugin = Plugin.create({
                         ...licensingFiles,
                         ...autoNumberFiles,
                         ...overrideFiles,
+                        ...sysDictionaryFiles,
+                        ...sysDbObjectFiles,
                     ],
                 }
             },
@@ -1068,7 +1225,9 @@ export const TablePlugin = Plugin.create({
                 const table = callExpression.getArgument(0).asObject().withAliasedKeys(tableAliases)
                 generateDeprecatedDiagnostics(table, diagnostics)
                 const relatedRecords: Record[] = []
-                const tableName = table.get('name').asString()
+                const augments = table.get('augments').ifString()
+                const isAugmentation = augments !== undefined
+                const tableName = isAugmentation ? augments! : table.get('name').asString()
                 if (!tableName.getValue().match(tableNameRegex)) {
                     diagnostics.error(
                         table.get('name'),
@@ -1078,16 +1237,28 @@ export const TablePlugin = Plugin.create({
 
                 let ignoreColumnNameCheck = false
                 const scopeName = config.scope
-                const scopeRegex = new RegExp(`^${scopeName}_`)
-                const globalRegex = /^u_/
-                const tableNameMatch = tableName.getValue().match(scopeRegex)
-                if (!tableNameMatch && !isSNScope(scopeName) && scopeName !== 'global') {
+                const scopePrefix = scopeName === 'global' ? 'u_' : `${scopeName}_`
+                const prefixRegex = new RegExp(`^${scopePrefix}`)
+                const tableNameMatch = tableName.getValue().match(prefixRegex)
+                if (isAugmentation) {
+                    if (tableNameMatch && scopeName !== 'global') {
+                        const nameNode = tableName.getOriginalNode()
+                        if (!nameNode?.getParentIfKind(ts.SyntaxKind.AsExpression)) {
+                            diagnostics.error(
+                                table.get('augments'),
+                                `'augments' flag set on in-scope table '${tableName.getValue()}'`
+                            )
+                        } else {
+                            ignoreColumnNameCheck = true
+                        }
+                    }
+                } else if (!tableNameMatch && !isSNScope(scopeName) && scopeName !== 'global') {
                     const nameNode = tableName.getOriginalNode()
                     if (nameNode && !nameNode.getParentIfKind(ts.SyntaxKind.AsExpression)) {
                         // 'sn' and 'now' scoped apps ignore this validation
                         diagnostics.error(
                             table.get('name'),
-                            `'name' property should start with scope prefix '${scopeName}_'`
+                            `'name' property should start with scope prefix '${scopePrefix}'`
                         )
                     } else {
                         ignoreColumnNameCheck = true
@@ -1106,13 +1277,11 @@ export const TablePlugin = Plugin.create({
                     )
                 }
 
-                const globalTableNameMatch = tableName.getValue().match(globalRegex)
                 let anyNonPrefixedGlobalColumn = false
-
-                if (scopeName === 'global' && !globalTableNameMatch) {
+                if (!isAugmentation && scopeName === 'global' && !tableNameMatch) {
                     const schema = table.get('schema').asObject()
                     for (const [name, _] of schema.entries()) {
-                        if (!name.match(globalRegex)) {
+                        if (!name.match(prefixRegex)) {
                             anyNonPrefixedGlobalColumn = true
                             break
                         }
@@ -1124,7 +1293,7 @@ export const TablePlugin = Plugin.create({
                             `Global table 'name' property should start with custom prefix 'u_'`
                         )
                     }
-                } else if (scopeName === 'global') {
+                } else if (scopeName === 'global' && !isAugmentation) {
                     // Global table starts with custom prefix `u_`, allow any column name prefix
                     ignoreColumnNameCheck = true
                 }
@@ -1217,22 +1386,30 @@ export const TablePlugin = Plugin.create({
                         relatedRecords.push(overrideRecord)
                     } else {
                         // Handle regular column - create sys_dictionary record
-                        if (
+                        if (isAugmentation && !tableNameMatch) {
+                            if (!isSNScope(scopeName) && !name.match(prefixRegex)) {
+                                diagnostics.error(
+                                    column.getOriginalNode().getParentIfKind(ts.SyntaxKind.PropertyAssignment) ??
+                                        column,
+                                    `Column name '${name}' must be prefixed with '${scopePrefix}' when augmenting a table`
+                                )
+                            }
+                        } else if (
                             !ignoreColumnNameCheck &&
                             !tableNameMatch &&
                             !isSNScope(scopeName) &&
                             scopeName !== 'global' &&
-                            !name.match(scopeRegex)
+                            !name.match(prefixRegex)
                         ) {
                             // '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`
+                                `Column name should be prefixed with scope '${scopePrefix}' if table name does not contain prefix`
                             )
-                        } else if (scopeName === 'global' && !globalTableNameMatch && !name.match(globalRegex)) {
+                        } else if (scopeName === 'global' && !tableNameMatch && !name.match(prefixRegex)) {
                             diagnostics.error(
                                 column.getOriginalNode().getParentIfKind(ts.SyntaxKind.PropertyAssignment) ?? column,
-                                `Column name should be prefixed with 'u_' custom prefix if table name does not contain this prefix, such as when adding columns to an existing global table`
+                                `Column name should be prefixed with '${scopePrefix}' custom prefix if table name does not contain this prefix, such as when adding columns to an existing global table`
                             )
                         }
                         const display = table.get('display').ifString()?.getValue() === name
@@ -1409,29 +1586,32 @@ export const TablePlugin = Plugin.create({
                 }
 
                 // sys_dictionary (collection)
-                relatedRecords.push(
-                    await 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),
-                        })),
-                    })
-                )
+                if (!isAugmentation) {
+                    relatedRecords.push(
+                        await factory.createRecord({
+                            source: statement ?? callExpression,
+                            table: 'sys_dictionary',
+                            properties: table.transform(({ $ }) => ({
+                                name: $,
+                                element: $.val(undefined),
+                                internal_type: $.def('collection'),
+                                active: $.val(true),
+                                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
@@ -1449,6 +1629,17 @@ export const TablePlugin = Plugin.create({
                       })
                     : ext.ifDefined()?.toRecordId()
 
+                const userRoleField = table.get('userRole')
+                const userRoleReference = userRoleField.isString()
+                    ? userRoleField.getValue() === ''
+                        ? undefined
+                        : await factory.createReference({
+                              source: userRoleField,
+                              table: 'sys_user_role',
+                              keys: { name: userRoleField },
+                          })
+                    : userRoleField.ifDefined()?.toRecordId()
+
                 // sys_db_object
                 const tableRecord = await factory.createRecord({
                     source: statement ?? callExpression,
@@ -1460,11 +1651,15 @@ export const TablePlugin = Plugin.create({
                         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'
-                            )
-                        ),
+                        caller_access: $.from('callerAccess').map((callerAccess) => {
+                            const value = callerAccess.ifString()?.getValue()
+                            if (!value) {
+                                return undefined
+                            }
+                            const index = callerAccessLevels.indexOf(value as 'none' | 'tracking' | 'restricted')
+                            // index 0 ('none') is the platform default — emit empty <caller_access/>, matching stock.
+                            return index > 0 ? index : undefined
+                        }),
                         super_class: $.val(parentReference),
                         read_access: $.from('actions')
                             .map((actions) => hasAction('read', actions))
@@ -1481,8 +1676,14 @@ export const TablePlugin = Plugin.create({
                         is_extendable: $.from('extensible').toBoolean().def(false),
                         label: $.map((label) => getLabelForDefaultLanguage(label, config.defaultLanguage)),
                         live_feed_enabled: $.from('liveFeed').toBoolean().def(false),
-                        name: $,
+                        name: $.from('name', 'augments').map(
+                            (nameVal, augmentsVal) => augmentsVal.ifString() ?? nameVal
+                        ),
+                        create_access_controls: $.from('createAccessControls').toBoolean().def(false),
+                        user_role: $.val(userRoleReference),
                         scriptable_table: $.from('scriptableTable').toBoolean().def(false),
+                        // Controls toFile output, not written to record XML
+                        augments: $.from('augments'),
                     })),
                 })
 
@@ -1569,6 +1770,18 @@ function parseTableBootstrapXml(xml: unknown): TableDefinition | null {
             useDynamicDefault: column['@_use_dynamic_default'],
             reference: column['@_reference'],
             isVirtual: column['@_virtual'],
+            formula: column['@_formula'],
+            virtualType:
+                column['@_virtual_type'] === 'script' || column['@_virtual_type'] === 'formula'
+                    ? column['@_virtual_type']
+                    : undefined,
+            useReferenceQualifier:
+                column['@_use_reference_qualifier'] === 'simple' ||
+                column['@_use_reference_qualifier'] === 'dynamic' ||
+                column['@_use_reference_qualifier'] === 'advanced'
+                    ? column['@_use_reference_qualifier']
+                    : undefined,
+            dynamicRefQual: column['@_dynamic_ref_qual'],
             calculation: column['@_calculation'],
             choiceField: column['@_choice_field'],
             functionDefinition: column['@_function_definition'],
@@ -1642,6 +1855,8 @@ function parseTableBootstrapXml(xml: unknown): TableDefinition | null {
         actionsAccess: table['@_actions_access'],
         readAccess: table['@_read_access'],
         isExtendable: table['@_is_extendable'],
+        createAccessControls: table['@_create_access_controls'],
+        userRole: table['@_user_role'],
         scriptableTable: table['@_scriptable_table'],
         attributes: table['@_attributes'],
     }
@@ -1663,6 +1878,8 @@ function tableDefToRecordProperties(
         label: tableDef.label,
         super_class: tableDef.extends,
         is_extendable: tableDef.isExtendable,
+        create_access_controls: tableDef.createAccessControls,
+        user_role: tableDef.userRole,
         scriptable_table: tableDef.scriptableTable,
         client_scripts_access: tableDef.clientScriptsAccess,
         ws_access: tableDef.wsAccess,
@@ -1712,6 +1929,10 @@ function tableDefToRecordProperties(
             use_dynamic_default: column.useDynamicDefault,
             reference: column.reference,
             virtual: column.isVirtual,
+            formula: column.formula,
+            virtual_type: column.virtualType,
+            use_reference_qualifier: column.useReferenceQualifier,
+            dynamic_ref_qual: column.dynamicRefQual,
             default: column.defaultValue,
             calculation: column.calculation,
             choice_field: column.choiceField,
@@ -1794,6 +2015,10 @@ function tableDefToRecordProperties(
         use_dynamic_default: undefined,
         reference: undefined,
         virtual: undefined,
+        formula: undefined,
+        virtual_type: undefined,
+        use_reference_qualifier: undefined,
+        dynamic_ref_qual: undefined,
         default: undefined,
         calculation: undefined,
         choice_field: undefined,
@@ -1852,7 +2077,7 @@ function addTableToGlobalGeneratedFile(tableArg: ObjectShape, sourceFilePath: st
         >,
     }
     const generatedTableFile: ts.SourceFile | undefined = compiler.getGeneratedTableFile()
-    const tableName = tableArg.get('name').asString().getValue()
+    const tableName = tableArg.get('augments').ifString()?.getValue() ?? tableArg.get('name').asString().getValue()
     if (!(tableName.trim().length > 0 && tableName.match(tableNameRegex))) {
         return
     }
@@ -1910,6 +2135,58 @@ function addTableToGlobalGeneratedFile(tableArg: ObjectShape, sourceFilePath: st
     }
 }
 
+/**
+ * Records a bootstrap-derived Table() shape into $$GENERATED$$_bootstrapped_tables.ts so that other plugins (e.g. RecordPlugin)
+ * can resolve Data<T> column types via TypeScript during the same transform pass — no sys_dictionary query needed.
+ *
+ * The `declare global` augmentation lives inside the bootstrapped file (referencing its LOCAL `typeof tableName` export) rather
+ * than the common table file. That avoids the duplicate-import error when a pre-existing Fluent Table() of the same name was
+ * already wired into the common file, and TypeScript still merges the two TableSchemas interface declarations so both
+ * contribute their columns to the resolved Data<T>.
+ */
+function registerBootstrappedTable(
+    tableCall: CallExpressionShape,
+    schema: { [key: string]: CallExpressionShape },
+    compiler: Compiler
+): void {
+    const file = compiler.getGeneratedBootstrappedTablesFile()
+    if (!file || Object.keys(schema).length === 0) {
+        return
+    }
+
+    const tableArg = tableCall.getArgument(0).asObject()
+    const tableName = tableArg.get('augments').ifString()?.getValue() ?? tableArg.get('name').asString().getValue()
+
+    const tableSchemas = file.getModule('global')?.getModule('Now')?.getModule('Internal')?.getModule('TableSchemas')
+    const tables = file.getModule('global')?.getModule('Now')?.getModule('Internal')?.getInterface('Tables')
+    if (!tableSchemas || !tables) {
+        return
+    }
+
+    const coreImport = file.getImportDeclaration('@servicenow/sdk/core')
+    const existingImports = new Set(coreImport?.getNamedImports().map((n) => n.getName()))
+    for (const callee of new Set(Object.values(schema).map((s) => s.getCallee()))) {
+        if (!existingImports.has(callee)) {
+            coreImport?.addNamedImport(callee)
+        }
+    }
+
+    // Replace any existing export (re-transform of same XML), then write the shape's rendered code.
+    file.getVariableDeclaration(tableName)?.getVariableStatement()?.remove()
+    file.addVariableStatement({
+        isExported: true,
+        declarationKind: ts.VariableDeclarationKind.Const,
+        declarations: [{ name: tableName, initializer: tableCall.getCode() }],
+    })
+
+    if (!tableSchemas.getInterface(tableName)) {
+        tableSchemas.addInterface({ name: tableName, extends: [`Helper<typeof ${tableName}>`] })
+    }
+    if (!tables.getProperty(tableName)) {
+        tables.addProperty({ name: tableName, type: `Table<TableSchemas.${tableName}>` })
+    }
+}
+
 function filterUndefinedProperties<T extends object>(obj: T): T {
     return Object.fromEntries(Object.entries(obj).filter(([_, value]) => value !== undefined)) as T
 }
@@ -1933,7 +2210,8 @@ function createElement(name: string, attributes: [string, string][] = [], childr
 async function generateRecordXml(
     records: Record[],
     config: { scope: string; scopeId: string },
-    transform: Transform
+    transform: Transform,
+    excludeFields: string[] = []
 ): Promise<OutputFile[]> {
     const files: OutputFile[] = []
     for (const record of records) {
@@ -1944,6 +2222,7 @@ async function generateRecordXml(
         record
             .entries()
             .sort(([a], [b]) => a.localeCompare(b))
+            .filter(([prop]) => excludeFields.length === 0 || !excludeFields.includes(prop))
             .forEach(([prop, shape]) => builder.field(prop, shape))
 
         files.push({