@uipath/maestro-builder-sdk 6.17.6 → 6.18.1

package/dist/bpmn/intsvc.js

@@ -1,6 +1,6 @@
 import { createTypedNode, typedNodeOutputVar } from './typed-node.js';
 import { connectorBindingRef } from './connector.js';
-import { eventFilterJmes, eventFilterProblem, readEventFilter } from '../core/event-filters.js';
+import { eventFilterJmes, eventFilterProblem, jmesString, jmesStringProblem, readEventFilter } from '../core/event-filters.js';
 /**
  * Which extension type an external invocation lowers to.
  *
@@ -128,7 +128,12 @@ export function createConnectorEvent(ctx, n) {
  */
 export function eventFilterBody(nodeId, scope, filters) {
     const scopeEntries = Object.entries(scope ?? {}).filter(([, v]) => v !== undefined && v !== null && String(v) !== '');
-    const scopeClauses = scopeEntries.map(([k, v]) => `(${k} == '${String(v).replace(/'/g, "\\'")}')`);
+    const scopeClauses = scopeEntries.map(([k, v]) => {
+        const problem = jmesStringProblem(String(v));
+        if (problem)
+            throw new Error(`connector event "${nodeId}": \`filter.${k}\`: ${problem}`);
+        return `(${k} == ${jmesString(String(v))})`;
+    });
     const conditions = (filters ?? []).map((leaf, i) => {
         const { read } = readEventFilter(leaf);
         if (!read) {

package/dist/bpmn/serialize.js

@@ -456,7 +456,7 @@ export const SCRIPT_ARGS_ENVELOPE = { vars: '=vars', metadata: '=metadata' };
 export function defaultScriptInputSchema(args) {
     const properties = {};
     for (const k of Object.keys(args))
-        properties[k] = k in SCRIPT_ARGS_ENVELOPE ? { type: 'object' } : {};
+        properties[k] = Object.hasOwn(SCRIPT_ARGS_ENVELOPE, k) ? { type: 'object' } : {};
     return { type: 'object', properties };
 }
 function createScriptTask(ctx, n) {

package/dist/bpmn/typed-node.js

@@ -2,6 +2,7 @@ import { createRequire } from 'node:module';
 import { resolveFromRegistry } from './registry-fallback.js';
 import { nestConnectorBody } from '../core/connector-inputs.js';
 import { types } from '../core/expr.js';
+import { ownEntry } from '../core/own-entry.js';
 const require = createRequire(import.meta.url);
 const REGISTRY = require('./registry-types.json');
 /** Every extension type in the snapshot, sorted. */
@@ -270,10 +271,10 @@ function contextRows(m, type, spec, supplied, verbatim = false) {
     // platform is known to accept fields the registry omits.
     const known = new Set([
         ...spec.context.map((f) => f.name),
-        ...(REGISTRY_GAPS[type]?.extraContext ?? []),
+        ...(ownEntry(REGISTRY_GAPS, type)?.extraContext ?? []),
         // A field the platform REQUIRES is necessarily one it permits, so recording it as
         // required is enough — an `extraContext` twin is not also needed.
-        ...(REGISTRY_GAPS[type]?.requiredContext ?? []),
+        ...(ownEntry(REGISTRY_GAPS, type)?.requiredContext ?? []),
     ]);
     const unknown = Object.keys(supplied).filter((k) => !known.has(k));
     if (unknown.length) {
@@ -669,7 +670,7 @@ export function missingRequiredContext(type, context = {}, inline) {
         .context.filter((f) => f.required && unset(f.name) && (f.default ?? '') === '')
         .map((f) => f.name);
     // Fields the platform requires that the snapshot does not — see `REGISTRY_GAPS`.
-    const gaps = (REGISTRY_GAPS[type]?.requiredContext ?? []).filter((name) => !declared.includes(name) && unset(name));
+    const gaps = (ownEntry(REGISTRY_GAPS, type)?.requiredContext ?? []).filter((name) => !declared.includes(name) && unset(name));
     return [...declared, ...gaps];
 }
 /**
@@ -697,7 +698,7 @@ export function missingRequiredInputs(type, inputs = {},
  * agree with the CLI instead of guessing on either side of it.
  */
 context = {}, inline) {
-    const notEnforced = new Set(REGISTRY_GAPS[type]?.notEnforcedInputs ?? []);
+    const notEnforced = new Set(ownEntry(REGISTRY_GAPS, type)?.notEnforcedInputs ?? []);
     return registryType(type, inline)
         .inputs.filter((f) => f.required &&
         !notEnforced.has(f.name) &&

package/dist/case/check-cli.js

@@ -2,23 +2,37 @@
 /**
  * check-cli — fast static validation of <Name>.case.ts (no output file).
  *
- * Usage: node --experimental-strip-types check-cli.js <case.ts | BaseName>
+ * Usage: node --experimental-strip-types check-cli.js <case.ts | BaseName> \
+ *     [--library <library-json dir>] [--connectors-local <overlay dir>]
  * Exits 0 when clean (warnings allowed), 1 on any error.
+ *
+ * The library is opened exactly as `compile-cli` opens it (`openCliLibrary`), so
+ * a connector task `compile` cannot resolve fails here first (#1014).
  */
 import { reportDiagnostics } from '../cli-result.js';
 import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { check } from './check.js';
+import { caseCheckOpts } from './cli-library.js';
+import { openCliLibrary } from '../core/cli-library.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
+/** Flags that take a value: their argument is never the source positional. */
+const VALUE_FLAGS = new Set(['--library', '--connectors-local']);
+const USAGE = 'usage: check <case.ts | BaseName> [--library <dir>] [--connectors-local <dir>]';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: check <case.ts | BaseName>');
+        console.error(USAGE);
+        return 2;
+    }
+    const input = argv.find((a, i) => !a.startsWith('--') && !VALUE_FLAGS.has(argv[i - 1]));
+    if (input === undefined) {
+        console.error(USAGE);
         return 2;
     }
-    const file = resolveCaseFile(argv[0]);
+    const file = resolveCaseFile(input);
     ensureTypeScriptRuntime();
     const built = await loadBuiltCase(file);
-    const diags = check(built);
+    const diags = check(built, caseCheckOpts(openCliLibrary(argv)));
     reportDiagnostics(diags);
     for (const d of diags)
         console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);

package/dist/case/check.d.ts

@@ -8,6 +8,8 @@
  * `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 { EventCheckOpts } from '../core/event-checks.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
@@ -15,4 +17,27 @@ export interface Diagnostic {
     where?: string;
     suggestion?: string;
 }
-export declare function check(built: BuiltCase): 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.
+ *
+ * Every hook fails open: without a library, `check` stays a pure function of the
+ * built model.
+ */
+export type CaseCheckOpts = Pick<ConnectorCheckOpts, 'connectorResolveError' | 'schemaReadiness'> & Pick<EventCheckOpts, 'eventResolveError'>;
+/**
+ * Validate a built case.
+ *
+ * @param built - The case `casePlan(...).build()` returned.
+ * @param opts - Connector-library facts (see {@link CaseCheckOpts}); omit them to
+ *   check only the model itself.
+ * @returns Every diagnostic found; any `error` means `compile` refuses the case.
+ */
+export declare function check(built: BuiltCase, opts?: CaseCheckOpts): Diagnostic[];

package/dist/case/check.js

@@ -2,13 +2,21 @@ 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';
 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
 // parses these object literals; the product-pin matrix currently rejects none.
 const ILLEGAL = [];
-// audit-case-coverage: rule-slot table end
-export function check(built) {
+/**
+ * Validate a built case.
+ *
+ * @param built - The case `casePlan(...).build()` returned.
+ * @param opts - Connector-library facts (see {@link CaseCheckOpts}); omit them to
+ *   check only the model itself.
+ * @returns Every diagnostic found; any `error` means `compile` refuses the case.
+ */
+export function check(built, opts = {}) {
     const diags = [];
     for (const message of caseJsonPreservationErrors(caseJsonPreservation(built)))
         diags.push({
@@ -252,8 +260,78 @@ export function check(built) {
                 refStage(r, 'case-exit');
                 refPlacement(r, 'case-exit', 'case-exit');
             }
+    checkLibraryConnectors(built, opts, diags);
     return diags;
 }
+/**
+ * The connector-library rules (#1014): every place Case `serialize` resolves a
+ * connector against the library, checked with the same call and the same text.
+ *
+ * - a connector task and an External Agent / External Workflow task resolve
+ *   their operation (`library.resolve`): CONNECTOR_NOT_IN_LIBRARY,
+ *   CONNECTOR_OBJECT_REQUIRED, CONNECTOR_OBJECT_NOT_GENERIC;
+ * - an event trigger, a wait-for-connector task and a wait-for-connector rule
+ *   resolve their subscription (`library.resolveEvent`): EVENT_UNKNOWN.
+ *
+ * A connector task also gets the schema-readiness warnings, because the
+ * `connectors-local` overlay `registry prepare` writes is what Case compile
+ * resolves against too.
+ */
+function checkLibraryConnectors(built, opts, diags) {
+    const reporter = (_where, at) => (d) => {
+        diags.push({ level: d.level, code: d.code, message: d.message, where: at, ...(d.suggestion ? { suggestion: d.suggestion } : {}) });
+    };
+    const subscription = (kind, sub, where, at) => {
+        // Exactly the arguments `resolvedSubscriptionBag` passes to `resolveEvent`.
+        // It passes no `object` (a Case compile gap, tracked separately), so neither
+        // does this: check must refuse what compile refuses, no more.
+        const unresolved = opts.eventResolveError?.(kind, {
+            connector: sub.connector,
+            event: sub.event,
+            ...(sub.version !== undefined ? { version: sub.version } : {}),
+        });
+        if (unresolved !== undefined)
+            diags.push({ level: 'error', code: 'EVENT_UNKNOWN', message: `${where}: ${unresolved}`, where: at });
+    };
+    const rules = (conditions, where) => {
+        for (const c of conditions)
+            for (const g of c.rules)
+                for (const r of g)
+                    if (r.rule === 'wait-for-connector' && isSubscription(r.connector))
+                        subscription('event', r.connector, `wait-for-connector rule in ${where}`, where);
+    };
+    built.triggers.forEach((t, i) => {
+        if (t.kind !== 'event' || !t.eventSubscription)
+            return;
+        const name = t.name ?? `Trigger ${i + 1}`;
+        subscription('trigger', t.eventSubscription, `Event trigger "${name}"`, name);
+    });
+    for (const stage of built.stages) {
+        rules(stage.entry, `stage "${stage.label}" entry`);
+        rules(stage.exit, `stage "${stage.label}" exit`);
+        for (const t of stage.lanes.flat()) {
+            rules(t.entry, `task "${t.name}" entry`);
+            if (t.kind === 'connector' && t.connector) {
+                const where = `Connector task "${t.name}"`;
+                const spec = t.connector;
+                checkConnectorSchema(where, spec, opts, EQUALS_EXPR_DIALECT, reporter(where, t.name));
+                checkConnectorContract(where, spec, opts, reporter(where, t.name));
+            }
+            if ((t.kind === 'external-agent' || t.kind === 'external-workflow')
+                && t.external?.connector?.key?.trim() && t.external.connector.action?.trim()) {
+                const where = `${t.kind === 'external-agent' ? 'External Agent' : 'External Workflow'} task "${t.name}"`;
+                checkConnectorContract(where, t.external.connector, opts, reporter(where, t.name));
+            }
+            if (t.kind === 'wait-for-connector' && isSubscription(t.waitConnector))
+                subscription('event', t.waitConnector, `Wait-for-connector task "${t.name}"`, t.name);
+        }
+    }
+    rules(built.caseExit, 'case exit');
+}
+/** A resolved subscription, not a placeholder; the test `serialize`'s `isResolvedSubscription` makes. */
+function isSubscription(spec) {
+    return !!spec && typeof spec === 'object' && 'connector' in spec && 'event' in spec;
+}
 /**
  * SLA guardrails surfaced early: zero at-risk percentages that the engine
  * coerces to 100, empty recipient lists, and deadlines with no escalations.

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

@@ -0,0 +1,14 @@
+import type { Library } from '../core/library.js';
+import type { CaseCheckOpts } from './check.js';
+/**
+ * Case's check options from a library the CLI already opened, or `{}` without one.
+ *
+ * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
+ * the operation and event resolution, 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.
+ *
+ * @param library - The library `openCliLibrary` returned, or `undefined`.
+ * @returns The options for Case `check`.
+ */
+export declare function caseCheckOpts(library: Library | undefined): CaseCheckOpts;

package/dist/case/cli-library.js

@@ -0,0 +1,31 @@
+/**
+ * case/cli-library — Case's check options, built from the shared connector hooks.
+ *
+ * `case check` took no options at all, so a connector task naming an operation
+ * the library does not carry passed `check` and failed at `compile` (#1014).
+ * Flow and BPMN read their connector facts from `connectorCheckOpts`
+ * (`core/cli-library.ts`); Case now does too, through this one builder, which
+ * both `case check` and `case compile`'s check pass call.
+ */
+import { connectorCheckOpts } from '../core/cli-library.js';
+/**
+ * Case's check options from a library the CLI already opened, or `{}` without one.
+ *
+ * Only the hooks for refusals Case `compile` makes (see {@link CaseCheckOpts}):
+ * the operation and event resolution, 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.
+ *
+ * @param library - The library `openCliLibrary` returned, or `undefined`.
+ * @returns The options for Case `check`.
+ */
+export function caseCheckOpts(library) {
+    if (!library)
+        return {};
+    const shared = connectorCheckOpts(library);
+    return {
+        connectorResolveError: shared.connectorResolveError,
+        schemaReadiness: shared.schemaReadiness,
+        eventResolveError: shared.eventResolveError,
+    };
+}

package/dist/case/compile-cli.js

@@ -16,6 +16,7 @@ import { join, dirname, basename, resolve } from 'node:path';
 import { resolveCaseFile, loadBuiltCase } from './load.js';
 import { serialize } from './serialize.js';
 import { check } from './check.js';
+import { caseCheckOpts } from './cli-library.js';
 import { entryPointIO } from './entry-points.js';
 import { Bindings } from '../core/bindings.js';
 import { openCliLibrary } from '../core/cli-library.js';
@@ -24,6 +25,7 @@ import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
 import { sha256Uuid } from '../core/stable-id.js';
+import { isRecord } from '../core/node-envelope.js';
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error('usage: compile <case.ts | BaseName> [-o caseplan.json]');
@@ -38,7 +40,16 @@ export async function run(argv) {
     const file = resolveCaseFile(pos);
     ensureTypeScriptRuntime();
     const built = await loadBuiltCase(file);
-    const diags = check(built);
+    // Connector tasks resolve against the library; load it only when present, and
+    // bindings.json from alongside the case when present. Resolved through the same
+    // helper Flow and BPMN use, so `registry pull` serves all three families —
+    // reading the env directly skipped the shared cache, and a Case that compiled
+    // fine right after a pull on Flow failed here for no visible reason. The helper
+    // also auto-detects the `connectors-local/` overlay `registry prepare` writes,
+    // which is what the three copies of these lines used to each decide for itself.
+    // Opened BEFORE the check pass, which reads the same library (#1014).
+    const library = openCliLibrary(argv);
+    const diags = check(built, caseCheckOpts(library));
     for (const d of diags)
         console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);
     // Reported before serialize, so every exit path carries what stderr printed.
@@ -48,14 +59,6 @@ export async function run(argv) {
         console.error(`compile: ${errors.length} error(s); not emitting.`);
         return 1;
     }
-    // Connector tasks resolve against the library; load it only when present, and
-    // bindings.json from alongside the case when present. Resolved through the same
-    // helper Flow and BPMN use, so `registry pull` serves all three families —
-    // reading the env directly skipped the shared cache, and a Case that compiled
-    // fine right after a pull on Flow failed here for no visible reason. The helper
-    // also auto-detects the `connectors-local/` overlay `registry prepare` writes,
-    // which is what the three copies of these lines used to each decide for itself.
-    const library = openCliLibrary(argv);
     const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     let caseplan;
@@ -283,9 +286,6 @@ function visitRecords(value, visit) {
     for (const child of Object.values(value))
         visitRecords(child, visit);
 }
-function isRecord(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
 function stringValue(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }