@uipath/maestro-builder-sdk 6.18.2 → 6.18.4

package/dist/api-index.md

@@ -204,9 +204,9 @@ could hand you spans for a version you do not have.
 | `ran` | function | `dist/core/expr.d.ts:95-141` | Expressions and types | Did this step run? |
 | `rawNode` | function | `dist/core/node-classes.d.ts:180-242` | Supporting types | Place a node this SDK has no factory for, carrying its definition verbatim (`uipath.exotic.thing@2.1` and the manifest… |
 | `RawReference` | type | `dist/core/lookups.d.ts:190-198` | Supporting types |  |
-| `refuseLookupToken` | function | `dist/core/lookups.d.ts:207-226` | Generated descriptors | Refuse a lookup token where the family cannot resolve one. |
 | `RemoteA2aToolRef` | interface | `dist/core/actions.d.ts:1745-1765` | Supporting types | A remote A2A (agent-to-agent) endpoint the agent may delegate to. |
 | `resolvedValue` | function | `dist/core/lookups.d.ts:172-179` | Generated descriptors | The recorded id for a token, or `undefined`. |
+| `resolveEventWhere` | function | `dist/core/lookups.d.ts:207-224` | Generated descriptors | An event subscription's `where` with every lookup token swapped for the id `registry prepare --resolve` recorded, or a… |
 | `ReturnFieldType` | type | `dist/core/actions.d.ts:1317-1334` | Supporting types | A JSON-schema-ish type for one field of a step's declared `returns`. |
 | `ReturnOptions` | interface | `dist/flow-sdk.d.ts:397-428` | Option shapes | `.return(...)`-specific options. |
 | `rpaWorkflow` | function | `dist/core/actions.d.ts:2841-2885` | Actions | Invoke a deployed RPA (robotic process automation) workflow — a classic UI-automation process, published to… |

package/dist/case/check.d.ts

@@ -21,17 +21,17 @@ export interface Diagnostic {
  * The connector-library facts Case `check` reads, from the same `Library`
  * instance `compile` serializes against (`caseCheckOpts` in `./cli-library.ts`).
  *
- * Deliberately NARROWER than Flow's and BPMN's bag. An error here must be a
- * refusal Case `compile` actually makes, and Case `serialize` resolves the
- * connector operation and the event (`library.resolve` / `resolveEvent`) but does
- * not validate connector inputs, binding labels or BYOA. Those rules stay off
- * until Case compile enforces them; passing them here would refuse sources that
- * compile accepts.
+ * Deliberately NARROWER than Flow's bag. An error here must be a refusal Case
+ * `compile` actually makes. Case `serialize` resolves the connector operation and
+ * the event, and validates a connector task's inputs and resolves its lookups
+ * through the shared `buildConnectorInputs` (`connectorInputs`, `lookups`,
+ * `resolutions`). It does not check binding labels or BYOA, so those hooks stay
+ * off until Case compile enforces them.
  *
  * Every hook fails open: without a library, `check` stays a pure function of the
  * built model.
  */
-export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'schemaReadiness'> & {
+export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'connectorInputs' | 'lookups' | 'resolutions' | 'schemaReadiness'> & {
     /**
      * What Case `compile` would refuse an event subscription with, or `undefined`
      * when it resolves: `EVENT_UNKNOWN` (the event is not in the library, or

package/dist/case/check.js

@@ -2,7 +2,8 @@ import { types } from '../core/expr.js';
 import { authoredCaseVersion, CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors } from './preserve.js';
-import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorSchema, } from '../core/connector-checks.js';
+import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, } from '../core/connector-checks.js';
+import { checkEventResolution } from '../core/event-checks.js';
 const TYPE_NAMES = new Set(Object.values(types));
 // audit-case-coverage: rule-slot table start
 // This runtime table must equal the committed matrix's rejected cells. The audit
@@ -288,6 +289,9 @@ function checkLibraryConnectors(built, opts, diags) {
         const refused = opts.subscriptionError?.(kind, sub);
         if (refused !== undefined)
             diags.push({ level: 'error', code: refused.code, message: `${where}: ${refused.message}`, where: at });
+        // A `where` lookup nobody recorded: Flow's LOOKUP_UNRESOLVED warning, from the
+        // shared event rules. Only `resolutions` is passed, so nothing else in them fires.
+        checkEventResolution(sub, where, kind, { resolutions: opts.resolutions ?? {} }, (code, message) => diags.push({ level: 'error', code, message, where: at }), (code, message) => diags.push({ level: 'warning', code, message, where: at }));
     };
     const rules = (conditions, where) => {
         for (const c of conditions)
@@ -310,6 +314,7 @@ function checkLibraryConnectors(built, opts, diags) {
             if (t.kind === 'connector' && t.connector) {
                 const where = `Connector task "${t.name}"`;
                 const spec = t.connector;
+                checkConnectorLookups(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
                 checkConnectorSchema(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
                 checkConnectorContract(where, spec, opts, reporter(where, t.name));
             }

package/dist/case/cli-library.d.ts

@@ -5,9 +5,10 @@ import type { CaseCheckOpts } from './check.js';
  *
  * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
  * the operation and event resolution (the event through `resolveCaseSubscription`,
- * compile's own call), and the schema-readiness warnings. The
- * field-contract, binding-label and BYOA hooks of the shared bag are left out,
- * because Case `serialize` does not enforce them.
+ * compile's own call), a connector task's field contract and lookups (the
+ * `=`-expression validator Case compile runs), and the schema-readiness warnings.
+ * The binding-label and BYOA hooks of the shared bag are left out, because Case
+ * `serialize` does not enforce them.
  *
  * @param library - The library `openCliLibrary` returned, or `undefined`.
  * @returns The options for Case `check`.

package/dist/case/cli-library.js

@@ -14,9 +14,10 @@ import { EVENT_GENERIC_NO_OBJECT, GenericEventNoObjectError, resolveCaseSubscrip
  *
  * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
  * the operation and event resolution (the event through `resolveCaseSubscription`,
- * compile's own call), and the schema-readiness warnings. The
- * field-contract, binding-label and BYOA hooks of the shared bag are left out,
- * because Case `serialize` does not enforce them.
+ * compile's own call), a connector task's field contract and lookups (the
+ * `=`-expression validator Case compile runs), and the schema-readiness warnings.
+ * The binding-label and BYOA hooks of the shared bag are left out, because Case
+ * `serialize` does not enforce them.
  *
  * @param library - The library `openCliLibrary` returned, or `undefined`.
  * @returns The options for Case `check`.
@@ -27,6 +28,9 @@ export function caseCheckOpts(library) {
     const shared = connectorCheckOpts(library);
     return {
         connectorResolveError: shared.connectorResolveError,
+        connectorInputs: shared.connectorInputs,
+        lookups: shared.lookups,
+        resolutions: shared.resolutions,
         schemaReadiness: shared.schemaReadiness,
         subscriptionError: (kind, sub) => {
             try {

package/dist/case/serialize.js

@@ -9,8 +9,9 @@
  * name) are resolved here to the generated ids.
  */
 import { IdGen } from './ids.js';
-import { transportHttpMethod } from '../core/connector-inputs.js';
-import { refuseLookupToken } from '../core/lookups.js';
+import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
+import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
+import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from '../schema-version.js';
@@ -901,16 +902,13 @@ function resolvedSubscriptionBag(kind, spec, resolver, elementId) {
     return {
         serviceType: kind === 'trigger' ? CASE_FORMAT_PROFILE.eventServiceType : CASE_FORMAT_PROFILE.waitConnectorServiceType,
         context,
-        inputs: [eventInput(spec.where ?? {}, elementId)],
+        inputs: [eventInput(resolveEventWhere(spec.where, resolver.library.lookupResolutions, `${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} "${elementId}"`), elementId)],
         outputs: connectorOutputs(rc, elementId, resolver),
         bindings: [],
     };
 }
+/** The subscription's `body` input; `where` has its lookups already resolved (`resolveEventWhere`). */
 function eventInput(where, elementId) {
-    // Case compile does not read resolutions.json (Flow does); a token here
-    // would be emitted raw where the connector expects an id.
-    for (const [field, value] of Object.entries(where))
-        refuseLookupToken(value, 'case', field);
     return Object.keys(where).length
         ? { name: 'body', type: 'json', target: 'body', body: { queryParams: where }, var: 'vbody', id: 'vbody', elementId }
         : { name: 'body', type: 'json', target: 'body', value: '', var: 'vbody', id: 'vbody', elementId };
@@ -1083,7 +1081,6 @@ function connectorTaskData(spec, resolver, elementId) {
         throw new Error(`connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
     const op = rc.entry.operation ?? {};
-    const params = Array.isArray(op.parameters) ? op.parameters : [];
     const context = [
         io('connectorKey', 'string', { value: rc.connectorKey }),
     ];
@@ -1097,31 +1094,31 @@ function connectorTaskData(spec, resolver, elementId) {
     if (folderRef)
         context.push(io('folderKey', 'string', { value: `=bindings.${folderRef.id}` }));
     context.push(io('objectName', 'string', { value: op.objectName ?? spec.action }), io('method', 'string', { value: transportHttpMethod(rc.httpMethod) }), io('path', 'string', { value: rc.endpoint }), io('metadata', 'json', { body: connectorMetadata(rc, op) }));
-    // inputs: split declared parameters into path/query slots; the rest is the body.
+    // inputs: the shared validator (`core/connector-inputs.ts`), the one Flow's and
+    // BPMN's serializers and every family's `check` run. It refuses a missing
+    // required field, an unknown or mistyped input, and swaps a `lookup()` token for
+    // the id `registry prepare --resolve` recorded (refusing one nobody recorded).
+    // Case used to split the inputs itself: an unknown name went to the body
+    // unchecked, and every token was refused, because nothing here read
+    // `resolutions.json` (#1034, #1036).
     //
-    // Guard BEFORE the split. These values are emitted verbatim, so an unresolved
-    // lookup ships as `{"__lookup": …}` where the connector wants an id — verified
-    // by probe before this existed. Only Flow reads resolutions.json.
-    for (const [name, value] of Object.entries(spec.inputs ?? {})) {
-        refuseLookupToken(value, 'case', name);
-    }
-    const pathParameters = {};
-    const queryParameters = {};
-    const body = { ...spec.inputs };
-    for (const p of params) {
-        const name = String(p.name ?? '');
-        if (!(name in body))
-            continue;
-        const camel = toCamel(name);
-        if (p.type === 'path') {
-            pathParameters[camel] = body[name];
-            delete body[name];
-        }
-        else if (p.type === 'query') {
-            queryParameters[camel] = body[name];
-            delete body[name];
-        }
-    }
+    // The ROUTING is the library's (a field's location is a property of the
+    // operation); the SPELLING of the path/query keys is Case's own: the Case
+    // designer camelCases them (`send_as` → `sendAs`, see
+    // `fixtures/execute-connector-activity.sample.json`), and the body is nested.
+    const slots = buildConnectorInputs(rc, spec.inputs ?? {}, {
+        dialect: EQUALS_EXPR_DIALECT,
+        resolutions: resolver.library.lookupResolutions,
+        lookups: resolver.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object),
+    });
+    const camelKeys = (slot) => Object.fromEntries(Object.entries(slot ?? {}).map(([name, value]) => [toCamel(name), value]));
+    const pathParameters = camelKeys(slots.pathParameters);
+    const queryParameters = camelKeys(slots.queryParameters);
+    // Case has no multipart wire: a filled file part stays in the body, where it
+    // has always gone.
+    const parts = Object.fromEntries((slots.multipartParameters ?? [])
+        .filter((part) => part.value !== undefined).map((part) => [part.name, part.value]));
+    const body = nestConnectorBody({ ...(slots.bodyParameters ?? {}), ...parts });
     const inputs = [
         ioSlot('pathParameters', pathParameters, `${elementId}`),
         ioSlot('queryParameters', queryParameters, `${elementId}`),

package/dist/core/lookups.d.ts

@@ -205,23 +205,21 @@ type RawReference = {
  */
 export declare function lookupSpecOf(reference: RawReference, invariant?: ReadonlySet<string>): LookupSpec | undefined;
 /**
- * Refuse a lookup token where the family cannot resolve one.
- *
- * `lookup()` is a FLOW surface today: only `serialize.ts` substitutes a
- * recorded resolution, and only `check.ts` reports an unresolved one. Case and
- * BPMN pass connector input values straight into their emitted payload, so a
- * token reaching either one is embedded verbatim — a `.case` carrying
- * `{"__lookup": {…}}` where the connector expects an id.
- *
- * That is silent wrongness, which is the failure this whole surface exists to
- * remove; emitting it from the tool that removes it would be the worst possible
- * outcome. Until Case and BPMN read `resolutions.json` too, they refuse the
- * token and say so.
- *
- * @param value - A connector input value.
- * @param family - The authoring family, for the message.
- * @param field - The input name, for the message.
- * @throws If `value` is an unresolved {@link LookupToken}.
+ * An event subscription's `where` with every lookup token swapped for the id
+ * `registry prepare --resolve` recorded, or a throw naming the first one nobody
+ * recorded.
+ *
+ * The id is looked up under the token's own node type, which for an event
+ * lookup is the EVENT form `prepare` stores it under. Emitting a placeholder for
+ * a value nobody resolved would subscribe the trigger to the wrong folder,
+ * channel or queue, so an unrecorded token is refused, never passed through.
+ * Shared by Flow's and Case's serializers, so both resolve and refuse alike.
+ *
+ * @param where - The authored `where`.
+ * @param resolutions - The library's recorded resolutions (`library.lookupResolutions`).
+ * @param site - How the caller names the subscription, prefixed to the refusal.
+ * @returns The `where` with ids in place of tokens.
+ * @throws If a token has no recorded resolution.
  */
-export declare function refuseLookupToken(value: unknown, family: string, field: string): void;
+export declare function resolveEventWhere(where: Record<string, unknown> | undefined, resolutions: LookupResolutions, site: string): Record<string, unknown>;
 export {};

package/dist/core/lookups.js

@@ -259,33 +259,33 @@ function byAlias(lookupName) {
     return 'by' + words.map((w) => w[0].toUpperCase() + w.slice(1)).join('');
 }
 /**
- * Refuse a lookup token where the family cannot resolve one.
+ * An event subscription's `where` with every lookup token swapped for the id
+ * `registry prepare --resolve` recorded, or a throw naming the first one nobody
+ * recorded.
  *
- * `lookup()` is a FLOW surface today: only `serialize.ts` substitutes a
- * recorded resolution, and only `check.ts` reports an unresolved one. Case and
- * BPMN pass connector input values straight into their emitted payload, so a
- * token reaching either one is embedded verbatim — a `.case` carrying
- * `{"__lookup": {…}}` where the connector expects an id.
+ * The id is looked up under the token's own node type, which for an event
+ * lookup is the EVENT form `prepare` stores it under. Emitting a placeholder for
+ * a value nobody resolved would subscribe the trigger to the wrong folder,
+ * channel or queue, so an unrecorded token is refused, never passed through.
+ * Shared by Flow's and Case's serializers, so both resolve and refuse alike.
  *
- * That is silent wrongness, which is the failure this whole surface exists to
- * remove; emitting it from the tool that removes it would be the worst possible
- * outcome. Until Case and BPMN read `resolutions.json` too, they refuse the
- * token and say so.
- *
- * @param value - A connector input value.
- * @param family - The authoring family, for the message.
- * @param field - The input name, for the message.
- * @throws If `value` is an unresolved {@link LookupToken}.
+ * @param where - The authored `where`.
+ * @param resolutions - The library's recorded resolutions (`library.lookupResolutions`).
+ * @param site - How the caller names the subscription, prefixed to the refusal.
+ * @returns The `where` with ids in place of tokens.
+ * @throws If a token has no recorded resolution.
  */
-export function refuseLookupToken(value, family, field) {
-    if (!isLookupToken(value))
-        return;
-    const { nodeType, by, value: wanted } = value.__lookup;
-    throw new Error(`${family}: input "${field}" is a lookup(), which ${family} cannot resolve — ` +
-        `only Flow reads connectors-local/resolutions.json today, so this would be ` +
-        `emitted as a raw token where the connector expects an id.\n` +
-        `Resolve it first and pass the value:\n` +
-        `  ${prepareCommand()} ${nodeType.replace(/^uipath\.connector\.(?:trigger\.|event\.)?/, '').replace(/\.([^.]+)$/, ' --action $1')} \\\n` +
-        `    --resolve ${field}:${by}=${String(wanted)}\n` +
-        `then read the id out of connectors-local/resolutions.json.`);
+export function resolveEventWhere(where, resolutions, site) {
+    const out = {};
+    for (const [key, value] of Object.entries(where ?? {})) {
+        if (!isLookupToken(value)) {
+            out[key] = value;
+            continue;
+        }
+        const resolved = resolvedValue(value, resolutions);
+        if (resolved === undefined)
+            throw new Error(`${site}: \`where.${key}\` ` + unresolvedLookupMessage(value));
+        out[key] = resolved;
+    }
+    return out;
 }

package/dist/serialize.js

@@ -44,7 +44,7 @@ export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {})
         render: (value) => renderDeep(value, NO_RENAME),
     });
 }
-import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './core/lookups.js';
+import { isLookupToken, resolveEventWhere, } from './core/lookups.js';
 import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
@@ -4127,19 +4127,7 @@ function eventDetail(rc, sub, nodeId, opts, site) {
     // `prepare --resolve` stored under the EVENT-form node type — or refused.
     // Same rule as connector inputs: emitting a placeholder for a value nobody
     // resolved would subscribe the trigger to the wrong folder/channel/queue.
-    const eventResolutions = opts.library?.lookupResolutions ?? {};
-    const where = {};
-    for (const [k, v] of Object.entries(sub.where ?? {})) {
-        if (!isLookupToken(v)) {
-            where[k] = v;
-            continue;
-        }
-        const resolved = resolvedValue(v, eventResolutions);
-        if (resolved === undefined) {
-            throw new Error(`event node "${nodeId}": \`where.${k}\` ` + unresolvedLookupMessage(v));
-        }
-        where[k] = resolved;
-    }
+    const where = resolveEventWhere(sub.where, opts.library?.lookupResolutions ?? {}, `event node "${nodeId}"`);
     // A subscription's parameters do not all travel in the same slot. The
     // connector declares which, and the library bakes it per field as `bucket`:
     // measured against designer-authored triggers, Jira's `project`/`issuetype`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.18.2",
+  "version": "6.18.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "a1a9df938c60a4e31cc9025ec9664d34f41aa799"
+  "gitref": "35ff6e86b7aecb0b5c76663b6650a0924a8b7f6e"
 }