@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/db/DocumentationPlugin.ts

@@ -1,316 +0,0 @@
-import {
-    getCallExpressionName,
-    getPropertyAssignment,
-    Plugin,
-    stringify,
-    Context,
-    getOrCreatePropertyAssignment,
-    mergeDataIntoObjectLiteralArray,
-    filterEmpty,
-    generateCallExpressionExportForDocument,
-    getOrCreateEntitySourceFile,
-    linkDocument,
-    extractCallExpression,
-} from '@servicenow/sdk-build-core'
-import { Documentation, Record, Table } from '@servicenow/sdk-core/runtime/db'
-import { createObjectExpression } from './TablePlugin'
-import { ts, tsc } from '@servicenow/sdk-project'
-import { RecordPlugin, RecordEntitySchema } from './RecordPlugin'
-import { isEqual } from 'lodash'
-
-function isSysDocumentationRecord(node: ts.CallExpression) {
-    try {
-        return (
-            getCallExpressionName(node) === Record.name &&
-            ((node.getArguments()[0] as ts.ObjectLiteralExpression)?.getProperty('table') as ts.PropertyAssignment)
-                ?.getInitializerIfKind(ts.SyntaxKind.StringLiteral)
-                ?.getLiteralValue() === 'sys_documentation'
-        )
-    } catch (e) {
-        //don't throw
-    }
-    return false
-}
-
-type SysDocKey = { name: string; element: string | undefined; language: string }
-const generateSysId = (data: SysDocKey) =>
-    `${data['name']}_${data['element'] ? data['element'] + '_' : ''}${data['language']}`
-
-export default Plugin({
-    name: 'Documentation',
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression: (node, context) => {
-                    if (isSysDocumentationRecord(node)) {
-                        const result = extractCallExpression(
-                            Record,
-                            'record',
-                            node,
-                            context,
-                            (record) => {
-                                //Generate guid similar to documentation_plugin during sys_documentation record extraction
-                                return generateSysId(record.data as SysDocKey)
-                            },
-                            (record): record is Record => RecordEntitySchema.safeParse(record).success
-                        )
-
-                        if (!result.handled || !result.data) {
-                            return result
-                        }
-
-                        return {
-                            handled: true,
-                            diagnostics: result.diagnostics,
-                            data: result.data,
-                        }
-                    }
-                    return { handled: false }
-                },
-            },
-        },
-    },
-    composers: {
-        xml: {
-            sys_documentation(xml) {
-                const data = xml.data['data']!
-                return {
-                    kind: 'sys_documentation',
-                    guid: generateSysId(data as SysDocKey),
-                    data: xml.data,
-                    action: xml.action,
-                }
-            },
-        },
-    },
-    serializers: {
-        sys_documentation(document, context) {
-            return RecordPlugin.serializers.record(document, context)
-        },
-    },
-    arrangers: {
-        sys_documentation(document) {
-            if ((document.data as any).table !== 'sys_documentation') {
-                return { handled: false }
-            }
-            const tableName = (document.data as any).data.name
-            return {
-                handled: true,
-                result: tableName ? { kind: 'bootstrap', guid: tableName } : undefined,
-            }
-        },
-    },
-    generators: {
-        sys_documentation(document, context: Context, linkedDocuments) {
-            const tableName = (document.data as any).data.name
-            const table = linkedDocuments.find((doc) => doc.guid === tableName)
-            return table && table.node
-                ? { ...document, node: table.node }
-                : linkDocument(
-                      document,
-                      generateCallExpressionExportForDocument(
-                          context,
-                          {
-                              sourceFile: getOrCreateEntitySourceFile(context, `${document.guid}`),
-                              moduleSpecifier: '@servicenow/sdk/core',
-                          },
-                          Record,
-                          { $id: document.guid }
-                      ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-                  )
-        },
-    },
-    transformers: {
-        sys_documentation: {
-            CallExpression(document, context) {
-                const expressionName = getCallExpressionName(document.node)
-                if (expressionName !== Table.name) {
-                    return RecordPlugin.transformers!.record!.CallExpression(document, context)
-                }
-
-                const { element: column } = (document.data as any).data
-                const [baseArgs] = document.node.getArguments()
-                if (!baseArgs) {
-                    return false
-                }
-
-                const docData: Documentation = (document as any).data.data as Documentation
-                delete docData['element'], delete docData['name'], delete docData['sys_id']
-
-                let labelNode, objLitNode, existingNameNode
-                if (column) {
-                    const schemaProperty = getPropertyAssignment(baseArgs, 'schema')
-                    const schemaLiteral = schemaProperty?.getChildrenOfKind(ts.SyntaxKind.ObjectLiteralExpression)[0]
-                    if (!schemaLiteral) {
-                        return false
-                    }
-                    const columnNode = schemaLiteral
-                        .getProperties()
-                        .find(
-                            (prop) =>
-                                column === prop.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier).getText().trim()
-                        )
-                    if (!columnNode) {
-                        return false
-                    }
-
-                    const callExpNode = columnNode!.getFirstChildByKind(ts.SyntaxKind.CallExpression)
-                    if (!callExpNode) {
-                        return false
-                    }
-                    objLitNode = callExpNode.getFirstChildByKind(ts.SyntaxKind.ObjectLiteralExpression)
-                    if (!objLitNode) {
-                        return false
-                    }
-
-                    existingNameNode = columnNode.getFirstChildByKindOrThrow(ts.SyntaxKind.Identifier)
-                    labelNode = getPropertyAssignment(objLitNode, 'label')
-                } else {
-                    objLitNode =
-                        baseArgs.asKind(ts.SyntaxKind.ObjectLiteralExpression) ??
-                        baseArgs.getFirstDescendantByKind(ts.SyntaxKind.ObjectLiteralExpression)
-                    if (!objLitNode) {
-                        return false
-                    }
-                    existingNameNode = getPropertyAssignment(objLitNode, 'name')
-                    labelNode = getPropertyAssignment(objLitNode, 'label')
-                }
-
-                // Do transformation
-                const labelArrayNode = labelNode?.getFirstChildByKind(ts.SyntaxKind.ArrayLiteralExpression)
-                if (labelArrayNode) {
-                    mergeDataIntoObjectLiteralArray(labelArrayNode, [docData], 'language', document.action)
-                    return true
-                } else {
-                    const literalNode = labelNode?.getFirstChildByKind(ts.SyntaxKind.StringLiteral)
-                    if (isDefaultDocumentationRecord(docData)) {
-                        return updateDefaultLabelParameters(literalNode, docData, existingNameNode, objLitNode)
-                    } else {
-                        return createArrayLabel(labelNode, objLitNode, docData)
-                    }
-                }
-            },
-        },
-    },
-})
-
-function updateDefaultLabelParameters(literalNode, docData, existingNameNode, objLitNode) {
-    // Label should be written as a StringLiteral
-    if (literalNode) {
-        if (
-            literalNode.getLiteralValue() &&
-            docData.label?.toLowerCase().trim() === literalNode.getLiteralValue().toLowerCase().trim()
-        ) {
-            // Incoming label is the same as the node in code
-            return true
-        }
-
-        literalNode.setLiteralValue(docData.label)
-    } else {
-        if (
-            existingNameNode &&
-            existingNameNode.getText().toLowerCase().trim() === docData.label?.toLowerCase().trim()
-        ) {
-            // Label matches either `Table({name: 'xyz'})` or `name: xyzColumn({})`
-            return true
-        }
-        getOrCreatePropertyAssignment(objLitNode, 'label', stringify(docData.label))
-    }
-    return true
-}
-
-function createArrayLabel(labelNode, objLitNode, docData) {
-    labelNode = getOrCreatePropertyAssignment(objLitNode, 'label', '[]')
-    const existingLabel = labelNode.getFirstChildByKind(ts.SyntaxKind.StringLiteral)?.getLiteralText()
-
-    // Create the array since it didn't exist before
-    labelNode.transform((traversal) => {
-        if (tsc.isPropertyAssignment(traversal.currentNode)) {
-            const arrayLit = traversal.factory.createArrayLiteralExpression([
-                createObjectExpression({
-                    ...filterEmpty(docData),
-                }),
-            ])
-            return traversal.factory.updatePropertyAssignment(
-                traversal.currentNode,
-                tsc.factory.createIdentifier('label'),
-                arrayLit
-            )
-        }
-        return traversal.currentNode
-    })
-    if (existingLabel && docData.label?.toLowerCase().trim() !== existingLabel.toLowerCase().trim()) {
-        labelNode!
-            .getFirstChildByKindOrThrow(ts.SyntaxKind.ArrayLiteralExpression)
-            .addElement(stringify({ label: existingLabel }))
-    }
-    return true
-}
-
-function isDefaultDocumentationRecord(docData) {
-    const { label, name, element } = docData
-    const defaultRecord = defaultDocumentationRecord(label, name, element)
-    return isEqual(defaultRecord.data, docData)
-}
-
-// TODO make default language configurable
-function defaultDocumentationRecord(label: string, tableName: string, columnName: string) {
-    return Record({
-        table: 'sys_documentation',
-        $id: `${tableName}_${columnName ? columnName + '_' : ''}en`,
-        data: {
-            label: label,
-            hint: '',
-            help: '',
-            language: 'en',
-            plural: generatePlural(label),
-            url: '',
-            url_target: '',
-        },
-    })
-}
-
-const PLURAL_EQUALS_LABEL = [
-    's',
-    'ed',
-    'by',
-    'Active',
-    ')',
-    ' to',
-    ' with',
-    ' for',
-    ' in',
-    ' out',
-    ' use',
-    'Data',
-    ' data',
-]
-const PLURAL_SPECIAL_CASE_Y_TO_IES = ['ry', 'ty', 'dy', 'cy', 'fy', 'ly', 'ny']
-const PLURAL_SPECIAL_CASE_ADD_ES = ['x', 'sh', 'ch', 'z']
-
-// Modified from GlideLabelGenerator
-function generatePlural(label: string) {
-    if (!label) {
-        return ''
-    }
-
-    for (const l of PLURAL_EQUALS_LABEL) {
-        if (label.endsWith(l)) {
-            return label
-        }
-    }
-
-    for (const l of PLURAL_SPECIAL_CASE_Y_TO_IES) {
-        if (label.endsWith(l)) {
-            return label.substring(0, label.lastIndexOf('y')) + 'ies'
-        }
-    }
-
-    for (const l of PLURAL_SPECIAL_CASE_ADD_ES) {
-        if (label.endsWith(l)) {
-            return label + 'es'
-        }
-    }
-
-    return label + 's'
-}

package/src/db/LicensingPlugin.ts

@@ -1,138 +0,0 @@
-import {
-    getCallExpressionName,
-    Plugin,
-    Context,
-    getPropertyAssignment,
-    mergeDataIntoObjectLiteral,
-    linkDocument,
-    generateCallExpressionExportForDocument,
-    getOrCreateEntitySourceFile,
-    GUID,
-} from '@servicenow/sdk-build-core'
-import { Table, Record } from '@servicenow/sdk-core/runtime/db'
-import { RecordPlugin } from './RecordPlugin'
-import { ts } from '@servicenow/sdk-project'
-import { isEqual } from 'lodash'
-
-export const ua_table_licensing_config = 'ua_table_licensing_config'
-
-export default Plugin({
-    name: 'LicensingConfig',
-    composers: {
-        xml: {
-            ua_table_licensing_config(xml) {
-                return {
-                    kind: ua_table_licensing_config,
-                    guid: (xml.data['id'] as string) ?? GUID(),
-                    data: xml.data,
-                    action: xml.action,
-                }
-            },
-        },
-    },
-    serializers: {
-        ua_table_licensing_config(document, context) {
-            return RecordPlugin.serializers.record(document, context)
-        },
-    },
-    arrangers: {
-        ua_table_licensing_config(document) {
-            if ((document.data as any).table !== ua_table_licensing_config) {
-                return { handled: false }
-            }
-            const tableName = (document.data as any).data.name
-            return {
-                handled: true,
-                result: tableName ? { kind: 'bootstrap', guid: tableName } : undefined,
-            }
-        },
-    },
-    generators: {
-        ua_table_licensing_config(document, context: Context, linkedDocuments) {
-            const table = linkedDocuments.find((doc) => doc.guid === (document.data as any).data.name)
-            return table && table.node
-                ? { ...document, node: table.node }
-                : linkDocument(
-                      document,
-                      generateCallExpressionExportForDocument(
-                          context,
-                          {
-                              sourceFile: getOrCreateEntitySourceFile(context, `${document.kind}_${document.guid}`),
-                              moduleSpecifier: '@servicenow/sdk/core',
-                          },
-                          Record,
-                          { $id: document.guid }
-                      ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-                  )
-        },
-    },
-    transformers: {
-        ua_table_licensing_config: {
-            CallExpression(document, context) {
-                const expressionName = getCallExpressionName(document.node)
-                if (expressionName !== Table.name) {
-                    return RecordPlugin.transformers!.record!.CallExpression(document, context)
-                }
-
-                const [baseArgs] = document.node.getArguments()
-                if (!baseArgs) {
-                    return false
-                }
-
-                const changedData = (document.changedData as any).data
-                const data = (document.data as any).data
-
-                let objLit, dataToMerge
-                const licensingProp = getPropertyAssignment(baseArgs, 'licensing_config')
-                if (!licensingProp) {
-                    if (isDefaultLicensingConfig(data)) {
-                        return true
-                    }
-                    const defaultValues = defaultLicensingConfigRecord(data.name).data
-                    dataToMerge = {}
-                    Object.entries(data)
-                        .filter(([prop]) => {
-                            return data[prop] !== defaultValues[prop]
-                        })
-                        .map(([k, v]) => {
-                            dataToMerge[k] = v
-                        })
-                    const callExpLit = document.node.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                    const newProp = callExpLit.addPropertyAssignment({ name: 'licensing_config', initializer: '{}' })
-                    objLit = newProp!.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                } else {
-                    dataToMerge = changedData
-                    objLit = licensingProp!.getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                }
-
-                if (dataToMerge.license_roles) {
-                    dataToMerge.license_roles = dataToMerge.license_roles.split(',')
-                }
-
-                mergeDataIntoObjectLiteral(objLit, dataToMerge)
-                return true
-            },
-        },
-    },
-})
-function isDefaultLicensingConfig(data) {
-    return isEqual(data, defaultLicensingConfigRecord(data.name).data)
-}
-
-function defaultLicensingConfigRecord(tableName: string) {
-    return Record({
-        table: ua_table_licensing_config,
-        $id: `${tableName}_license`,
-        data: {
-            name: tableName,
-            op_insert: true,
-            op_update: true,
-            op_delete: true,
-            is_fulfillment: false,
-            license_model: 'none',
-            owner_condition: '',
-            license_condition: '',
-            license_roles: '',
-        },
-    })
-}