@uipath/packager-tool-businessrules 1.202.1 → 1.203.0-preview.180

package/dist/business-rules-tool.d.ts

@@ -1,12 +1,13 @@
 import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
 import { ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
 /**
- * Business Rules project tool.
+ * Business Rules project tool. Only `packAsync` does anything.
  *
- * Only `packAsync` does anything. A rule ships as the `.dmn` itself, not wrapped
- * in a nupkg: `options.outputPath` is already `files/{projectId}` in the archive,
- * so copying the file there is the whole job. The solution's `businessRule`
- * resource points at it by file name.
+ * A rule ships as a `.uirule`, not wrapped in a nupkg: `options.outputPath` is already
+ * `files/{projectId}`, so writing the archive there is the whole job. The archive holds every
+ * `.dmn` plus `entry-points.json` at its root, and the manifest is where a deployed rule's argument
+ * contract is read from. Its `filePath` values keep a `/content/` prefix, which is an identifier
+ * inherited from the nupkg convention rather than a path into this archive.
  */
 export declare class BusinessRulesTool extends ProjectTool {
     restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
@@ -14,25 +15,47 @@ export declare class BusinessRulesTool extends ProjectTool {
     buildAsync(_options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
-     * `{ruleName}-{version}.dmn`, which is what Orchestrator's export handler
+     * The v1 artefact: the rule's single document, copied under the resource's name.
+     *
+     * Reached only when the project has no manifest. One document, because a v1 rule is addressed by
+     * file name alone -- several would leave the extras unreferenced, since the project has a single
+     * `businessRule` resource.
+     */
+    private copyRuleDocumentAsync;
+    /**
+     * `{ruleName}-{version}.uirule`, which is what Orchestrator's export handler
      * builds for the same rule. Publish and export have to agree on this or a
      * rule stops round-tripping between solutions.
      *
-     * `ruleName` is the name of the `businessRule` resource, never the `.dmn`
+     * `ruleName` is the name of the `businessRule` resource, never any `.dmn`
      * file's own basename — a project folder named "Business Rules" holding
-     * "Business rule.dmn" is what Studio Web produces today. Orchestrator takes
-     * the rule's name from the resource (`Spec.Name`) and rebuilds the file name
-     * from it on export, and the service reads a rule's version back out of this
-     * name by stripping the resource name off the front. Deriving the name from
-     * the `.dmn` would break both.
+     * "Business rule.dmn" is what Studio Web produces today, and with several
+     * documents in the project no single basename could stand for the rule
+     * anyway. Orchestrator takes the rule's name from the resource (`Spec.Name`)
+     * and rebuilds the file name from it on export, and the service reads a
+     * rule's version back out of this name by stripping the resource name off
+     * the front. Deriving the name from a document would break both.
      *
      * So resolve it the way `solution projects add` does when it registers the
      * resource: `project.uiproj`'s `Name`, falling back to the folder. Blank also
      * falls back — `projects add` passes an empty `Name` through, but here it
-     * would produce a file called "-1.0.0.dmn".
+     * would produce a file called "-1.0.0.uirule".
      *
      * Returns `undefined` when the declared name cannot be used in a file name.
      */
     private resolveRuleName;
+    /**
+     * The document names the manifest declares, or `null` when it cannot be read.
+     *
+     * `filePath` is an identifier of the form `/content/{file}#{decisionId}` -- the `/content/`
+     * prefix is inherited from the nupkg convention and does not describe the archive, which is
+     * flat -- so only the file name is kept.
+     *
+     * A manifest that declares no entry points is readable and returns an empty list. That is the
+     * caller's to allow: it ships a `.uirule` exposing nothing, which is what the designer wrote.
+     */
+    private readDeclaredDocuments;
+    /** Declared documents that are not among the packed entries. */
+    private declaredDocumentsMissingFrom;
     private findRuleFiles;
 }

package/dist/index.js

@@ -11,9 +11,12 @@ import {
   Path,
   ProjectTool,
   ToolErrorCodes,
-  ToolResult
+  ToolResult,
+  ZipService
 } from "@uipath/solutionpackager-tool-core";
 var DmnExtension = ".dmn";
+var RuleArchiveExtension = ".uirule";
+var EntryPointsFileName = "entry-points.json";
 var ReservedInFileName = /[<>:"/\\|?*]/;
 function isUsableInFileName(name) {
   return !ReservedInFileName.test(name) && ![...name].some((character) => character.charCodeAt(0) < 32);
@@ -38,22 +41,38 @@ class BusinessRulesTool extends ProjectTool {
       if (ruleFiles.length === 0) {
         return ToolResult.error(ToolErrorCodes.InternalError, `No ${DmnExtension} file found in ${options.projectPath}.`, "Add a decision to the project, then pack again.");
       }
-      if (ruleFiles.length > 1) {
-        return ToolResult.error(ToolErrorCodes.InternalError, `Found ${ruleFiles.length} ${DmnExtension} files in ${options.projectPath}, expected one.`, `Keep one decision per project and move the rest to their own projects.`);
-      }
-      const sourceFile = ruleFiles[0];
       const ruleName = await this.resolveRuleName(options);
       if (ruleName === undefined) {
         return ToolResult.error(ToolErrorCodes.InternalError, `The project name in project.uiproj cannot be used in a file name.`, `Rename the project so its name has no path separators and none of < > : " | ? * characters.`);
       }
-      const targetName = `${ruleName}-${options.package.version}${DmnExtension}`;
-      const targetFile = Path.join(options.outputPath, targetName);
-      this.logger.progress(`Copying ${targetName}...`);
-      const content = await this.fileSystem.readFile(sourceFile);
-      if (!content) {
-        return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${sourceFile}.`);
+      const manifest = await this.fileSystem.readFile(Path.join(options.projectPath, EntryPointsFileName));
+      if (!manifest || manifest.length === 0) {
+        this.logger.warn(`No ${EntryPointsFileName} in ${options.projectPath}, so the rule ships as a ${DmnExtension} and exposes no arguments. Open the project in Studio Web and save it to write its entry points.`);
+        return this.copyRuleDocumentAsync(options, ruleFiles, ruleName);
+      }
+      const declared = this.readDeclaredDocuments(manifest);
+      if (declared === null) {
+        return ToolResult.error(ToolErrorCodes.InternalError, `${EntryPointsFileName} in ${options.projectPath} is not valid JSON.`, `Open the project in Studio Web and save it to rewrite its entry points, then pack again.`);
+      }
+      const entries = {
+        [EntryPointsFileName]: manifest
+      };
+      for (const ruleFile of ruleFiles) {
+        const content = await this.fileSystem.readFile(ruleFile);
+        if (!content) {
+          return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${ruleFile}.`);
+        }
+        entries[Path.basename(ruleFile)] = content;
       }
-      await this.fileSystem.writeFile(targetFile, content);
+      const missing = this.declaredDocumentsMissingFrom(declared, entries);
+      if (missing.length > 0) {
+        return ToolResult.error(ToolErrorCodes.InternalError, `${EntryPointsFileName} names ${missing.join(", ")}, which ${missing.length === 1 ? "is" : "are"} not in ${options.projectPath}.`, `Move every .dmn the rule uses to the top level of the project, then pack again.`);
+      }
+      const targetName = `${ruleName}-${options.package.version}${RuleArchiveExtension}`;
+      const targetFile = Path.join(options.outputPath, targetName);
+      this.logger.progress(`Packing ${ruleFiles.length} ${DmnExtension} file(s) into ${targetName}...`);
+      const archive = new ZipService(this.fileSystem).compressEntries(entries);
+      await this.fileSystem.writeFile(targetFile, archive);
       return new ToolResult(ToolErrorCodes.Success, "done", []);
     } catch (error) {
       const message = error instanceof Error ? error.toString() : String(error);
@@ -61,6 +80,19 @@ class BusinessRulesTool extends ProjectTool {
       return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing the Business Rules project");
     }
   }
+  async copyRuleDocumentAsync(options, ruleFiles, ruleName) {
+    if (ruleFiles.length > 1) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Found ${ruleFiles.length} ${DmnExtension} files in ${options.projectPath}, expected one.`, `Keep one decision per project and move the rest to their own projects, or save the project in Studio Web so its entry points name the callable one.`);
+    }
+    const content = await this.fileSystem.readFile(ruleFiles[0]);
+    if (!content) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Could not read ${ruleFiles[0]}.`);
+    }
+    const targetName = `${ruleName}-${options.package.version}${DmnExtension}`;
+    this.logger.progress(`Copying ${targetName}...`);
+    await this.fileSystem.writeFile(Path.join(options.outputPath, targetName), content);
+    return new ToolResult(ToolErrorCodes.Success, "done", []);
+  }
   async resolveRuleName(options) {
     const uiProject = await this.getUiProjectAsync(options.projectPath);
     const declared = uiProject?.Name?.trim();
@@ -69,6 +101,18 @@ class BusinessRulesTool extends ProjectTool {
     }
     return isUsableInFileName(declared) ? declared : undefined;
   }
+  readDeclaredDocuments(manifest) {
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(manifest));
+      return (parsed.entryPoints ?? []).map((entryPoint) => entryPoint.filePath).filter((filePath) => !!filePath).map((filePath) => Path.basename(filePath.split("#")[0]));
+    } catch {
+      return null;
+    }
+  }
+  declaredDocumentsMissingFrom(declared, entries) {
+    const packed = new Set(Object.keys(entries));
+    return [...new Set(declared)].filter((document) => !packed.has(document));
+  }
   async findRuleFiles(projectPath) {
     const entries = await this.fileSystem.readdir(projectPath);
     const ruleFiles = [];
@@ -103,4 +147,4 @@ export {
   BusinessRulesToolFactory
 };
 
-//# debugId=4D84B4901B7D0E3264756E2164756E21
+//# debugId=FC8F16D6B30A334C64756E2164756E21

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-businessrules",
-    "version": "1.202.1",
+    "version": "1.203.0-preview.180",
     "description": "UiPath Business Rules tool implementation",
     "type": "module",
     "exports": {
@@ -18,10 +18,10 @@
     "files": [
         "dist"
     ],
-    "author": "",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.202.1"
+        "@uipath/solutionpackager-tool-core": "1.203.0"
     },
-    "gitHead": "280b581b7893224d512dd194f47dd57243cc6a5c"
+    "gitHead": "4e0a51e3ab2c9d89afd3d35a7b087a7fa58133a0"
 }