@uipath/packager-tool-businessrules 1.202.0-preview.134

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

@@ -0,0 +1,8 @@
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+/**
+ * Factory for creating Business Rules project tools
+ */
+export declare class BusinessRulesToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

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

@@ -0,0 +1,38 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Business Rules project tool.
+ *
+ * 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.
+ */
+export declare class BusinessRulesTool extends ProjectTool {
+    restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(_options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    buildAsync(_options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * `{ruleName}-{version}.dmn`, 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`
+     * 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.
+     *
+     * 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".
+     *
+     * Returns `undefined` when the declared name cannot be used in a file name.
+     */
+    private resolveRuleName;
+    private findRuleFiles;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { BusinessRulesToolFactory } from "./business-rules-tool-factory.js";
+export { BusinessRulesTool } from "./business-rules-tool.js";
+export { BusinessRulesToolFactory };

package/dist/index.js

@@ -0,0 +1,106 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/business-rules-tool-factory.ts
+import {
+  ProjectTypes
+} from "@uipath/solutionpackager-tool-core";
+
+// src/business-rules-tool.ts
+import {
+  Path,
+  ProjectTool,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+var DmnExtension = ".dmn";
+var ReservedInFileName = /[<>:"/\\|?*]/;
+function isUsableInFileName(name) {
+  return !ReservedInFileName.test(name) && ![...name].some((character) => character.charCodeAt(0) < 32);
+}
+
+class BusinessRulesTool extends ProjectTool {
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for Business Rules projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Business Rules projects");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is not required for Business Rules projects");
+    return ToolResult.success();
+  }
+  async packAsync(options, _cancellationToken) {
+    try {
+      const ruleFiles = await this.findRuleFiles(options.projectPath);
+      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}.`);
+      }
+      await this.fileSystem.writeFile(targetFile, content);
+      return new ToolResult(ToolErrorCodes.Success, "done", []);
+    } catch (error) {
+      const message = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(message);
+      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing the Business Rules project");
+    }
+  }
+  async resolveRuleName(options) {
+    const uiProject = await this.getUiProjectAsync(options.projectPath);
+    const declared = uiProject?.Name?.trim();
+    if (!declared) {
+      return Path.basename(options.projectPath);
+    }
+    return isUsableInFileName(declared) ? declared : undefined;
+  }
+  async findRuleFiles(projectPath) {
+    const entries = await this.fileSystem.readdir(projectPath);
+    const ruleFiles = [];
+    for (const entry of entries) {
+      if (!entry.toLowerCase().endsWith(DmnExtension)) {
+        continue;
+      }
+      const fullPath = Path.join(projectPath, entry);
+      const stat = await this.fileSystem.stat(fullPath);
+      if (stat?.isFile()) {
+        ruleFiles.push(fullPath);
+      }
+    }
+    return ruleFiles;
+  }
+}
+
+// src/business-rules-tool-factory.ts
+class BusinessRulesToolFactory {
+  supportedTypes = [
+    ProjectTypes.BusinessRules
+  ];
+  async createAsync(logger, fileSystem) {
+    return new BusinessRulesTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new BusinessRulesToolFactory);
+export {
+  BusinessRulesTool,
+  BusinessRulesToolFactory
+};
+
+//# debugId=4D84B4901B7D0E3264756E2164756E21

package/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@uipath/packager-tool-businessrules",
+    "version": "1.202.0-preview.134",
+    "description": "UiPath Business Rules tool implementation",
+    "type": "module",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/cli.git",
+        "directory": "packages/packager/packager-tool-businessrules"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "author": "",
+    "license": "ISC",
+    "peerDependencies": {
+        "@uipath/solutionpackager-tool-core": "1.202.0"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.2",
+        "@uipath/solutionpackager-tool-core": "1.202.0",
+        "@vitest/browser": "^4.1.6",
+        "@vitest/browser-playwright": "^4.1.6",
+        "@vitest/coverage-v8": "^4.1.6",
+        "playwright": "^1.57.0",
+        "typescript": "^7.0.2",
+        "vitest": "^4.1.6"
+    },
+    "gitHead": "a335728adbdb02f28308e4f55d8936d0b150444b"
+}

package/src/business-rules-tool-factory.ts

@@ -0,0 +1,25 @@
+import {
+    type IFileSystem,
+    type IProjectToolFactory,
+    type IToolLogger,
+    type ProjectTool,
+    type ProjectType,
+    ProjectTypes,
+} from "@uipath/solutionpackager-tool-core";
+import { BusinessRulesTool } from "./business-rules-tool.js";
+
+/**
+ * Factory for creating Business Rules project tools
+ */
+export class BusinessRulesToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[] = [
+        ProjectTypes.BusinessRules,
+    ];
+
+    async createAsync(
+        logger: IToolLogger,
+        fileSystem: IFileSystem,
+    ): Promise<ProjectTool> {
+        return new BusinessRulesTool(fileSystem, logger);
+    }
+}

package/src/business-rules-tool.ts

@@ -0,0 +1,198 @@
+import type {
+    IProjectBuildOptions,
+    IProjectPackOptions,
+    IProjectRestoreOptions,
+    IProjectValidateOptions,
+} from "@uipath/solutionpackager-tool-core";
+import {
+    Path,
+    ProjectTool,
+    ToolErrorCodes,
+    ToolResult,
+} from "@uipath/solutionpackager-tool-core";
+
+const DmnExtension = ".dmn";
+
+// Path separators and the characters no mainstream filesystem accepts in a name.
+// `.`/`..` are not listed: the name always gains a "-{version}.dmn" suffix, so the
+// final path segment can never be either of them.
+const ReservedInFileName = /[<>:"/\\|?*]/;
+
+/** Whether `name` can stand as one segment of a file path. */
+function isUsableInFileName(name: string): boolean {
+    // Control characters are matched by code point rather than folded into the regex
+    // above: a control character inside a regex literal is itself a lint error.
+    return (
+        !ReservedInFileName.test(name) &&
+        ![...name].some((character) => character.charCodeAt(0) < 0x20)
+    );
+}
+
+/**
+ * Business Rules project tool.
+ *
+ * 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.
+ */
+export class BusinessRulesTool extends ProjectTool {
+    override async restoreAsync(
+        _options: IProjectRestoreOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Restore operation is not required for Business Rules projects",
+        );
+        return ToolResult.success();
+    }
+
+    override async validateAsync(
+        _options: IProjectValidateOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Validate operation is not required for Business Rules projects",
+        );
+        return ToolResult.success();
+    }
+
+    override async buildAsync(
+        _options: IProjectBuildOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Build operation is not required for Business Rules projects",
+        );
+        return ToolResult.success();
+    }
+
+    override async packAsync(
+        options: IProjectPackOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        try {
+            const ruleFiles = await this.findRuleFiles(options.projectPath);
+
+            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.",
+                );
+            }
+
+            // One rule per project today. Copying several would leave the extra
+            // files unreferenced, since the project has a single businessRule
+            // resource — so say so instead of packing something deploy can't place.
+            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}.`,
+                );
+            }
+            await this.fileSystem.writeFile(targetFile, content);
+
+            // Empty on purpose. A non-.nupkg path here breaks solution signing:
+            // the resolver finds nothing for it and the sign step fails hard.
+            // Nothing to resolve is safe.
+            return new ToolResult(ToolErrorCodes.Success, "done", []);
+        } catch (error: unknown) {
+            const message =
+                error instanceof Error ? error.toString() : String(error);
+            this.logger.error(message);
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                "An error occurred while packing the Business Rules project",
+            );
+        }
+    }
+
+    /**
+     * `{ruleName}-{version}.dmn`, 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`
+     * 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.
+     *
+     * 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".
+     *
+     * Returns `undefined` when the declared name cannot be used in a file name.
+     */
+    private async resolveRuleName(
+        options: IProjectPackOptions,
+    ): Promise<string | undefined> {
+        const uiProject = await this.getUiProjectAsync(options.projectPath);
+        const declared = uiProject?.Name?.trim();
+
+        // Absent or blank: `projects add` names the resource after the folder too,
+        // so the two still agree.
+        if (!declared) {
+            return Path.basename(options.projectPath);
+        }
+
+        // `project.uiproj` travels inside the solution, so `Name` is untrusted input
+        // that reaches a file path. `Path.join` only normalizes separators — it does
+        // not resolve `..` — so "../../x" would write outside `options.outputPath`.
+        // Falling back to the folder is not the answer either: the artefact name has
+        // to match the resource name or the service cannot read the version back off
+        // it, so an unusable name is reported rather than quietly replaced.
+        return isUsableInFileName(declared) ? declared : undefined;
+    }
+
+    private async findRuleFiles(projectPath: string): Promise<string[]> {
+        const entries = await this.fileSystem.readdir(projectPath);
+        const ruleFiles: string[] = [];
+
+        for (const entry of entries) {
+            if (!entry.toLowerCase().endsWith(DmnExtension)) {
+                continue;
+            }
+
+            const fullPath = Path.join(projectPath, entry);
+            const stat = await this.fileSystem.stat(fullPath);
+            if (stat?.isFile()) {
+                ruleFiles.push(fullPath);
+            }
+        }
+
+        // Deliberately unordered: packAsync only reads element 0 when there is exactly
+        // one, and the "more than one" error reports the count rather than a file, so
+        // nothing downstream can observe the order.
+        return ruleFiles;
+    }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+// Business Rules tool factory.
+//
+// Self-registers on import so micro-frontend consumers (whose MFEs UiPath does
+// not control) that load this package via a side-effect import get the factory
+// registered automatically — StudioWeb does not reference this package, so it
+// relies on self-registration. Also exported for consumers that register
+// explicitly; re-registering the same factory class is an idempotent no-op.
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+import { BusinessRulesToolFactory } from "./business-rules-tool-factory.js";
+
+toolsFactoryRepository.registerProjectToolFactory(
+    new BusinessRulesToolFactory(),
+);
+
+export { BusinessRulesTool } from "./business-rules-tool.js";
+export { BusinessRulesToolFactory };