@servicenow/sdk-build-plugins 3.0.2 → 4.0.0

package/src/role-plugin.ts

@@ -0,0 +1,128 @@
+import { isSNScope } from '@servicenow/sdk-build-core'
+import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
+import { generateDeprecatedDiagnostics } from './utils'
+
+const roleAliases = {
+    canDelegate: ['can_delegate'],
+    elevatedPrivilege: ['elevated_privilege'],
+    assignableBy: ['assignable_by'],
+    containsRoles: ['contains_roles'],
+    scopedAdmin: ['scoped_admin'],
+}
+
+export const RolePlugin = Plugin.create({
+    name: 'RolePlugin',
+    records: {
+        sys_user_role: {
+            relationships: {
+                sys_user_role_contains: {
+                    via: 'role',
+                    descendant: true,
+                    relationships: {
+                        sys_user_role: {
+                            via: 'contains',
+                            inverse: true,
+                        },
+                    },
+                },
+            },
+            coalesce: ['name'],
+            toShape(record, { descendants }) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'Role',
+                        args: [
+                            record
+                                .transform(({ $ }) => ({
+                                    name: $,
+                                    assignableBy: $.from('assignable_by').def(''),
+                                    description: $.def(''),
+                                    canDelegate: $.from('can_delegate').toBoolean().def(true),
+                                    elevatedPrivilege: $.from('elevated_privilege').toBoolean().def(false),
+                                    grantable: $.toBoolean().def(true),
+                                    scopedAdmin: $.from('scoped_admin').toBoolean().def(false),
+                                    containsRoles: $.val(
+                                        descendants
+                                            .query('sys_user_role_contains')
+                                            .map((m2m) => m2m.get('contains').toRecordId())
+                                    ).def([]),
+                                }))
+                                .withAliasedKeys(roleAliases),
+                        ],
+                    }),
+                }
+            },
+        },
+        sys_user_role_contains: {
+            coalesce: ['role', 'contains'],
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { config, diagnostics, factory }) {
+                if (callExpression.getCallee() !== 'Role') {
+                    return { success: false }
+                }
+
+                const arg = callExpression.getArgument(0).asObject().withAliasedKeys(roleAliases)
+                generateDeprecatedDiagnostics(arg, diagnostics)
+
+                const scope = config.scope
+                const name = arg.get('name').asString()
+                if (scope !== 'global' && !isSNScope(scope) && !name.getValue().startsWith(`${scope}.`)) {
+                    diagnostics.error(name.getOriginalNode(), `Role name must begin with '${scope}.'`)
+                }
+
+                const role = factory.createRecord({
+                    explicitId: arg.get('$id'),
+                    source: callExpression,
+                    table: 'sys_user_role',
+                    properties: arg.transform(({ $ }) => ({
+                        name: $,
+                        assignable_by: $.from('assignableBy').def(''),
+                        can_delegate: $.from('canDelegate').def(true),
+                        description: $.def(''),
+                        elevated_privilege: $.from('elevatedPrivilege').def(false),
+                        grantable: $.def(true),
+                        scoped_admin: $.from('scopedAdmin').def(false),
+                        suffix: $.from('name').map((v) =>
+                            v
+                                .asString()
+                                .getValue()
+                                .replace(new RegExp(`^${config.scope}\\.`), '')
+                        ),
+                    })),
+                })
+
+                const containedRoles = arg
+                    .get('containsRoles')
+                    .ifArray()
+                    ?.map((e) =>
+                        factory.createRecord({
+                            source: callExpression,
+                            table: 'sys_user_role_contains',
+                            properties: {
+                                role,
+                                contains:
+                                    e.ifStringLiteral()?.pipe((roleName) =>
+                                        factory.createReference({
+                                            source: roleName,
+                                            table: 'sys_user_role',
+                                            keys: { name: roleName },
+                                        })
+                                    ) ?? e,
+                            },
+                        })
+                    )
+                return {
+                    success: true,
+                    value: role.with(...(containedRoles ?? [])),
+                }
+            },
+        },
+    ],
+})

package/src/script-action-plugin.ts

@@ -0,0 +1,63 @@
+import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+import { ModuleFunctionShape } from './server-module-plugin'
+
+export const ScriptActionPlugin = Plugin.create({
+    name: 'ScriptActionPlugin',
+    records: {
+        sysevent_script_action: {
+            toShape(record) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'ScriptAction',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                description: $.def(''),
+                                eventName: $.from('event_name'),
+                                active: $.toBoolean().def(false),
+                                conditionScript: $.from('condition_script').def(''),
+                                script: $,
+                                order: $.toNumber().def(100),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory }) {
+                if (callExpression.getCallee() !== 'ScriptAction') {
+                    return { success: false }
+                }
+
+                const args = callExpression.getArgument(0).asObject()
+                const record = factory.createRecord({
+                    source: callExpression,
+                    table: 'sysevent_script_action',
+                    explicitId: args.get('$id'),
+                    properties: args.transform(({ $ }) => ({
+                        name: $,
+                        description: $.def(''),
+                        event_name: $.from('eventName'),
+                        active: $.def(false),
+                        condition_script: $.from('conditionScript').toCdata(),
+                        script: $.map(
+                            (v) => v.if(ModuleFunctionShape)?.toString((n) => `${n}({{PARAMS}})`) ?? v
+                        ).toCdata(),
+                        order: $.def(100),
+                    })),
+                })
+
+                return { success: true, value: record }
+            },
+        },
+    ],
+})

package/src/script-include-plugin.ts

@@ -0,0 +1,110 @@
+import { CallExpressionShape, isSNScope, Plugin } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+
+const nameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]+$/
+
+export const ScriptIncludePlugin = Plugin.create({
+    name: `ScriptIncludePlugin`,
+    records: {
+        sys_script_include: {
+            toShape(record) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'ScriptInclude',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                name: $,
+                                script: $,
+                                description: $.def(''),
+                                apiName: $.from('api_name').def(``),
+                                callerAccess: $.from('caller_access').map((v) =>
+                                    v
+                                        .ifString()
+                                        ?.pipe((v) =>
+                                            v.equals('1') ? 'tracking' : v.equals('2') ? 'restriction' : undefined
+                                        )
+                                ),
+                                clientCallable: $.from('client_callable').toBoolean(),
+                                mobileCallable: $.from('mobile_callable').toBoolean(),
+                                sandboxCallable: $.from('sandbox_callable').toBoolean(),
+                                accessibleFrom: $.from('access').def('package_private'),
+                                active: $.toBoolean(),
+                                protectionPolicy: $.from('sys_policy').def(''),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(shape, { factory, config, diagnostics }) {
+                if (shape.getCallee() !== 'ScriptInclude') {
+                    return { success: false }
+                }
+
+                const prop = shape.getArgument(0).asObject()
+                const name = prop.get('name').asString()
+
+                if (!nameRegex.test(name.getValue())) {
+                    diagnostics.error(name.getOriginalNode(), `name must be a valid JavaScript identifier`)
+                }
+
+                const apiName = prop.get('apiName')
+
+                if (apiName.isDefined()) {
+                    const scope = config.scope
+                    if (!isSNScope(scope) && !apiName.asString().getValue().startsWith(`${scope}.`)) {
+                        diagnostics.error(apiName.getOriginalNode(), `apiName must begin with '${scope}.'`)
+                    }
+                }
+
+                return {
+                    success: true,
+                    value: factory.createRecord({
+                        source: shape,
+                        table: 'sys_script_include',
+                        explicitId: prop.get('$id'),
+                        properties: prop.transform(({ $ }) => {
+                            return {
+                                name: $,
+                                script: $.toCdata(),
+                                description: $,
+                                api_name: $.from('apiName').def(`${config.scope}.${name.getValue()}`),
+                                caller_access: $.from('callerAccess')
+                                    .map((v) => {
+                                        if (v.isUndefined()) {
+                                            return undefined
+                                        }
+
+                                        const t = v.asString().getValue() as 'restriction' | 'tracking'
+                                        switch (t) {
+                                            case 'restriction':
+                                                return 2
+                                            case 'tracking':
+                                                return 1
+                                            default:
+                                                return undefined
+                                        }
+                                    })
+                                    .def(''),
+                                client_callable: $.from('clientCallable').def(false),
+                                mobile_callable: $.from('mobileCallable').def(false),
+                                sandbox_callable: $.from('sandboxCallable').def(false),
+                                access: $.from('accessibleFrom').def('package_private'),
+                                active: $.def(true),
+                                sys_policy: $.from('protectionPolicy'),
+                            }
+                        }),
+                    }),
+                }
+            },
+        },
+    ],
+})