@servicenow/sdk-build-plugins 2.1.4 → 2.2.2

package/src/db/TablePlugin.ts

@@ -48,7 +48,6 @@ import {
     removeNode,
     stringify,
     transformFunctionArguments,
-    writeCustomProperty,
     XmlData,
     FluentDiagnostic,
     PartialElements,
@@ -58,30 +57,17 @@ import {
     ObjectData,
     isSNScope,
     GUID,
+    mergeDataIntoObjectLiteral,
+    getPropertyAssignment,
+    mergeDataIntoObjectLiteralArray,
 } from '@servicenow/sdk-build-core'
 import { create } from 'xmlbuilder2'
 import { isArray, isEmpty, isObject, parseInt } from 'lodash'
 import { z } from 'zod'
 import { RecordPlugin, TextBooleanSchema, TextNumberSchema, TextStringSchema } from './RecordPlugin'
-import {
-    SyntaxKind,
-    Node,
-    ts,
-    ObjectLiteralExpression,
-    CallExpression,
-    Structure,
-    SourceFile,
-    ImportDeclarationStructure,
-    PropertySignatureStructure,
-    InterfaceDeclarationStructure,
-    ImportSpecifierStructure,
-    OptionalKind,
-    ImportDeclaration,
-} from 'ts-morph'
-import { Diagnostic } from '@servicenow/sdk-project'
+import { Diagnostic, ts, tsc } from '@servicenow/sdk-project'
 import { formatScript } from '../ScriptTemplatePlugin'
 import * as os from 'os'
-import * as path from 'path'
 import { XMLBuilder } from 'xmlbuilder2/lib/interfaces'
 import { getLabelDiagnostics } from './DBUtils'
 import { ModuleFunctionData } from '../ServerModulePlugin'
@@ -94,10 +80,10 @@ import { ModuleFunctionData } from '../ServerModulePlugin'
  * - `restricted`: 2
  *
  */
-export const callerAccess = ['none', 'tracking', 'restricted'] as const
+const callerAccess = ['none', 'tracking', 'restricted'] as const
 
 // Basic info needed for table references
-export const TableSchemaFull = z.object({
+const TableSchemaFull = z.object({
     /** lowercase, one word name. Numbers, letters and underscores only */
     name: z.string(),
     /** Object literal of column names with <type>Column() calls as values.
@@ -158,7 +144,10 @@ export const TableSchemaFull = z.object({
             z.object({
                 name: z.string(),
                 unique: z.boolean(),
-                element: z.string(),
+                element: z
+                    .string()
+                    .or(z.array(z.string()))
+                    .transform((el) => (isArray(el) ? el : [el])),
             })
         )
         .optional(),
@@ -169,7 +158,7 @@ const componentTables = ['sys_dictionary', 'sys_choice', 'sys_documentation']
 type IndexType = {
     name: string
     unique: boolean
-    element: string
+    element: string[] | string
 }
 
 // Everything that goes into a table
@@ -248,7 +237,7 @@ const DBObjectIncomingAttributes = z.object({
 })
 
 // Attributes in the element='collection' tag of bootstrap xml
-export const TableSchemaBootstrap = z.object({
+const TableSchemaBootstrap = z.object({
     name: z.string(),
     extends: z.string().optional(),
     label: z.string().max(80, 'Cannot exceed 80 characters').or(z.array(z.any())).optional(),
@@ -325,7 +314,7 @@ const DBObjectIncoming = z.object({
     sys_db_object: z.record(z.any()),
 })
 
-export const SysDocumentation = z.object({
+const SysDocumentation = z.object({
     sys_documentation: z.object({
         element: TextStringSchema.optional(),
         label: TextStringSchema.optional(),
@@ -341,7 +330,7 @@ export const SysDocumentation = z.object({
 })
 
 // Attributes from element=table in bootstrap.xml
-export const TableSchemaBootstrapAttributes = z
+const TableSchemaBootstrapAttributes = z
     .object({
         '@_name': z.string(),
         '@_extends': z.string().optional(),
@@ -391,12 +380,24 @@ export const TableSchemaBootstrapAttributes = z
 const IndexSchemaBootstrapAttributes = z.object({
     '@_name': z.string(),
     '@_unique': BooleanFromString,
-    element: z.object({
-        '@_name': z.string(),
-    }),
+    element: z
+        .object({ '@_name': z.string() })
+        .or(
+            z.array(
+                z.object({
+                    '@_name': z.string(),
+                })
+            )
+        )
+        .transform((val) => {
+            if (isArray(val)) {
+                return val
+            }
+            return [val]
+        }),
 })
 
-export const ColumnSchemaBootstrapAttributes = TableSchemaBootstrapAttributes.omit({ '@_extends': true })
+const ColumnSchemaBootstrapAttributes = TableSchemaBootstrapAttributes.omit({ '@_extends': true })
     .extend({
         '@_choice': z.coerce.number().optional(),
         '@_active': BooleanFromString,
@@ -446,11 +447,11 @@ export default Plugin({
                 // TODO: Cast to `any` is temporary workaround for the circular nature of Table entities
                 CallExpression: (node, context) => {
                     const result = extractCallExpression(Table, 'table', node, context, (table) => table.name)
-                    if (!result.handled || !(0 in result.data)) {
+                    if (!result.handled || !result.data) {
                         return result
                     }
 
-                    const data = result.data[0]
+                    const data = result.data
                     const diagnostics = result.diagnostics
                     const scopeName = context.app.config.scope
                     const scopeRegex = new RegExp(`^${scopeName}_`)
@@ -470,7 +471,7 @@ export default Plugin({
                     }
 
                     if (!scopeMatches) {
-                        const nameNode = tableName.getNode().asKindOrThrow(SyntaxKind.StringLiteral)
+                        const nameNode = tableName.getNode().asKindOrThrow(ts.SyntaxKind.StringLiteral)
                         if (nameNode.getParent().getKindName() !== 'AsExpression') {
                             diagnostics.push(
                                 new FluentDiagnostic(
@@ -484,7 +485,7 @@ export default Plugin({
                     }
 
                     const schema = data.getProperty('schema')
-                    const schemaNode = schema.getNode().asKindOrThrow(SyntaxKind.ObjectLiteralExpression)
+                    const schemaNode = schema.getNode().asKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
                     for (const columnName in schema.getValue()) {
                         const columnNode = schemaNode.getPropertyOrThrow(columnName)
                         if (
@@ -511,7 +512,7 @@ export default Plugin({
                         }
                     }
 
-                    const declaration = node.getParentIfKind(SyntaxKind.VariableDeclaration)
+                    const declaration = node.getParentIfKind(ts.SyntaxKind.VariableDeclaration)
                     if (
                         !declaration ||
                         !declaration.isExported() ||
@@ -528,7 +529,7 @@ export default Plugin({
                     }
 
                     diagnostics.push(...getLabelDiagnostics(data))
-                    return { handled: true, data: [data], diagnostics }
+                    return { handled: true, data, diagnostics }
                 },
             },
         },
@@ -622,7 +623,10 @@ export default Plugin({
                     if (idxData.success) {
                         idxElements.push({
                             name: idxData.data['@_name'],
-                            element: idxData.data.element['@_name'],
+                            element: idxData.data.element.reduce((arr, curr) => {
+                                arr.push(curr['@_name'])
+                                return arr
+                            }, [] as string[]),
                             unique: idxData.data['@_unique'] ?? false,
                         })
                     }
@@ -740,15 +744,12 @@ export default Plugin({
                     },
                     Table,
                     {}
-                ).getInitializerIfKindOrThrow(SyntaxKind.CallExpression)
+                ).getInitializerIfKindOrThrow(ts.SyntaxKind.CallExpression)
             )
         },
 
         record(document, context) {
-            if (
-                document.data?.['table'] !== 'sys_documentation' &&
-                document.data?.['table'] !== 'ua_table_licensing_config'
-            ) {
+            if (document.data?.['table'] !== 'sys_documentation') {
                 return
             }
 
@@ -803,7 +804,7 @@ export default Plugin({
                     return false
                 }
                 const [args] = document.node.getArguments()
-                if (!Node.isObjectLiteralExpression(args)) {
+                if (!ts.Node.isObjectLiteralExpression(args)) {
                     return false
                 }
 
@@ -850,34 +851,21 @@ export default Plugin({
                 }
 
                 if (!isEmpty(db_data)) {
-                    const actions = getActionsArray({ create_access, delete_access, update_access, read_access })
-                    if (actions.length > 0) {
-                        writeCustomProperty(args, 'actions', '[]', stringify(actions))
-                    } else {
-                        const actionsProp = getOrCreatePropertyAssignment(args, 'actions', '[]')
-                        actionsProp.remove()
-                    }
+                    rest.actions = getActionsArray(xmlData.dbObjectData)
                 }
 
                 if (!rest.attributes) {
                     delete rest.attributes
                 }
 
-                if (xmlData.bootstrapData && xmlData.bootstrapData.index) {
-                    const indexProp = getOrCreatePropertyAssignment(args, 'index', '[]')
-                    indexProp.setInitializer(stringify(xmlData.bootstrapData.index))
-                    if (xmlData.bootstrapData.index.length === 0) {
-                        indexProp.remove()
-                    }
-                }
-
                 transformFunctionArguments(document.node, Table as any, rest)
 
                 // Handle columns
                 const incomingColumns = xmlData.bootstrapData ? xmlData.bootstrapData.columns : undefined
 
                 updateDisplayValue(document.node, columns, incomingColumns)
-                transformColumns(incomingColumns, args)
+                transformColumns(columns, incomingColumns, args)
+                transformIndexes(xmlData, args)
                 return true
             },
         },
@@ -885,14 +873,14 @@ export default Plugin({
     postProcessors: {
         entities(entities, context) {
             const { interfaces, properties, imports, namedImports } = {
-                interfaces: [] as OptionalKind<InterfaceDeclarationStructure>[],
-                properties: [] as OptionalKind<PropertySignatureStructure>[],
-                imports: {} as Record<string, OptionalKind<ImportDeclarationStructure>>,
-                namedImports: [] as (OptionalKind<ImportSpecifierStructure> & {
-                    existingImport: ImportDeclaration
+                interfaces: [] as ts.OptionalKind<ts.InterfaceDeclarationStructure>[],
+                properties: [] as ts.OptionalKind<ts.PropertySignatureStructure>[],
+                imports: {} as Record<string, ts.OptionalKind<ts.ImportDeclarationStructure>>,
+                namedImports: [] as (ts.OptionalKind<ts.ImportSpecifierStructure> & {
+                    existingImport: ts.ImportDeclaration
                 })[],
             }
-            const generatedTableFile: SourceFile | undefined = context.compiler.getGeneratedTableFile()
+            const generatedTableFile: ts.SourceFile | undefined = context.compiler.getGeneratedTableFile()
             entities
                 .filter((entity) => entity.getKind() === 'table')
                 .forEach((table) => {
@@ -916,7 +904,7 @@ export default Plugin({
                             })
                         }
 
-                        const filePath = path.normalize(table.getNode().getSourceFile().getFilePath())
+                        const filePath = table.getNode().getSourceFile().getFilePath()
                         const resolvedModuleSpecifier = generatedTableFile?.getRelativePathAsModuleSpecifierTo(
                             filePath
                         ) as string
@@ -954,10 +942,32 @@ export default Plugin({
     },
 })
 
+function transformIndexes(xmlData, args) {
+    if (xmlData.bootstrapData?.index?.length > 0) {
+        // find the correct object literal
+        const indexProp = getPropertyAssignment(args, 'index')
+        if (indexProp) {
+            mergeDataIntoObjectLiteralArray(
+                indexProp.getFirstChildByKindOrThrow(ts.SyntaxKind.ArrayLiteralExpression),
+                Object.values(xmlData.bootstrapData?.index),
+                'name'
+            )
+        } else {
+            const newIndexProp = getOrCreatePropertyAssignment(args, 'index', '[]')
+            newIndexProp.setInitializer(stringify(xmlData.bootstrapData.index))
+        }
+    } else {
+        const indexProp = getPropertyAssignment(args, 'index')
+        if (indexProp) {
+            indexProp.remove()
+        }
+    }
+}
+
 function generateCallExpressionExportForDocument<const A extends unknown[]>(
     context: Context,
     info: {
-        sourceFile: SourceFile
+        sourceFile: ts.SourceFile
         moduleSpecifier: string
         exportName: string
     },
@@ -978,7 +988,7 @@ function composeAttributes(attributes: Record<string, any> | undefined) {
         .join(',')
 }
 
-function updateDisplayValue(node: CallExpression, columns: ColumnSchema, incomingColumns: ColumnSchema) {
+function updateDisplayValue(node: ts.CallExpression, columns: ColumnSchema, incomingColumns: ColumnSchema) {
     const display = Object.values(columns ?? {}).filter((col: any) => col.display)
     if (display) {
         const displayName = Object.values(incomingColumns ?? {}).find((c) => c.display)
@@ -1159,40 +1169,131 @@ function mapNames(schema: any) {
 
 let schemaPosition = 4
 
-function transformColumns(incoming_schema: ColumnSchema, args: ObjectLiteralExpression) {
+function transformColumns(columns: ColumnSchema, incomingSchema: ColumnSchema, args: ts.ObjectLiteralExpression) {
     const schemaProperty = getOrCreatePropertyAssignment(args, 'schema', '{}')
     const schemaLiteral = schemaProperty.getChildrenOfKind(ts.SyntaxKind.ObjectLiteralExpression)[0]
     if (!schemaLiteral) {
         return
     }
 
-    const keys = Object.keys(incoming_schema ?? {})
+    const keys = Object.keys(columns ?? {})
     if (keys.length === 0) {
         return
     }
 
     //TODO:: need to come up with a way to format script more accurately
     schemaPosition = schemaLiteral.getSourceFile().getLineAndColumnAtPos(schemaLiteral.getStart()).column
-    const assignments: ts.PropertyAssignment[] = []
+    const existingColumns = {}
+    schemaLiteral.getProperties().forEach((property) => {
+        const propertyAssignment = property.asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
+        const name = propertyAssignment.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier).getText()
+        const callExp = propertyAssignment.getFirstChildByKindOrThrow(ts.SyntaxKind.CallExpression)
+        const callExpType = callExp.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier).getText()
+        const objectLiteral = callExp.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+        existingColumns[name] = {
+            node: propertyAssignment,
+            type: callExpType,
+            objectLiteral,
+        }
+
+        if (!incomingSchema[name]) {
+            // Full bootstrap.xml does not have this existing column so remove it
+            removeNode(propertyAssignment)
+        }
+    })
+
     keys.forEach((key) => {
-        const data = incoming_schema[key]
-        const callExpFromType = getCallExpressionFromType(data.type)
-        const transformedColumn = transformColumnData(data, callExpFromType)
-        const callExp = generateColumnExpression(callExpFromType, {
-            ...transformedColumn,
-            choices: data.choice_elements,
-        })
-        assignments.push(ts.factory.createPropertyAssignment(createPropertyIdentifier(data.name), callExp))
+        const partialData = columns[key]
+        if (!existingColumns[key]) {
+            // This column doesn't exist so let's make it
+            const callExpFromType = getCallExpressionFromType(partialData.type)
+            createNewColumn(schemaLiteral, callExpFromType.name, partialData)
+        } else {
+            const existingColumn = existingColumns[key]
+            if (partialData.type && existingColumn.type !== partialData.type) {
+                // Switching the column type so regenerate the CallExpression and add all incoming data
+                removeNode(existingColumn.node)
+                const callExpFromType = getCallExpressionFromType(partialData.type)
+                createNewColumn(schemaLiteral, callExpFromType.name, incomingSchema[key])
+            } else {
+                // Update the existing column with changed data only
+                const transformedColumnData = transformColumnData(partialData, existingColumn.type)
+                mergeDataIntoObjectLiteral(existingColumn.objectLiteral, {
+                    ...transformedColumnData,
+                    choices: partialData.choice_elements,
+                })
+
+                removeChoicesIfNecessary(existingColumn, incomingSchema[key])
+                removeAttributesIfNecessary(existingColumn, incomingSchema[key])
+            }
+        }
     })
+}
+
+function removeChoicesIfNecessary(existingColumn: any, columnFromBootstrap: any) {
+    const existingProperties = existingColumn.objectLiteral
+        .getProperties()
+        .reduce((a, v) => ({ ...a, [(v as ts.PropertyAssignment).getName()]: v }), {})
 
-    schemaLiteral.transform((traversal) => {
-        if (ts.isObjectLiteralExpression(traversal.currentNode)) {
-            return traversal.factory.updateObjectLiteralExpression(traversal.currentNode, assignments)
+    if (!existingProperties['choices']) {
+        return
+    }
+
+    if (!columnFromBootstrap['choice_elements']) {
+        removeNode(existingProperties['choices'])
+        return
+    }
+
+    const choicesFromBootstrap = Object.keys(columnFromBootstrap['choice_elements'])
+    const existingChoices = existingProperties['choices']
+        .getFirstChildByKind(ts.SyntaxKind.ObjectLiteralExpression)
+        .getProperties()
+        .reduce((a, v) => ({ ...a, [v.getName()]: v }), {})
+    Object.keys(existingChoices).forEach((choice) => {
+        if (!choicesFromBootstrap.includes(choice)) {
+            removeNode(existingChoices[choice])
         }
-        return traversal.currentNode
     })
 }
 
+function removeAttributesIfNecessary(existingColumn: any, columnFromBootstrap: any) {
+    const existingProperties = existingColumn.objectLiteral
+        .getProperties()
+        .reduce((a, v) => ({ ...a, [(v as ts.PropertyAssignment).getName()]: v }), {})
+
+    if (!existingProperties['attributes']) {
+        return
+    }
+
+    if (!columnFromBootstrap['attributes']) {
+        removeNode(existingProperties['attributes'])
+        return
+    }
+
+    const attributesFromBootstrap = Object.keys(columnFromBootstrap['attributes'])
+    const existingChoices = existingProperties['attributes']
+        .getFirstChildByKind(ts.SyntaxKind.ObjectLiteralExpression)
+        .getProperties()
+        .reduce((a, v) => ({ ...a, [v.getName()]: v }), {})
+    Object.keys(existingChoices).forEach((choice) => {
+        if (!(choice in attributesFromBootstrap)) {
+            removeNode(existingChoices[choice])
+        }
+    })
+}
+
+function createNewColumn(schemaLiteral: ts.ObjectLiteralExpression, callExpName: string, data: any) {
+    const propertyAssignment = schemaLiteral.addPropertyAssignment({
+        name: data.name,
+        initializer: `${callExpName}({})`,
+    })
+    const objectLiteral = propertyAssignment
+        .getInitializer()!
+        .getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
+    const transformedColumnData = transformColumnData(data, callExpName)
+    mergeDataIntoObjectLiteral(objectLiteral, { ...transformedColumnData, choices: data.choice_elements })
+}
+
 type DB_ACTIONS = 'read' | 'delete' | 'create' | 'update'
 
 function getActionsArray(data) {
@@ -1223,7 +1324,13 @@ function getDynamicDefault(val: string | undefined) {
 function buildIndexes(indexes: IndexType[] = [], collection: XMLBuilder) {
     indexes.forEach((index) => {
         const indexElement = collection.ele('index', { name: index.name, unique: index.unique })
-        indexElement.ele('element', { name: index.element })
+        if (isArray(index.element)) {
+            index.element.forEach((element) => {
+                indexElement.ele('element', { name: element })
+            })
+        } else {
+            indexElement.ele('element', { name: index.element })
+        }
     })
 }
 
@@ -1259,7 +1366,7 @@ function buildChoices(column: ColumnSchema, element: XMLBuilder) {
     }
 }
 
-export function transformColumnData(col: any, callExpFromType: any) {
+function transformColumnData(col: any, callExpFromType: string) {
     const {
         type: internal_type,
         choice,
@@ -1284,10 +1391,10 @@ export function transformColumnData(col: any, callExpFromType: any) {
     } = col
 
     if (max_length !== undefined) {
-        column.maxLength = max_length
+        column.maxLength = parseInt(max_length, 10)
     }
 
-    if (internal_type && (callExpFromType.entityKind === 'generic' || callExpFromType.name === 'GenericColumn')) {
+    if (internal_type && callExpFromType === 'GenericColumn') {
         column.column_type = internal_type
     }
 
@@ -1362,7 +1469,7 @@ function removeAttributeTag(obj: any) {
     return obj
 }
 
-export function SysNumber(
+function SysNumber(
     category: TableName,
     maximum_digits: number | undefined,
     number?: number | undefined,
@@ -1381,7 +1488,7 @@ export function SysNumber(
 }
 
 // TODO should this reference sys_filter_option_dynamic instead?
-export const dynamic_value_mapping = {
+const dynamic_value_mapping = {
     'Current Name': `current.name`,
     'Next ECC Sequence Number': `GlideCounter.next('ecc:sequence');`,
     'Get Module View': `var viewDefault='';if(current.device_type=='mobile') viewDefault='Mobile';else if(!current.application.nil() && current.application.device_type=='mobile' && current.device_type.nil()) viewDefault='Mobile';viewDefault`,
@@ -1406,7 +1513,7 @@ export function generateColumnExpression<Type extends (...args: any) => any>(
     expression: Type,
     args: Parameters<Type>[0],
     argsSetIfDefined?: Undefined<Parameters<Type>[0]>
-): ts.CallExpression {
+): tsc.CallExpression {
     const setArgs = { ...args }
     if (argsSetIfDefined) {
         Object.keys(argsSetIfDefined).forEach((key) => {
@@ -1416,56 +1523,56 @@ export function generateColumnExpression<Type extends (...args: any) => any>(
         })
     }
 
-    return ts.factory.createCallExpression(ts.factory.createIdentifier(expression.name), undefined, [
+    return tsc.factory.createCallExpression(tsc.factory.createIdentifier(expression.name), undefined, [
         createObjectExpression(setArgs),
     ])
 }
 
-export function createObjectExpression(firstArg: object): ts.Expression {
-    return ts.factory.createObjectLiteralExpression(
+export function createObjectExpression(firstArg: object): tsc.Expression {
+    return tsc.factory.createObjectLiteralExpression(
         Object.entries(firstArg)
             .filter(([_key, value]) => value !== undefined)
             .map(([key, value]) => {
                 if (key === 'referenceTable') {
-                    return ts.factory.createPropertyAssignment(
-                        ts.factory.createIdentifier('referenceTable'),
-                        ts.factory.createStringLiteral(value)
+                    return tsc.factory.createPropertyAssignment(
+                        tsc.factory.createIdentifier('referenceTable'),
+                        tsc.factory.createStringLiteral(value)
                     )
                 } else if (key === 'calculated_value') {
                     const calVal = `${os.EOL}${formatScript(value, schemaPosition)}`
-                    return ts.factory.createPropertyAssignment(
-                        ts.factory.createIdentifier(key),
-                        ts.factory.createTaggedTemplateExpression(
-                            ts.factory.createIdentifier('script'),
+                    return tsc.factory.createPropertyAssignment(
+                        tsc.factory.createIdentifier(key),
+                        tsc.factory.createTaggedTemplateExpression(
+                            tsc.factory.createIdentifier('script'),
                             undefined,
-                            ts.factory.createNoSubstitutionTemplateLiteral(calVal, calVal)
+                            tsc.factory.createNoSubstitutionTemplateLiteral(calVal, calVal)
                         )
                     )
                 } else if (key === 'maxLength') {
                     if (isNaN(+value)) {
-                        return ts.factory.createPropertyAssignment(
-                            ts.factory.createIdentifier(key),
-                            ts.factory.createAsExpression(
-                                ts.factory.createStringLiteral(value),
-                                ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
+                        return tsc.factory.createPropertyAssignment(
+                            tsc.factory.createIdentifier(key),
+                            tsc.factory.createAsExpression(
+                                tsc.factory.createStringLiteral(value),
+                                tsc.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
                             )
                         )
                     }
 
-                    return ts.factory.createPropertyAssignment(
-                        ts.factory.createIdentifier(key),
-                        ts.factory.createNumericLiteral(value)
+                    return tsc.factory.createPropertyAssignment(
+                        tsc.factory.createIdentifier(key),
+                        tsc.factory.createNumericLiteral(value)
                     )
                 }
-                return ts.factory.createPropertyAssignment(
+                return tsc.factory.createPropertyAssignment(
                     createPropertyIdentifier(key),
-                    factoryCreateValue(value, ts.factory)
+                    factoryCreateValue(value, tsc.factory)
                 )
             })
     )
 }
 
-export function factoryCreateValue(value: unknown, factory: ts.NodeFactory) {
+function factoryCreateValue(value: unknown, factory: tsc.NodeFactory) {
     if (typeof value === 'string') {
         return factory.createStringLiteral(value)
     }
@@ -1475,7 +1582,7 @@ export function factoryCreateValue(value: unknown, factory: ts.NodeFactory) {
             return factory.createNumericLiteral(value)
         } else {
             return factory.createPrefixUnaryExpression(
-                ts.SyntaxKind.MinusToken,
+                tsc.SyntaxKind.MinusToken,
                 factory.createNumericLiteral(Math.abs(value))
             )
         }
@@ -1490,14 +1597,14 @@ export function factoryCreateValue(value: unknown, factory: ts.NodeFactory) {
             return factory.createNull()
         }
         if (isArray(value)) {
-            const newvals: ts.Expression[] = []
+            const newvals: tsc.Expression[] = []
 
             Object.values(value).forEach((v) => {
                 newvals.push(factoryCreateValue(v, factory))
             })
 
             return factory.createArrayLiteralExpression(newvals)
-        } else if (Structure.isImportSpecifier(value)) {
+        } else if (ts.Structure.isImportSpecifier(value)) {
             return factory.createIdentifier(value['name'])
         } else {
             return createObjectExpression(value)
@@ -1512,7 +1619,7 @@ export function factoryCreateValue(value: unknown, factory: ts.NodeFactory) {
 type Undefined<T> = {
     [P in keyof T]: T[P] | undefined
 }
-export function getCallExpressionFromType(internal_type: string) {
+function getCallExpressionFromType(internal_type: string) {
     switch (internal_type) {
         case undefined:
         case 'string':