@servicenow/sdk-build-plugins 2.0.1

package/src/DefaultPlugin.ts

@@ -0,0 +1,272 @@
+import { isSupportedNode } from '@servicenow/sdk-project'
+import {
+    getValueDeclaration,
+    Plugin,
+    BooleanData,
+    FluentDiagnostic,
+    StringData,
+    NumberData,
+    Data,
+    ArrayData,
+    ObjectData,
+} from '@servicenow/sdk-build-core'
+import * as ts from 'ts-morph'
+
+export default Plugin({
+    name: 'Default',
+    extractors: {
+        raw: {
+            TrueKeyword(node) {
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [new BooleanData(true, node)],
+                }
+            },
+
+            FalseKeyword(node) {
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [new BooleanData(false, node)],
+                }
+            },
+
+            StringLiteral(node) {
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [new StringData(node.getLiteralValue(), node)],
+                }
+            },
+
+            NoSubstitutionTemplateLiteral(node) {
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [new StringData(node.getLiteralValue(), node)],
+                }
+            },
+
+            NumericLiteral(node) {
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [new NumberData(node.getLiteralValue(), node)],
+                }
+            },
+
+            AsExpression(node, context) {
+                return context.extractAst(node.getExpression())
+            },
+
+            ComputedPropertyName(node, context) {
+                return context.extractAst(node.getExpression())
+            },
+
+            Identifier(node, context) {
+                return context.extractAst(getValueDeclaration(node))
+            },
+
+            PropertyAccessExpression(node, context) {
+                return context.extractAst(node.getNameNode())
+            },
+
+            ShorthandPropertyAssignment(node, context) {
+                return context.extractAst(node.getNameNode())
+            },
+
+            VariableDeclaration(node, context) {
+                const initializer = node.getInitializer()
+                if (!initializer) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [
+                            new FluentDiagnostic(
+                                node,
+                                `Expected variable declaration to have an initializer: ${node.getText()}`
+                            ),
+                        ],
+                    }
+                }
+
+                return context.extractAst(initializer)
+            },
+
+            PropertyAssignment(node, context) {
+                const initializer = node.getInitializer()
+                if (!initializer) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [
+                            new FluentDiagnostic(
+                                node,
+                                `Expected property assignment to have an initializer: ${node.getText()}`
+                            ),
+                        ],
+                    }
+                }
+
+                return context.extractAst(initializer)
+            },
+
+            ArrayLiteralExpression(node, context) {
+                const diagnostics: FluentDiagnostic[] = []
+                const data: Data[] = []
+
+                for (const element of node.getElements()) {
+                    const result = context.extractAst(element)
+                    if (!result.handled) {
+                        return {
+                            handled: true,
+                            data: [],
+                            diagnostics: [new FluentDiagnostic(element, 'Unsupported array element')],
+                        }
+                    }
+
+                    diagnostics.push(...result.diagnostics)
+                    data.push(...result.data)
+                }
+
+                return {
+                    handled: true,
+                    diagnostics,
+                    data: [new ArrayData(data, node)],
+                }
+            },
+
+            ObjectLiteralExpression(node, context) {
+                const diagnostics: FluentDiagnostic[] = []
+                const data: Record<string, Data> = {}
+
+                for (const prop of node.getProperties()) {
+                    if (!ts.Node.isPropertyAssignment(prop) && !ts.Node.isShorthandPropertyAssignment(prop)) {
+                        diagnostics.push(new FluentDiagnostic(prop, 'Only property assignments are allowed'))
+                        continue
+                    }
+
+                    const nameNode = prop.getNameNode()
+                    const result = context.extractAst(prop)
+                    if (!result.handled) {
+                        return {
+                            handled: true,
+                            data: [],
+                            diagnostics: [new FluentDiagnostic(prop, 'Unsupported property assignment')],
+                        }
+                    }
+
+                    diagnostics.push(...result.diagnostics)
+                    if (!(0 in result.data) || result.data.length !== 1) {
+                        diagnostics.push(new FluentDiagnostic(prop, `Property assignment has unsupported structure`))
+                        continue
+                    }
+
+                    const name = ts.Node.isStringLiteral(nameNode) ? nameNode.getLiteralValue() : prop.getName()
+                    data[name] = result.data[0]
+                }
+
+                return {
+                    handled: true,
+                    diagnostics,
+                    data: [new ObjectData(data, node)],
+                }
+            },
+
+            TemplateExpression(node, context) {
+                const diagnostics: FluentDiagnostic[] = []
+                const text =
+                    node.getHead().getLiteralText() +
+                    node
+                        .getTemplateSpans()
+                        .map((s) => {
+                            const result = context.extractAst(s.getExpression())
+                            if (!result.handled) {
+                                diagnostics.push(new FluentDiagnostic(s, 'Unsupported expression in template'))
+                                return undefined
+                            }
+
+                            if (!(0 in result.data) || result.data.length !== 1) {
+                                diagnostics.push(new FluentDiagnostic(s, `Unsupported expression in template`))
+                                return undefined
+                            }
+
+                            diagnostics.push(...result.diagnostics)
+                            return `${result.data[0].getValue()}${s.getLiteral().getLiteralText()}`
+                        })
+                        .join('')
+
+                return {
+                    handled: true,
+                    diagnostics,
+                    data: [new StringData(text, node)],
+                }
+            },
+
+            //Added support for -ve number alone. Can be upgraded later to support other expressions as required.
+            PrefixUnaryExpression(node) {
+                if (
+                    !ts.Node.isNumericLiteral(node.getOperand()) ||
+                    node.getOperatorToken() !== ts.SyntaxKind.MinusToken
+                ) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [new FluentDiagnostic(node, 'Unsupported prefix unary expression')],
+                    }
+                }
+
+                return {
+                    handled: true,
+                    diagnostics: [],
+                    data: [
+                        new NumberData(
+                            -node.getOperand().asKind(ts.SyntaxKind.NumericLiteral)!.getLiteralValue(),
+                            node
+                        ),
+                    ],
+                }
+            },
+        },
+    },
+    diagnostics: {
+        Node(node) {
+            if (isSupportedNode(node)) {
+                return []
+            }
+
+            return [new FluentDiagnostic(node, `${getRawKindName(node)} is not allowed`)]
+        },
+    },
+})
+
+let rawKindNames: Record<ts.SyntaxKind, string> | undefined
+
+/**
+ * This is a hack to get more accurate names for given syntax kinds. TypeScript's
+ * `SyntaxKind` enum has a lot of reused numeric values, so when you try to index
+ * it with a number, you might get a different name than you expect. For example,
+ * `VariableStatement` and `FirstStatement` both have the same numeric value, and
+ * you probably never would expect the latter. Thankfully, all the names that you
+ * probably never want are towards the end, so this just grabs all the first ones
+ * and ignores any duplicates that come after.
+ */
+function getRawKindName(node: ts.Node): string | undefined {
+    if (!rawKindNames) {
+        rawKindNames = Object.entries(ts.SyntaxKind)
+            .filter(([k]) => isNaN(Number(k)))
+            .reduce(
+                (names, [name, value]) => {
+                    if (typeof value === 'number' && !names[value]) {
+                        names[value] = name // Only add if it hasn't been added already
+                    }
+
+                    return names
+                },
+                {} as Record<ts.SyntaxKind, string>
+            )
+    }
+
+    return rawKindNames[node.getKind()]
+}

package/src/IdPlugin.ts

@@ -0,0 +1,47 @@
+import { isSupportedNode } from '@servicenow/sdk-project'
+import { ElementAccessExpression, SyntaxKind } from 'ts-morph'
+import { Plugin, FluentDiagnostic } from '@servicenow/sdk-build-core'
+
+export default Plugin({
+    name: 'NowID',
+    extractors: {
+        raw: {
+            ElementAccessExpression(node: ElementAccessExpression, context) {
+                const nowIdExpression = node.getExpressionIfKind(SyntaxKind.PropertyAccessExpression)
+                if (!nowIdExpression || nowIdExpression.getText() !== 'Now.ID') {
+                    return {
+                        handled: false,
+                    }
+                }
+
+                const argExpression = node.getArgumentExpression()
+                if (!argExpression || !isSupportedNode(argExpression)) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [new FluentDiagnostic(node, 'Now.ID must have an argument')],
+                    }
+                }
+
+                const result = context.extractRaw(argExpression)
+                if (!result.handled) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [new FluentDiagnostic(node, 'Unsupported Now.ID argument')],
+                    }
+                }
+
+                if (!(0 in result.data) || result.data.length !== 1) {
+                    return {
+                        handled: true,
+                        data: [],
+                        diagnostics: [...result.diagnostics, new FluentDiagnostic(node, 'Unsupported Now.ID argument')],
+                    }
+                }
+
+                return result
+            },
+        },
+    },
+})