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

package/dist/case-debug-studio-web-service-qcb328bt.js

@@ -0,0 +1,335 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-p7jgrm5r.js";
+import {
+  buildSolutionPackageFromDir,
+  createZipFromDir,
+  uploadOrOverwriteSolution
+} from "./packager-tool-w5ek334f.js";
+import {
+  findSolutionFile,
+  updateSolutionFile
+} from "./packager-tool-56j6keqr.js";
+import"./packager-tool-b098y4a2.js";
+import {
+  extractStartEventId,
+  uploadAndDebugSolution
+} from "./packager-tool-9scn4b15.js";
+import {
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/case-debug-studio-web-service.ts
+class CaseDebugStudioWebService {
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async readCaseFile(caseFilePath) {
+    const absolutePath = this.fs.path.resolve(caseFilePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    if (!absolutePath.endsWith(".json")) {
+      throw new Error(`Expected a .json file but got: ${this.fs.path.basename(absolutePath)}`);
+    }
+    const content = await this.fs.readFile(absolutePath, "utf-8");
+    if (content === null) {
+      throw new Error(`Could not read file: ${absolutePath}`);
+    }
+    return JSON.parse(content);
+  }
+  async readBpmnFile(bpmnFilePath) {
+    const absolutePath = this.fs.path.resolve(bpmnFilePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    if (!absolutePath.endsWith(".bpmn")) {
+      throw new Error(`Expected a .bpmn file but got: ${this.fs.path.basename(absolutePath)}`);
+    }
+    const xml = await this.fs.readFile(absolutePath, "utf-8");
+    if (xml === null) {
+      throw new Error(`Could not read file: ${absolutePath}`);
+    }
+    return xml;
+  }
+  async generateProjectFiles(caseData, bpmnXml, casePlanJson, caseFileContent, startEventId) {
+    const caseName = caseData.name ?? caseData.root?.name ?? "case";
+    const safeName = caseName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.case-debug-${safeName}-${Date.now()}`);
+    await this.fs.mkdir(projectDir);
+    const entryPointId = crypto.randomUUID();
+    const name = safeName;
+    const resolvedStartEventId = startEventId ?? extractStartEventId(bpmnXml);
+    const entryPointsJson = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points.json",
+      entryPoints: [
+        {
+          filePath: `/caseplan.json.bpmn#${resolvedStartEventId}`,
+          uniqueId: entryPointId,
+          type: "CaseManagement",
+          displayName: caseName
+        }
+      ]
+    };
+    const bindingsJson = {
+      version: "2.0",
+      resources: caseData.bindings ?? []
+    };
+    const projectUiproj = {
+      Name: caseName,
+      ProjectType: "CaseManagement"
+    };
+    await this.fs.writeFile(this.fs.path.join(projectDir, "project.uiproj"), `${JSON.stringify(projectUiproj, null, 2)}
+`);
+    await this.fs.writeFile(this.fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(entryPointsJson, null, 2)}
+`);
+    await this.fs.writeFile(this.fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(bindingsJson, null, 2)}
+`);
+    await this.fs.writeFile(this.fs.path.join(projectDir, "case-plan.json"), `${JSON.stringify(casePlanJson, null, 2)}
+`);
+    await this.fs.writeFile(this.fs.path.join(projectDir, `${name}.bpmn`), bpmnXml);
+    if (caseFileContent) {
+      await this.fs.writeFile(this.fs.path.join(projectDir, "caseplan.json"), caseFileContent);
+    }
+    return projectDir;
+  }
+  async generateBpmnProjectFiles(filePath) {
+    const bpmnXml = await this.readBpmnFile(filePath);
+    const startEventId = extractStartEventId(bpmnXml);
+    const displayName = this.fs.path.basename(filePath, ".bpmn");
+    const safeName = displayName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.case-debug-${safeName}-${Date.now()}`);
+    await this.fs.mkdir(projectDir);
+    const entryPointsJson = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
+      $id: "entry-points.json",
+      entryPoints: [
+        {
+          filePath: `/${safeName}.bpmn#${startEventId}`,
+          uniqueId: crypto.randomUUID(),
+          type: "CaseManagement",
+          displayName
+        }
+      ]
+    };
+    const bindingsJson = { version: "2.0", resources: [] };
+    const projectUiproj = {
+      Name: displayName,
+      ProjectType: "CaseManagement"
+    };
+    await this.fs.writeFile(this.fs.path.join(projectDir, "project.uiproj"), JSON.stringify(projectUiproj, null, 2));
+    await this.fs.writeFile(this.fs.path.join(projectDir, "entry-points.json"), JSON.stringify(entryPointsJson, null, 2));
+    await this.fs.writeFile(this.fs.path.join(projectDir, "bindings_v2.json"), JSON.stringify(bindingsJson, null, 2));
+    await this.fs.writeFile(this.fs.path.join(projectDir, `${safeName}.bpmn`), bpmnXml);
+    return {
+      projectDir,
+      projectName: safeName,
+      entryPointBpmnFile: `${safeName}.bpmn`,
+      startEventId
+    };
+  }
+  async executeProjectViaStudioWeb(projectPath, config, callbacks, pollInterval) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const projectUiprojPath = this.fs.path.join(absoluteProjectPath, "project.uiproj");
+    if (!await this.fs.exists(projectUiprojPath)) {
+      throw new Error(`Not a valid case project directory: missing project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectUiprojContent = await this.fs.readFile(projectUiprojPath, "utf-8");
+    if (projectUiprojContent === null) {
+      throw new Error(`Could not read project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectUiproj = JSON.parse(projectUiprojContent);
+    const projectName = projectUiproj.Name;
+    const entryPointsPath = this.fs.path.join(absoluteProjectPath, "entry-points.json");
+    if (!await this.fs.exists(entryPointsPath)) {
+      throw new Error(`Not a valid case project directory: missing entry-points.json in ${absoluteProjectPath}`);
+    }
+    const entryPointsContent = await this.fs.readFile(entryPointsPath, "utf-8");
+    if (entryPointsContent === null) {
+      throw new Error(`Could not read entry-points.json in ${absoluteProjectPath}`);
+    }
+    const entryPointsJson = JSON.parse(entryPointsContent);
+    const rawEntryPoint = entryPointsJson.entryPoints?.[0]?.filePath ?? "";
+    const entryPoint = rawEntryPoint.replace(/^\/content/, "");
+    logger.info("Looking for .uipx solution file...");
+    const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+    const existingSolutionId = solutionInfo?.solutionId;
+    logger.info("Reading case JSON file...");
+    const caseJsonPath = this.fs.path.join(absoluteProjectPath, "caseplan.json");
+    if (!await this.fs.exists(caseJsonPath)) {
+      throw new Error(`Not a valid case project directory: missing caseplan.json in ${absoluteProjectPath}`);
+    }
+    const caseFileContent = await this.fs.readFile(caseJsonPath, "utf-8");
+    if (caseFileContent === null) {
+      throw new Error(`Could not read file: ${caseJsonPath}`);
+    }
+    logger.info("Converting case JSON to BPMN and case plan JSON...");
+    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
+    const { bpmnXml, rulesJson: casePlanJson } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseFileContent);
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "caseplan.json.bpmn"), bpmnXml);
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "case-plan.json"), `${JSON.stringify(casePlanJson, null, 2)}
+`);
+    logger.info("Building solution package from project...");
+    const solutionDir = this.fs.path.resolve(absoluteProjectPath, "..");
+    const uisPath = await buildSolutionPackageFromDir(this.fs, solutionDir);
+    const apiConfig = {
+      baseUrl: config.baseUrl,
+      organizationId: config.organizationId,
+      tenantName: config.tenantName,
+      tenantId: config.tenantId,
+      authToken: config.authToken,
+      organizationUnitId: config.organizationUnitId
+    };
+    return uploadAndDebugSolution({
+      upload: () => uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, existingSolutionId, this.fs),
+      onSolutionId: (id) => updateSolutionFile(this.fs, absoluteProjectPath, id),
+      projectName,
+      entryPoint,
+      projectType: "CaseManagement",
+      apiConfig,
+      organizationName: config.organizationName,
+      callbacks,
+      pollInterval
+    });
+  }
+  async buildSolutionPackage(projectDir, projectName) {
+    const solutionId = crypto.randomUUID();
+    const projectId = crypto.randomUUID();
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.case-debug-solution-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    const solutionStorage = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          ProjectId: projectId,
+          ProjectRelativePath: `${projectName}/project.uiproj`
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify(solutionStorage));
+    const uipx = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          Type: "CaseManagement",
+          ProjectRelativePath: `${projectName}/project.uiproj`,
+          Id: projectId
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, `${projectName}Solution.uipx`), JSON.stringify(uipx, null, 2));
+    const destProjectDir = this.fs.path.join(stagingDir, projectName);
+    await this.fs.mkdir(destProjectDir);
+    await this.flattenCopyToDir(projectDir, destProjectDir);
+    const uisPath = this.fs.path.join(this.fs.env.tmpdir(), `${projectName}Solution-${Date.now()}.uis`);
+    const zipData = await createZipFromDir(this.fs, stagingDir);
+    await this.fs.writeFile(uisPath, zipData);
+    await this.fs.rm(stagingDir).catch(() => {});
+    return uisPath;
+  }
+  async executeViaStudioWeb(filePath, config, callbacks, pollInterval) {
+    const dotIndex = filePath.lastIndexOf(".");
+    const ext = dotIndex >= 0 ? filePath.slice(dotIndex).toLowerCase() : "";
+    if (ext !== ".json" && ext !== ".bpmn") {
+      throw new Error(`Unsupported file type "${ext}". Only .json and .bpmn files are supported.`);
+    }
+    let projectDir;
+    let projectName;
+    let entryPointBpmnFile;
+    let startEventId;
+    if (ext === ".json") {
+      logger.info("Reading case JSON file...");
+      const absolutePath = this.fs.path.resolve(filePath);
+      if (!await this.fs.exists(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+      }
+      const rawContent = await this.fs.readFile(absolutePath, "utf-8");
+      if (rawContent === null) {
+        throw new Error(`Could not read file: ${absolutePath}`);
+      }
+      const caseData = JSON.parse(rawContent);
+      logger.info("Converting case JSON to BPMN and case plan JSON...");
+      const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
+      const { bpmnXml, rulesJson: casePlanJson } = await serializeCaseDiskJsonToBpmnAndRulesJson(rawContent);
+      startEventId = extractStartEventId(bpmnXml);
+      logger.info("Generating project files...");
+      projectDir = await this.generateProjectFiles(caseData, bpmnXml, casePlanJson, rawContent, startEventId);
+      const caseName = caseData.name ?? caseData.root?.name ?? "case";
+      projectName = caseName.replace(/[^a-zA-Z0-9_-]/g, "_");
+      entryPointBpmnFile = `${projectName}.bpmn`;
+    } else {
+      ({ projectDir, projectName, entryPointBpmnFile, startEventId } = await this.generateBpmnProjectFiles(filePath));
+    }
+    logger.info("Building solution package...");
+    const uisPath = await this.buildSolutionPackage(projectDir, projectName);
+    const cleanupPaths = [projectDir, uisPath];
+    try {
+      const apiConfig = {
+        baseUrl: config.baseUrl,
+        organizationId: config.organizationId,
+        tenantName: config.tenantName,
+        tenantId: config.tenantId,
+        authToken: config.authToken,
+        organizationUnitId: config.organizationUnitId
+      };
+      const entryPoint = `/${entryPointBpmnFile}#${startEventId}`;
+      return await uploadAndDebugSolution({
+        upload: () => uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, undefined, this.fs),
+        projectName,
+        entryPoint,
+        projectType: "CaseManagement",
+        apiConfig,
+        organizationName: config.organizationName,
+        callbacks,
+        pollInterval
+      });
+    } finally {
+      for (const p of cleanupPaths) {
+        this.fs.rm(p).catch(() => {});
+      }
+    }
+  }
+  async copyDirRecursive(src, dest) {
+    await this.fs.mkdir(dest);
+    const entries = await this.fs.readdir(src);
+    for (const entry of entries) {
+      const srcPath = this.fs.path.join(src, entry);
+      const destPath = this.fs.path.join(dest, entry);
+      const stats = await this.fs.stat(srcPath);
+      if (stats?.isDirectory()) {
+        await this.copyDirRecursive(srcPath, destPath);
+      } else {
+        const content = await this.fs.readFile(srcPath);
+        if (content !== null) {
+          await this.fs.writeFile(destPath, content);
+        }
+      }
+    }
+  }
+  async flattenCopyToDir(src, dest) {
+    const entries = await this.fs.readdir(src);
+    for (const entry of entries) {
+      const srcPath = this.fs.path.join(src, entry);
+      const stats = await this.fs.stat(srcPath);
+      if (stats?.isDirectory()) {
+        await this.copyDirRecursive(srcPath, this.fs.path.join(dest, entry));
+      } else {
+        const content = await this.fs.readFile(srcPath);
+        if (content !== null) {
+          await this.fs.writeFile(this.fs.path.join(dest, entry), content);
+        }
+      }
+    }
+  }
+}
+export {
+  CaseDebugStudioWebService
+};
+
+//# debugId=5431DE1BB4EFCF8F64756E2164756E21

package/dist/{case-pack-service-bxas5bxz.js → case-pack-service-txby2znw.js}

@@ -1,30 +1,23 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-p7jgrm5r.js";
 import {
   NugetPackager,
   ensureProjectId
-} from "./packager-tool-wvqz81mx.js";
+} from "./packager-tool-gtzs471w.js";
+import"./packager-tool-b098y4a2.js";
 import {
-  VALID_PACKAGE_NAME_REGEX,
-  loadCaseSchemaAsync
-} from "./packager-tool-gq6952nc.js";
-import"./packager-tool-we1phz71.js";
-import"./packager-tool-zqa5k9f7.js";
+  VALID_PACKAGE_NAME_REGEX
+} from "./packager-tool-vepqrsse.js";
 import {
   catchError,
   logger,
   mapPackageMetadataOptions
-} from "./packager-tool-zx48pq4v.js";
-import"./packager-tool-3wygxefb.js";
-import"./packager-tool-sc961w0q.js";
-import"./packager-tool-p9j43p8h.js";
-import"./packager-tool-jysvpt8p.js";
-import"./packager-tool-b098y4a2.js";
-import"./packager-tool-9qecd4wb.js";
-import"./packager-tool-qa9gftnj.js";
+} from "./packager-tool-5ax2ywcg.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
-import"./packager-tool-5arsyj36.js";
-import"./packager-tool-wckvcay0.js";
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
 
 // src/services/case-pack-service.ts
 class CasePackService {
@@ -116,4 +109,4 @@ export {
   CasePackService
 };
 
-//# debugId=3F3DF77D1086226264756E2164756E21
+//# debugId=96B15094B9DD778F64756E2164756E21