@uipath/maestro-tool 0.1.10 → 0.1.12

package/dist/packager-tool.js

@@ -0,0 +1,168 @@
+// ../packager/packager-tool-bpmn/src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// ../packager/packager-tool-bpmn/src/bpmn-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes2
+} from "@uipath/solutionpackager-tool-core";
+
+// ../packager/packager-tool-bpmn/src/bpmn-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  ProjectTypes,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+var BpmnConstants = {
+  EntryPointsFileName: "entry-points.json",
+  BindingsV2FileName: "bindings_v2.json"
+};
+
+class BpmnTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for ProcessOrchestration projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for ProcessOrchestration projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    try {
+      this.logger.progress("Copying files...");
+      await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress("Creating operate.json file...");
+      await this.createOperateFile(options, contentFolder);
+      this.logger.progress("Creating package-descriptor.json file...");
+      await this.createPackageDescriptor(localBuildFolder, contentFolder);
+      return new ToolResult(ToolErrorCodes.Success, "done", [
+        localBuildFolder
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while building ProcessOrchestration project files");
+    }
+  }
+  async packAsync(options, cancellationToken) {
+    const buildResult = await this.buildAsync(options, cancellationToken);
+    if (!buildResult.isSuccess) {
+      return buildResult;
+    }
+    const localBuildFolder = buildResult.packages[0];
+    try {
+      this.logger.progress("Creating NuGet package...");
+      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
+      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
+      this.logger.progress("Package created successfully");
+      return new ToolResult(ToolErrorCodes.Success, "done", [
+        result.outputPath
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, "An error occurred while packing ProcessOrchestration project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing ProcessOrchestration Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async copyFiles(sourcePath, destinationPath) {
+    await this.fileSystem.mkdir(destinationPath);
+    const files = await this.fileSystem.readdir(sourcePath);
+    for (const file of files) {
+      const sourceFile = Path.join(sourcePath, file);
+      const destinationFile = Path.join(destinationPath, file);
+      const stat = await this.fileSystem.stat(sourceFile);
+      if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceFile);
+        if (content) {
+          await this.fileSystem.writeFile(destinationFile, content);
+        }
+      }
+    }
+  }
+  async createOperateFile(options, contentFolder) {
+    const operateJsonFilePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const exists = await this.fileSystem.exists(operateJsonFilePath);
+    if (!exists) {
+      await this.createOperateJsonFile(contentFolder, options.projectStorageId ?? "", operateJsonFilePath);
+    }
+  }
+  async createOperateJsonFile(projectPath, projectId, filePath) {
+    const entryPointsFilePath = Path.join(projectPath, BpmnConstants.EntryPointsFileName);
+    let mainPath = "";
+    const entryPointsExists = await this.fileSystem.exists(entryPointsFilePath);
+    if (entryPointsExists) {
+      const entryPointsContent = await this.fileSystem.readFile(entryPointsFilePath);
+      if (entryPointsContent) {
+        try {
+          const entryPointsText = new TextDecoder().decode(entryPointsContent);
+          const entryPoints = JSON.parse(entryPointsText);
+          mainPath = entryPoints.entryPoints?.[0]?.filePath ?? "";
+        } catch {}
+      }
+    }
+    const operateFileModel = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+      contentType: ProjectTypes.ProcessOrchestration,
+      projectId,
+      main: mainPath,
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    };
+    const operateJsonString = JSON.stringify(operateFileModel, null, 2);
+    await this.fileSystem.writeFile(filePath, operateJsonString);
+  }
+  async createPackageDescriptor(localBuildFolder, contentFolder) {
+    const descriptorFiles = {};
+    descriptorFiles[NugetConstants.OperateFileName] = Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
+    descriptorFiles[BpmnConstants.EntryPointsFileName] = Path.join(NugetConstants.ContentFolderName, BpmnConstants.EntryPointsFileName);
+    descriptorFiles[NugetConstants.BindingsFileId] = Path.join(NugetConstants.ContentFolderName, BpmnConstants.BindingsV2FileName);
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    for (const file of contentFiles) {
+      if (file.endsWith(".bpmn")) {
+        descriptorFiles[file] = Path.join(NugetConstants.ContentFolderName, file);
+      }
+    }
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorJson = JSON.stringify({
+      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+      files: descriptorFiles
+    }, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+}
+
+// ../packager/packager-tool-bpmn/src/bpmn-tool-factory.ts
+class BpmnToolFactory {
+  supportedTypes = [
+    ProjectTypes2.ProcessOrchestration
+  ];
+  async createAsync(logger, fileSystem) {
+    return new BpmnTool(fileSystem, logger);
+  }
+}
+
+// ../packager/packager-tool-bpmn/src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new BpmnToolFactory);