@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/data-plugin.ts

@@ -3,17 +3,19 @@ import {
     type Shape,
     type Result,
     type Diagnostics,
+    CallExpressionShape,
     DurationShape,
     TimeShape,
     FieldListShape,
     TemplateValueShape,
-    CallExpressionShape,
-    ts,
     DATA_HELPER_NAMES,
+    ts,
 } from '@servicenow/sdk-build-core'
 import { getCallExpressionName } from './utils'
-import type { Duration, TimeOfDay } from '@servicenow/sdk-core/runtime/db'
 
+/**
+ * Check if a ts.Node is a data helper call expression.
+ */
 export function isDataHelper(node: ts.Node): boolean {
     if (!ts.Node.isCallExpression(node)) {
         return false
@@ -25,10 +27,11 @@ export function isDataHelper(node: ts.Node): boolean {
 /**
  * Shape creators for each data helper.
  * Maps helper function names to their shape creation logic.
+ * All data helper shapes extend CallExpressionShape.
  */
 const shapeCreators: Record<
     string,
-    (source: ts.CallExpression, shape: Shape, diagnostics: Diagnostics, secondArg?: string) => Result<Shape>
+    (shape: CallExpressionShape, diagnostics: Diagnostics) => Result<CallExpressionShape>
 > = {
     [DATA_HELPER_NAMES.DURATION]: createDurationShape,
     [DATA_HELPER_NAMES.TIME]: createTimeShape,
@@ -38,97 +41,19 @@ const shapeCreators: Record<
 
 export const DataPlugin = Plugin.create({
     name: 'DataPlugin',
-    nodes: [
+    shapes: [
         {
-            node: 'CallExpression',
+            shape: CallExpressionShape,
             fileTypes: ['fluent'],
-            entryPoint: true,
-            async toShape(node, { transform, diagnostics }) {
-                const callee = getCallExpressionName(node)
-                const args = node.getArguments()
-                const nodeData = args[0]
+            toSubclass(shape, { diagnostics }) {
+                const callee = shape.getCallee()
                 const shapeCreator = shapeCreators[callee]
-                if (!shapeCreator || !nodeData) {
+                // Only handle known data helper callees (Duration, Time, FieldList, TemplateValue)
+                if (!shapeCreator) {
                     return { success: false }
                 }
 
-                const result = await transform.toShape(nodeData)
-                if (!result.success) {
-                    return result
-                }
-
-                // Extract optional second argument (e.g., timezone for Time helper)
-                let secondArg: string | undefined
-                if (callee === DATA_HELPER_NAMES.TIME && args[1]) {
-                    if (!ts.Node.isStringLiteral(args[1])) {
-                        diagnostics.error(args[1], 'Second argument must be a string literal')
-                        return { success: false }
-                    }
-                    secondArg = args[1].getLiteralValue()
-                }
-
-                return shapeCreator(node, result.value, diagnostics, secondArg)
-            },
-        },
-    ],
-    shapes: [
-        {
-            shape: DurationShape,
-            async commit(shape, target, { commit }) {
-                const durationExpression = new CallExpressionShape({
-                    source: shape.getSource(),
-                    callee: DATA_HELPER_NAMES.DURATION,
-                    args: [shape.getDuration()],
-                })
-
-                await commit(durationExpression, target)
-                return { success: true }
-            },
-        },
-        {
-            shape: TimeShape,
-            async commit(shape, target, { commit }) {
-                const args: unknown[] = [shape.getTimeData()]
-                // Preserve timezone if it was specified in the source code
-                const timeZone = shape.getTimeZone()
-                if (timeZone) {
-                    args.push(timeZone)
-                }
-
-                const timeExpression = new CallExpressionShape({
-                    source: shape.getSource(),
-                    callee: DATA_HELPER_NAMES.TIME,
-                    args,
-                })
-
-                await commit(timeExpression, target)
-                return { success: true }
-            },
-        },
-        {
-            shape: FieldListShape,
-            async commit(shape, target, { commit }) {
-                const fieldListExpression = new CallExpressionShape({
-                    source: shape.getSource(),
-                    callee: DATA_HELPER_NAMES.FIELD_LIST,
-                    args: [shape.getFields()],
-                })
-
-                await commit(fieldListExpression, target)
-                return { success: true }
-            },
-        },
-        {
-            shape: TemplateValueShape,
-            async commit(shape, target, { commit }) {
-                const templateValueExpression = new CallExpressionShape({
-                    source: shape.getSource(),
-                    callee: DATA_HELPER_NAMES.TEMPLATE_VALUE,
-                    args: [shape.getValue()],
-                })
-
-                await commit(templateValueExpression, target)
-                return { success: true }
+                return shapeCreator(shape, diagnostics)
             },
         },
     ],
@@ -136,121 +61,124 @@ export const DataPlugin = Plugin.create({
 
 /**
  * Helper to validate that all defined fields are non-negative.
- * Returns array of error messages for invalid fields.
+ * Returns errors for negative values
  */
-function validateNonNegative(data: Record<string, number | undefined>, fields: string[]): string[] {
-    return fields
-        .filter((field) => data[field] !== undefined && (data[field] as number) < 0)
-        .map((field) => `${field} must be >= 0, got ${data[field]}`)
+function validateNonNegative(data: Record<string, Shape>, fields: string[]): string[] {
+    const errors: string[] = []
+    for (const field of fields) {
+        const value = data[field]
+        if (!value?.isDefined() || !value.isNumber()) {
+            continue // Skip undefined or non-numeric (will be caught by constructor)
+        }
+        const numericValue = value.asNumber().getValue()
+        if (numericValue < 0) {
+            errors.push(`${field} must be >= 0, got ${numericValue}`)
+        }
+    }
+    return errors
 }
 
 /**
  * Helper to validate that at least one field is defined.
  * Returns true if at least one field has a defined value.
  */
-function hasAtLeastOneField(data: Record<string, number | undefined>, fields: string[]): boolean {
-    return fields.some((field) => data[field] !== undefined)
+function hasAtLeastOneField(data: Record<string, Shape>, fields: string[]): boolean {
+    return fields.some((field) => data[field]?.isDefined())
 }
 
 /**
- * Creates a DurationShape from an ObjectShape.
+ * Creates a DurationShape from a CallExpressionShape.
  * Validates that duration values are within acceptable ranges.
  */
-function createDurationShape(source: ts.CallExpression, shape: Shape, diagnostics: Diagnostics): Result<DurationShape> {
-    const duration = shape.asObject().getValue() as Duration
+function createDurationShape(shape: CallExpressionShape, diagnostics: Diagnostics): Result<DurationShape> {
+    const argShape = shape.getArgument(0)
+    const duration = argShape.asObject().properties({ resolve: false })
 
     // Validate at least one field is provided
     if (!hasAtLeastOneField(duration, ['days', 'hours', 'minutes', 'seconds'])) {
-        diagnostics.error(source, 'Duration must have at least one field defined (days, hours, minutes, or seconds)')
+        diagnostics.error(shape, 'Duration must have at least one field defined (days, hours, minutes, or seconds)')
         return { success: false }
     }
 
     const errors = validateNonNegative(duration, ['days', 'hours', 'minutes', 'seconds'])
 
     if (errors.length > 0) {
-        diagnostics.error(source, `Invalid duration values: ${errors.join(', ')}`)
+        diagnostics.error(shape, `Invalid duration values: ${errors.join(', ')}`)
         return { success: false }
     }
 
-    return { success: true, value: new DurationShape({ source, value: duration }) }
+    return { success: true, value: new DurationShape({ source: shape, value: argShape.asObject() }) }
 }
 
 /**
- * Creates a TimeShape from an ObjectShape.
+ * Creates a TimeShape from a CallExpressionShape.
  * Validates that time values are within acceptable ranges.
- * @param source - The source CallExpression node
- * @param shape - The shape containing time data
- * @param diagnostics - Diagnostics for error reporting
- * @param timeZone - Optional IANA timezone string (e.g., 'America/New_York')
  */
-function createTimeShape(
-    source: ts.CallExpression,
-    shape: Shape,
-    diagnostics: Diagnostics,
-    timeZone?: string
-): Result<TimeShape> {
-    const timeData = shape.asObject().getValue() as TimeOfDay
+function createTimeShape(shape: CallExpressionShape, diagnostics: Diagnostics): Result<TimeShape> {
+    const argShape = shape.getArgument(0)
+    const timeData = argShape.asObject().properties({ resolve: false })
 
     // Validate at least one field is provided
     if (!hasAtLeastOneField(timeData, ['hours', 'minutes', 'seconds'])) {
-        diagnostics.error(source, 'Time must have at least one field defined (hours, minutes, or seconds)')
+        diagnostics.error(shape, 'Time must have at least one field defined (hours, minutes, or seconds)')
         return { success: false }
     }
 
     const errors = validateNonNegative(timeData, ['hours', 'minutes', 'seconds'])
 
     if (errors.length > 0) {
-        diagnostics.error(source, `Invalid time values: ${errors.join(', ')}`)
+        diagnostics.error(shape, `Invalid time values: ${errors.join(', ')}`)
         return { success: false }
     }
 
-    // Validate timezone if provided
-    if (timeZone && !isValidTimeZone(timeZone)) {
+    // Extract and validate optional timezone from second argument
+    const tzArg = shape.getArgument(1)
+    if (tzArg.isUndefined()) {
+        return { success: true, value: new TimeShape({ source: shape, value: argShape.asObject() }) }
+    }
+
+    if (!tzArg.isString()) {
+        diagnostics.error(shape, 'Second argument (timezone) must be a string literal')
+        return { success: false }
+    }
+    const timeZone = tzArg.asString().getValue()
+    if (!isValidTimeZone(timeZone)) {
         diagnostics.error(
-            source,
+            shape,
             `Invalid IANA timezone: '${timeZone}'. Use a valid timezone like 'America/New_York', 'Europe/London', or 'UTC'.`
         )
         return { success: false }
     }
 
-    return { success: true, value: new TimeShape({ source, value: timeData, timeZone }) }
+    return { success: true, value: new TimeShape({ source: shape, value: argShape.asObject(), timeZone }) }
 }
 
 /**
- * Creates a FieldListShape from an ArrayShape.
+ * Creates a FieldListShape from a CallExpressionShape.
  */
-function createFieldListShape(
-    source: ts.CallExpression,
-    shape: Shape,
-    _diagnostics: Diagnostics
-): Result<FieldListShape> {
-    const fields = shape.asArray().getElements()
-    const fieldListShape = new FieldListShape({ source, fields })
-    return { success: true, value: fieldListShape }
+function createFieldListShape(shape: CallExpressionShape, _diagnostics: Diagnostics): Result<FieldListShape> {
+    const fields = shape.getArgument(0).asArray().getElements()
+    return { success: true, value: new FieldListShape({ source: shape, fields }) }
 }
 
 /**
- * Creates a TemplateValueShape from an ObjectShape.
+ * Creates a TemplateValueShape from a CallExpressionShape.
  */
-function createTemplateValueShape(
-    source: ts.CallExpression,
-    shape: Shape,
-    diagnostics: Diagnostics
-): Result<TemplateValueShape> {
-    const value = shape.asObject().getValue()
+function createTemplateValueShape(shape: CallExpressionShape, diagnostics: Diagnostics): Result<TemplateValueShape> {
+    const value = shape.getArgument(0).asObject().properties({ resolve: false })
 
     // Validate that values don't contain ^^ (double caret)
     for (const [key, val] of Object.entries(value)) {
-        if (typeof val === 'string' && val.includes('^^')) {
+        if (val.isString() && val.getValue().includes('^^')) {
             diagnostics.error(
-                source,
+                shape,
                 `Template field '${key}' contains an invalid character sequence: multiple carets (^^). Use a single caret (^) if needed, it will be escaped automatically.`
             )
             return { success: false }
         }
     }
 
-    return { success: true, value: new TemplateValueShape({ source, value }) }
+    return { success: true, value: new TemplateValueShape({ source: shape, value }) }
 }
 
 /**