@hahnpro/flow-cli 2.17.20 → 2025.10.0

package/main.js

@@ -0,0 +1,1020 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// lib/flow-cli/src/main.ts
+import "reflect-metadata";
+import "dotenv/config";
+import fs2 from "node:fs";
+import path3 from "node:path";
+import archiver from "archiver";
+import Axios from "axios";
+import { Command } from "commander";
+import copyfiles from "copyfiles";
+import { execa } from "execa";
+import FormData from "form-data";
+import { glob } from "glob";
+import { HttpsProxyAgent as HttpsProxyAgent2 } from "https-proxy-agent";
+import ora from "ora";
+
+// lib/flow-cli/src/auth.ts
+import path2 from "node:path";
+import express from "express";
+import getPort from "get-port";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import nconf from "nconf";
+import open from "open";
+import openidClient, { custom } from "openid-client";
+
+// lib/flow-cli/src/utils.ts
+import fs from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+var defaultLogger = {
+  /* eslint-disable no-console */
+  log: console.log,
+  error: console.error,
+  ok: console.info
+  /* eslint-enable no-console */
+};
+function checkTypes(definedTypes, propertiesSchema, jsonPath, logger1 = defaultLogger) {
+  const knownTypes = /* @__PURE__ */ new Set([
+    ...definedTypes,
+    "string",
+    "undefined",
+    "number",
+    "boolean",
+    "any",
+    "object",
+    "array",
+    "integer",
+    "Asset",
+    "AssetType",
+    "Flow",
+    "Secret",
+    "TimeSeries"
+  ]);
+  const properties = propertiesSchema.properties || {};
+  for (const property of Object.keys(properties)) {
+    if (properties[property].type && !knownTypes.has(properties[property].type)) {
+      logger1.error(
+        `ERROR: unknown type ${properties[property].type}.
+       Please add a schema for this type in ${jsonPath}
+       for more info check the documentation`
+      );
+      return false;
+    }
+  }
+  return true;
+}
+async function getTypes(filePath) {
+  try {
+    const json = JSON.parse(await fs.readFile(path.join(process.cwd(), filePath), "utf-8"));
+    return json.definitions ? Object.keys(json.definitions) : [];
+  } catch {
+    return [];
+  }
+}
+async function handleConvertedOutput(result, jsonPath, json, logger1 = defaultLogger) {
+  let schema;
+  try {
+    schema = JSON.parse(result);
+  } catch {
+    logger1.error(result);
+    return json;
+  }
+  const values = [
+    ["propertiesSchema", "Properties"],
+    ["inputStreams", "InputProperties"],
+    ["outputStreams", "OutputProperties"]
+  ];
+  for (const value of values) {
+    const propertiesSchema = schema[value[1]] || {};
+    for (const requestProperty of propertiesSchema.required || []) {
+      propertiesSchema.properties[requestProperty] = { ...propertiesSchema.properties[requestProperty], required: true };
+    }
+    delete propertiesSchema.required;
+    const types = await getTypes(jsonPath);
+    checkTypes(types, propertiesSchema, jsonPath);
+    const completeSchema = {
+      schema: {
+        type: "object",
+        properties: {
+          ...propertiesSchema.properties
+        }
+      }
+    };
+    if (value[0] === "propertiesSchema") {
+      if (!json["propertiesSchema"]) {
+        json["propertiesSchema"] = completeSchema;
+      }
+    } else {
+      if (!json[value[0]].some((v) => v.name === "default") && propertiesSchema) {
+        json[value[0]].push({
+          name: "default",
+          ...completeSchema
+        });
+      }
+    }
+  }
+  if (Object.keys(schema).some((key) => !["Properties", "InputProperties", "OutputProperties"].includes(key))) {
+    const typeDefinitions = Object.keys(schema).filter((key) => !["Properties", "InputProperties", "OutputProperties"].includes(key));
+    json.definitions = typeDefinitions.reduce((previousValue, currentValue) => {
+      const additionalSchema = schema[currentValue];
+      for (const requestProperty of additionalSchema.required || []) {
+        additionalSchema.properties[requestProperty] = { ...additionalSchema.properties[requestProperty], required: true };
+      }
+      delete additionalSchema.required;
+      previousValue[currentValue] = additionalSchema;
+      return previousValue;
+    }, {});
+  }
+  return json;
+}
+function prepareTsFile(file) {
+  const codeBlocks = getCodeBlocks(file);
+  const emptyExtendsBlock = codeBlocks.find((block) => blockDefinitionIncludes(block, "extends") && isBlockEmpty(block));
+  if (emptyExtendsBlock) {
+    let replBlock = `${emptyExtendsBlock}`;
+    if (replBlock.replace(/\s\s+/g, " ").trim().startsWith("class OutputProperties")) {
+      replBlock = replBlock.replace("extends InputProperties", "");
+      const inputPropertiesBlock = codeBlocks.find(
+        (v) => blockDefinitionIncludes(v, "InputProperties") && !blockDefinitionIncludes(v, "OutputProperties")
+      );
+      replBlock = replBlock.replace(getBlockContent(replBlock), getBlockContent(inputPropertiesBlock));
+      file = file.replace(emptyExtendsBlock, replBlock);
+    }
+  }
+  return `import { validationMetadatasToSchemas as v } from 'class-validator-jsonschema';
+import { defaultMetadataStorage as classTransformerDefaultMetadataStorage } from 'class-transformer/cjs/storage';
+${file}
+const s = v({
+
+      additionalConverters: {
+
+        UnitArgsValidator: (meta) => {
+
+          return {
+
+            measure: meta.constraints[0],
+
+            unit: meta.constraints[1],
+
+            type: 'number',
+
+          };
+
+        },
+
+      },
+
+      classTransformerMetadataStorage
+
+    });
+console.log(JSON.stringify(s));`;
+}
+function getCodeBlocks(string_) {
+  const blocks = [];
+  let counter = 0;
+  let start = 0;
+  let lastNewline = 0;
+  for (const [index, char] of [...string_].entries()) {
+    if (char === "\n") {
+      lastNewline = index;
+    }
+    if (char === "{") {
+      if (counter === 0) {
+        start = lastNewline;
+      }
+      counter++;
+    } else if (char === "}") {
+      counter--;
+      if (counter === 0) {
+        blocks.push(string_.slice(start, index + 1));
+      }
+    }
+  }
+  return blocks;
+}
+var logger = {
+  /* eslint-disable no-console */
+  log: console.log,
+  error: (message) => console.log(chalk.bold.red(message)),
+  ok: (message) => console.log(chalk.bold.green(message))
+  /* eslint-enable no-console */
+};
+function handleApiError(error) {
+  if (error.isAxiosError && error.response) {
+    logger.error(`${error.response.status} ${error.response.statusText}`);
+    if (error.response.data) {
+      logger.error(JSON.stringify(error.response.data));
+    }
+  } else {
+    logger.error(error);
+  }
+}
+function blockDefinitionIncludes(block, value) {
+  return block.trim().split("\n", 1)[0].includes(value);
+}
+function getBlockContent(block) {
+  return block.slice(block.indexOf("{"), block.lastIndexOf("}") + 1);
+}
+function isBlockEmpty(block) {
+  const blockContent = block.slice(block.indexOf("{") + 1, block.lastIndexOf("}"));
+  return !blockContent.trim();
+}
+
+// lib/flow-cli/src/auth.ts
+var BASE_URL = process.env.BASE_URL || process.env.PLATFORM_URL;
+var CLIENT_ID = process.env.CLIENT_ID || process.env.API_USER || "flow-cli";
+var CLIENT_SECRET = process.env.CLIENT_SECRET || process.env.API_KEY;
+var REALM = process.env.REALM;
+var BUFFER = 120;
+var viewsPath = path2.join(__dirname, "views");
+var server = null;
+nconf.file({ file: path2.join(__dirname, "config") });
+if (process.env.https_proxy || process.env.http_proxy) {
+  custom.setHttpOptionsDefaults({
+    agent: new HttpsProxyAgent(process.env.https_proxy || process.env.http_proxy)
+  });
+}
+async function getAccessToken(baseUrl = BASE_URL, realm = REALM) {
+  checkEnvironment([
+    ["BASE_URL", baseUrl],
+    ["REALM", realm]
+  ]);
+  nconf.load();
+  let tokenSet = nconf.get(baseUrl.replace(/:/g, "")) || {};
+  if (tokenSet.access_token && tokenSet.expires_at > Date.now() / 1e3 + BUFFER) {
+    return tokenSet.access_token;
+  } else {
+    return CLIENT_ID && CLIENT_SECRET ? new Promise(async (resolve, reject) => {
+      try {
+        const kcIssuer = await openidClient.Issuer.discover(`${baseUrl}/auth/realms/${realm}/`);
+        const client = new kcIssuer.Client({
+          client_id: CLIENT_ID,
+          client_secret: CLIENT_SECRET,
+          token_endpoint_auth_method: "client_secret_jwt"
+        });
+        tokenSet = await client.grant({ grant_type: "client_credentials" });
+        nconf.set(baseUrl.replace(/:/g, ""), tokenSet);
+        nconf.save((error) => {
+          if (error) {
+            logger.error(error);
+          }
+          return resolve(tokenSet.access_token);
+        });
+      } catch (error) {
+        return reject(error);
+      }
+    }) : login(baseUrl, realm);
+  }
+}
+function login(baseUrl = BASE_URL, realm = REALM) {
+  return new Promise(async (resolve, reject) => {
+    checkEnvironment([
+      ["BASE_URL", baseUrl],
+      ["REALM", realm]
+    ]);
+    server = null;
+    const port = process.env.PORT || await getPort({ port: 3e3 });
+    const redirectUri = `http://localhost:${port}/callback`;
+    const kcIssuer = await openidClient.Issuer.discover(`${baseUrl}/auth/realms/${realm}/`);
+    const client = new kcIssuer.Client({
+      client_id: "flow-cli",
+      redirect_uris: [redirectUri],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    });
+    const code_verifier = openidClient.generators.codeVerifier();
+    const code_challenge = openidClient.generators.codeChallenge(code_verifier);
+    const auhtUrl = client.authorizationUrl({ code_challenge, code_challenge_method: "S256" });
+    const app = express();
+    app.disable("x-powered-by");
+    app.use(express.static(viewsPath));
+    app.set("views", viewsPath);
+    app.get("/callback", async (request, response) => {
+      const parameters = client.callbackParams(request.url);
+      if (parameters.code) {
+        response.render("index.ejs", { message: "Authentication successful", hint: "You can close this window" });
+      } else {
+        response.render("index.ejs", { message: "Authentication failed", hint: "Please try again" });
+      }
+      response.end();
+      try {
+        const tokenSet = await client.callback(redirectUri, parameters, { code_verifier });
+        nconf.set(baseUrl.replace(/:/g, ""), tokenSet);
+        server.close();
+        nconf.save((error) => {
+          if (error) {
+            logger.error(error);
+          }
+          return resolve(tokenSet.access_token);
+        });
+      } catch (error) {
+        return reject(error);
+      }
+    });
+    server = await app.listen(port);
+    await open(auhtUrl);
+  });
+}
+function logout(baseUrl = BASE_URL) {
+  return new Promise((resolve, reject) => {
+    if (baseUrl) {
+      nconf.clear(baseUrl.replace(/:/g, ""));
+    } else {
+      nconf.reset();
+    }
+    server = null;
+    nconf.save((error) => {
+      return error ? reject(error) : resolve();
+    });
+  });
+}
+function checkEnvironment(values) {
+  let missing = false;
+  for (const [name, value] of values) {
+    if (!value && !process.env[name]) {
+      logger.error(`"${name}" env var is required`);
+      missing = true;
+    }
+  }
+  if (missing) {
+    throw new Error("Missing environment variables");
+  }
+}
+
+// lib/flow-cli/src/main.ts
+var BASE_URL2 = process.env.BASE_URL || process.env.PLATFORM_URL;
+var BUILD_DIR = process.env.BUILD_DIR || "dist";
+var axios = Axios.create();
+if (process.env.https_proxy || process.env.http_proxy) {
+  const httpsAgent = new HttpsProxyAgent2(process.env.https_proxy || process.env.http_proxy);
+  axios = Axios.create({ httpsAgent, proxy: false });
+}
+var apiToken;
+var projectsRoot = "modules";
+var packageJson = JSON.parse(fs2.readFileSync(path3.join(__dirname, "..", "package.json")).toString());
+var CMD = {
+  AUDIT: "audit",
+  BUILD: "build",
+  FORMAT: "format",
+  INSTALL: "install",
+  LINT: "lint",
+  RUN: "run",
+  TEST: "test",
+  WATCH: "watch"
+};
+var program = new Command();
+program.version(packageJson.version, "-v, --version").usage("[command] [options]").description("Flow Module Management Tool").on("--help", () => {
+});
+program.command("build [moduleNames]").description("Build specified Module(s)").action(async (moduleNames) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    for (const project of projects) {
+      await exec(CMD.INSTALL, project);
+      await exec(CMD.BUILD, project);
+      await copyProjectFiles(project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("install [moduleNames]").description("Install the dependencies of the specified Module(s)").action(async (moduleNames) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    for (const project of projects) {
+      await exec(CMD.INSTALL, project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("audit [moduleNames]").description("Audit dependencies for the specified Module(s)").action(async (moduleNames) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    for (const project of projects) {
+      await exec(CMD.AUDIT, project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("lint [moduleNames]").description("Lint source files for the specified Module(s)").action(async (moduleNames) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    for (const project of projects) {
+      await exec(CMD.LINT, project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("login").requiredOption("--url <url>", "URL of target platform", process.env.BASE_URL).requiredOption("-r, --realm <realm>", "Auth realm of target platform", process.env.REALM).description("Authenticate against platform").action(async (options) => {
+  try {
+    await login(options.url, options.realm);
+    process.exit(0);
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("logout").requiredOption("--url <url>", "URL of target platform", process.env.BASE_URL).description("Remove authentication data").action(async (options) => {
+  try {
+    await logout(options.url);
+    process.exit(0);
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("format").description("Format all typescript files according to prettier configuration").action(async () => {
+  try {
+    await exec(CMD.FORMAT, { name: "all" });
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("package [moduleNames]").description("Build specified Module(s) and package as .zip file for manual upload to the platform").action(async (moduleNames) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    await clean(BUILD_DIR);
+    for (const project of projects) {
+      await exec(CMD.INSTALL, project);
+      await exec(CMD.BUILD, project);
+      await copyProjectFiles(project);
+      await validateModule(project);
+      await packageModule(project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("publish-module [moduleNames]").requiredOption("--url <url>", "URL of target platform", process.env.BASE_URL).requiredOption("-r, --realm <realm>", "Auth realm of target platform", process.env.REALM).option("-f, --functions", "publish flow functions").option("-u, --update", "update existing flow functions").option("-s, --skip", "skip modules that already exists with the current version").description("Publish specified Module(s) to Cloud Platform").action(async (moduleNames, options) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    apiToken = await getAccessToken(options.url, options.realm);
+    logger.ok("Got Access Token");
+    await clean(BUILD_DIR);
+    for (const project of projects) {
+      await exec(CMD.INSTALL, project);
+      await exec(CMD.BUILD, project);
+      await copyProjectFiles(project);
+      await validateModule(project);
+      try {
+        await publishModule(project, options.url);
+      } catch (error) {
+        if (options.skip && error && error.response && error.response.data && error.response.data.message === "New module version must greater than latest version") {
+          logger.ok(`Module "${project.name}" is up to date. Skipping.`);
+        } else {
+          logger.error(`Publishing Module "${project.name}" failed.`);
+          handleApiError(error);
+          process.exit(1);
+        }
+      }
+      if (options.functions) {
+        await publishFunctions(project, options.update, options.url);
+      }
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("publish-functions [moduleNames]").requiredOption("--url <url>", "URL of target platform", process.env.BASE_URL).requiredOption("-r, --realm <realm>", "Auth realm of target platform", process.env.REALM).option("-u, --update", "update existing flow functions").description("Publish all Flow Functions inside specified Module(s) to Cloud Platform").action(async (moduleNames, options) => {
+  try {
+    const projects = await selectProjects(moduleNames);
+    apiToken = await getAccessToken(options.url, options.realm);
+    logger.ok("Got Access Token");
+    for (const project of projects) {
+      await publishFunctions(project, options.update, options.url);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("serve [projectName]").description("Builds and serves your project. Rebuilding on file changes").action(async (projectName) => {
+  try {
+    if (checkIfAll(projectName)) {
+      process.exit(1);
+    }
+    const project = await findProject(projectName);
+    await exec(CMD.INSTALL, project);
+    await exec(CMD.BUILD, project);
+    await copyProjectFiles(project);
+    await exec(CMD.WATCH, project);
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("start [projectName]").description("Runs your project").action(async (projectName) => {
+  try {
+    if (checkIfAll(projectName)) {
+      process.exit(1);
+    }
+    const project = await findProject(projectName);
+    await exec(CMD.RUN, project);
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("test [moduleNames]").description("Runs tests for specified Module(s)").action(async (moduleNames) => {
+  try {
+    let projects = await selectProjects(moduleNames);
+    if (process.env.CI) {
+      projects = projects.filter((project) => !project["excludeTestsInCI"]);
+    }
+    for (const project of projects) {
+      await exec(CMD.TEST, project);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+program.command("generate-schemas [projectName]").description("Generates Input, Output and Properties-Schemas for the project").option("-h, --hide", "hide warnings").option("-v, --verbose", "get more output info").action(async (projectName) => {
+  try {
+    const project = await findProject(projectName);
+    const globOptions = {
+      cwd: project.location,
+      ignore: ["node_modules/**/*", "**/package*.json", "**/tsconfig*.json"]
+    };
+    const files = await glob("**/*.*", globOptions);
+    const filtered = files.filter((file) => !file.endsWith(".spec.ts"));
+    const tsJsonMap = filtered.reduce((accumulator, current, index, array) => {
+      if (current.endsWith(".ts")) {
+        const json = array.find((v) => v === `${current.split(".")[0]}.json`);
+        if (json) {
+          accumulator.push({
+            ts: path3.join(globOptions.cwd, current),
+            json: path3.join(globOptions.cwd, json)
+          });
+        }
+      }
+      return accumulator;
+    }, []);
+    for (const entry of tsJsonMap) {
+      await generateSchemasForFile(entry.ts, entry.json);
+    }
+  } catch (error) {
+    if (error) {
+      logger.log(error);
+    }
+    process.exit(1);
+  }
+});
+if (process.env.NODE_ENV !== "test") {
+  program.parse(process.argv);
+}
+async function generateSchemasForFile(tsPath, jsonPath) {
+  const fileContent = await fs2.promises.readFile(path3.join(process.cwd(), jsonPath));
+  let json = JSON.parse(fileContent.toString());
+  const filePath = path3.join(process.cwd(), tsPath);
+  const tsFile = await fs2.promises.readFile(filePath);
+  const directory = path3.dirname(filePath);
+  const result = await execa("ts-node", ["-T", "--dir", directory], { input: prepareTsFile(tsFile.toString()), preferLocal: true });
+  json = await handleConvertedOutput(result.stdout, jsonPath, json);
+  await fs2.promises.writeFile(path3.join(process.cwd(), jsonPath), JSON.stringify(json, null, 2) + "\n");
+}
+async function clean(buildFolder) {
+  return new Promise((resolve, reject) => {
+    const spinner = getSpinner("Cleaning").start();
+    fs2.rm(buildFolder, { recursive: true, force: true }, (error) => {
+      if (error) {
+        spinner.stop();
+        logger.error("Cleaning failed");
+        logger.error(error);
+        return reject(error);
+      } else {
+        spinner.stop();
+        logger.ok("Cleaning successful");
+        return resolve();
+      }
+    });
+  });
+}
+function exec(cmd, project) {
+  return new Promise((resolve, reject) => {
+    if (!project) {
+      return reject();
+    }
+    const options = { ...getProcessOptions(cmd, project), env: process.env };
+    if (cmd === CMD.RUN || cmd === CMD.WATCH) {
+      logger.ok(`
+${getLabel(cmd)} ${project.name}:
+`);
+      execa(getProcess(cmd), getProcessArguments(cmd, project), options).stdout.pipe(process.stdout);
+    } else {
+      const spinner = getSpinner(`${getLabel(cmd)} ${project.name}`);
+      spinner.start();
+      execa(getProcess(cmd), getProcessArguments(cmd, project), options).then((result) => {
+        spinner.stop();
+        logger.log(result.stdout);
+        logger.ok(`${getLabel(cmd)} Succeeded`);
+        return resolve();
+      }).catch((error) => {
+        spinner.stop();
+        if (error.stderr) {
+          logger.error(error.stderr);
+        } else {
+          logger.error(error);
+        }
+        if (error.stdout) {
+          logger.log(error.stdout);
+        }
+        logger.error(`${getLabel(cmd)} Failed`);
+        return reject();
+      });
+    }
+  });
+}
+function isDirectory(p) {
+  return new Promise((resolve) => {
+    fs2.lstat(p, (error, stats) => {
+      if (!error && stats) {
+        resolve(stats.isDirectory());
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+async function findProjects() {
+  const isProject = (directory) => new Promise((resolve) => {
+    fs2.access(path3.join(directory, "package.json"), (error) => {
+      if (error) {
+        resolve(false);
+      } else {
+        resolve(true);
+      }
+    });
+  });
+  const rootPackage = await readJson(path3.join(process.cwd(), "package.json"));
+  const projects = [];
+  const files = await fs2.promises.readdir(projectsRoot);
+  if (files) {
+    for (const file of files) {
+      if (file && await isDirectory(path3.join(projectsRoot, file))) {
+        const projectPath = path3.join(projectsRoot, file, "package.json");
+        if (await isProject(path3.join(projectsRoot, file))) {
+          try {
+            const package_ = await readJson(path3.join(path3.dirname(projectPath), "package.json"));
+            package_.location = path3.posix.join(projectsRoot, file);
+            package_.dist = path3.posix.join(process.cwd(), BUILD_DIR, file);
+            if (rootPackage) {
+              package_.dependencies = { ...package_.dependencies, ...rootPackage.dependencies };
+              package_.repository = rootPackage.repository;
+            }
+            projects.push(package_);
+          } catch (error) {
+            if (error) {
+              logger.log(error);
+            }
+          }
+        }
+      }
+    }
+  }
+  return projects;
+}
+function findProject(projectName) {
+  return new Promise(async (resolve, reject) => {
+    if (!projectName) {
+      logger.error("No project specified");
+      return reject();
+    }
+    if (projectName === "all") {
+      const project = {
+        name: "all",
+        version: "0.0.0",
+        location: "."
+      };
+      return resolve(project);
+    }
+    const projects = await findProjects();
+    for (const project of projects) {
+      const location = path3.parse(project.location);
+      const directoryName = location.name + location.ext;
+      if (project.name === projectName || directoryName === projectName) {
+        return resolve(project);
+      }
+    }
+    logger.error(`Cloud not find ${projectName} Module.`);
+    reject();
+  });
+}
+function selectProjects(value) {
+  return new Promise(async (resolve, reject) => {
+    if (!value) {
+      logger.error("No Module specified");
+      return reject();
+    }
+    const projectNames = value.split(",").map((v) => v.trim());
+    const allProjects = await findProjects();
+    if (value === "all") {
+      return resolve(allProjects);
+    }
+    const projects = [];
+    for (const project of allProjects) {
+      const location = path3.parse(project.location);
+      const directoryName = location.name + location.ext;
+      if (projectNames.includes(project.name) || projectNames.includes(directoryName)) {
+        projects.push(project);
+      }
+    }
+    if (projects.length === 0) {
+      logger.error(`Cloud not find any Modules for ${JSON.stringify(projectNames)}.`);
+      reject();
+    }
+    return resolve(projects);
+  });
+}
+async function packageModule(project) {
+  const { dist, ...package_ } = project;
+  const file = path3.posix.join(dist, "..", `${project.name}.zip`);
+  await writeJson(path3.join(dist, "package.json"), package_);
+  await zipDirectory(dist, file);
+  return file;
+}
+async function publishModule(project, baseUrl = BASE_URL2) {
+  return new Promise(async (resolve, reject) => {
+    const file = await packageModule(project);
+    const form = new FormData();
+    form.append("file", fs2.createReadStream(file));
+    form.append("name", project.name);
+    form.append("description", project.description || "");
+    form.append("version", project.version || "");
+    try {
+      await axios.post(`${baseUrl}/api/flow/modules`, form, {
+        headers: {
+          ...form.getHeaders(),
+          Authorization: `Bearer ${apiToken}`
+        },
+        maxBodyLength: Number.POSITIVE_INFINITY,
+        maxContentLength: Number.POSITIVE_INFINITY
+      });
+      logger.ok(`Module "${project.name}" published!`);
+      return resolve();
+    } catch (error) {
+      return reject(error);
+    } finally {
+      deleteFile(file);
+    }
+  });
+}
+async function validateModule(project) {
+  const module = __require(project.dist);
+  const moduleName = Reflect.getMetadata("module:name", module.default);
+  const moduleDeclarations = Reflect.getMetadata("module:declarations", module.default);
+  const functionFqns = [];
+  for (const declaration of moduleDeclarations) {
+    const fqn = Reflect.getMetadata("element:functionFqn", declaration);
+    if (!fqn) {
+      throw new Error(`FlowFunction (${declaration.name}) metadata is missing or invalid.`);
+    }
+    functionFqns.push(fqn);
+  }
+  if (moduleName) {
+    project.name = moduleName;
+    project.functions = functionFqns;
+  } else {
+    throw new Error("Could not validate module name");
+  }
+}
+async function publishFunctions(project, update, baseUrl = BASE_URL2) {
+  return new Promise(async (resolve, reject) => {
+    const globOptions = {
+      cwd: project.location,
+      ignore: ["node_modules/**/*", "**/package*.json", "**/tsconfig*.json"]
+    };
+    const files = await glob("**/*.json", globOptions).catch((error) => reject(error));
+    const headers = { Authorization: `Bearer ${apiToken}` };
+    for (const file of files || []) {
+      try {
+        const data = await fs2.promises.readFile(path3.join(globOptions.cwd, file));
+        const json = JSON.parse(data.toString());
+        if (json.fqn && json.category) {
+          if (update) {
+            try {
+              await axios.put(`${baseUrl}/api/flow/functions/${json.fqn}`, json, { headers });
+              logger.ok(`Flow Function "${json.fqn}" has been updated`);
+            } catch (error) {
+              logger.error(`Flow Function "${json.fqn}" could not be updated`);
+              handleApiError(error);
+            }
+          } else {
+            try {
+              await axios.post(`${baseUrl}/api/flow/functions`, json, { headers });
+              logger.ok(`Flow Function "${json.fqn}" has been created`);
+            } catch (error) {
+              logger.error(`Flow Function "${json.fqn}" could not be created`);
+              handleApiError(error);
+            }
+          }
+        }
+      } catch (error) {
+        logger.error(error);
+      }
+    }
+    return resolve();
+  });
+}
+function zipDirectory(source, out) {
+  const archive = archiver("zip", { zlib: { level: 8 } });
+  const stream = fs2.createWriteStream(out);
+  return new Promise((resolve, reject) => {
+    archive.directory(source, false).on("error", (error) => reject(error)).pipe(stream);
+    stream.on("close", () => resolve());
+    archive.finalize();
+  });
+}
+function deleteFile(filePath) {
+  return new Promise((resolve, reject) => {
+    fs2.unlink(filePath, (error) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve();
+    });
+  });
+}
+function getProcess(cmd) {
+  switch (cmd) {
+    case CMD.BUILD: {
+      return "tsc";
+    }
+    case CMD.FORMAT: {
+      return "prettier";
+    }
+    case CMD.INSTALL:
+    case CMD.AUDIT: {
+      return "npm";
+    }
+    case CMD.LINT: {
+      return "eslint";
+    }
+    case CMD.RUN: {
+      return "node";
+    }
+    case CMD.TEST: {
+      return "jest";
+    }
+    case CMD.WATCH: {
+      return "nodemon";
+    }
+    default: {
+      return "";
+    }
+  }
+}
+function copyProjectFiles(project) {
+  return new Promise((resolve, reject) => {
+    copyfiles(
+      [`${project.location}/**`, `${BUILD_DIR}/`],
+      {
+        exclude: [`${project.location}/*.json`, `${project.location}/**/*.ts`, `${project.location}/**/test/**`],
+        up: 1
+      },
+      (error) => {
+        if (error) {
+          return reject(error);
+        }
+        return resolve();
+      }
+    );
+  });
+}
+function getProcessArguments(cmd, project) {
+  switch (cmd) {
+    case CMD.AUDIT: {
+      return ["audit", "--audit-level=moderate"];
+    }
+    case CMD.BUILD: {
+      const filename = path3.join(project.location, "tsconfig.module.json");
+      const configFile = fs2.existsSync(filename) ? filename : project.location;
+      return ["-p", configFile];
+    }
+    case CMD.FORMAT: {
+      return ["--write", "**/*.ts"];
+    }
+    case CMD.INSTALL: {
+      return ["install", "--no-package-lock"];
+    }
+    case CMD.LINT: {
+      return [project.location + "/**/*.{js,ts}", "--fix"];
+    }
+    case CMD.RUN: {
+      return [project.location];
+    }
+    case CMD.TEST: {
+      return project.name === "all" ? ["--runInBand", "--coverage", "--forceExit", "--verbose", "--passWithNoTests"] : ["roots", project.location, "--forceExit", "--verbose", "--passWithNoTests"];
+    }
+    case CMD.WATCH: {
+      return ["--inspect", project.location];
+    }
+    default: {
+      return [];
+    }
+  }
+}
+function getProcessOptions(cmd, project) {
+  switch (cmd) {
+    case CMD.INSTALL: {
+      return { cwd: project.location };
+    }
+  }
+}
+function getLabel(cmd) {
+  switch (cmd) {
+    case CMD.RUN: {
+      return "Running";
+    }
+    default: {
+      return `${cmd.charAt(0).toUpperCase()}${cmd.slice(1)}ing`;
+    }
+  }
+}
+function getSpinner(message) {
+  return ora({
+    color: "magenta",
+    spinner: "dots",
+    text: message
+  });
+}
+function checkIfAll(projectName) {
+  if (projectName === "all") {
+    logger.error(`Please specify a project. Command can't be run for all.`);
+    return true;
+  }
+  return false;
+}
+function readJson(filePath) {
+  return new Promise((resolve, reject) => {
+    fs2.readFile(filePath, { encoding: "utf8" }, (error, data) => {
+      if (error) {
+        return reject(error);
+      }
+      try {
+        return resolve(JSON.parse(data));
+      } catch (error_) {
+        return reject(error_);
+      }
+    });
+  });
+}
+function writeJson(filePath, data) {
+  return new Promise((resolve, reject) => {
+    let dataString;
+    try {
+      dataString = JSON.stringify(data, null, 2) + "\n";
+    } catch (error) {
+      return reject(error);
+    }
+    fs2.writeFile(filePath, dataString, (error) => {
+      if (error) {
+        return reject(error);
+      }
+      return resolve();
+    });
+  });
+}