@servicenow/sdk-build-plugins 4.2.0 → 4.4.0

package/src/flow/utils/utils.ts

@@ -0,0 +1,395 @@
+import {
+    CallExpressionShape,
+    type Database,
+    type Diagnostics,
+    type IdentifierShape,
+    type Logger,
+    type ObjectShape,
+    type PropertyAccessShape,
+    type Record,
+    type Shape,
+    type TemplateExpressionShape,
+    type Transform,
+    ts,
+    VariableStatementShape,
+} from '@servicenow/sdk-build-core'
+import { PillShape, PillTemplateShape } from '../utils/data-pill-shapes'
+import { DataPillPlugin } from '../plugins/flow-data-pill-plugin'
+import { TriggerInstancePlugin } from '../plugins/flow-trigger-instance-plugin'
+import { CallExpressionPlugin } from '../../call-expression-plugin'
+import { FlowLogicPlugin } from '../flow-logic/flow-logic-plugin'
+import { FlowInstancePlugin } from '../plugins/flow-instance-plugin'
+import { FDInstanceShape } from './flow-shapes'
+import { CORE_ACTIONS_PREFIX, CORE_ACTIONS_SYS_ID_NAME_MAP, UNSUPPORTED_FLOW_DESCENDANTS } from './flow-constants'
+
+export function sysIdToUuid(id: string): string {
+    return id.length === 32
+        ? `${id.slice(0, 8)}-${id.slice(8, 12)}-${id.slice(12, 16)}-${id.slice(16, 20)}-${id.slice(20)}`
+        : id // already UUID or unexpected
+}
+
+export function uuidToSysId(id: string): string {
+    return id.includes('-') ? id.replace(/-/g, '') : id // already sys_id or unexpected
+}
+
+/**
+ * Get the identifier name from an original source (TypeScript node)
+ * Searches for a VariableDeclaration ancestor and extracts the identifier name
+ *
+ * @param originalSource - The original TypeScript source node
+ * @returns The identifier name if found, undefined otherwise
+ */
+export function getIdentifierFromSource(originalSource: unknown): string | undefined {
+    if (ts.Node.isNode(originalSource)) {
+        const node = originalSource as ts.Node
+        const varDecl = node.getFirstAncestorByKind(ts.SyntaxKind.VariableDeclaration)
+        const idNode = varDecl?.getNameNode()
+        if (idNode) {
+            return idNode.getText()
+        }
+    }
+    return undefined
+}
+
+/**
+ * Get the identifier name for an action/subflow instance from its original source
+ * Only checks if this node is DIRECTLY wrapped in a VariableDeclaration (not any ancestor)
+ * This prevents scope collisions where inner actions inherit parent Subflow/Flow variable names
+ *
+ * Use this specifically for preserving action/subflow variable names during transform
+ *
+ * @param originalSource - The original source to extract the identifier from
+ * @returns The identifier name if found, undefined otherwise
+ */
+export function getDirectVariableIdentifier(originalSource: unknown): string | undefined {
+    if (!ts.Node.isNode(originalSource)) {
+        return undefined
+    }
+
+    const node = originalSource as ts.Node
+
+    // Only check immediate parent, not any ancestor
+    // This prevents actions inside Subflow/Flow bodies from inheriting the Subflow/Flow's variable name
+    const varDecl = node.getParentIfKind(ts.SyntaxKind.VariableDeclaration)
+    if (!varDecl) {
+        return undefined
+    }
+
+    const idNode = varDecl.getNameNode()
+    return idNode?.getText()
+}
+
+/**
+ * Get the identifier name from a record's original source
+ * Convenience wrapper around getIdentifierFromSource for Record types
+ *
+ * @param record - The record to extract the identifier from
+ * @returns The identifier name if found, undefined otherwise
+ */
+export function getIdentifierFromRecord(record: Record): string | undefined {
+    return getIdentifierFromSource(record.getOriginalSource())
+}
+
+/**
+ * Get the identifier name from a shape's original source
+ * Convenience wrapper around getIdentifierFromSource for Shape types
+ *
+ * @param shape - The shape to extract the identifier from
+ * @returns The identifier name if found, undefined otherwise
+ */
+export function getIdentifierFromShape(shape: Shape): string | undefined {
+    return getIdentifierFromSource(shape.getOriginalSource())
+}
+
+/**
+ * Set of allowed FlowValueType helper function names for flow variable validation
+ *
+ * @constant {Set<string>}
+ * @example
+ * ```typescript
+ * // Supported types: StringColumn, IntegerColumn, DecimalColumn, ReferenceColumn,
+ * // DateTimeColumn, BooleanColumn, GenericColumn, FlowObject, FlowArray
+ * if (ALLOWED_VARIABLE_CALLEES.has('StringColumn')) {
+ *   // StringColumn is supported
+ * }
+ * ```
+ */
+export const ALLOWED_VARIABLE_CALLEES = new Set([
+    'StringColumn',
+    'IntegerColumn',
+    'DecimalColumn',
+    'ReferenceColumn',
+    'DateTimeColumn',
+    'BooleanColumn',
+    'FloatColumn',
+    'JsonColumn',
+    'GenericColumn',
+    'FlowObject',
+    'FlowArray',
+])
+
+export const ALLOWED_VARIABLE_CALLEES_IN_FLOW_OBJECT = new Set([
+    'StringColumn',
+    'IntegerColumn',
+    'DecimalColumn',
+    'DateTimeColumn',
+    'BooleanColumn',
+    'FlowObject',
+    'FlowArray',
+])
+
+/**
+ * Validates a single flow variable call expression for type safety and correctness
+ *
+ * @param variableCall - The CallExpressionShape representing the variable definition
+ * @param path - The path/name of the variable for error reporting
+ * @param diagnostics - Diagnostics object for reporting validation errors
+ *
+ * @example
+ * ```typescript
+ * // Validates allowed types, GenericColumn columnType (json/float only),
+ * // and recursively validates FlowArray/FlowObject structures
+ * validateFlowVariableCall(StringColumn({ label: 'Name' }), 'flow_variables.userName', diagnostics)
+ * ```
+ */
+export function validateFlowVariableCall(variableCall: CallExpressionShape, path: string, diagnostics: Diagnostics) {
+    const callee = variableCall.getCallee()
+
+    if (!ALLOWED_VARIABLE_CALLEES.has(callee)) {
+        diagnostics.error(
+            variableCall.getOriginalNode(),
+            `${path} uses unsupported type '${callee}'. Only FlowValueType helpers are allowed.`
+        )
+    } else if (callee === 'GenericColumn') {
+        const arg0 = variableCall.getArgument(0)
+        const colTypeNode = arg0.ifObject()?.get('columnType')
+        const colType = colTypeNode?.ifString()?.asString().getValue()
+        if (colType && colType !== 'json' && colType !== 'float') {
+            diagnostics.error(
+                colTypeNode!.getOriginalNode(),
+                `${path} GenericColumn supports only columnType 'json' or 'float'. Found '${colType}'.`
+            )
+        }
+    } else if (callee === 'FlowArray') {
+        // Validate FlowArray structure recursively
+        // Primitive types (StringColumn, IntegerColumn, etc.) are now supported as elementType
+        const arg0 = variableCall.getArgument(0)
+        const elementTypeNode = arg0.ifObject()?.get('elementType')
+        if (elementTypeNode?.if(CallExpressionShape)) {
+            const elementTypeCall = elementTypeNode.as(CallExpressionShape)
+            const elementTypeCallee = elementTypeCall.getCallee()
+
+            // Recursively validate if elementType is FlowObject or FlowArray
+            if (elementTypeCallee === 'FlowObject') {
+                validateFlowObjectFields(elementTypeCall, `${path}.elementType`, diagnostics)
+            } else if (elementTypeCallee === 'FlowArray') {
+                validateFlowVariableCall(elementTypeCall, `${path}.elementType`, diagnostics)
+            }
+            // Primitive column types (StringColumn, IntegerColumn, etc.) are allowed - no validation needed
+        }
+    } else if (callee === 'FlowObject') {
+        validateFlowObjectFields(variableCall, path, diagnostics)
+    }
+}
+
+/**
+ * Recursively validates FlowObject fields for nested FlowArray violations and other type validations
+ *
+ * @param flowObjectCall - The CallExpressionShape representing the FlowObject definition
+ * @param path - The path/name of the variable for error reporting
+ * @param diagnostics - Diagnostics object for reporting validation errors
+ *
+ * @example
+ * ```typescript
+ * // Validates all field types are allowed, recursively validates nested
+ * // FlowArray/FlowObject structures, and checks GenericColumn columnType
+ * FlowObject({ fields: { name: StringColumn({...}), data: FlowArray({...}) } })
+ * ```
+ */
+export function validateFlowObjectFields(flowObjectCall: CallExpressionShape, path: string, diagnostics: Diagnostics) {
+    const arg0 = flowObjectCall.getArgument(0)
+    if (arg0.ifObject()) {
+        const fieldsNode = arg0.asObject().get('fields')
+        fieldsNode
+            ?.ifObject()
+            ?.entries()
+            .forEach(([fieldName, fieldValue]) => {
+                if (fieldValue.if(CallExpressionShape)) {
+                    const fieldCall = fieldValue.as(CallExpressionShape)
+                    const fieldPath = `${path}.${fieldName}`
+                    const fieldCallee = fieldCall.getCallee()
+
+                    if (!ALLOWED_VARIABLE_CALLEES.has(fieldCallee)) {
+                        diagnostics.error(
+                            fieldValue.getOriginalNode(),
+                            `${fieldPath} uses unsupported type '${fieldCallee}'. Only FlowValueType helpers are allowed.`
+                        )
+                        return
+                    }
+
+                    // work around until DEF0797916 is fixed : Check if ReferenceColumn, JSONColumn, FloatColumn is used inside a FlowObject in flow variables
+                    if (!ALLOWED_VARIABLE_CALLEES_IN_FLOW_OBJECT.has(fieldCallee)) {
+                        diagnostics.error(
+                            fieldValue.getOriginalNode(),
+                            `Unsupported type '${fieldCallee}' inside flow object in the flow variable is not allowed for flow variables at ${fieldPath}.`
+                        )
+                        return
+                    }
+
+                    validateFlowVariableCall(fieldCall, fieldPath, diagnostics)
+                } else {
+                    diagnostics.error(
+                        fieldValue.getOriginalNode(),
+                        `${path}.${fieldName} is not a valid variable expression.`
+                    )
+                }
+            })
+    }
+}
+
+/**
+ * Recursively searches ancestors of a node to find a CallExpression
+ * with any of the given callee names.
+ *
+ * @param node - The starting node
+ * @param calleeNames - One or more function names to match against
+ * @returns The CallExpression if found, otherwise undefined
+ */
+export function findAncestorByCalleeName(
+    node: ts.Node | undefined,
+    ...calleeNames: string[]
+): ts.CallExpression | undefined {
+    if (!node) {
+        return undefined
+    }
+    if (ts.Node.isCallExpression(node)) {
+        const expr = node.getExpression()
+        // Handle simple identifiers: Flow, Subflow, etc.
+        if (ts.Node.isIdentifier(expr) && calleeNames.includes(expr.getText())) {
+            return node
+        }
+        // Handle property access expressions: wfa.flowLogic.if, wfa.flowLogic.forEach, etc.
+        if (ts.Node.isPropertyAccessExpression(expr) && calleeNames.includes(expr.getText())) {
+            return node
+        }
+    }
+    // recurse upwards
+    return findAncestorByCalleeName(node.getFirstAncestorByKind(ts.SyntaxKind.CallExpression), ...calleeNames)
+}
+
+/**
+ * Resolves a data pill shape by transforming it and handling trigger pills
+ * @param shape - The shape to resolve (PropertyAccessShape, TemplateExpressionShape, or IdentifierShape)
+ * @param transform - The transform instance
+ * @returns The resolved value or the original shape value if not a data pill
+ */
+export async function resolveDataPillShape(
+    shape: PillShape | PropertyAccessShape | TemplateExpressionShape | IdentifierShape,
+    transform: Transform
+): Promise<unknown> {
+    const mayBePills = await transform.toSubclass(shape, DataPillPlugin)
+    if (mayBePills.success) {
+        let processedShape = mayBePills.value
+
+        // Magical code to handle trigger pills :) as they do not follow the same pattern as other pills
+        // subflow inputs will be {{subflow.<pill-name>}}, flow variable {{flow_variable.<pill-name>}} but for triggers {{Created_1.<pill-name>}}
+        if (processedShape instanceof PillShape && processedShape.getRootIdentifier() === 'trigger') {
+            processedShape = await resolveTriggerPills(processedShape, transform)
+        }
+        // Magical code to handle PillTemplateShape with trigger pills
+        else if (processedShape.is(PillTemplateShape)) {
+            // Process each pill shape in the template
+            const pillShapes = processedShape.getParts()
+            const elements = pillShapes.getElements(false)
+
+            for (const shapePart of elements) {
+                if (shapePart instanceof PillShape && shapePart.getRootIdentifier() === 'trigger') {
+                    await resolveTriggerPills(shapePart, transform) // mutates shapePart
+                }
+            }
+        }
+
+        return processedShape.getValue()
+    }
+
+    return shape.getValue()
+}
+
+async function resolveTriggerPills(shape: PillShape, transform: Transform) {
+    const flowCallExpression = findAncestorByCalleeName(shape.getOriginalNode(), 'Flow')
+    if (flowCallExpression instanceof ts.CallExpression) {
+        if (flowCallExpression?.getArguments()?.length > 2) {
+            const triggerExpression = flowCallExpression?.getArguments()[1]
+            const triggerRecord = triggerExpression
+                ? await transform.toRecord(triggerExpression, CallExpressionPlugin, TriggerInstancePlugin)
+                : { success: false, value: undefined }
+
+            if (triggerRecord.success && triggerRecord.value?.isRecord()) {
+                const triggerName = triggerRecord.value.asRecord().get('name')?.getValue() as string
+                shape.setRootIdentifier(triggerName.concat('_1')) // <-- TODO: Temp code to match what UI does now, but raised a defect against FD team to fix it in the app itself.
+                return shape
+            }
+        }
+    }
+    return shape
+}
+
+/**
+ * Function to get the record by transforming the FDInstanceShape
+ * @param shape - The shape to transform (VariableStatementShape, CallExpressionShape)
+ * @param transform - The transform instance
+ * @returns The instance record of the FDInstanceShape
+ */
+export async function getRecordFromFlowInstaceShape(shape: Shape, transform: Transform) {
+    let instanceRecord: Record | undefined
+    const callExpressionShape = shape.is(VariableStatementShape) ? shape.getInitializer() : shape
+    if (callExpressionShape.is(CallExpressionShape)) {
+        //Get the Flow Instance Shape using toSubclass() utility
+        const flowInstanceShape = await transform.toSubclass(callExpressionShape, FlowLogicPlugin, FlowInstancePlugin)
+        if (flowInstanceShape.success && flowInstanceShape.value.is(FDInstanceShape)) {
+            //Get the Flow Instance Record using toRecord() utility
+            const flowInstanceRecord = await transform.toRecord(
+                flowInstanceShape.value,
+                FlowLogicPlugin,
+                FlowInstancePlugin
+            )
+            if (flowInstanceRecord.success) {
+                instanceRecord = flowInstanceRecord.value
+            }
+        }
+    }
+    return instanceRecord
+}
+
+export function checkForUnsupportedFlowDescendants(descendants: Database, record: Record, logger: Logger): boolean {
+    if (descendants) {
+        for (const tableName of UNSUPPORTED_FLOW_DESCENDANTS) {
+            const descendantRecords = descendants.query(tableName)
+
+            if (descendantRecords?.length > 0) {
+                logger.warn(
+                    `Unsupported flow descendant tables found, falling back to Record() api. Flow = ${record.getId().getValue()}, table = ${tableName}`
+                )
+
+                return true
+            }
+        }
+    }
+    return false
+}
+
+export const getCoreActionIdentifier = (sysId: string) => {
+    const actionName = CORE_ACTIONS_SYS_ID_NAME_MAP[sysId]
+    return actionName ? `${CORE_ACTIONS_PREFIX}.${actionName}` : undefined
+}
+
+/**
+ * Extracts the order value from a record for sorting purposes.
+ * Converts the 'order' field to a number, defaulting to 0 if not present or invalid.
+ *
+ * @param record - The record containing the order field
+ * @returns The numeric order value
+ */
+export function getOrder(x: ObjectShape) {
+    return Number(x.get('order').asString()?.getValue() ?? 0)
+}

package/src/index.ts

@@ -35,10 +35,29 @@ export * from './html-import-plugin'
 export * from './static-content-plugin'
 export * from './script-action-plugin'
 export * from './claims-plugin'
+export * from './flow/plugins/flow-action-definition-plugin'
+export * from './flow/plugins/wfa-datapill-plugin'
+export * from './flow/plugins/flow-instance-plugin'
+export * from './flow/plugins/inline-script-plugin'
+export * from './flow/plugins/approval-rules-plugin'
+export * from './flow/plugins/flow-trigger-instance-plugin'
+export * from './flow/plugins/flow-definition-plugin'
+export * from './flow/plugins/trigger-plugin'
+export * from './flow/flow-logic/flow-logic-plugin'
+export * from './flow/plugins/step-instance-plugin'
+export * from './flow/plugins/step-definition-plugin'
+export * from './flow/plugins/flow-diagnostics-plugin'
 export * from './ui-policy-plugin'
 export * from './import-sets-plugin'
 export * from './now-attach-plugin'
+export * from './sla-plugin'
+export * from './email-notification-plugin'
 
+export * from './service-catalog'
+export * from './ux-list-menu-config-plugin'
+export * from './workspace-plugin'
+export * from './dashboard/dashboard-plugin'
+export * from './applicability-plugin'
 // non-plugins
 export * from './atf/step-configs'
-export { REPACK_OUTPUT_DIR, checkModuleExists } from './repack'
+export { REPACK_OUTPUT_DIR, checkModuleExists, resolveModule } from './repack'

package/src/list-plugin.ts

@@ -197,7 +197,7 @@ export const ListPlugin = Plugin.create({
                     },
                 }
             },
-            async diff(existing, incoming, { factory }) {
+            async diff(existing, incoming, _, { factory }) {
                 if (incoming.query().length === 0 || existing.query().length === 0) {
                     return {
                         success: true,

package/src/now-attach-plugin.ts

@@ -150,6 +150,10 @@ export class NowAttachShape extends CallExpressionShape implements AssociateReco
         return [attachment, ...attachmentDocs]
     }
 
+    override equals<E = unknown>(value: E): boolean {
+        return value instanceof NowAttachShape && value.baseProperties.hash === this.baseProperties.hash
+    }
+
     static async create(source: Source, fs: FileSystem, filePath: string) {
         const buffer = (await fs.readFileSync(filePath)) as Buffer
 
@@ -210,17 +214,23 @@ export const NowAttachPlugin = Plugin.create({
     records: {
         '*': {
             async toFile(record, { config, database, factory, transform }) {
+                const entries = record.entries()
+                const hasAttachments =
+                    entries.some(([, shape]) => isLazyValue(shape)) ||
+                    Object.keys(record.properties()).some((field) => hasAssociatedRecords(record.get(field)))
+
+                if (!hasAttachments) {
+                    return { success: false }
+                }
+
                 const recordBuilder = unloadBuilder(config)
                 const updateName = await transform.getUpdateName(record)
                 const builder = recordBuilder.record(record, updateName)
-                let attachmentsProcessed = false
 
-                record
-                    .entries()
+                entries
                     .sort(([a], [b]) => a.localeCompare(b)) // Sort keys to make outputs more deterministic
                     .forEach(([prop, shape]) => {
                         if (isLazyValue(shape)) {
-                            attachmentsProcessed = true
                             builder.field(prop, shape.evaluate(record, prop))
                         } else {
                             builder.field(prop, shape)
@@ -230,7 +240,6 @@ export const NowAttachPlugin = Plugin.create({
                 for (const field in record.properties()) {
                     const shape = record.get(field)
                     if (hasAssociatedRecords(shape)) {
-                        attachmentsProcessed = true
                         for (const rec of await shape.createAssociatedRecords({
                             parentRecord: record,
                             factory,
@@ -245,12 +254,6 @@ export const NowAttachPlugin = Plugin.create({
                     }
                 }
 
-                if (!attachmentsProcessed) {
-                    return {
-                        success: false,
-                    }
-                }
-
                 const claims = database
                     .query('sys_claim')
                     .filter((claim) => claim.get('metadata_update_name').equals(updateName))

package/src/now-ref-plugin.ts

@@ -24,7 +24,7 @@ export const NowRefPlugin = Plugin.create({
                     .getArgument(1)
                     .as(
                         [StringShape, ObjectShape],
-                        'The second argument to Now.ref() must be a GUID or a coalesce keys object'
+                        'The second argument to Now.ref() must be a GUID, a Now ID string, or a coalesce keys object'
                     )
                 const maybeKeys = callExpression.hasArgument(2)
                     ? callExpression

package/src/record-plugin.ts

@@ -10,6 +10,7 @@ import {
     Test,
     UserPreference,
     ImportSet,
+    Sla,
 } from '@servicenow/sdk-core/runtime/app'
 import {
     SPWidget,
@@ -18,12 +19,22 @@ import {
     CssInclude,
     JsInclude,
 } from '@servicenow/sdk-core/runtime/service-portal'
+import {
+    CatalogItem,
+    CatalogClientScript,
+    VariableSet,
+    CatalogUiPolicy,
+    CatalogItemRecordProducer,
+} from '@servicenow/sdk-core/runtime/service-catalog'
 import { ClientScript } from '@servicenow/sdk-core/runtime/clientscript'
 import { ScriptAction, ScriptInclude } from '@servicenow/sdk-core/runtime/sys'
 import { List } from '@servicenow/sdk-core/runtime/ui'
 import { Table } from '@servicenow/sdk-core/runtime/db'
 import { RestApi } from '@servicenow/sdk-core/runtime/rest'
+import { EmailNotification } from '@servicenow/sdk-core/runtime/notification'
 import { UiAction, UiPage, UiPolicy } from '@servicenow/sdk-core/runtime/ui'
+import { Applicability, UxListMenuConfig, Workspace } from '@servicenow/sdk-core/runtime/uxf'
+import { Dashboard } from '@servicenow/sdk-core/runtime/dashboard'
 
 export const RecordPlugin = Plugin.create({
     name: 'RecordPlugin',
@@ -39,7 +50,40 @@ export const RecordPlugin = Plugin.create({
                     value: changeDatabase.hasChanges() ? new Database(changeDatabase.query()) : new Database(),
                 }
             },
-            async toShape(record) {
+            async toShape(record, { compiler }) {
+                const tableName = record.getTable()
+                const columnTypes = compiler.getTableColumnTypes(tableName)
+
+                const dataProperties = record.transform(({ $ }) =>
+                    Object.fromEntries(
+                        record
+                            .keys()
+                            .filter((key) => key !== 'sys_name')
+                            .map((key) => {
+                                const shape = record.get(key)
+                                if (columnTypes?.has(key) && shape?.isString()) {
+                                    const expectedType = columnTypes.get(key)
+                                    try {
+                                        if (expectedType === 'boolean') {
+                                            return [key, $.val(shape.toBoolean())]
+                                        } else if (expectedType === 'number') {
+                                            return [key, $.val(shape.toNumber())]
+                                        } else if (expectedType === 'array') {
+                                            return [key, $.val(shape.asString().split(',')).def([''])]
+                                        } else if (expectedType === 'array-optional') {
+                                            const arrayParts = shape.asString().includes(',')
+                                            return [key, arrayParts ? $.val(shape.asString().split(',')).def(['']) : $]
+                                        }
+                                    } catch {
+                                        // Keep as string if conversion fails
+                                    }
+                                }
+
+                                return [key, shape?.isString() ? $.def('') : $] //to avoid writing empty string values to the code
+                            })
+                    )
+                )
+
                 const value = new CallExpressionShape({
                     source: record,
                     callee: 'Record',
@@ -47,16 +91,8 @@ export const RecordPlugin = Plugin.create({
                     args: [
                         {
                             $id: NowIdShape.from(record),
-                            table: record.getTable(),
-                            data: record.transform(
-                                ({ $ }) =>
-                                    Object.fromEntries(
-                                        record
-                                            .keys()
-                                            .filter((key) => key !== 'sys_name')
-                                            .map((key) => [key, record.get(key).isString() ? $.def('') : $])
-                                    ) //to avoid writing empty string values to the code
-                            ),
+                            table: tableName,
+                            data: dataProperties,
                         },
                     ],
                 })
@@ -170,6 +206,7 @@ export const RecordPlugin = Plugin.create({
 })
 
 export const TableOwnership = {
+    contract_sla: Sla.name,
     sys_security_acl: Acl.name,
     sys_security_acl_role: Acl.name,
     sys_app_application: ApplicationMenu.name,
@@ -210,9 +247,37 @@ export const TableOwnership = {
     sys_ui_policy_action: UiPolicy.name,
     sys_ui_policy_rl_action: UiPolicy.name,
     sysevent_script_action: ScriptAction.name,
+    sysevent_email_action: EmailNotification.name,
     sys_db_object: Table.name,
     sys_dictionary: Table.name,
+    sys_hub_flow: 'Flow',
+    sys_hub_trigger_instance_v2: 'wfa.trigger',
+    sys_hub_action_instance_v2: 'wfa.action',
+    sys_hub_sub_flow_instance_v2: 'wfa.subflow',
+    sys_hub_flow_logic_instance_v2: 'wfa.flowLogic',
+    sys_flow_step_definition: 'ActionStepDefinition',
+    sys_decision: 'DecisionTablePlugin',
+    sys_hub_action_type_definition: 'Action',
+    sys_hub_step_instance: 'wfa.action_step',
     sys_transform_map: ImportSet.name,
     sys_transform_entry: ImportSet.name,
     sys_transform_script: ImportSet.name,
+    sys_ux_applicability: Applicability.name,
+    sys_ux_list_menu_config: UxListMenuConfig.name,
+    sys_ux_list_category: UxListMenuConfig.name,
+    sys_ux_list: UxListMenuConfig.name,
+    sys_ux_applicability_m2m_list: UxListMenuConfig.name,
+    sys_ux_page_registry: Workspace.name,
+    sys_ux_app_config: Workspace.name,
+    par_dashboard: Dashboard.name,
+    par_dashboard_canvas: Dashboard.name,
+    par_dashboard_tab: Dashboard.name,
+    par_dashboard_widget: Dashboard.name,
+    par_dashboard_permission: Dashboard.name,
+    par_dashboard_visibility: Dashboard.name,
+    item_option_new_set: VariableSet.name,
+    sc_cat_item: CatalogItem.name,
+    sc_cat_item_producer: CatalogItemRecordProducer.name,
+    catalog_script_client: CatalogClientScript.name,
+    catalog_ui_policy: CatalogUiPolicy.name,
 }

package/src/repack/index.ts

@@ -11,6 +11,16 @@ export async function checkModuleExists(
     return repackService.checkModuleExists(module)
 }
 
+export async function resolveModule(
+    module: string,
+    logger: RepackOptions['logger'],
+    fs: RepackOptions['fs'],
+    workingDir: RepackOptions['workingDir']
+): Promise<string | undefined> {
+    const repackService = await RepackService.create(logger, fs, workingDir)
+    return repackService.resolveModule(module)
+}
+
 export const REPACK_OUTPUT_DIR = path.join('.now', '.output')
 
 export class RepackService {
@@ -52,4 +62,8 @@ export class RepackService {
     async checkModuleExists(module: string) {
         return this.repack.checkModuleExists(module, this.fs, this.workingDir, this.logger!)
     }
+
+    async resolveModule(module: string): Promise<string | undefined> {
+        return this.repack.resolveModule(module, this.fs, this.workingDir, this.logger)
+    }
 }