@uipath/case-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/README.md

@@ -96,7 +96,7 @@ field:in=value1|value2        field matches any of the values
 field1=v1,field2=v2           multiple conditions (AND logic)
 ```
 
-Filterable fields: `name`, `description`, `category`, `tags`
+Filterable fields: `name`, `title`, `description`, `category`, `connectorKey`, `systemName`, `tags`
 
 **Examples:**
 

package/dist/{authoring-k4xzp7fh.js → authoring-aaaqwck3.js}

@@ -1,10 +1,13 @@
+import {
+  resolveMaestroRegistry
+} from "./packager-tool-we1phz71.js";
 import {
   OutputFormatter,
   RESULTS,
   getOutputFormat,
   getOutputFormatExplicit,
   processContext
-} from "./packager-tool-pcd0vhvd.js";
+} from "./packager-tool-zx48pq4v.js";
 import {
   getFileSystem
 } from "./packager-tool-1cb0d5e0.js";
@@ -74,37 +77,70 @@ async function runChild(cliPath, args, cwd, label) {
     });
   });
 }
-async function delegateToFlowSdk({
-  family,
-  commandVerb,
-  sdkVerb = commandVerb,
-  argv,
-  cwd
-}) {
+async function resolveFlowSdk(workspace, label) {
   const fs = getFileSystem();
-  const workspace = cwd ?? fs.env.cwd();
-  const label = commandLabel(family, commandVerb);
   let packagePath;
   try {
     packagePath = createRequire(import.meta.url).resolve("@uipath/flow-sdk/package.json", { paths: [workspace] });
   } catch {
-    return fail(`${label}: @uipath/flow-sdk is not installed in this workspace.`, "Add it to this project's dependencies: npm install --save-dev @uipath/flow-sdk (requires an .npmrc routing @uipath to https://npm.pkg.github.com/).");
+    return {
+      ok: false,
+      message: `${label}: @uipath/flow-sdk is not installed in this workspace.`,
+      instructions: "Add it to this project's dependencies: npm install --save-dev @uipath/flow-sdk (requires an .npmrc routing @uipath to https://npm.pkg.github.com/)."
+    };
   }
   const packageText = await fs.readFile(packagePath, "utf-8");
   if (packageText === null) {
-    return fail(`${label}: could not read ${packagePath}.`, "Reinstall @uipath/flow-sdk, then retry.");
+    return {
+      ok: false,
+      message: `${label}: could not read ${packagePath}.`,
+      instructions: "Reinstall @uipath/flow-sdk, then retry."
+    };
   }
-  let version;
+  let version = "";
+  let bin = {};
   try {
     const parsed = JSON.parse(packageText);
     version = typeof parsed.version === "string" ? parsed.version : "";
+    if (parsed.bin && typeof parsed.bin === "object") {
+      for (const [name, target] of Object.entries(parsed.bin)) {
+        if (typeof target === "string")
+          bin[name] = target;
+      }
+    }
   } catch {
     version = "";
+    bin = {};
   }
   if (!versionMeetsFloor(version, MINIMUM_FLOW_SDK_VERSION)) {
-    return fail(`${label}: found @uipath/flow-sdk ${version || "with no valid version"}; need >= ${MINIMUM_FLOW_SDK_VERSION}.`, "Run: npm install --save-dev @uipath/flow-sdk@latest.");
+    return {
+      ok: false,
+      message: `${label}: found @uipath/flow-sdk ${version || "with no valid version"}; need >= ${MINIMUM_FLOW_SDK_VERSION}.`,
+      instructions: "Run: npm install --save-dev @uipath/flow-sdk@latest."
+    };
+  }
+  return {
+    ok: true,
+    packageDir: fs.path.dirname(packagePath),
+    version,
+    bin
+  };
+}
+async function delegateToFlowSdk({
+  family,
+  commandVerb,
+  sdkVerb = commandVerb,
+  argv,
+  cwd
+}) {
+  const fs = getFileSystem();
+  const workspace = cwd ?? fs.env.cwd();
+  const label = commandLabel(family, commandVerb);
+  const resolution = await resolveFlowSdk(workspace, label);
+  if (!resolution.ok) {
+    return fail(resolution.message, resolution.instructions);
   }
-  const cliPath = fs.path.join(fs.path.dirname(packagePath), "dist", "cli", "index.js");
+  const cliPath = fs.path.join(resolution.packageDir, "dist", "cli", "index.js");
   return await runChild(cliPath, [family, sdkVerb, ...argv], workspace, label);
 }
 
@@ -122,6 +158,14 @@ function sdkCliExample(description, command, message) {
   ];
 }
 
+// ../builder-sdk/src/library-option.ts
+async function resolveLibraryOption(explicit) {
+  if (explicit !== undefined)
+    return explicit;
+  const registry = await resolveMaestroRegistry();
+  return registry?.libraryJson;
+}
+
 // ../builder-sdk/src/commands/check.ts
 var CHECK_EXAMPLES = {
   flow: { input: "Order.flow.ts", message: "✓ no issues" },
@@ -131,7 +175,7 @@ var CHECK_EXAMPLES = {
 var registerCheckCommand = (program, family) => {
   const command = program.previewCommand("check <input>").description("Run the authoring-time SDK analyzer on source or an artifact.").option("--source", "Check authored TypeScript").option("--compiled", "Check the compiled artifact");
   if (family === "flow") {
-    command.option("--library <dir>", "Connector library directory (source checks also honor $FLOW_SDK_LIBRARY_JSON)").option("--json", "Print compiled-check diagnostics as JSON").option("--uip", "Resolve missing schemas with the UiPath CLI").option("--max-errors <count>", "Stop after this many compiled-check errors").option("--script-determinism", "Check script blocks for non-deterministic calls").option("--quiet", "Suppress warnings and information");
+    command.option("--library <dir>", "Connector library directory (defaults to the pulled registry; source checks also honor $FLOW_SDK_LIBRARY_JSON)").option("--json", "Print compiled-check diagnostics as JSON").option("--uip", "Resolve missing schemas with the UiPath CLI").option("--max-errors <count>", "Stop after this many compiled-check errors").option("--script-determinism", "Check script blocks for non-deterministic calls").option("--quiet", "Suppress warnings and information");
   }
   const example = CHECK_EXAMPLES[family];
   command.examples(sdkCliExample(`Check a ${family} source file before compiling it`, `uip maestro ${family} check ${example.input} --source`, example.message)).trackedAction(processContext, async (input, options) => {
@@ -140,7 +184,7 @@ var registerCheckCommand = (program, family) => {
       argv.push("--source");
     if (options.compiled)
       argv.push("--compiled");
-    addValue(argv, "--library", options.library);
+    addValue(argv, "--library", await resolveLibraryOption(options.library));
     if (options.json || getOutputFormatExplicit() && getOutputFormat() === "json")
       argv.push("--json");
     if (options.uip)
@@ -178,7 +222,7 @@ var COMPILE_EXAMPLES = {
   }
 };
 var registerCompileCommand = (program, family) => {
-  const command = program.previewCommand("compile <source>").description(`Compile authored TypeScript to a ${family} artifact.`).option("-o, --output <file>", "Output artifact path").option("--library <dir>", "Connector library directory").option("--bindings <file>", "bindings.json path");
+  const command = program.previewCommand("compile <source>").description(`Compile authored TypeScript to a ${family} artifact.`).option("-o, --output <file>", "Output artifact path").option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--bindings <file>", "bindings.json path");
   if (family !== "bpmn") {
     command.option("--connectors-local <dir>", "Connection-resolved connector overlay");
   }
@@ -189,7 +233,7 @@ var registerCompileCommand = (program, family) => {
   command.examples(sdkCliExample(`Compile a ${family} source file to an artifact`, `uip maestro ${family} compile ${example.source} --output ${example.output}`, example.message)).trackedAction(processContext, async (source, options) => {
     const argv = [source];
     addValue(argv, "-o", options.output);
-    addValue(argv, "--library", options.library);
+    addValue(argv, "--library", await resolveLibraryOption(options.library));
     addValue(argv, "--bindings", options.bindings);
     addValue(argv, "--connectors-local", options.connectorsLocal);
     if (options.check === false)
@@ -249,4 +293,4 @@ export {
   registerCaseAuthoringCommands
 };
 
-//# debugId=15A8978EA34C2B0F64756E2164756E21
+//# debugId=847E8056C2AECFF464756E2164756E21

package/dist/case-pack-service-96tjknaz.js

@@ -0,0 +1,119 @@
+import {
+  NugetPackager,
+  ensureProjectId
+} from "./packager-tool-wvqz81mx.js";
+import {
+  VALID_PACKAGE_NAME_REGEX,
+  loadCaseSchemaAsync
+} from "./packager-tool-8f28ypk9.js";
+import"./packager-tool-we1phz71.js";
+import"./packager-tool-zqa5k9f7.js";
+import {
+  catchError,
+  logger,
+  mapPackageMetadataOptions
+} from "./packager-tool-zx48pq4v.js";
+import"./packager-tool-cqrsre00.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-1yy9x4vk.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-b098y4a2.js";
+import"./packager-tool-9qecd4wb.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  getFileSystem
+} from "./packager-tool-1cb0d5e0.js";
+import"./packager-tool-5arsyj36.js";
+import"./packager-tool-wckvcay0.js";
+
+// src/services/case-pack-service.ts
+class CasePackService {
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async execute(projectPath, options) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const absoluteOutputPath = this.fs.path.resolve(options.output);
+    const packageName = options.name || this.fs.path.basename(projectPath);
+    if (!VALID_PACKAGE_NAME_REGEX.test(packageName)) {
+      throw new Error(`Invalid package name "${packageName}". Package name can only contain letters, numbers, dots (.), underscores (_), and hyphens (-).`);
+    }
+    logger.info(`
+Packing Case project...
+`);
+    logger.info("Details:");
+    logger.info(`  Project:  ${absoluteProjectPath}`);
+    logger.info(`  Package:  ${packageName}@${options.version}`);
+    logger.info(`  Output:   ${absoluteOutputPath}`);
+    logger.info("");
+    await this.validate(absoluteProjectPath);
+    await this.convertCaseToBpmnIfNeeded(absoluteProjectPath);
+    await ensureProjectId(absoluteProjectPath, this.fs);
+    await this.fs.mkdir(absoluteOutputPath);
+    let tempDir;
+    try {
+      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 packageId = `${packageName}.case.Case`;
+      const version = options.version || "1.0.0";
+      const nupkgPath = this.fs.path.join(absoluteOutputPath, `${packageId}.${version}.nupkg`);
+      const packager = new NugetPackager(this.fs);
+      const result = await packager.packAsync(stagingDir, {
+        id: packageId,
+        version,
+        tags: "Case",
+        ...mapPackageMetadataOptions(options)
+      }, nupkgPath);
+      return {
+        packageName: `${packageName}@${options.version}`,
+        outputPath: result.outputPath
+      };
+    } finally {
+      if (tempDir) {
+        await catchError((async () => {
+          if (await this.fs.exists(tempDir)) {
+            await this.fs.rm(tempDir);
+          }
+        })());
+      }
+    }
+  }
+  async convertCaseToBpmnIfNeeded(projectPath) {
+    const caseFilePath = this.fs.path.join(projectPath, "caseplan.json");
+    if (!await this.fs.exists(caseFilePath)) {
+      return;
+    }
+    logger.info("Converting case JSON to BPMN...");
+    const caseContent = String(await this.fs.readFile(caseFilePath, "utf-8"));
+    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await loadCaseSchemaAsync();
+    const { bpmnXml: bpmn } = await serializeCaseDiskJsonToBpmnAndRulesJson(caseContent);
+    const bpmnFilePath = this.fs.path.join(projectPath, "caseplan.json.bpmn");
+    await this.fs.writeFile(bpmnFilePath, bpmn);
+    logger.info(`BPMN file written to ${bpmnFilePath}`);
+  }
+  async validate(projectPath) {
+    if (!await this.fs.exists(projectPath)) {
+      throw new Error(`Project path does not exist: ${projectPath}`);
+    }
+    const stats = await this.fs.stat(projectPath);
+    if (!stats?.isDirectory()) {
+      throw new Error(`Project path must be a directory: ${projectPath}`);
+    }
+    const descriptorPath = this.fs.path.join(projectPath, "package-descriptor.json");
+    if (!await this.fs.exists(descriptorPath)) {
+      throw new Error(`Missing package-descriptor.json in: ${projectPath}`);
+    }
+    const operatePath = this.fs.path.join(projectPath, "operate.json");
+    if (!await this.fs.exists(operatePath)) {
+      throw new Error(`Missing operate.json in: ${projectPath}`);
+    }
+  }
+}
+export {
+  CasePackService
+};
+
+//# debugId=3F3DF77D1086226264756E2164756E21