@uipath/maestro-builder-sdk 6.68.6 → 6.69.0

package/dist/bpmn/intsvc.js

@@ -191,6 +191,16 @@ export function createExternalTask(ctx, n) {
             `${n.key}/${n.action} is "${String(op.subType ?? 'untyped')}". ` +
             `The shipped library has very few of these — ${wanted === 'AgentExecution' ? '2' : '1'} operation(s).`);
     }
+    // The object's execution type, when the library records it (#1369): a `mode`
+    // that contradicts it compiles the other contract, which validate accepts and
+    // the run gets wrong. Studio Web runs `hybrid` as `async`.
+    const recorded = op.executionType;
+    if (recorded === 'sync' || recorded === 'async' || recorded === 'hybrid') {
+        const runs = recorded === 'sync' ? 'sync' : 'async';
+        if (n.mode !== runs)
+            throw new CompileRefusal('EXTERNAL_TASK_MODE_MISMATCH', `external ${n.family} "${n.id}" has mode "${n.mode}", but the connector library records ${n.key}/${n.action}'s ` +
+                `executionType as "${recorded}", which runs ${runs}; the node would run the wrong contract. Use mode: "${runs}".`);
+    }
     const conn = connectorBindingRef(ctx, n.connection, 'Connection', 'ConnectionId', `${rc.connectorKey} connection`);
     const folder = connectorBindingRef(ctx, n.folder, 'Connection', 'folderKey', 'FolderKey', conn?.resourceKey);
     if (!conn || !folder) {

package/dist/case/case-sdk.d.ts

@@ -430,9 +430,12 @@ export type ConnectorSpecData = Extract<ActionSpec, {
  * reports it for the connector object.
  *
  * @remarks
- * This is a property of the connector object, not a choice about the case: copy
- * it from the activity's `case spec` result
- * (`Data.EssentialConfiguration.essentialConfiguration.executionType`). The Case
+ * This is a property of the connector object, not a choice about the case. The
+ * connector library records it for the object when it was built or prepared
+ * from Integration Service metadata that reports it, and compile then takes it
+ * from there: leave `mode` out. Otherwise copy it from the activity's `case spec`
+ * result (`Data.EssentialConfiguration.essentialConfiguration.executionType`).
+ * A `mode` the library contradicts is refused (EXTERNAL_TASK_MODE_MISMATCH). The Case
  * Designer saves `sync` as the `Sync…Execution` service type and both `async`
  * and `hybrid` as `Async…Execution`, and writes the value itself into the task's
  * `executionType` context.
@@ -457,10 +460,10 @@ export type ExternalExecutionMode = 'sync' | 'async' | 'hybrid';
  * the Case Designer reads it from the object's metadata (its first event mode
  * and that mode's first event type) and saves it as the task's `operation` and
  * `eventMode` context rows, and as `eventType` / `eventMode` in the metadata's
- * `activityPropertyConfiguration`. Copy it from the same two rows of the
- * activity's `case spec` result (`caseShape.context`). `decompile` lifts it from
- * a saved task. For
- * example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
+ * `activityPropertyConfiguration`. Like `mode`, compile takes it from the
+ * connector library when the library records it; otherwise copy it from the same
+ * two rows of the activity's `case spec` result (`caseShape.context`).
+ * `decompile` lifts it from a saved task. For example, the Power Automate "Invoke a Flow" object (`hybrid`) answers with
  * `{ operation: 'TRIGGER_CREATED', mode: 'polling' }`.
  */
 export interface ExternalEventPair {
@@ -476,16 +479,18 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
     /** Symbolic Orchestrator folder binding name declared in `bindings.json`. */
     folder: string;
     /**
-     * The connector object's `executionType` from its `case spec` result. Required:
-     * the connector library does not carry it yet (#1369), and a wrong value passes
-     * `validate` but runs the wrong contract. Not whether the stage waits: that is
+     * The connector object's `executionType`. Leave it out when the connector
+     * library records it (compile reads it from there); otherwise copy it from the
+     * `case spec` result. Compile refuses a task with no mode from either
+     * (EXTERNAL_TASK_MODE), and one the library contradicts
+     * (EXTERNAL_TASK_MODE_MISMATCH). Not whether the stage waits: that is
      * `.required(false)`. See {@link ExternalExecutionMode}.
      */
-    mode: ExternalExecutionMode;
+    mode?: ExternalExecutionMode;
     /**
-     * The event an `async` or `hybrid` object answers with. Required for `hybrid`;
-     * optional for `async`; refused for `sync`, which answers inline. See
-     * {@link ExternalEventPair}.
+     * The event an `async` or `hybrid` object answers with. Leave it out when the
+     * connector library records it. A `hybrid` task needs one from either place;
+     * a `sync` one refuses it, since it answers inline. See {@link ExternalEventPair}.
      */
     event?: ExternalEventPair;
     /** Inputs statically checked by the generated connector descriptor. */
@@ -493,9 +498,9 @@ export interface ExternalTaskOptions<I extends Record<string, unknown>> {
 }
 /** Normalized descriptor and execution mode stored on a built external task. */
 export interface ExternalTaskSpecData {
-    /** The connector object's `executionType`. */
-    mode: ExternalExecutionMode;
-    /** The event an `async` or `hybrid` object answers with, when given. */
+    /** The connector object's `executionType`, when authored (else the library's). */
+    mode?: ExternalExecutionMode;
+    /** The event an `async` or `hybrid` object answers with, when authored (else the library's). */
     event?: ExternalEventPair;
     /** Shared connector action identity, inputs, and symbolic bindings. */
     connector: ConnectorSpecData;

package/dist/case/case-sdk.js

@@ -333,7 +333,7 @@ class TaskBuilder {
     external(kind, descriptor, opts) {
         this.setKind(kind);
         this._external = {
-            mode: opts.mode,
+            ...(opts.mode !== undefined ? { mode: opts.mode } : {}),
             ...(opts.event !== undefined ? { event: { ...opts.event } } : {}),
             connector: makeConnector(descriptor, opts.inputs, {
                 connection: opts.connection,

package/dist/case/check.d.ts

@@ -1,61 +1,48 @@
 /**
- * case/check — fast static validation of a BuiltCase before serialization.
+ * case/check — fast validation of a BuiltCase.
  *
  * Surfaces the common `uip maestro case validate` failures early (task without
  * an entry rule, case/stage without a completion rule, an unsatisfiable
- * `required-tasks-completed`, unresolved stage/task references, duplicate stage
- * labels) so authoring gets instant feedback. The authoritative gate is still
- * `uip maestro case validate` / `@uipath/case-schema` on the emitted file.
+ * `required-tasks-completed`) so authoring gets instant feedback, and runs the
+ * serializer in collect mode (`serializerRefusals`), so it also reports every
+ * refusal `compile` would raise (unresolved stage/task references, duplicate
+ * stage labels, a connector input the operation does not declare), each from
+ * its one implementation and placed on its task, stage or trigger
+ * (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5, phase 8). The authoritative gate
+ * is still `uip maestro case validate` / `@uipath/case-schema` on the emitted file.
  */
 import type { BuiltCase } from './case-sdk.js';
 import { type ConnectorCheckOpts } from '../core/connector-checks.js';
-import type { EventSubscription } from '../core/actions.js';
-import { type EventCheckOpts } from '../core/event-checks.js';
+import type { Library } from '../core/library.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
     message: string;
+    /** What the finding is about: a task's name, a stage's label, a trigger's label. */
     where?: string;
     suggestion?: string;
+    /** The id of the node `where` names, for a refusal the serializer placed on one (`serializerRefusals`). */
+    nodeId?: string;
 }
 /**
  * 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 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`), and refuses a connection/folder label bindings.json cannot
- * turn into a resource key (`bindings`, `bindingLabelRefusal`), and refuses an
- * event on an unverified BYOA connection (`eventFacts`, `byoa`).
+ * `check` runs the serializer in collect mode (`serializerRefusals`), with
+ * `library` and `bindings`, so every refusal `compile` makes (an operation or
+ * event the library cannot resolve, a connector input the operation does not
+ * declare, an unrecorded lookup, a binding label bindings.json cannot answer,
+ * an unverified BYOA connection, an external task's descriptor contract) is
+ * reported from its one implementation. The other hooks feed the warnings only
+ * `check` gives: the schema-readiness warnings and the lookup rules of
+ * `checkConnectorLookups`.
  *
- * Every hook fails open: without a library, `check` stays a pure function of the
- * built model.
+ * Every hook fails open: without a library, `check` judges a connector task up
+ * to the library, as `compile` would.
  */
-export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'connectorInputs' | 'lookups' | 'resolutions' | 'schemaReadiness' | 'bindings'> & Pick<EventCheckOpts, 'eventFacts' | 'byoa'> & {
-    /**
-     * What Case `compile` would refuse an event subscription with, or `undefined`
-     * when it resolves: `EVENT_UNKNOWN` (the event is not in the library, or
-     * refuses the `object`) or `EVENT_GENERIC_NO_OBJECT` (a GENERIC event with no
-     * `object`). Built on `resolveCaseSubscription`, the call compile makes.
-     */
-    /**
-     * What Case `compile` would refuse an External Agent / External Workflow
-     * task's resolved descriptor with (`externalDescriptorRefusal`), or
-     * `undefined`: also `undefined` when the descriptor does not resolve, which
-     * `connectorResolveError` reports.
-     */
-    externalDescriptorError?: (kind: 'external-agent' | 'external-workflow', descriptor: {
-        key: string;
-        action: string;
-        version?: string;
-        object?: string;
-    }) => string | undefined;
-    subscriptionError?: (kind: 'trigger' | 'event', subscription: EventSubscription) => {
-        code: string;
-        message: string;
-    } | undefined;
+export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'lookups' | 'resolutions' | 'schemaReadiness' | 'bindings'> & {
+    /** The library `compile` serializes against, for the serializer `check` runs. */
+    library?: Library;
 };
 /**
  * Validate a built case.