@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/src/db/RecordPlugin.ts

@@ -1,459 +0,0 @@
-import { Record, TableName } from '@servicenow/sdk-core/runtime/db'
-import {
-    Context,
-    Plugin,
-    getCallExpressionName,
-    isGUID,
-    removeNode,
-    transformFunctionArguments,
-    unloadBuilder,
-    linkDocument,
-    generateCallExpressionExportForDocument,
-    getOrCreateEntitySourceFile,
-    XmlData,
-    FluentDiagnostic,
-    ExtractionResult,
-    EntityData,
-    extractCallExpression,
-    Data,
-    ObjectData,
-    Document,
-    type Directories,
-} from '@servicenow/sdk-build-core'
-import { z } from 'zod'
-import { ts } from '@servicenow/sdk-project'
-import { except } from '../scripts/scriptUtils'
-import { fieldHasNowIncludeCallExpression } from '../IncludePlugin'
-
-// TODO: This schema should live with the Record entity function itself
-export const RecordEntitySchema = z.object({
-    $id: z.string().or(z.number()),
-    data: z.record(z.any()),
-    table: z.string(),
-})
-
-type RecordData = z.output<typeof RecordEntitySchema>
-
-const RecordUpdate = z.object({
-    record_update: z.record(z.any()),
-})
-
-const RecordUpdateTableSchema = z.object({
-    '@_table': z.string(),
-})
-
-export const TextStringSchema = z.object({ '#text': z.string() }).transform((val) => val['#text'])
-export const TextBooleanSchema = z.object({ '#text': z.boolean() }).transform((val) => val['#text'])
-export const TextNumberSchema = z.object({ '#text': z.number().or(z.literal('')) }).transform((val) => val['#text'])
-
-const ignoreFields = [
-    'sys_created_by',
-    'sys_created_on',
-    'sys_updated_by',
-    'sys_updated_on',
-    'sys_mod_count',
-    'sys_class_name',
-    'sys_id',
-    'sys_package',
-    'sys_policy',
-    'sys_scope',
-    'sys_update_name',
-]
-const ignoreXMLElement = ['sys_translated_text', 'sys_es_latest_script']
-
-export const RecordXmlSchema = z
-    .object({
-        '@_action': z.union([z.literal('INSERT_OR_UPDATE'), z.literal('DELETE'), z.literal('delete_multiple')]),
-        sys_id: z.object({
-            '#text': z
-                .string()
-                .min(32)
-                .max(32)
-                .or(z.number().transform((val) => val.toString())),
-        }),
-    })
-    .catchall(
-        z.intersection(
-            z.object({
-                '#text': z.union([z.string(), z.boolean(), z.number(), z.undefined()]),
-            }),
-            z.record(z.any()) // capture all attributes
-        )
-    )
-
-const RecordDocumentSchema = z.object({
-    data: z.record(z.union([z.string(), z.number(), z.boolean(), z.undefined(), z.null()])),
-    table: z.string(),
-})
-
-const InstallDir = z
-    .union([
-        z.literal('update'),
-        z.literal('dictionary'),
-        z.literal('scope'),
-        z.literal('demo'),
-        z.literal('first install'),
-    ])
-    .default('update')
-    .transform((directory) => {
-        if (directory === 'demo') {
-            return 'unload.demo'
-        } else if (directory === 'first install') {
-            return 'unload'
-        }
-        return directory
-    })
-
-export function getOutputDirectoryForDocument(document: Document, table: string): Directories {
-    if (table === 'sys_app') {
-        return 'scope'
-    }
-    return InstallDir.parse(document['directory'])
-}
-
-function cleanRecordUpdate(recordUpdate: globalThis.Record<string, unknown>) {
-    ignoreXMLElement.forEach((element) => delete recordUpdate[element])
-    return recordUpdate
-}
-
-export function propertyAssignmentIsInlineScript(pa: ts.PropertyAssignment) {
-    return (
-        pa.getInitializerIfKind(ts.SyntaxKind.StringLiteral) ||
-        pa.getInitializerIfKind(ts.SyntaxKind.TaggedTemplateExpression) ||
-        pa.getInitializerIfKind(ts.SyntaxKind.TemplateExpression) ||
-        pa.getInitializerIfKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)
-    )
-}
-
-export const RecordPlugin = Plugin({
-    name: 'Record',
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression: (node, context) => {
-                    const result = extractCallExpression(
-                        Record,
-                        'record',
-                        node,
-                        context,
-                        (record) => {
-                            // Take the guid from the id property, a sys_id property, or generate one
-                            if ('sys_id' in record.data) {
-                                return record.data['sys_id'] as string
-                            } else if (isGUID(record.$id as string)) {
-                                return record.$id as string
-                            } else {
-                                return context.keys.registerExplicitId(record.table, record.$id as string)
-                            }
-                        },
-                        (record): record is Record => RecordEntitySchema.safeParse(record).success
-                    )
-
-                    if (!result.handled || !result.data) {
-                        return result
-                    }
-
-                    const record = result.data
-                    const diagnostics = result.diagnostics
-                    const tableName = record.getProperty('table').getValue()
-                    const pluginInfo = context.getPluginForTable(tableName)
-
-                    if (pluginInfo) {
-                        const { logLevel, api } = pluginInfo
-                        const tableNode = node
-                            .getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                            .getPropertyOrThrow('table')
-
-                        diagnostics.push(
-                            new FluentDiagnostic(
-                                tableNode,
-                                `${tableName} should not be created by the Record API. Please use the ${api} API.`,
-                                { level: logLevel }
-                            )
-                        )
-                    }
-
-                    // TODO: Get this out of the RecordPlugin somehow. Maybe need to provide a new mechanism for
-                    // plugins to add diagnostics for entities extracted by other plugins?
-                    if (tableName === 'sys_ui_view') {
-                        const viewName = record.getProperty('data').getProperty('name')?.getValue()
-                        const viewDataNode = node
-                            .getFirstChildByKindOrThrow(ts.SyntaxKind.ObjectLiteralExpression)
-                            .getPropertyOrThrow('data')
-                            .asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
-                            .getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-
-                        const viewNameNode = viewDataNode?.getPropertyOrThrow('name')
-                        const nameRegex = new RegExp(`^[a-zA-Z0-9_]+$`)
-
-                        if (typeof viewName !== 'string' || !viewName.match(nameRegex)) {
-                            diagnostics.push(
-                                new FluentDiagnostic(
-                                    viewNameNode!,
-                                    `View name can only contain alphanumeric characters`
-                                )
-                            )
-                        }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: record,
-                    }
-                },
-            },
-        },
-        xml(xml) {
-            // Parse out record_Update info
-            const recordUpdateResult = RecordUpdate.safeParse(xml.data)
-            if (!recordUpdateResult.success) {
-                return undefined
-            }
-
-            // Parse root level @_table from record_update
-            const recordUpdate = cleanRecordUpdate(recordUpdateResult.data.record_update)
-            let tableRecord, recordTable
-            const table = RecordUpdateTableSchema.safeParse(recordUpdate)
-            if (!table.success) {
-                // TODO A record plugin should only handle 1 table record?
-                // Taking the first one for now. Shouldn't assume this is the right one
-                recordTable = Object.keys(recordUpdate)[0] as string
-                tableRecord = recordUpdate[recordTable]
-            } else {
-                recordTable = table.data['@_table']
-                tableRecord = recordUpdate[table.data['@_table']]
-            }
-
-            if (!tableRecord) {
-                return undefined
-            }
-            const recordParse = RecordXmlSchema.safeParse(tableRecord)
-            if (!recordParse.success) {
-                return undefined
-            }
-
-            if (
-                tableRecord['@_action'] !== 'DELETE' &&
-                Object.keys(recordUpdate).some((k) => k !== recordTable && !k.startsWith('@_'))
-            ) {
-                // Record contains other entries in the file that cannot be processed
-                return undefined
-            }
-
-            try {
-                const {
-                    '@_action': action,
-                    sys_id: { '#text': sysId },
-                    ...rest
-                } = tableRecord
-
-                const record = Object.entries(rest).reduce((out, [k, v]) => {
-                    out[k] = v ? v['#text'] : undefined
-                    return out
-                }, {})
-
-                return new XmlData(
-                    {
-                        id: sysId,
-                        table: recordTable,
-                        data: record,
-                    },
-                    xml.filePath,
-                    'record',
-                    action
-                )
-            } catch (err) {
-                return undefined // TODO: What are we catching here?
-            }
-        },
-    },
-    composers: {
-        entity: {
-            record(entity, _context) {
-                const $id = entity.getProperty('$id')
-                if (!Data.isString($id) && !Data.isNumber($id)) {
-                    Promise.reject(`Record ID must be a string or number`)
-                }
-
-                const table = entity.getProperty('table')
-                if (!Data.isString(table)) {
-                    Promise.reject(`Record table must be a string`)
-                }
-
-                const data = entity.getProperty('data')
-                if (!Data.isObject(data)) {
-                    Promise.reject(`Record data must be an object`)
-                }
-
-                const dataProps = entity.getProperty('data', 'object')?.getProperties()
-                const cdataFields: string[] = []
-                if (dataProps) {
-                    cdataFields.push(
-                        ...Object.entries(dataProps).reduce((fields, [key, value]) => {
-                            if (Data.isString(value) && value.needsCDATATag()) {
-                                fields.push(key)
-                            }
-                            return fields
-                        }, [] as string[])
-                    )
-                }
-
-                return Promise.resolve({
-                    kind: 'record',
-                    guid: entity.getGuid(),
-                    node: entity.getNode(),
-                    directory: entity.getInstallMethod(),
-                    cdataFields,
-                    data: {
-                        $id: $id.getValue(),
-                        table: table.getValue(),
-                        data: data.getValue(),
-                    },
-                })
-            },
-        },
-        xml: {
-            record(xml) {
-                const table = xml.data['table'] as string
-                const sysId = xml.data['id'] as string
-
-                return {
-                    action: xml.action,
-                    guid: sysId,
-                    kind: 'record',
-                    data: { table, data: xml.data['data'] },
-                }
-            },
-        },
-    },
-    serializers: {
-        record(document, context) {
-            const cdataFields = document['cdataFields']
-            const { table, data } = RecordDocumentSchema.parse(document.data)
-            const recordBuilder = unloadBuilder(context)
-            const builder = recordBuilder.record(table, document.guid, document.action)
-
-            Object.entries(data)
-                .filter(([c, v]) => typeof v !== 'undefined' && c !== 'sys_id')
-                .forEach(([c, v]) => {
-                    if (cdataFields && cdataFields.includes(c)) {
-                        builder.field(c, v, {}, true)
-                    } else {
-                        builder.field(c, v)
-                    }
-                })
-
-            return {
-                name: `${table}_${document.guid}.xml`,
-                directory: getOutputDirectoryForDocument(document, table),
-                content: recordBuilder.end(),
-            }
-        },
-    },
-    generators: {
-        record(document, context) {
-            return linkDocument(
-                document,
-                generateCallExpressionExportForDocument(
-                    context,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(
-                            context,
-                            `${document.data?.['table']}_${document.guid}`
-                        ),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                    },
-                    Record,
-                    { $id: document.guid }
-                ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-    },
-    transformers: {
-        record: {
-            CallExpression(document, context) {
-                if (getCallExpressionName(document.node) !== Record.name) {
-                    return false
-                }
-
-                if (document.action === 'DELETE') {
-                    removeNode(document.node)
-                    return true
-                }
-
-                if (!document.changedData) {
-                    return false
-                }
-
-                const [args] = document.node.getArguments()
-                if (!ts.Node.isObjectLiteralExpression(args)) {
-                    return false
-                }
-
-                const { table } = document.data as RecordData
-                const data = (document.changedData as any).data
-
-                const properties = Object.keys(data).reduce((out, key) => {
-                    if (ignoreFields.includes(key)) {
-                        return out
-                    }
-
-                    if (data[key] !== '' && data[key] !== undefined) {
-                        out[key] = data[key]
-                    }
-
-                    return out
-                }, {} as Record)
-
-                const preexistingData = args
-                    .getProperty('data')
-                    ?.asKind(ts.SyntaxKind.PropertyAssignment)
-                    ?.getInitializerIfKind(ts.SyntaxKind.ObjectLiteralExpression)
-
-                transformFunctionArguments(document.node, Record, {
-                    table,
-                    data: except(
-                        properties,
-                        (field) => !!preexistingData && fieldHasNowIncludeCallExpression(preexistingData, field)
-                    ),
-                })
-
-                context.argTypesToFix.push(document.node)
-                return true
-            },
-        },
-    },
-})
-
-export function extractCallExpressionAsRecord<
-    const A extends unknown[],
-    const E extends A extends [infer T extends globalThis.Record<string, unknown>] ? T : never,
-    const T extends TableName,
->(
-    fn: (...args: A) => E,
-    asRecord: (entity: EntityData<E>) => ObjectData<Record<T>>,
-    guid: (entity: E) => string,
-    node: ts.CallExpression,
-    context: Context
-): ExtractionResult<EntityData<Record<T>>> {
-    const result = extractCallExpression(fn, 'record', node, context, guid)
-    if (!result.handled) {
-        return result
-    }
-
-    return {
-        handled: true,
-        diagnostics: result.diagnostics,
-        data: result.data
-            ? new EntityData(
-                  'record',
-                  result.data.getGuid(),
-                  asRecord(result.data),
-                  node,
-                  result.data.getInstallMethod(),
-                  result.data.getExplicitIds()
-              )
-            : undefined,
-    }
-}