@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/index.ts

@@ -1,21 +1,39 @@
-export * from './db'
-export * from './uxf'
-export { default as DefaultPlugin } from './DefaultPlugin'
-export { default as ApplicationMenuPlugin } from './app/ApplicationMenuPlugin'
-export { default as PropertyPlugin } from './PropertyPlugin'
-export { default as RestApiPlugin, RestApiPluginTechDebt } from './scriptedRESTAPI/RestApiPlugin'
-export { default as UserPreferencePlugin } from './UserPreferencePlugin'
-export { default as CrossScopePrivilegePlugin } from './CrossScopePrivilegePlugin'
-export { default as ClientScriptPlugin } from './scripts/ClientScriptPlugin'
-export { default as BusinessRulePlugin } from './BusinessRulePlugin'
-export { default as ListPluginPlugin } from './ListPlugin'
-export { default as RolePlugin } from './aclAndRole/RolePlugin'
-export { default as AclPlugin } from './aclAndRole/AclPlugin'
-export { default as ScriptTemplatePlugin } from './ScriptTemplatePlugin'
-export { default as IdPlugin } from './IdPlugin'
-export { default as JsonPlugin } from './JsonPlugin'
-export { default as HtmlTemplatePlugin } from './HtmlTemplatePlugin'
-export { default as NowConfigPlugin } from './NowConfigPlugin'
-export { default as PackageJsonPlugin } from './PackageJsonPlugin'
-export { default as ServerModulePlugin } from './ServerModulePlugin'
-export { default as IncludePlugin } from './IncludePlugin'
+export * from './application-menu-plugin'
+export * from './basic-syntax-plugin'
+export * from './call-expression-plugin'
+export * from './client-script-plugin'
+export * from './cross-scope-privilege-plugin'
+export * from './record-plugin'
+export * from './now-id-plugin'
+export * from './now-ref-plugin'
+export * from './now-unresolved-plugin'
+export * from './property-plugin'
+export * from './role-plugin'
+export * from './acl-plugin'
+export * from './server-module-plugin'
+export * from './view-plugin'
+export * from './json-plugin'
+export * from './now-config-plugin'
+export * from './package-json-plugin'
+export * from './business-rule-plugin'
+export * from './user-preference-plugin'
+export * from './now-include-plugin'
+export * from './table-plugin'
+export * from './column-plugin'
+export * from './ui-page-plugin'
+export * from './list-plugin'
+export * from './ui-action-plugin'
+export * from './script-include-plugin'
+export * from './arrow-function-plugin'
+export * from './atf/test-plugin'
+export * from './service-portal/widget-plugin'
+export * from './service-portal/dependency-plugin'
+export * from './service-portal/angular-provider-plugin'
+export * from './rest-api-plugin'
+export * from './html-import-plugin'
+export * from './static-content-plugin'
+export * from './script-action-plugin'
+
+// non-plugins
+export * from './atf/step-configs'
+export { REPACK_OUTPUT_DIR } from './repack'

package/src/json-plugin.ts

@@ -0,0 +1,128 @@
+import {
+    ts,
+    JSON5,
+    CallExpressionShape,
+    type ObjectShape,
+    Plugin,
+    Shape,
+    type Source,
+    SourceFileShape,
+    StringShape,
+} from '@servicenow/sdk-build-core'
+
+export class JsonStringifyShape extends CallExpressionShape {
+    constructor({ source, json }: { source: Source; json: NonNullable<object> | ObjectShape }) {
+        super({ source, callee: 'JSON.stringify', args: [json] })
+    }
+
+    getJson(): ObjectShape {
+        return this.getArgument(0).asObject()
+    }
+
+    override getValue(): string {
+        return JSON.stringify(this.getJson().getValue())
+    }
+}
+
+export class JsonFileShape extends SourceFileShape {
+    private readonly json: ObjectShape
+
+    constructor(file: SourceFileShape, json: ObjectShape) {
+        super({ file: file.getSource() })
+        this.json = json
+    }
+
+    getJson(): ObjectShape {
+        return this.json
+    }
+}
+
+export const JsonPlugin = Plugin.create({
+    name: 'JsonPlugin',
+    shapes: [
+        {
+            shape: SourceFileShape,
+            fileTypes: ['json'],
+            toSubclass(file) {
+                const rawContent = file.getContent().trim()
+                const jsonContent = rawContent || '{}'
+
+                let json: ObjectShape
+                try {
+                    json = Shape.from(
+                        file.getSource().getFirstDescendantByKind(ts.SyntaxKind.ObjectLiteralExpression) ?? file,
+                        JSON5.parse(jsonContent)
+                    ).asObject('Expected JSON file content to be a JSON object')
+                } catch (e) {
+                    throw new Error(`Failed to parse JSON content from file (${file.getPath()})`, { cause: e })
+                }
+
+                return {
+                    success: true,
+                    value: new JsonFileShape(file, json),
+                }
+            },
+        },
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            toSubclass(callExpression, { diagnostics }) {
+                if (callExpression.getCallee() !== 'JSON.stringify') {
+                    return { success: false }
+                }
+
+                if (callExpression.getArguments().length > 1) {
+                    diagnostics.error(
+                        callExpression.getArgument(1),
+                        'Additional arguments to JSON.stringify are not supported'
+                    )
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0)
+                if (!arg.isObject() && !arg.is(JsonFileShape)) {
+                    diagnostics.error(arg, 'Argument to JSON.stringify must be an object or an import from a JSON file')
+                    return { success: false }
+                }
+
+                return {
+                    success: true,
+                    value: new JsonStringifyShape({
+                        source: callExpression,
+                        json: arg.if(JsonFileShape)?.getJson() ?? arg,
+                    }),
+                }
+            },
+        },
+        {
+            shape: StringShape,
+            async commit(shape, target, { logger, transform, commit }) {
+                const result = await transform.toShape(target)
+                if (!result.success) {
+                    return { success: false }
+                }
+
+                const { value: targetShape } = result
+                if (targetShape.is(JsonStringifyShape)) {
+                    await commit(shape, targetShape.getJson().getOriginalNode())
+                    return { success: true }
+                }
+
+                if (!targetShape.isObject() && !targetShape.is(JsonFileShape)) {
+                    return { success: false }
+                }
+
+                let json: ObjectShape
+                try {
+                    json = Shape.from(shape, JSON5.parse(shape.getValue())).asObject()
+                } catch (e) {
+                    logger.info('Incoming string value could not be parsed as JSON and will overwrite the node')
+                    return { success: false }
+                }
+
+                await commit(json, (targetShape.if(JsonFileShape)?.getJson() ?? targetShape).getOriginalNode())
+                return { success: true }
+            },
+        },
+    ],
+})

package/src/list-plugin.ts

@@ -0,0 +1,222 @@
+import {
+    CallExpressionShape,
+    Plugin,
+    IdentifierShape,
+    Record,
+    StringShape,
+    type ObjectShape,
+    type Diagnostics,
+} from '@servicenow/sdk-build-core'
+import { create } from 'xmlbuilder2'
+import { generateDeprecatedDiagnostics } from './utils'
+
+const DEFAULT_VIEW = 'Default view'
+const listElementAliases = {
+    averageValue: ['average_value'],
+    maxValue: ['max_value'],
+    minValue: ['min_value'],
+}
+
+function generateListColumnProps(column: ObjectShape, index: number, diagnostics: Diagnostics) {
+    const props = column
+        .withAliasedKeys(listElementAliases)
+        .transform(({ $ }) => ({
+            element: $.from('element'),
+            position: $.from('position').map((p) => (p.ifUndefined() ? index : p)),
+            max_value: $.from('maxValue'),
+            min_value: $.from('minValue'),
+            average_value: $.from('averageValue'),
+            sum: $,
+        }))
+        .properties()
+    generateDeprecatedDiagnostics(column, diagnostics)
+    return props
+}
+
+export const ListPlugin = Plugin.create({
+    name: 'ListPlugin',
+    records: {
+        sys_ui_list: {
+            coalesce: ['name', 'view', 'sys_domain', 'element', 'relationship', 'parent'],
+            relationships: {
+                sys_ui_list_element: {
+                    via: 'list_id',
+                    descendant: true,
+                },
+                sys_ui_view: {
+                    via: 'view',
+                    inverse: true,
+                },
+            },
+            toShape(record, { descendants }) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'List',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                table: $.from('name').map((n) => n.ifString()?.getValue() ?? ''),
+                                view: $.map((v) =>
+                                    v.equals(DEFAULT_VIEW)
+                                        ? new IdentifierShape({ source: record, name: 'default_view' })
+                                        : (v.ifString() ?? v.toRecordId())
+                                ),
+                                parent: $.def(''),
+                                relationship: $.def(''),
+                                columns: $.val(
+                                    descendants
+                                        .query('sys_ui_list_element')
+                                        .sort(
+                                            (a, b) =>
+                                                a.get('position').toNumber().getValue() -
+                                                b.get('position').toNumber().getValue()
+                                        )
+                                        .map((element) => {
+                                            const averageValue = element.get('average_value').equals('true')
+                                            const maxValue = element.get('max_value').equals('true')
+                                            const minValue = element.get('min_value').equals('true')
+                                            const sum = element.get('sum').equals('true')
+
+                                            if (!averageValue && !minValue && !maxValue && !sum) {
+                                                // Element can be represented as a simple string because it does not have any special configuration
+                                                return element.get('element')
+                                            } else {
+                                                // Element has special configuration, so we need to return an object
+                                                return element
+                                                    .transform(({ $ }) => ({
+                                                        element: $.from('element'),
+                                                        averageValue: $.val(averageValue || undefined),
+                                                        maxValue: $.val(maxValue || undefined),
+                                                        minValue: $.val(minValue || undefined),
+                                                        sum: $.val(sum || undefined),
+                                                    }))
+                                                    .withAliasedKeys(listElementAliases)
+                                            }
+                                        })
+                                ),
+                            })),
+                        ],
+                    }),
+                }
+            },
+            toFile(list, { config, descendants }) {
+                if (!list.has('name')) {
+                    // Probably generated from a deleted key
+                    return { success: false }
+                }
+
+                const listName = list.get('name').asString().getValue()
+                const xml = create().ele('record_update')
+                const root = xml.ele('sys_ui_list', { table: listName })
+
+                descendants.query('sys_ui_list_element').forEach((element) => {
+                    const child = root.ele('sys_ui_list_element', { action: 'INSERT_OR_UPDATE' })
+                    child.ele('sys_id').txt(element.getId().getValue())
+                    child
+                        .ele('list_id', { display_value: listName, ...list.getId().resolveKeys() })
+                        .txt(list.getId().getValue())
+
+                    for (const prop of ['element', 'position', 'min_value', 'max_value', 'average_value', 'sum']) {
+                        element
+                            .get(prop)
+                            .ifDefined()
+                            ?.toString()
+                            .pipe((p) => child.ele(prop).txt(p.getValue()))
+                    }
+                })
+
+                const child = root.ele('sys_ui_list', { action: 'INSERT_OR_UPDATE' })
+                child.ele('sys_id').txt(list.getId().getValue())
+                child.ele('sys_scope', { display_value: config.scope }).txt(config.scopeId)
+
+                const view = list.get('view').toRecordId()
+                child.ele('view', view.resolveKeys()).txt(view.getValue())
+
+                const name = list.get('name')
+                if (name.isDefined()) {
+                    child.ele('name').txt(name.asString().getValue())
+                }
+
+                const parent = list.get('parent')
+                if (parent.isDefined()) {
+                    child.ele('parent').txt(parent.asString().getValue())
+                }
+
+                const relationship = list.get('relationship')
+                if (relationship.isDefined()) {
+                    child
+                        .ele('relationship', relationship.ifRecord()?.getId().resolveKeys())
+                        .txt(relationship.ifString()?.getValue() ?? relationship.asRecord().getId().getValue())
+                }
+
+                return {
+                    success: true,
+                    value: {
+                        name: `sys_ui_list_${list.getId().getValue()}.xml`,
+                        category: list.getInstallCategory(),
+                        content: xml.end({ prettyPrint: true }),
+                    },
+                }
+            },
+        },
+        sys_ui_list_element: {
+            coalesce: ['list_id', 'element'],
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory, diagnostics }) {
+                if (callExpression.getCallee() !== 'List') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject()
+                const columns = arg.get('columns').ifArray()?.getElements() ?? []
+                const list = factory.createRecord({
+                    source: callExpression,
+                    table: 'sys_ui_list',
+                    explicitId: arg.get('$id'),
+                    properties: arg.transform(({ $ }) => ({
+                        name: $.from('table'),
+                        view: $.map((v) =>
+                            v.ifString()
+                                ? factory.createReference({
+                                      source: v,
+                                      table: 'sys_ui_view',
+                                      keys: {
+                                          name: v,
+                                      },
+                                  })
+                                : v
+                        ),
+                        parent: $,
+                        relationship: $.map((v) => v.if([Record, StringShape])),
+                        sys_domain: $.val('global'), // TODO: Domain support?
+                    })),
+                })
+
+                return {
+                    success: true,
+                    value: list.with(
+                        ...columns.map((column, index) =>
+                            factory.createRecord({
+                                source: callExpression,
+                                table: 'sys_ui_list_element',
+                                properties: {
+                                    list_id: list,
+                                    position: index,
+                                    ...(column.isString()
+                                        ? { element: column }
+                                        : generateListColumnProps(column.asObject(), index, diagnostics)),
+                                },
+                            })
+                        )
+                    ),
+                }
+            },
+        },
+    ],
+})

package/src/now-config-plugin.ts

@@ -0,0 +1,194 @@
+import { NowConfig, ObjectShape, Plugin, Shape } from '@servicenow/sdk-build-core'
+
+import { JsonFileShape } from './json-plugin'
+
+export class NowConfigShape extends ObjectShape {}
+
+export const NowConfigPlugin = Plugin.create({
+    name: 'NowConfigPlugin',
+    files: [
+        {
+            matcher: /\Wnow\.config\.json$/,
+            entryPoint: true,
+        },
+    ],
+    records: {
+        sys_app: {
+            toShape(record, { packageJson }) {
+                const { name: packageName } = packageJson
+
+                return {
+                    success: true,
+                    value: new NowConfigShape({
+                        source: record,
+                        properties: record.transform(({ $ }) => ({
+                            name: $.toString().def(packageName),
+                            active: $.toBoolean().def(true),
+                            accessControls: $.from(
+                                'scoped_administration',
+                                'restrict_table_access',
+                                'can_edit_in_studio',
+                                'runtime_access_tracking',
+                                'private',
+                                'trackable',
+                                'uninstall_blocked',
+                                'hide_on_ui',
+                                'user_role'
+                            )
+                                .def({
+                                    scopedAdministration: false,
+                                    restrictTableAccess: false,
+                                    canEditInStudio: true,
+                                    runtimeAccessTracking: 'permissive',
+                                    private: false,
+                                    trackable: true,
+                                    uninstallBlocked: false,
+                                    hideOnUI: false,
+                                    userRole: '',
+                                })
+                                .map(
+                                    (
+                                        scoped_administration,
+                                        restrict_table_access,
+                                        can_edit_in_studio,
+                                        runtime_access_tracking,
+                                        p,
+                                        trackable,
+                                        uninstall_blocked,
+                                        hide_on_ui,
+                                        user_role
+                                    ) => ({
+                                        scopedAdministration: scoped_administration.ifBoolean()?.toBoolean(),
+                                        restrictTableAccess: restrict_table_access.ifBoolean()?.toBoolean(),
+                                        canEditInStudio: can_edit_in_studio.ifBoolean()?.toBoolean(),
+                                        runtimeAccessTracking:
+                                            runtime_access_tracking.toString().getValue() === ''
+                                                ? 'none'
+                                                : runtime_access_tracking.toString(),
+                                        private: p.ifBoolean()?.toBoolean(),
+                                        trackable: trackable.ifBoolean()?.toBoolean(),
+                                        uninstallBlocked: uninstall_blocked.ifBoolean()?.toBoolean(),
+                                        hideOnUI: hide_on_ui.ifBoolean()?.toBoolean(),
+                                        userRole: user_role.toString(),
+                                    })
+                                ),
+                            licensing: $.from(
+                                'licensable',
+                                'enforce_license',
+                                'license_model',
+                                'subscription_entitlement',
+                                'license_category'
+                            )
+                                .def({
+                                    licensable: true,
+                                    enforceLicense: 'log',
+                                    licenseModel: 'none',
+                                    subscriptionEntitlement: '',
+                                    licenseCategory: 'none',
+                                })
+                                .map(
+                                    (
+                                        licensable,
+                                        enforce_license,
+                                        license_model,
+                                        subscription_entitlement,
+                                        license_category
+                                    ) => ({
+                                        licensable: licensable.ifBoolean()?.toBoolean(),
+                                        enforceLicense: enforce_license.toString().getValue()
+                                            ? enforce_license.toString()
+                                            : 'log',
+                                        licenseModel: license_model.toString().getValue()
+                                            ? license_model.toString()
+                                            : 'none',
+                                        subscriptionEntitlement: subscription_entitlement.toString(),
+                                        licenseCategory: license_category.toString().getValue()
+                                            ? license_category.toString()
+                                            : 'none',
+                                    })
+                                ),
+
+                            jsLevel: $.from('js_level').toString().def('es_latest'),
+                            menu: $.toString().def(''),
+                            description: $.from('short_description').toString().def(''),
+                            logo: $.toString().def(''),
+                            guidedSetupGuid: $.from('guided_setup_guid').toString().def(''),
+                            installedAsDependency: $.from('installed_as_dependency').toBoolean().def(false),
+                        })),
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: JsonFileShape,
+            toRecord(file, { factory, config: rawConfig, packageJson }) {
+                if (file.getBaseName() !== NowConfig.FILE_NAME) {
+                    return { success: false }
+                }
+
+                const config = Shape.from(file.getJson(), rawConfig).asObject()
+                const scope = config.get('scope').asString().getValue()
+
+                const { name: packageName, version } = packageJson
+                const name = config.get('name').isDefined() ? config.get('name').asString().getValue() : packageName
+
+                const accessControls = config.get('accessControls').ifDefined()?.asObject()
+                const licensing = config.get('licensing').ifDefined()?.asObject()
+
+                return {
+                    success: true,
+                    value: factory.createRecord({
+                        source: config,
+                        table: 'sys_app',
+                        properties: config.transform(({ $ }) => ({
+                            active: $.toBoolean().def(true),
+                            scoped_administration: $.val(accessControls?.get('scopedAdministration'))
+                                .toBoolean()
+                                .def(false),
+                            can_edit_in_studio: $.val(accessControls?.get('canEditInStudio')).toBoolean().def(true),
+                            js_level: $.from('jsLevel').toString().def('es_latest'),
+                            restrict_table_access: $.val(accessControls?.get('restrictTableAccess'))
+                                .toBoolean()
+                                .def(false),
+                            runtime_access_tracking: $.map(() => {
+                                const rac = accessControls?.get('runtimeAccessTracking').getValue()
+                                if (!rac) {
+                                    return 'permissive'
+                                } else if (rac === 'none') {
+                                    return undefined
+                                }
+                                return rac
+                            }),
+                            licensable: $.val(licensing?.get('licensable')).toBoolean().def(true),
+                            enforce_license: $.val(licensing?.get('enforceLicense')).toString().def('log'),
+                            license_model: $.val(licensing?.get('licenseModel')).toString().def('none'),
+                            menu: $.toString().def(''),
+                            user_role: $.val(accessControls?.get('userRole')).toString().def(''),
+                            short_description: $.from('description').toString().def(''),
+                            logo: $.toString().def(''),
+                            guided_setup_guid: $.from('guidedSetupGuid').toString().def(''),
+                            subscription_entitlement: $.val(licensing?.get('subscriptionEntitlement'))
+                                .toString()
+                                .def(''),
+                            private: $.val(accessControls?.get('private')).toBoolean().def(false),
+                            trackable: $.val(accessControls?.get('trackable')).toBoolean().def(true),
+                            uninstall_blocked: $.val(accessControls?.get('uninstallBlocked')).toBoolean().def(false),
+                            hide_on_ui: $.val(accessControls?.get('hideOnUI')).toBoolean().def(false),
+                            installed_as_dependency: $.toBoolean().def(false),
+                            license_category: $.val(licensing?.get('licenseCategory')).toString().def('none'),
+
+                            scope: $.val(scope),
+                            package_json: $.val(`${scope}/${packageName}/${version}/package.json`),
+                            name: $.val(name),
+                            source: $.val(scope),
+                            sys_id: $.from('scopeId'),
+                            version: $.val(version),
+                        })),
+                    }),
+                }
+            },
+        },
+    ],
+})