@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/PackageJsonPlugin.ts

@@ -1,68 +0,0 @@
-import { Plugin, Context } from '@servicenow/sdk-build-core'
-import { ModuleEntityData } from './ServerModulePlugin'
-import { RepackService } from './repack'
-
-export default Plugin({
-    name: 'PackageJson',
-    extractors: {
-        entity: {
-            json: {
-                SourceFile(file, context) {
-                    if (file.getBaseName() !== 'package.json') {
-                        return { handled: false }
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics: [],
-                        data: new ModuleEntityData(file.getFilePath(), file.getFullText(), file, context),
-                    }
-                },
-            },
-        },
-    },
-    composers: {
-        entity: {
-            async module(module, context) {
-                if (!module.getProperty('path', 'string')?.getValue().endsWith('package.json')) {
-                    return Promise.resolve(undefined)
-                }
-
-                // eslint-disable-next-line prefer-const
-                let { path, content } = module.getValue()
-
-                /**
-                 * We do this to avoid having package plugin depend on the server module plugin to get resolved versions of dependencies.
-                 */
-                content = await fixDependencyVersion(content as string, context)
-
-                return Promise.resolve({
-                    kind: 'module',
-                    guid: module.getGuid(),
-                    node: module.getNode(),
-                    data: {
-                        path,
-                        content,
-                    },
-                })
-            },
-        },
-    },
-})
-
-async function fixDependencyVersion(jsonString: string, context: Context) {
-    const json = JSON.parse(jsonString)
-    const { dependencies: packageDependencies } = json
-    if (!packageDependencies) {
-        return jsonString
-    }
-
-    const repack = await RepackService.create(context.logger, context.fs, context.app.rootDir)
-    for (const [name] of Object.entries(packageDependencies)) {
-        const { name: rname, version: rversion } = await repack.getResolvedDepDetails(name)
-        packageDependencies[rname] = rversion
-    }
-
-    json.dependencies = packageDependencies
-    return JSON.stringify(json, null, 2)
-}

package/src/PropertyPlugin.ts

@@ -1,237 +0,0 @@
-import { Property, getRolesArray, roleSchema } from '@servicenow/sdk-core/runtime/app'
-import { Record } from '@servicenow/sdk-core/runtime/db'
-import { PropertyType } from '@servicenow/sdk-core/runtime/fluent'
-import {
-    EntityData,
-    FluentDiagnostic,
-    ObjectData,
-    Plugin,
-    extractCallExpression,
-    generateCallExpressionExportForDocument,
-    getCallExpressionName,
-    getOrCreateEntitySourceFile,
-    getSysUpdateName,
-    linkDocument,
-    isSNScope,
-    removeNode,
-    transformFunctionArguments,
-    writePropertyAsReference,
-    transformCustomizedProperties,
-} from '@servicenow/sdk-build-core'
-import { RecordPlugin } from './db/RecordPlugin'
-import { z } from 'zod'
-import { pickBy } from 'lodash'
-import { Diagnostic, ts } from '@servicenow/sdk-project'
-import { getRolesString } from './aclAndRole/RolePlugin'
-
-const PropertySchema = z.object({
-    $id: z.string().or(z.number()),
-    name: z.string(),
-    type: PropertyType.or(z.literal('')).default(''),
-    value: z.union([z.string(), z.number(), z.boolean()]).default(''),
-    description: z.string().default(''),
-    ignoreCache: z.boolean().default(false),
-    isPrivate: z.boolean().default(false),
-    choices: z.array(z.string()).default([]),
-    roles: z
-        .record(z.union([z.literal('read'), z.literal('write')]), z.array(z.union([roleSchema, z.string()])).optional())
-        .default({ read: [], write: [] }),
-})
-
-const PropertyConfigSchema = z.object({
-    name: PropertySchema.shape.name,
-    type: z.string().default(''),
-    value: PropertySchema.shape.value.optional(),
-    description: PropertySchema.shape.description,
-    is_private: PropertySchema.shape.isPrivate,
-    ignore_cache: PropertySchema.shape.ignoreCache,
-    read_roles: z.string().optional(),
-    write_roles: z.string().optional(),
-    choices: z.string().optional(),
-})
-
-type PropertyConfig = z.output<typeof PropertyConfigSchema>
-
-const transformProperties = (
-    data: PropertyConfig,
-    xmlRoles: { read_roles: string; write_roles: string }
-): Partial<Property> => {
-    const { read_roles, write_roles, ...rest } = data
-
-    let roles
-    if (read_roles !== undefined || write_roles !== undefined) {
-        roles = {
-            ...(xmlRoles.read_roles !== undefined && { read: getRolesArray(xmlRoles.read_roles) }),
-            ...(xmlRoles.write_roles !== undefined && { write: getRolesArray(xmlRoles.write_roles) }),
-        }
-    }
-    const result = {
-        name: rest.name,
-        type: rest.type,
-        value: rest.value,
-        description: rest.description,
-        ignoreCache: rest.ignore_cache,
-        isPrivate: rest.is_private,
-        roles: roles,
-        choices: rest.choices
-            ?.split(/\r?\n/)
-            .map((choice) => choice.trim())
-            .filter((choice) => choice),
-    }
-    return pickBy(result, (v) => v !== undefined)
-}
-
-export default Plugin({
-    name: 'Property',
-    ownedTables: {
-        sys_properties: { diagnosticLevel: Diagnostic.Level.Warn },
-    },
-    extractors: {
-        entity: {
-            fluent: {
-                CallExpression: (node, context) => {
-                    const result = extractCallExpression(Property, 'property', node, context, (prop) =>
-                        context.registerExplicitId('sys_properties', prop.$id as string)
-                    )
-
-                    if (!result.handled || !result.data) {
-                        return result
-                    }
-
-                    const propertyData = result.data
-                    const diagnostics = result.diagnostics
-                    const scope = context.app.config.scope
-                    const nameData = propertyData.getProperty('name')
-                    const nameNode = nameData.getNode()
-
-                    if (!isSNScope(scope) && !nameData.getValue().startsWith(`${scope}.`)) {
-                        diagnostics.push(new FluentDiagnostic(nameNode, `Property name must begin with '${scope}.'`))
-                    }
-
-                    return {
-                        handled: true,
-                        diagnostics,
-                        data: propertyData,
-                    }
-                },
-            },
-        },
-    },
-    composers: {
-        entity: {
-            property(entity, context) {
-                const scope = context.app.config.scope
-                const property = PropertySchema.and(z.any()).safeParse(entity.getValue())
-                if (!property.success) {
-                    return Promise.resolve(undefined)
-                }
-
-                const { $id, name, value, isPrivate, ignoreCache, choices, type, roles: _, ...rest } = property.data
-
-                const roles = entity.getProperty('roles', 'object')
-                const readRoles = roles?.getProperty('read', 'array')
-                const writeRoles = roles?.getProperty('write', 'array')
-                const readRolesString = readRoles ? getRolesString(readRoles) : ''
-                const writeRolesString = writeRoles ? getRolesString(writeRoles) : ''
-
-                const suffix = name.replace(new RegExp(`^${scope}\\.`), '')
-                const propertyRecord = Record({
-                    table: 'sys_properties',
-                    $id,
-                    data: {
-                        name,
-                        suffix,
-                        ...rest,
-                        ...(type === '' ? {} : { type }),
-                        value: `${value}`, // TODO: Should be allowed to assign non-strings to string columns
-                        is_private: isPrivate,
-                        ignore_cache: ignoreCache,
-                        choices: choices.join('\n'),
-                        read_roles: readRolesString,
-                        write_roles: writeRolesString,
-                    },
-                })
-
-                return context.composeEntities(
-                    [
-                        new EntityData(
-                            'record',
-                            entity.getGuid(),
-                            ObjectData.fromObjectValue(propertyRecord, entity.getNode()),
-                            entity.getNode(),
-                            entity.getInstallMethod()
-                        ),
-                    ],
-                    [RecordPlugin]
-                )
-            },
-        },
-    },
-
-    generators: {
-        record(document, context) {
-            const tableName = document.data!['table']
-            if (tableName !== 'sys_properties') {
-                return undefined
-            }
-            return linkDocument(
-                document,
-                generateCallExpressionExportForDocument(
-                    context,
-                    {
-                        sourceFile: getOrCreateEntitySourceFile(context, getSysUpdateName(document, 'sys_properties')),
-                        moduleSpecifier: '@servicenow/sdk/core',
-                    },
-                    Property,
-                    { $id: document.guid }
-                ).getExpressionIfKindOrThrow(ts.SyntaxKind.CallExpression)
-            )
-        },
-    },
-    transformers: {
-        record: {
-            CallExpression(document, context) {
-                if (getCallExpressionName(document.node) !== Property.name) {
-                    return false
-                }
-
-                if (document.action === 'DELETE') {
-                    removeNode(document.node)
-                    return true
-                }
-
-                if (!document.changedData) {
-                    return false
-                }
-                const { read_roles, write_roles } = (document.xmlData as any).data
-                const data = transformProperties(document.changedData!['data'] as PropertyConfig, {
-                    read_roles,
-                    write_roles,
-                })
-
-                const [args] = document.node.getArguments()
-                if (!ts.Node.isObjectLiteralExpression(args)) {
-                    return false
-                }
-                transformCustomizedProperties(Property, document.node, document.changedData!['data'], data)
-                transformFunctionArguments(document.node, Property, data)
-
-                if (data.roles) {
-                    removeEmptyRoles(args, data)
-                    writePropertyAsReference(context.logger, args, 'roles', '{}', data.roles)
-                }
-
-                return true
-            },
-        },
-    },
-})
-
-function removeEmptyRoles(arg: ts.ObjectLiteralExpression, data: Partial<Property>) {
-    ;['read', 'write'].forEach((type) => {
-        if (data.roles?.[type].length === 0) {
-            arg.getProperty('roles')?.asKind(ts.SyntaxKind.ObjectLiteralExpression)?.getProperty(type)?.remove()
-            delete data.roles?.[type]
-        }
-    })
-}

package/src/ScriptTemplatePlugin.ts

@@ -1,53 +0,0 @@
-import { escapeStringLiteralValues, Plugin } from '@servicenow/sdk-build-core'
-import { ts } from '@servicenow/sdk-project'
-import { fieldHasNowIncludeCallExpression } from './IncludePlugin'
-
-export default Plugin({
-    name: 'scriptTemplate',
-    extractors: {
-        raw: {
-            fluent: {
-                TaggedTemplateExpression(node, context) {
-                    if (node.getTag().getText() !== 'script') {
-                        return { handled: false }
-                    }
-
-                    return context.extractAst(node.getTemplate())
-                },
-            },
-        },
-    },
-})
-
-export function processScript(args: ts.ObjectLiteralExpression, argName: string, script: string) {
-    if (!args.getProperty(argName)) {
-        createNewScriptTemplate(args, argName, script)
-    } else if (fieldHasNowIncludeCallExpression(args, argName)) {
-        return
-    } else {
-        const prop = args.getProperty(argName)!.asKindOrThrow(ts.SyntaxKind.PropertyAssignment)
-        const kind = prop.getInitializer()?.getKind()
-        if (kind === ts.SyntaxKind.TaggedTemplateExpression) {
-            const taggedTempExp = prop.getInitializer()?.asKind(ts.SyntaxKind.TaggedTemplateExpression)
-            updateTaggedTempExpWithScript(taggedTempExp!, script)
-        } else {
-            args.getProperty(argName)?.remove()
-            createNewScriptTemplate(args, argName, script)
-        }
-    }
-}
-
-function createNewScriptTemplate(args: ts.ObjectLiteralExpression, argName: string, script: string) {
-    const prop = args.addPropertyAssignment({ name: argName, initializer: '"place_holder"' })
-    script = escapeStringLiteralValues(script)
-    prop.setInitializer((writer) => {
-        writer.write('`')
-        writer.write(script)
-        writer.write('`')
-    })
-}
-
-function updateTaggedTempExpWithScript(node: ts.TaggedTemplateExpression, script: string) {
-    const literal = node!.getTemplate().asKind(ts.SyntaxKind.NoSubstitutionTemplateLiteral)!
-    literal.setLiteralValue(escapeStringLiteralValues(script))
-}