@uipath/case-tool 1.202.0 → 1.203.0-preview.160

package/dist/case-debug-studio-web-service-0624c07c.js

@@ -0,0 +1,133 @@
+import {
+  loadCaseSchemaAsync
+} from "./packager-tool-p7jgrm5r.js";
+import {
+  buildSolutionPackageFromDir,
+  uploadOrOverwriteSolution
+} from "./packager-tool-jf4hmztd.js";
+import {
+  findSolutionFile,
+  updateSolutionFile
+} from "./packager-tool-052kvydg.js";
+import {
+  CasePlanFileNames,
+  buildCasePackageDescriptor,
+  casePlanSidecarName,
+  entryPointBpmnNames,
+  findCasePlanFileName,
+  misnamedEntryPointBpmn,
+  normalizeEntryPointPath,
+  resolveDeclaredFileName
+} from "./packager-tool-83qnybab.js";
+import"./packager-tool-b098y4a2.js";
+import {
+  uploadAndDebugSolution
+} from "./packager-tool-adcaxdhs.js";
+import {
+  logger
+} from "./packager-tool-kpcjnxd1.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 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 declared = entryPointBpmnNames(entryPointsContent);
+    if (declared === null) {
+      throw new Error(`entry-points.json in ${absoluteProjectPath} could not be read as JSON, so debug cannot check that the BPMN it declares is in the project.`);
+    }
+    const entryPointsJson = JSON.parse(entryPointsContent);
+    const rawEntryPoint = entryPointsJson.entryPoints?.[0]?.filePath ?? "";
+    const entryPoint = normalizeEntryPointPath(rawEntryPoint);
+    logger.info("Looking for .uipx solution file...");
+    const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+    const existingSolutionId = solutionInfo?.solutionId;
+    logger.info("Reading case plan file...");
+    const casePlanFileName = findCasePlanFileName(await this.fs.readdir(absoluteProjectPath));
+    if (!casePlanFileName) {
+      throw new Error(`Not a valid case project directory: no case plan in ${absoluteProjectPath}. Expected one of ${CasePlanFileNames.join(", ")}.`);
+    }
+    const caseJsonPath = this.fs.path.join(absoluteProjectPath, casePlanFileName);
+    const caseFileContent = await this.fs.readFile(caseJsonPath, "utf-8");
+    if (caseFileContent === null) {
+      throw new Error(`Could not read file: ${caseJsonPath}`);
+    }
+    const sidecarFileName = casePlanSidecarName(casePlanFileName);
+    logger.info("Converting case plan 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, sidecarFileName), bpmnXml);
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "case-plan.json"), `${JSON.stringify(casePlanJson, null, 2)}
+`);
+    const projectFiles = new Set([
+      ...await this.fs.readdir(absoluteProjectPath),
+      sidecarFileName
+    ]);
+    const missing = declared.filter((file) => !projectFiles.has(file));
+    if (missing.length > 0) {
+      throw new Error(`entry-points.json points at ${missing.join(", ")}, which ${absoluteProjectPath} does not hold, so the debug run would fault. Point the entry point at '${sidecarFileName}', or add the missing file.`);
+    }
+    const misnamed = misnamedEntryPointBpmn(declared, casePlanFileName);
+    if (misnamed) {
+      throw new Error(`entry-points.json points at '${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${sidecarFileName}', so the debug run would resolve a BPMN nothing here produced. Point the entry point at '${sidecarFileName}'.`);
+    }
+    const entryPointFileName = resolveDeclaredFileName(rawEntryPoint);
+    if (!declared.includes(entryPointFileName)) {
+      throw new Error(`entry-points.json's first entry point resolves to '${entryPointFileName || entryPoint}', which is not a declared .bpmn file this project ships, so the debug run would fault. Point the entry point at '${sidecarFileName}'.`);
+    }
+    await this.fs.writeFile(this.fs.path.join(absoluteProjectPath, "package-descriptor.json"), `${JSON.stringify(buildCasePackageDescriptor([...projectFiles]), 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
+    });
+  }
+}
+export {
+  CaseDebugStudioWebService
+};
+
+//# debugId=BA02F2B9880B270D64756E2164756E21

package/dist/case-format-service-q345a2fd.js

@@ -0,0 +1,84 @@
+import {
+  catchError
+} from "./packager-tool-kpcjnxd1.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
+
+// src/services/case-format-service.ts
+var INDENT = 2;
+var longestLineOf = (text) => {
+  let longest = 0;
+  let current = 0;
+  for (const ch of text) {
+    if (ch === `
+`) {
+      longest = Math.max(longest, current);
+      current = 0;
+      continue;
+    }
+    current += 1;
+  }
+  return Math.max(longest, current);
+};
+var formatCasePlan = async (filePath) => {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(filePath);
+  if (!await fs.exists(resolved)) {
+    return {
+      ok: false,
+      message: `Case plan file not found: ${resolved}`,
+      instructions: "Pass the path to an existing case plan JSON file, for example 'uip maestro case format case.json'."
+    };
+  }
+  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
+  if (readError || raw == null) {
+    return {
+      ok: false,
+      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
+      instructions: `Verify read permissions on ${resolved}.`
+    };
+  }
+  const [parseError, document] = catchError(() => JSON.parse(raw));
+  if (parseError) {
+    return {
+      ok: false,
+      message: `Case plan is not valid JSON: ${parseError.message}`,
+      instructions: `Fix the JSON in ${resolved} before formatting it — formatting cannot repair a file it cannot parse.`
+    };
+  }
+  const formatted = `${JSON.stringify(document, null, INDENT)}
+`;
+  if (formatted === raw) {
+    return {
+      ok: true,
+      path: resolved,
+      changed: false,
+      lines: formatted.split(`
+`).length - 1,
+      longestLine: longestLineOf(formatted)
+    };
+  }
+  const [writeError] = await catchError(fs.writeFile(resolved, formatted));
+  if (writeError) {
+    return {
+      ok: false,
+      message: `Failed to write case plan: ${writeError.message}`,
+      instructions: `Verify write permissions on ${resolved}.`
+    };
+  }
+  return {
+    ok: true,
+    path: resolved,
+    changed: true,
+    lines: formatted.split(`
+`).length - 1,
+    longestLine: longestLineOf(formatted)
+  };
+};
+export {
+  formatCasePlan
+};
+
+//# debugId=E8837B95902F865564756E2164756E21

package/dist/{case-pack-service-8exkecnd.js → case-pack-service-29rza2q2.js}

@@ -5,6 +5,15 @@ import {
   NugetPackager,
   ensureProjectId
 } from "./packager-tool-sfkyb4kz.js";
+import {
+  CasePlanFileNames,
+  buildCasePackageDescriptor,
+  casePlanSidecarName,
+  entryPointBpmnNames,
+  findCasePlanFileName,
+  misnamedEntryPointBpmn,
+  resolveDeclaredFileName
+} from "./packager-tool-83qnybab.js";
 import"./packager-tool-b098y4a2.js";
 import {
   VALID_PACKAGE_NAME_REGEX
@@ -13,7 +22,7 @@ import {
   catchError,
   logger,
   mapPackageMetadataOptions
-} from "./packager-tool-4knkebkr.js";
+} from "./packager-tool-kpcjnxd1.js";
 import {
   getFileSystem
 } from "./packager-tool-0v3s8r01.js";
@@ -41,7 +50,7 @@ Packing Case project...
     logger.info(`  Output:   ${absoluteOutputPath}`);
     logger.info("");
     await this.validate(absoluteProjectPath);
-    await this.convertCaseToBpmnIfNeeded(absoluteProjectPath);
+    const casePlanFileName = await this.convertCaseToBpmn(absoluteProjectPath);
     await ensureProjectId(absoluteProjectPath, this.fs);
     await this.fs.mkdir(absoluteOutputPath);
     let tempDir;
@@ -49,7 +58,10 @@ Packing Case project...
       tempDir = await this.fs.getTempDir();
       const stagingDir = this.fs.path.join(tempDir, "case-pack-staging");
       await this.fs.mkdir(stagingDir);
-      await this.fs.copyDirectory(absoluteProjectPath, this.fs.path.join(stagingDir, "content"));
+      const contentDir = this.fs.path.join(stagingDir, "content");
+      await this.fs.copyDirectory(absoluteProjectPath, contentDir);
+      await this.checkEntryPointBpmn(contentDir, casePlanFileName);
+      await this.regeneratePackageDescriptor(contentDir);
       const packageId = `${packageName}.case.Case`;
       const version = options.version || "1.0.0";
       const nupkgPath = this.fs.path.join(absoluteOutputPath, `${packageId}.${version}.nupkg`);
@@ -74,18 +86,51 @@ Packing Case project...
       }
     }
   }
-  async convertCaseToBpmnIfNeeded(projectPath) {
-    const caseFilePath = this.fs.path.join(projectPath, "caseplan.json");
-    if (!await this.fs.exists(caseFilePath)) {
-      return;
+  async convertCaseToBpmn(projectPath) {
+    const casePlanFileName = findCasePlanFileName(await this.fs.readdir(projectPath));
+    if (!casePlanFileName) {
+      throw new Error(`No case plan in ${projectPath}. Expected one of ${CasePlanFileNames.join(", ")}.`);
     }
-    logger.info("Converting case JSON to BPMN...");
-    const caseContent = String(await this.fs.readFile(caseFilePath, "utf-8"));
+    logger.info("Converting case plan to BPMN...");
+    const caseContent = String(await this.fs.readFile(this.fs.path.join(projectPath, casePlanFileName), "utf-8"));
     const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
     const { bpmnXml: bpmn } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseContent);
-    const bpmnFilePath = this.fs.path.join(projectPath, "caseplan.json.bpmn");
+    const bpmnFilePath = this.fs.path.join(projectPath, casePlanSidecarName(casePlanFileName));
     await this.fs.writeFile(bpmnFilePath, bpmn);
     logger.info(`BPMN file written to ${bpmnFilePath}`);
+    return casePlanFileName;
+  }
+  async checkEntryPointBpmn(contentPath, casePlanFileName) {
+    const entryPointsPath = this.fs.path.join(contentPath, "entry-points.json");
+    if (!await this.fs.exists(entryPointsPath)) {
+      return;
+    }
+    const raw = await this.fs.readFile(entryPointsPath, "utf-8");
+    const declared = raw ? entryPointBpmnNames(String(raw)) : null;
+    if (declared === null) {
+      throw new Error(`entry-points.json in ${contentPath} could not be read as JSON, so pack cannot check that the BPMN it declares is in the package.`);
+    }
+    const firstEntry = firstEntryPointFileName(String(raw));
+    if (firstEntry && !declared.includes(firstEntry)) {
+      const own = casePlanSidecarName(casePlanFileName);
+      throw new Error(`entry-points.json's first entry point resolves to '${firstEntry}', which is not a declared .bpmn file this project ships, so it would deploy and activate and then fault every job. Point the first entry point at '${own}'.`);
+    }
+    const present = new Set(await this.fs.readdir(contentPath));
+    const missing = declared.filter((file) => !present.has(file));
+    if (missing.length > 0) {
+      throw new Error(`entry-points.json points at ${missing.join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job.`);
+    }
+    const misnamed = misnamedEntryPointBpmn(declared, casePlanFileName);
+    if (misnamed) {
+      const own = casePlanSidecarName(casePlanFileName);
+      throw new Error(`entry-points.json points at '${misnamed}', the sidecar of a case plan this project does not carry. '${casePlanFileName}' compiles to '${own}', so the entry point would resolve to a BPMN pack did not produce. Point it at '${own}'.`);
+    }
+  }
+  async regeneratePackageDescriptor(contentDir) {
+    const contentFiles = await this.fs.readdir(contentDir);
+    const descriptor = buildCasePackageDescriptor(contentFiles);
+    await this.fs.writeFile(this.fs.path.join(contentDir, "package-descriptor.json"), `${JSON.stringify(descriptor, null, 2)}
+`);
   }
   async validate(projectPath) {
     if (!await this.fs.exists(projectPath)) {
@@ -105,8 +150,13 @@ Packing Case project...
     }
   }
 }
+function firstEntryPointFileName(entryPointsJson) {
+  const parsed = JSON.parse(entryPointsJson);
+  const filePath = parsed.entryPoints?.[0]?.filePath ?? "";
+  return resolveDeclaredFileName(filePath);
+}
 export {
   CasePackService
 };
 
-//# debugId=96B15094B9DD778F64756E2164756E21
+//# debugId=AFB0C029C8C764C664756E2164756E21