@servicenow/sdk-build-plugins 3.0.3 → 4.0.0

package/src/ListPlugin.ts

@@ -1,570 +0,0 @@
-import { List } from '@servicenow/sdk-core/runtime/ui'
-import {
-    Data,
-    Plugin,
-    PrimitiveData,
-    extractCallExpression,
-    generateCallExpressionExportForDocument,
-    getCallExpressionName,
-    getOrCreateEntitySourceFile,
-    linkDocument,
-    recordXml,
-    removeNode,
-    unloadBuilder,
-    getOrCreatePropertyAssignment,
-    setPropertyAssignmentValue,
-    getSysUpdateName,
-    XmlData,
-    writePropertyAsReference,
-    addDefaultImportIfAbsent,
-    addNamedImportIfAbsent,
-    getPropertyAssignment,
-} from '@servicenow/sdk-build-core'
-import { getOutputDirectoryForDocument, RecordXmlSchema } from './db/RecordPlugin'
-import * as z from 'zod'
-import { Diagnostic, path, ts } from '@servicenow/sdk-project'
-import { isObject } from 'lodash'
-import { Record as NowRecord } from '@servicenow/sdk-core/runtime/db'
-
-const DEFAULT_VIEW = 'Default view'
-
-type View = {
-    id: string
-    name: string
-    title: string
-}
-
-type TransformData = {
-    sys_id: string
-    parent?: string
-    relationship?: { id: string; name: string }
-    view: View
-    list: Omit<List, 'columns'>
-    table: string
-    elements: SysUIListElementXml
-}
-
-export default Plugin({
-    name: 'List',
-    ownedTables: {
-        sys_ui_list: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression(node, context) {
-                    return extractCallExpression(List, 'list', node, context, (list) =>
-                        context.keys.registerExplicitId('sys_ui_list', list.$id as string)
-                    )
-                },
-            },
-        },
-        xml(xml) {
-            const result = SysUIListXmlSchema.safeParse(xml.data['record_update'])
-            if (!result.success) {
-                return undefined
-            }
-
-            const {
-                data: {
-                    sys_ui_list: { sys_ui_list, sys_ui_list_element },
-                    sys_metadata_delete,
-                },
-            } = result
-
-            //Delete only gets set on the top level sys_ui_list action attribute, not on sub nodes
-            const isDelete = result.data.sys_ui_list['@_action'] === 'DELETE'
-            const list = xmlElementToObject(sys_ui_list)
-            const elements = toArray(sys_ui_list_element).map(xmlElementToObject)
-            let updateName = list['sys_update_name']
-            // sys_update_name is not present on the list element, but is present on the delete element on delete payload
-            if (isDelete && sys_metadata_delete) {
-                const metadataDelete = xmlElementToObject(sys_metadata_delete)
-                updateName = metadataDelete['sys_update_name']
-            }
-
-            const viewName = sys_ui_list['view']['@_name']
-            const view = {
-                title: sys_ui_list['view']['@_display_value'],
-                name: viewName === 'NULL' ? 'default_view' : viewName,
-                id: sys_ui_list['view']['#text'],
-            }
-
-            return new XmlData(
-                {
-                    updateName,
-                    sys_id: list['sys_id'],
-                    view,
-                    elements,
-                    table: list['name'],
-                    parent: list['parent'],
-                    relationship: {
-                        id: list['relationship'],
-                        name: sys_ui_list['relationship']?.['@_display_value'],
-                    },
-                },
-                xml.filePath,
-                'list',
-                isDelete ? 'DELETE' : list['@_action']
-            )
-        },
-    },
-    composers: {
-        entity: {
-            list(entity, context) {
-                const node = entity.getNode()
-                const guid = entity.getGuid()
-                const view = entity.getProperty('view').getValue()
-                const table = entity.getPropertyOrThrow('table', 'string').getValue()
-                const parent = entity.getProperty('parent', 'string')?.getValue()
-
-                const relationship = entity.getProperty('relationship')
-                const relationshipId = Data.isEntity(relationship)
-                    ? relationship?.getGuid()
-                    : (relationship?.getValue() as string)
-
-                const columns = entity.getPropertyOrThrow('columns', 'array').getValue()
-                const viewInfo: View = composeView(view as List['view'], context)
-
-                return Promise.resolve({
-                    kind: 'list',
-                    node,
-                    guid: getListUpdateName(viewInfo, table, parent, relationshipId),
-                    data: {
-                        id: guid,
-                        table,
-                        view: viewInfo,
-                        elements: columns,
-                        parent,
-                        relationship: relationshipId,
-                    },
-                })
-            },
-        },
-        xml: {
-            list(xml) {
-                const { sys_id, view, elements, table } = xml.data as unknown as TransformData
-                return {
-                    action: xml.action,
-                    kind: xml.kind,
-                    guid: xml.data['updateName'] as string,
-                    data: {
-                        id: sys_id,
-                        table,
-                        view,
-                        elements,
-                        parent: xml.data['parent'],
-                        relationship: xml.data['relationship'],
-                    },
-                }
-            },
-        },
-    },
-    transformers: {
-        list: {
-            CallExpression(document, context) {
-                const expressionName = getCallExpressionName(document.node)
-                if (expressionName !== List.name) {
-                    return false
-                }
-
-                if (document.action === 'DELETE') {
-                    removeNode(document.node)
-                    return true
-                }
-                if (document.action !== 'INSERT_OR_UPDATE') {
-                    return false
-                }
-                const [listArgument] = document.node.getArguments()
-                if (!ts.Node.isObjectLiteralExpression(listArgument)) {
-                    return false
-                }
-
-                const { elements, view, table, parent, relationship } = document.xmlData as TransformData
-                updateView(context, listArgument, view)
-
-                //create the table reference for now, user will need to fix to proper import
-                const tableProperty = getOrCreatePropertyAssignment(listArgument, 'table', '')
-                setPropertyAssignmentValue(tableProperty, table)
-
-                const arrayElements = toArray(elements)
-
-                //update the columns
-                const columnsProperty = getOrCreatePropertyAssignment(listArgument, 'columns', '[]')
-                const columns = arrayElements.sort((a, b) => (a['position'] as number) - (b['position'] as number))
-                setColumnsList(columnsProperty, columns)
-
-                if (parent) {
-                    const parentProperty = getOrCreatePropertyAssignment(listArgument, 'parent', '')
-                    setPropertyAssignmentValue(parentProperty, parent)
-                }
-
-                const relationAssignment = getPropertyAssignment(listArgument, 'relationship')
-                if (!relationAssignment && relationship?.id) {
-                    const { id, name } = relationship
-                    writeRecordReference(context, listArgument, 'relationship', { id, refName: name })
-                }
-
-                return true
-            },
-        },
-    },
-    generators: {
-        list(document, context) {
-            const { id } = document.data as any
-            return linkDocument(
-                document,
-                generateCallExpressionExportForDocument(
-                    context,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_ui_list')),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                    },
-                    List,
-                    { $id: id }
-                ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-    },
-    serializers: {
-        list(document, context) {
-            const {
-                id: listId,
-                elements: columns,
-                table,
-                view,
-                parent,
-                relationship,
-            } = document.data as {
-                id: string
-                elements: Array<any>
-                table: string
-                view: View
-                parent: string
-                relationship: string
-            }
-            const xmlBuilder = unloadBuilder(context)
-            /**
-             * Structure that needs to be built for sys_ui_list
-             * <sys_ui_list>
-             *  <sys_ui_list_element>
-             *    <sys_id/>
-             *  </sys_ui_list_element>
-             *  <sys_ui_list>
-             *   <sys_id/>
-             *   <view/>
-             *  </sys_ui_list>
-             * </sys_ui_list>
-             */
-
-            const listBuilder = xmlBuilder.xml.ele('sys_ui_list', {
-                table: table,
-                view: view.id === DEFAULT_VIEW ? '' : view.name,
-            })
-
-            columns.forEach((column, index) => {
-                let elementProperties = column
-
-                if (typeof column === 'string') {
-                    elementProperties = {
-                        element: column,
-                        position: index,
-                    }
-                }
-
-                if (elementProperties.position === undefined) {
-                    elementProperties.position = index
-                }
-
-                const childNode = recordXml(
-                    listBuilder,
-                    'sys_ui_list_element',
-                    context.keys.registerCompositeId('sys_ui_list_element', {
-                        list: listId,
-                        element: elementProperties.element,
-                    })
-                )
-
-                childNode.field('list_id', listId, {
-                    display_value: table,
-                    view: view.id,
-                })
-
-                Object.entries(elementProperties)
-                    .filter(([, v]) => typeof v !== 'undefined')
-                    .forEach(([n, v]) => childNode.field(n, v))
-            })
-
-            const sysUIList = recordXml(listBuilder, 'sys_ui_list', listId)
-            sysUIList.addSysScope(context)
-            sysUIList.field('view', view.id, {
-                display_value: view.title,
-                name: view.name,
-            })
-            sysUIList.field('name', table)
-
-            sysUIList.field('parent', parent ?? '')
-            sysUIList.field('relationship', relationship ?? '')
-
-            return {
-                name: `${document.guid}.xml`,
-                directory: getOutputDirectoryForDocument(document, table),
-                content: xmlBuilder.end(),
-            }
-        },
-    },
-})
-
-/*
- * Update the view property of the list argument
- * If the view is the default view, write view as a reference from the core package
- * If the view is a record, look for a record entity and write the view as a reference
- *
- * **Note:** View Cannot be updated using list layout on the instance,
- * if the view is updated directly from sys_ui_list table, then update name changes and a new List entity is created
- *
- */
-const updateView = (context, listArgument, view) => {
-    const viewAssignment = getPropertyAssignment(listArgument, 'view')
-    if (viewAssignment) {
-        return
-    }
-
-    if (view.id === DEFAULT_VIEW) {
-        writePropertyAsReference(context.logger, listArgument, 'view', '', view.name)
-        return
-    }
-    if (!writeRecordReference(context, listArgument, 'view', { id: view.id, refName: view.name })) {
-        writePropertyAsReference(context.logger, listArgument, 'view', '', view.name)
-    }
-}
-
-function writeRecordReference(context, listArgument, field, record: { id: string; refName: string }) {
-    const refName = record.refName.replace(/\s+/g, '_').toLowerCase()
-    const refRecord = context.getDocument(record.id)
-    const refNode = refRecord?.node
-    if (!refRecord || !refNode) {
-        context.logger.debug(`Could not find a reference record with sys_id ${record.id}`)
-        return false
-    }
-
-    const nodeSource = listArgument.getSourceFile()
-    const refPath = getImportPath(nodeSource.getFilePath(), refNode.getSourceFile().getFilePath())
-
-    if (!refPath) {
-        // reference is in the same file
-        const identifier = getIdentifier(refNode)
-        if (identifier) {
-            listArgument.addPropertyAssignment({ name: field, initializer: identifier })
-            return true
-        }
-        context.logger.warn(
-            `Could not find identifier for ${field}, with sys_id ${record.id}, consider adding one to use as a reference`
-        )
-        listArgument.addPropertyAssignment({ name: field, initializer: `'${refName ?? record.id}'` })
-        return true
-    }
-
-    // If the view record is not in the same file, add a reference to the view record
-    const viewExport = getExportTypeAndName(refNode)
-
-    if (!viewExport.exported) {
-        context.logger.warn(`View record is defined in ${refNode.getSourceFile().getFilePath()} and is not exported`)
-        listArgument.addPropertyAssignment({ name: field, initializer: `'${record.id}'` })
-        return true
-    }
-
-    // Add a reference to the view record and add an import statement
-    if (viewExport.type === 'Default') {
-        listArgument.addPropertyAssignment({ name: field, initializer: refName })
-        addDefaultImportIfAbsent(nodeSource, refPath, refName)
-    } else {
-        listArgument.addPropertyAssignment({ name: field, initializer: viewExport.identifier })
-        addNamedImportIfAbsent(context, nodeSource, refPath, viewExport.identifier)
-    }
-    return true
-}
-
-function composeView(view: NowRecord<'sys_ui_view'> | string, context): View {
-    if (isObject(view)) {
-        return {
-            id:
-                view.$id === DEFAULT_VIEW
-                    ? view.$id
-                    : context.keys.registerExplicitId('sys_ui_view', view.$id as unknown as string),
-            name: view.data.name,
-            title: view.data.title,
-        }
-    }
-
-    return {
-        id: view,
-        name: view,
-        title: view,
-    }
-}
-
-type ExportsInfo =
-    | { exported: false; identifier?: string }
-    | { exported: true; identifier: string; type: 'Named' }
-    | { exported: true; type: 'Default' }
-
-const getExportTypeAndName = (sourceNode: ts.CallExpression): ExportsInfo => {
-    // const defaultExports = sourceNode.getSourceFile().getExportSymbols()
-    const parentNode = sourceNode.getParent()
-
-    // export declarations are blocked by fluent-diagnostics
-    switch (parentNode?.getKind()) {
-        case ts.SyntaxKind.ExportAssignment:
-            return { exported: true, type: 'Default' }
-        case ts.SyntaxKind.VariableDeclaration: {
-            const identifier = getIdentifier(parentNode as ts.VariableDeclaration)!
-
-            const variableStmt = parentNode.getFirstAncestorByKind(ts.SyntaxKind.VariableStatement)
-            const exportKeyword = variableStmt?.getFirstModifierByKind(ts.SyntaxKind.ExportKeyword)
-            if (exportKeyword) {
-                return { exported: true, type: 'Named', identifier }
-            }
-            return { exported: false, identifier }
-        }
-
-        case ts.SyntaxKind.ExpressionStatement:
-        default:
-            return { exported: false }
-    }
-}
-
-const getIdentifier = (sourceNode: ts.CallExpression | ts.VariableDeclaration): string | undefined => {
-    const variableDeclaration =
-        sourceNode.getKind() === ts.SyntaxKind.CallExpression
-            ? sourceNode.getParentIfKind(ts.SyntaxKind.VariableDeclaration)
-            : sourceNode
-
-    return variableDeclaration?.getFirstChildByKind(ts.SyntaxKind.Identifier)?.getText()
-}
-
-const getImportPath = (listSourcePath, viewSourcePath): string | undefined => {
-    if (listSourcePath === viewSourcePath) {
-        return
-    }
-
-    const viewFilePath = path.parse(viewSourcePath)
-    const listFilePath = path.parse(listSourcePath)
-    const relativePath = path.join(path.relative(listFilePath.dir, viewFilePath.dir), viewFilePath.name)
-    // relativePath = relativePath.replace(path.extname(relativePath), '')
-    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`
-}
-
-const setColumnsList = (columnsProperty: ts.PropertyAssignment, elements: SysUIListElementXml) => {
-    const [array] = columnsProperty.getChildrenOfKind(ts.SyntaxKind.ArrayLiteralExpression)
-    let serializeValue: string = '[]'
-    if (array) {
-        const elementSyntaxList = array.getChildAtIndexIfKind(1, ts.SyntaxKind.SyntaxList)
-
-        //If the columns are defined as objects or need to be expressed that way due to additional properties set on instance
-        if (
-            !!elementSyntaxList?.getChildrenOfKind(ts.SyntaxKind.ObjectLiteralExpression).length ||
-            columnsNeedObjectLiterals(elements)
-        ) {
-            const newElements = elements.map((element, index) => {
-                let newValue: Record<string, unknown>
-
-                if (typeof element === 'string') {
-                    newValue = element
-                } else {
-                    newValue = {
-                        element: element['element'],
-                        position: element['position'] ?? index,
-                    }
-                    if (element['average_value']) {
-                        newValue['average_value'] = true
-                    }
-                    if (element['max_value']) {
-                        newValue['max_value'] = true
-                    }
-                    if (element['min_value']) {
-                        newValue['min_value'] = true
-                    }
-                    if (element['sum']) {
-                        newValue['sum'] = true
-                    }
-                }
-
-                return newValue
-            })
-
-            serializeValue = JSON.stringify(newElements)
-        } else {
-            serializeValue = JSON.stringify(elements.map((e) => e['element']))
-        }
-    }
-    columnsProperty?.replaceWithText(`columns: ${serializeValue}`)
-}
-
-const columnsNeedObjectLiterals = (elements: SysUIListElementXml) => {
-    return elements.some((element) => {
-        return Object.keys(element)
-            .filter((key) => !key.startsWith('sys_') && !key.startsWith('@_'))
-            .some((key) => {
-                switch (key) {
-                    case 'position':
-                    case 'list_id':
-                    case 'element':
-                        return false
-                    case 'average_value':
-                    case 'max_value':
-                    case 'sum':
-                    case 'min_value':
-                        return !!element[key]
-                    default: //Non default properties are unknown so just return true
-                        return true
-                }
-            })
-    })
-}
-
-const xmlElementToObject = (element: PrimitiveData) => {
-    return Object.entries(element).reduce((out, [k, v]) => {
-        out[k] = typeof v === 'string' ? v : v ? v['#text'] : ''
-        return out
-    }, {})
-}
-
-const getListUpdateName = (view: View, table: string, parent: string | undefined, relation: string | undefined) => {
-    const viewName = view.title === DEFAULT_VIEW ? 'null' : view.name
-
-    if (!parent && !relation) {
-        // Case 1: no parent/ no relation - sys_ui_list_table_view
-        return `sys_ui_list_${table}_${viewName}`
-    }
-    if (parent && !relation) {
-        // Case 2: parent/ no relation  - sys_ui_list_table_parent_view
-        return `sys_ui_list_${table}_${parent}_${viewName}`
-    }
-    if (!parent && relation) {
-        // Case 3: no parent/ relation - sys_ui_list_null_relation_view
-        return `sys_ui_list_null_${relation}_${viewName}`
-    }
-    // Case 4: parent/ relation - sys_ui_list_parent_relation_view
-    return `sys_ui_list_${parent}_${relation}_${viewName}`
-}
-
-const SysUIListXmlSchema = z.object({
-    sys_ui_list: z.object({
-        '@_action': z.union([z.literal('DELETE'), z.literal('INSERT_OR_UPDATE')]).optional(),
-        '@_table': z.string(),
-        '@_view': z.string(),
-        sys_ui_list: RecordXmlSchema,
-        sys_ui_list_element: z.union([z.array(RecordXmlSchema), RecordXmlSchema]),
-    }),
-    sys_metadata_delete: z
-        .object({
-            sys_update_name: z.object({
-                '#text': z.string(),
-            }),
-        })
-        .optional(),
-})
-
-const toArray = (value: unknown) => (Array.isArray(value) ? value : [value])
-type SysUIListElementXml = z.infer<typeof RecordXmlSchema>[]

package/src/NowConfigPlugin.ts

@@ -1,69 +0,0 @@
-import { Plugin, Data, EntityData, ObjectData } from '@servicenow/sdk-build-core'
-import JsonPlugin from './JsonPlugin'
-import { NowConfigFileName, path } from '@servicenow/sdk-project'
-
-export default Plugin({
-    name: 'NowConfig',
-    extractors: {
-        entity: {
-            json: {
-                SourceFile(node, context) {
-                    if (path.basename(node.getFilePath()) !== NowConfigFileName) {
-                        return { handled: false }
-                    }
-
-                    const configExtraction = context.extractAst(node, [JsonPlugin])
-                    if (!configExtraction.handled) {
-                        return { handled: false }
-                    }
-
-                    const configObject = configExtraction.data
-                    if (!Data.isObject(configObject)) {
-                        return { handled: false }
-                    }
-
-                    const { scope: scopeName, scopeId, name } = context.app.config
-                    const { name: packageName, version } = context.app.package
-
-                    const sysAppRecord = {
-                        $id: scopeId,
-                        table: 'sys_app',
-                        data: {
-                            active: true,
-                            can_edit_in_studio: true,
-                            enforce_license: 'none',
-                            hide_on_ui: false,
-                            installed_as_dependency: false,
-                            js_level: 'es_latest',
-                            licensable: true,
-                            license_category: 'none',
-                            license_model: 'none',
-                            package_json: `${scopeName}/${packageName}/${version}/package.json`,
-                            name: name || packageName,
-                            private: false,
-                            restrict_table_access: false,
-                            runtime_access_tracking: 'permissive',
-                            scope: scopeName,
-                            scoped_administration: false,
-                            source: scopeName,
-                            trackable: true,
-                            uninstall_blocked: false,
-                            version: version,
-                        },
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: configExtraction.diagnostics,
-                        data: new EntityData(
-                            'record',
-                            context.app.config.scopeId,
-                            ObjectData.fromObjectValue(sysAppRecord, configObject.getNode()),
-                            node
-                        ),
-                    }
-                },
-            },
-        },
-    },
-})