@uipath/packager-tool-case 1.201.0 → 1.202.0-preview.136

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 import { CaseToolFactory } from "./case-tool-factory.js";
+export { type CaseBpmnCompiler, registerCaseBpmnCompiler, } from "./case-bpmn-compiler.js";
 export { CaseToolFactory };

package/dist/index.js

@@ -18,9 +18,23 @@ import {
   ToolErrorCodes,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
+
+// src/case-bpmn-compiler.ts
+var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+var _global = globalThis;
+function registerCaseBpmnCompiler(caseBpmnCompiler) {
+  _global[COMPILER_KEY] = caseBpmnCompiler;
+}
+function getCaseBpmnCompiler() {
+  return _global[COMPILER_KEY];
+}
+
+// src/case-tool.ts
 var CaseConstants = {
   EntryPointsFileName: "entry-points.json",
-  BindingsV2FileName: "bindings_v2.json"
+  BindingsV2FileName: "bindings_v2.json",
+  CasePlanFileName: "caseplan.json",
+  CompiledBpmnFileName: "caseplan.json.bpmn"
 };
 
 class CaseTool extends ProjectTool {
@@ -44,6 +58,11 @@ class CaseTool extends ProjectTool {
     try {
       this.logger.progress("Copying files...");
       await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress("Compiling case plan to BPMN...");
+      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
+      if (!compileResult.isSuccess) {
+        return compileResult;
+      }
       this.logger.progress("Creating operate.json file...");
       await this.createOperateFile(options, contentFolder);
       this.logger.progress("Creating package-descriptor.json file...");
@@ -100,6 +119,59 @@ class CaseTool extends ProjectTool {
       }
     }
   }
+  async compileCasePlan(projectPath, contentFolder) {
+    const compile = getCaseBpmnCompiler();
+    const casePlanPath = Path.join(projectPath, CaseConstants.CasePlanFileName);
+    if (!compile || !await this.fileSystem.exists(casePlanPath)) {
+      return this.checkEntryPointBpmnPresent(contentFolder);
+    }
+    const casePlan = await this.fileSystem.readFile(casePlanPath);
+    if (!casePlan || casePlan.length === 0) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.CasePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${CaseConstants.CompiledBpmnFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
+    }
+    try {
+      const bpmnXml = await compile(new TextDecoder().decode(casePlan));
+      await this.fileSystem.writeFile(Path.join(contentFolder, CaseConstants.CompiledBpmnFileName), bpmnXml);
+      return await this.checkEntryPointBpmnPresent(contentFolder);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(message);
+      return ToolResult.error(ToolErrorCodes.InternalError, `Failed to compile '${CaseConstants.CasePlanFileName}' into '${CaseConstants.CompiledBpmnFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
+    }
+  }
+  async checkEntryPointBpmnPresent(contentFolder) {
+    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
+    if (referenced === null) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
+    }
+    if (referenced.length === 0) {
+      return ToolResult.success();
+    }
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    const missing = referenced.filter((file) => !contentFiles.includes(file));
+    if (missing.length === 0) {
+      return ToolResult.success();
+    }
+    const fix = missing.includes(CaseConstants.CompiledBpmnFileName) ? `Author '${CaseConstants.CasePlanFileName}' so pack can compile it (see 'uip maestro case init'), then pack again.` : `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.`;
+    return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at ${missing.map((f) => `'content/${f}'`).join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job. ${fix}`);
+  }
+  async readEntryPointBpmnFiles(contentFolder) {
+    const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
+    if (!await this.fileSystem.exists(entryPointsPath)) {
+      return [];
+    }
+    const raw = await this.fileSystem.readFile(entryPointsPath);
+    if (!raw || raw.length === 0) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(raw));
+      const names = (parsed.entryPoints ?? []).map((entry) => entry.filePath ?? "").map((filePath) => filePath.split("#")[0]).map((filePath) => filePath.split("/").pop() ?? "").filter((name) => name.endsWith(".bpmn"));
+      return [...new Set(names)];
+    } catch {
+      return null;
+    }
+  }
   async createOperateFile(options, contentFolder) {
     await ensureContentOperateFile(this.fileSystem, {
       contentFolder,
@@ -141,7 +213,8 @@ class CaseToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
 export {
-  CaseToolFactory
+  CaseToolFactory,
+  registerCaseBpmnCompiler
 };
 
-//# debugId=C4347E7455C1904D64756E2164756E21
+//# debugId=0879235A557F09E364756E2164756E21

package/dist/node-1de529jm.js

@@ -0,0 +1,39 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM, __commonJS, __require };
+
+//# debugId=4A15A0D6FCDB684764756E2164756E21

package/dist/node.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Register the Node `caseplan.json` -> BPMN compiler. Call it wherever the
+ * Case project tool factory is registered on Node — without it a Case project
+ * can only be packed from an already-compiled `.bpmn`.
+ */
+export declare function registerNodeCaseBpmnCompiler(): void;

package/dist/node.js

@@ -0,0 +1,26 @@
+import {
+  __require,
+  __toESM
+} from "./node-1de529jm.js";
+
+// src/case-bpmn-compiler.ts
+var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+var _global = globalThis;
+function registerCaseBpmnCompiler(caseBpmnCompiler) {
+  _global[COMPILER_KEY] = caseBpmnCompiler;
+}
+
+// src/node.ts
+var compileCasePlan = async (casePlanJson) => {
+  const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import("./index-x6xpvwgg.js").then((m)=>__toESM(m.default,1));
+  const { bpmnXml } = await serializeCaseDiskJsonToBpmnAndRulesJson(casePlanJson);
+  return bpmnXml;
+};
+function registerNodeCaseBpmnCompiler() {
+  registerCaseBpmnCompiler(compileCasePlan);
+}
+export {
+  registerNodeCaseBpmnCompiler
+};
+
+//# debugId=0A08F635657DD68164756E2164756E21

package/package.json

@@ -1,12 +1,17 @@
 {
     "name": "@uipath/packager-tool-case",
-    "version": "1.201.0",
+    "version": "1.202.0-preview.136",
     "description": "UiPath Case Management tool implementation",
     "type": "module",
     "exports": {
         ".": {
             "source": "./src/index.ts",
             "default": "./dist/index.js"
+        },
+        "./node": {
+            "source": "./src/node.ts",
+            "types": "./dist/node.d.ts",
+            "default": "./dist/node.js"
         }
     },
     "repository": {
@@ -25,7 +30,7 @@
     "author": "",
     "license": "ISC",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.201.0"
+        "@uipath/solutionpackager-tool-core": "1.202.0"
     },
-    "gitHead": "7933378ad5276ac369900293a1447474dcec6826"
+    "gitHead": "f6270de2c7c04f4c43b2f5187b0c3d3c314c2610"
 }

package/src/case-bpmn-compiler.ts

@@ -0,0 +1,48 @@
+/**
+ * Registry for the `caseplan.json` -> BPMN compiler.
+ *
+ * The compiler lives in `@uipath/case-schema`, a 2.5 MB CommonJS bundle that
+ * `require`s `child_process`, `tls` and `http2`. This package builds for the
+ * browser (StudioWeb loads it as a micro-frontend), so it cannot import that
+ * dependency directly. Instead it declares the interface and whoever runs on
+ * Node registers the real thing — `@uipath/packager-tool-case/node` provides
+ * that implementation, and the CLI tools that register the Case factory call
+ * it alongside.
+ *
+ * Nothing registered means no compile: `CaseTool` then requires the project to
+ * carry an already-compiled `.bpmn` and fails the build with an actionable
+ * message if it does not. It never packs a case silently missing its BPMN.
+ */
+
+/** Compiles the contents of `caseplan.json` into BPMN XML. */
+export type CaseBpmnCompiler = (casePlanJson: string) => Promise<string>;
+
+/**
+ * Global singleton key, keyed with `Symbol.for()` so every copy of this module
+ * resolves to the same slot. There are always several: `maestro-tool` and
+ * `case-tool` each bundle their own copy of this package, and the Node entry
+ * that registers the compiler is a separate build output from the browser one
+ * that reads it. A module-local `let` would leave the registration in one copy
+ * and the lookup in another — which is silently the old bug, a package packed
+ * without its BPMN. Mirrors `toolsFactoryRepository` in
+ * `@uipath/solutionpackager-tool-core`.
+ */
+const COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+
+const _global = globalThis as Record<symbol, CaseBpmnCompiler | undefined>;
+
+/**
+ * Register the compiler used by `CaseTool.buildAsync`. Last call wins. Pass
+ * `undefined` to clear it — how a test reproduces a host that never
+ * registered one.
+ */
+export function registerCaseBpmnCompiler(
+    caseBpmnCompiler: CaseBpmnCompiler | undefined,
+): void {
+    _global[COMPILER_KEY] = caseBpmnCompiler;
+}
+
+/** The registered compiler, or `undefined` when none was registered. */
+export function getCaseBpmnCompiler(): CaseBpmnCompiler | undefined {
+    return _global[COMPILER_KEY];
+}

package/src/case-tool.ts

@@ -17,6 +17,7 @@ import {
     ToolErrorCodes,
     ToolResult,
 } from "@uipath/solutionpackager-tool-core";
+import { getCaseBpmnCompiler } from "./case-bpmn-compiler.js";
 
 /**
  * Case Management-specific file names
@@ -24,14 +25,18 @@ import {
 const CaseConstants = {
     EntryPointsFileName: "entry-points.json",
     BindingsV2FileName: "bindings_v2.json",
+    CasePlanFileName: "caseplan.json",
+    CompiledBpmnFileName: "caseplan.json.bpmn",
 } as const;
 
 /**
  * Case Management project tool implementation.
  *
- * Case Management projects use .stage.json source files that are converted
- * to .bpmn format. All files are placed in the content/ folder (no separate
- * source folder like flow_files/).
+ * The authored source is `caseplan.json`; the runtime reads the BPMN compiled
+ * from it. `entry-points.json` points at `/content/caseplan.json.bpmn`, so the
+ * build compiles that file into content/ — a package without it deploys and
+ * activates fine and then faults every job it starts (UV-15809). All files are
+ * placed in the content/ folder (no separate source folder like flow_files/).
  */
 export class CaseTool extends ProjectTool {
     private readonly _temporaryStorage: TemporaryStorageService;
@@ -79,6 +84,15 @@ export class CaseTool extends ProjectTool {
             this.logger.progress("Copying files...");
             await this.copyFiles(options.projectPath, contentFolder);
 
+            this.logger.progress("Compiling case plan to BPMN...");
+            const compileResult = await this.compileCasePlan(
+                options.projectPath,
+                contentFolder,
+            );
+            if (!compileResult.isSuccess) {
+                return compileResult;
+            }
+
             this.logger.progress("Creating operate.json file...");
             await this.createOperateFile(options, contentFolder);
 
@@ -175,6 +189,153 @@ export class CaseTool extends ProjectTool {
         }
     }
 
+    /**
+     * Compile `caseplan.json` into `content/caseplan.json.bpmn`.
+     *
+     * Runs after copyFiles on purpose: a stale `caseplan.json.bpmn` left in the
+     * project directory by an earlier `uip maestro case pack` is copied in
+     * first and then overwritten here, so an edited case plan can never ship
+     * against an old BPMN. Nothing is written back into the project directory —
+     * packing a solution does not mutate the user's source tree.
+     *
+     * The compiler is injected (see `case-bpmn-compiler.ts`). With none
+     * registered — a browser host, where `@uipath/case-schema` cannot run — the
+     * project has to bring its own compiled `.bpmn`.
+     */
+    private async compileCasePlan(
+        projectPath: string,
+        contentFolder: string,
+    ): Promise<ToolResult> {
+        const compile = getCaseBpmnCompiler();
+        const casePlanPath = Path.join(
+            projectPath,
+            CaseConstants.CasePlanFileName,
+        );
+
+        if (!compile || !(await this.fileSystem.exists(casePlanPath))) {
+            return this.checkEntryPointBpmnPresent(contentFolder);
+        }
+
+        const casePlan = await this.fileSystem.readFile(casePlanPath);
+        if (!casePlan || casePlan.length === 0) {
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                `'${CaseConstants.CasePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${CaseConstants.CompiledBpmnFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`,
+            );
+        }
+
+        try {
+            const bpmnXml = await compile(new TextDecoder().decode(casePlan));
+            await this.fileSystem.writeFile(
+                Path.join(contentFolder, CaseConstants.CompiledBpmnFileName),
+                bpmnXml,
+            );
+            // A compile alone does not prove the package is coherent: the
+            // entry point could name a different file. Check what was declared.
+            return await this.checkEntryPointBpmnPresent(contentFolder);
+        } catch (error) {
+            const message =
+                error instanceof Error ? error.message : String(error);
+            this.logger.error(message);
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                `Failed to compile '${CaseConstants.CasePlanFileName}' into '${CaseConstants.CompiledBpmnFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`,
+            );
+        }
+    }
+
+    /**
+     * Verify every `.bpmn` `entry-points.json` names is actually in content/.
+     *
+     * This is the defect UV-15809 reported, checked mechanically: the entry
+     * point resolved to a file the package did not contain, so it deployed and
+     * activated cleanly and then faulted every job. Checking the declaration
+     * rather than a fixed filename covers both project shapes — a CLI project
+     * (`caseplan.json` -> `caseplan.json.bpmn`) and a Studio Web one
+     * (`<name>.stage.json` shipped with its compiled `<name>.stage.json.bpmn`)
+     * — and a stray `.bpmn` left behind by `uip case debug` cannot stand in for
+     * the one that is missing.
+     *
+     * No `entry-points.json` means nothing declares an entry point, so there is
+     * nothing to resolve and nothing to fail on.
+     */
+    private async checkEntryPointBpmnPresent(
+        contentFolder: string,
+    ): Promise<ToolResult> {
+        const referenced = await this.readEntryPointBpmnFiles(contentFolder);
+        if (referenced === null) {
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`,
+            );
+        }
+        if (referenced.length === 0) {
+            return ToolResult.success();
+        }
+
+        const contentFiles = await this.fileSystem.readdir(contentFolder);
+        const missing = referenced.filter(
+            (file) => !contentFiles.includes(file),
+        );
+        if (missing.length === 0) {
+            return ToolResult.success();
+        }
+
+        // Only the CLI shape can be produced by packing: the missing file is
+        // compiled from `caseplan.json`. A Studio Web project ships its own
+        // `<name>.stage.json.bpmn`, and telling that user to author a
+        // `caseplan.json` their project type does not use is wrong.
+        const fix = missing.includes(CaseConstants.CompiledBpmnFileName)
+            ? `Author '${CaseConstants.CasePlanFileName}' so pack can compile it (see 'uip maestro case init'), then pack again.`
+            : `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.`;
+
+        return ToolResult.error(
+            ToolErrorCodes.InternalError,
+            `'${CaseConstants.EntryPointsFileName}' points at ${missing.map((f) => `'content/${f}'`).join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job. ${fix}`,
+        );
+    }
+
+    /**
+     * The `.bpmn` file names `entry-points.json` refers to. Entries look like
+     * `/content/caseplan.json.bpmn#<triggerId>`; `uip case debug` writes them
+     * without the `content/` prefix, so both forms are accepted.
+     *
+     * No file at all means nothing is declared, so the caller has nothing to
+     * check. A file that is there but cannot be read as JSON returns `null`:
+     * treating that as "nothing declared" would wave through the very package
+     * this check exists to stop, since the entry point it names is unknown.
+     */
+    private async readEntryPointBpmnFiles(
+        contentFolder: string,
+    ): Promise<string[] | null> {
+        const entryPointsPath = Path.join(
+            contentFolder,
+            CaseConstants.EntryPointsFileName,
+        );
+        if (!(await this.fileSystem.exists(entryPointsPath))) {
+            return [];
+        }
+
+        const raw = await this.fileSystem.readFile(entryPointsPath);
+        if (!raw || raw.length === 0) {
+            return null;
+        }
+
+        try {
+            const parsed = JSON.parse(new TextDecoder().decode(raw)) as {
+                entryPoints?: { filePath?: string }[];
+            };
+            const names = (parsed.entryPoints ?? [])
+                .map((entry) => entry.filePath ?? "")
+                .map((filePath) => filePath.split("#")[0])
+                .map((filePath) => filePath.split("/").pop() ?? "")
+                .filter((name) => name.endsWith(".bpmn"));
+            return [...new Set(names)];
+        } catch {
+            return null;
+        }
+    }
+
     /**
      * Create operate.json file if it doesn't already exist
      */

package/src/index.ts

@@ -10,4 +10,8 @@ import { CaseToolFactory } from "./case-tool-factory.js";
 
 toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory());
 
+export {
+    type CaseBpmnCompiler,
+    registerCaseBpmnCompiler,
+} from "./case-bpmn-compiler.js";
 export { CaseToolFactory };

package/src/node.ts

@@ -0,0 +1,35 @@
+// Node-only entry point: wires the real `caseplan.json` -> BPMN compiler into
+// the Case packager. Kept out of `index.ts` because `@uipath/case-schema`
+// requires Node built-ins and would break the browser build — see
+// `case-bpmn-compiler.ts`.
+
+import {
+    type CaseBpmnCompiler,
+    registerCaseBpmnCompiler,
+} from "./case-bpmn-compiler.js";
+
+/**
+ * `@uipath/case-schema` ships as a single 2.5 MB CommonJS bundle with no
+ * `exports` map, so nothing in it can be tree-shaken — importing one function
+ * costs the whole file. Behind `await import` it becomes its own lazy chunk,
+ * parsed only when a Case project is actually built, instead of loading with
+ * every `uip maestro -h`. `case-tool` keeps the same shape for its own
+ * `uip maestro case pack` path (`services/case-schema-loader.ts`).
+ */
+const compileCasePlan: CaseBpmnCompiler = async (casePlanJson) => {
+    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import(
+        "@uipath/case-schema"
+    );
+    const { bpmnXml } =
+        await serializeCaseDiskJsonToBpmnAndRulesJson(casePlanJson);
+    return bpmnXml;
+};
+
+/**
+ * Register the Node `caseplan.json` -> BPMN compiler. Call it wherever the
+ * Case project tool factory is registered on Node — without it a Case project
+ * can only be packed from an already-compiled `.bpmn`.
+ */
+export function registerNodeCaseBpmnCompiler(): void {
+    registerCaseBpmnCompiler(compileCasePlan);
+}