@servicenow/sdk-build-plugins 3.0.3 → 4.0.1

package/src/application-menu-plugin.ts

@@ -0,0 +1,109 @@
+import { CallExpressionShape, Plugin } from '@servicenow/sdk-build-core'
+import { NowIdShape } from './now-id-plugin'
+
+/**
+ * Creates an Application Menu (`sys_app_application`).
+ *
+ * @see https://docs.servicenow.com/csh?topicname=app-menu-api-now-ts.html&version=latest
+ *
+ * @param config - an object containing the following properties:
+ *   * **$id** - unique id for the record, typically using `Now.ID["value"]`
+ *   * **category** - The variable identifier of a menu category that defines the navigation menu style.
+ *   * **title** - The label for the menu in the application navigator.
+ *   * **active**? - whether the record is enabled
+ *   * **description**? - Additional information about what the application does.
+ *   * **hint**? - The tooltip text that appears when a user hovers over the menu.
+ *   * **name**? - An internal name to differentiate between applications with the same title.
+ *   * **order**? - The relative position of the application menu in the application navigator.
+ *   * **roles**? - A list of variable identifiers of `Role` objects or names of roles that can access the menu. @see {Role}
+ */
+export const ApplicationMenuPlugin = Plugin.create({
+    name: 'ApplicationMenuPlugin',
+    records: {
+        sys_app_application: {
+            relationships: {
+                sys_app_category: {
+                    via: 'category',
+                    inverse: true,
+                },
+                sys_app_application: {
+                    via: 'sys_overrides',
+                    inverse: true,
+                },
+            },
+            toShape(record, { factory }) {
+                return {
+                    success: true,
+                    value: new CallExpressionShape({
+                        source: record,
+                        callee: 'ApplicationMenu',
+                        args: [
+                            record.transform(({ $ }) => ({
+                                $id: $.val(NowIdShape.from(record)),
+                                title: $,
+                                category: $,
+                                hint: $.def(''),
+                                description: $.def(''),
+                                name: $.def(''),
+                                active: $.toBoolean().def(true),
+                                order: $.map((v) => v.ifString()?.ifNotEmpty()?.toNumber()).def(100),
+                                roles: $.map((v) => {
+                                    const roleNames =
+                                        v.isString() && v.asString().getValue() !== '' ? v.asString().split(',') : []
+                                    return roleNames.map((roleName) =>
+                                        factory.createReference({
+                                            source: v,
+                                            table: 'sys_user_role',
+                                            keys: { name: roleName },
+                                        })
+                                    )
+                                }).def([]),
+                            })),
+                        ],
+                    }),
+                }
+            },
+        },
+    },
+    shapes: [
+        {
+            shape: CallExpressionShape,
+            fileTypes: ['fluent'],
+            async toRecord(callExpression, { factory }) {
+                if (callExpression.getCallee() !== 'ApplicationMenu') {
+                    return { success: false }
+                }
+
+                return {
+                    success: true,
+                    value: callExpression
+                        .getArgument(0)
+                        .asObject()
+                        .pipe((menu) =>
+                            factory.createRecord({
+                                source: callExpression,
+                                table: 'sys_app_application',
+                                explicitId: menu.get('$id'),
+                                properties: menu.transform(({ $ }) => ({
+                                    title: $,
+                                    hint: $.def(''),
+                                    description: $.def(''),
+                                    name: $.def(''),
+                                    active: $.def(true),
+                                    order: $.def(100),
+                                    device_type: $.val('browser'),
+                                    roles: $.map((v) =>
+                                        v
+                                            .ifArray()
+                                            ?.map((r) => (r.ifRecord()?.get('name') ?? r.asString()).getValue())
+                                            .join(',')
+                                    ).def(''),
+                                    category: $,
+                                })),
+                            })
+                        ),
+                }
+            },
+        },
+    ],
+})

package/src/arrow-function-plugin.ts

@@ -0,0 +1,127 @@
+import { Plugin, Shape, type Source, ts, IdentifierShape, type StringShape } from '@servicenow/sdk-build-core'
+
+export class ArrowFunctionShape extends Shape {
+    private readonly parameters: IdentifierShape[]
+    private readonly statements: Shape[]
+
+    constructor({
+        source,
+        parameters,
+        statements,
+    }: {
+        source: Source
+        parameters?: (IdentifierShape | StringShape | string)[]
+        statements?: Shape[]
+    }) {
+        super({ source })
+        this.parameters = (parameters ?? []).map((s) =>
+            s instanceof IdentifierShape
+                ? s
+                : new IdentifierShape({
+                      source,
+                      name: typeof s === 'string' ? s : s.getValue(),
+                  })
+        )
+        this.statements = statements ?? []
+    }
+
+    getParameters(): IdentifierShape[] {
+        return this.parameters
+    }
+
+    getParameter(index: number): IdentifierShape {
+        const parameter = this.parameters[index]
+        if (!parameter) {
+            throw new Error(`Arrow function does not have a parameter at index: ${index}`)
+        }
+
+        return parameter
+    }
+
+    getStatements(): Shape[] {
+        return this.statements
+    }
+
+    getStatement(index: number): Shape {
+        const statement = this.statements[index]
+        if (!statement) {
+            throw new Error(`Arrow function does not have a statement at index: ${index}`)
+        }
+
+        return statement
+    }
+
+    override getCode(): string {
+        return `(${this.getParameters()
+            .map((p) => p.getCode())
+            .join(', ')}) => {\n    ${this.getStatements()
+            .map((s) => s.getCode())
+            .join('\n    ')}\n}`
+    }
+}
+
+export const ArrowFunctionPlugin = Plugin.create({
+    name: 'ArrowFunctionPlugin',
+    nodes: [
+        {
+            node: 'ArrowFunction',
+            fileTypes: ['fluent'],
+            async toShape(node, { transform, diagnostics }) {
+                const parameters: IdentifierShape[] = []
+                for (const param of node.getParameters()) {
+                    const result = await transform.toShape(param)
+                    if (result.success && result.value.isIdentifier()) {
+                        parameters.push(result.value)
+                    } else {
+                        diagnostics.error(param, 'Unsupported parameter in arrow function')
+                        return { success: false }
+                    }
+                }
+
+                const statements: Shape[] = []
+                for (const statement of node.getStatements()) {
+                    const result = await transform.toShape(statement)
+                    if (!result.success) {
+                        diagnostics.error(statement, 'Unsupported statement in arrow function body')
+                        return { success: false }
+                    }
+
+                    statements.push(result.value)
+                }
+
+                return {
+                    success: true,
+                    value: new ArrowFunctionShape({
+                        source: node,
+                        parameters,
+                        statements,
+                    }),
+                }
+            },
+        },
+    ],
+    shapes: [
+        {
+            shape: ArrowFunctionShape,
+            async commit(shape, target, { commit }) {
+                const arrowFunction = ts.Node.isArrowFunction(target)
+                    ? target
+                    : target.replaceWithText('() => {}').asKindOrThrow(ts.SyntaxKind.ArrowFunction)
+
+                const nodeStatements = arrowFunction.getStatements()
+                const shapeStatements = shape.getStatements()
+                const excess = nodeStatements.length - shapeStatements.length
+                for (let i = 1; i <= excess; i++) {
+                    arrowFunction.removeStatement(nodeStatements.length - i)
+                }
+
+                for (const [i, statement] of shapeStatements.entries()) {
+                    const targetStatement = nodeStatements[i] ?? arrowFunction.addStatements('undefined')[0]!
+                    await commit(statement, targetStatement)
+                }
+
+                return { success: true }
+            },
+        },
+    ],
+})