@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/esm/src/auth.js

@@ -1,42 +0,0 @@
-import fs from "fs";
-import {
-  akanCloudBackendUrl,
-  akanCloudHost,
-  basePath,
-  configPath,
-  defaultAkanGlobalConfig,
-  defaultHostConfig
-} from "./constants";
-const getAkanGlobalConfig = () => {
-  const akanConfig = fs.existsSync(configPath) ? JSON.parse(fs.readFileSync(configPath, "utf8")) : defaultAkanGlobalConfig;
-  return akanConfig;
-};
-const setAkanGlobalConfig = (akanConfig) => {
-  fs.mkdirSync(basePath, { recursive: true });
-  fs.writeFileSync(configPath, JSON.stringify(akanConfig, null, 2));
-};
-const getHostConfig = (host = akanCloudHost) => {
-  const akanConfig = getAkanGlobalConfig();
-  return akanConfig.cloudHost[host] ?? defaultHostConfig;
-};
-const setHostConfig = (host = akanCloudHost, config = {}) => {
-  const akanConfig = getAkanGlobalConfig();
-  akanConfig.cloudHost[host] = config;
-  setAkanGlobalConfig(akanConfig);
-};
-const getSelf = async (token) => {
-  try {
-    const res = await fetch(`${akanCloudBackendUrl}/user/getSelf`, { headers: { Authorization: `Bearer ${token}` } });
-    const user = await res.json();
-    return user;
-  } catch (e) {
-    return null;
-  }
-};
-export {
-  getAkanGlobalConfig,
-  getHostConfig,
-  getSelf,
-  setAkanGlobalConfig,
-  setHostConfig
-};

package/esm/src/builder.js

@@ -1,81 +0,0 @@
-import * as esbuild from "esbuild";
-import { dtsPlugin } from "esbuild-plugin-d.ts";
-import fs from "fs";
-import { extractDependencies } from "./extractDeps";
-const assetExtensions = [".css", ".md", ".js", ".png", ".ico", ".svg", ".json", ".template"];
-const assetLoader = Object.fromEntries(assetExtensions.map((ext) => [ext, "copy"]));
-class Builder {
-  #executor;
-  #distExecutor;
-  #pkgJson;
-  #rootPackageJson;
-  constructor({ executor, distExecutor, pkgJson, rootPackageJson }) {
-    this.#executor = executor;
-    this.#distExecutor = distExecutor;
-    this.#pkgJson = pkgJson;
-    this.#rootPackageJson = rootPackageJson;
-  }
-  #getBuildOptions(format, { bundle = false, additionalEntryPoints = [] } = {}) {
-    return {
-      entryPoints: [
-        ...bundle ? [`${this.#executor.cwdPath}/index.ts`] : [`${this.#executor.cwdPath}/**/*.ts`, `${this.#executor.cwdPath}/**/*.tsx`],
-        ...additionalEntryPoints
-      ],
-      bundle,
-      packages: "external",
-      splitting: false,
-      platform: this.#pkgJson.esbuild?.platform,
-      format,
-      outdir: `${this.#distExecutor.cwdPath}/${format}`,
-      logLevel: "error",
-      // external: ["react", "react-dom"],
-      loader: assetLoader
-    };
-  }
-  #getAssetBuildOptions() {
-    return {
-      write: true,
-      bundle: false,
-      entryPoints: [
-        `${this.#executor.cwdPath}/**/*.css`,
-        `${this.#executor.cwdPath}/**/*.md`,
-        `${this.#executor.cwdPath}/**/*.js`
-      ],
-      outdir: this.#distExecutor.cwdPath,
-      logLevel: "error",
-      loader: assetLoader
-    };
-  }
-  async build(options = {}) {
-    if (fs.existsSync(this.#distExecutor.cwdPath))
-      await this.#distExecutor.exec(`rm -rf ${this.#distExecutor.cwdPath}`);
-    const plugins = [dtsPlugin({ tsconfig: `${this.#executor.cwdPath}/tsconfig.json` })];
-    const [buildResult] = await Promise.all([
-      esbuild.build({ ...this.#getBuildOptions("cjs", options), write: false, plugins }),
-      esbuild.build({ write: true, ...this.#getBuildOptions("esm", options) }),
-      esbuild.build({ ...this.#getAssetBuildOptions() })
-    ]);
-    const existingDeps = Object.keys(this.#pkgJson.dependencies ?? {});
-    const dependencies = extractDependencies(buildResult.outputFiles, this.#rootPackageJson, existingDeps);
-    const pkgPackageJson = {
-      ...this.#pkgJson,
-      main: "./index.js",
-      engines: { node: ">=20" },
-      dependencies,
-      exports: {
-        ...this.#pkgJson.exports ?? {},
-        ".": {
-          require: "./cjs/index.js",
-          import: "./esm/index.js",
-          types: "./index.d.ts"
-        }
-      }
-    };
-    buildResult.outputFiles.map((file) => this.#distExecutor.writeFile(file.path, file.text));
-    this.#distExecutor.setPackageJson(pkgPackageJson);
-    this.#executor.setPackageJson(pkgPackageJson);
-  }
-}
-export {
-  Builder
-};

package/esm/src/commandDecorators/argMeta.js

@@ -1,54 +0,0 @@
-import "reflect-metadata";
-const argTypes = ["Argument", "Option"];
-const internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg", "Module", "Exec"];
-const getArgMetas = (command, key) => {
-  const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
-  const argMetas = allArgMetas.filter((argMeta) => argMeta.type === "Option");
-  const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
-  return [allArgMetas, argMetas, internalArgMetas];
-};
-const getArgMetasOnPrototype = (prototype, key) => {
-  return Reflect.getMetadata("args", prototype, key) ?? [];
-};
-const setArgMetasOnPrototype = (prototype, key, argMetas) => {
-  Reflect.defineMetadata("args", argMetas, prototype, key);
-};
-const getArg = (type) => function(name, argsOption = {}) {
-  return function(prototype, key, idx) {
-    const argMetas = getArgMetasOnPrototype(prototype, key);
-    argMetas[idx] = { name, argsOption, key, idx, type };
-    setArgMetasOnPrototype(prototype, key, argMetas);
-  };
-};
-const Argument = getArg("Argument");
-const Option = getArg("Option");
-const createArgMetaDecorator = (type) => {
-  return function(option = {}) {
-    return function(prototype, key, idx) {
-      const argMetas = getArgMetasOnPrototype(prototype, key);
-      argMetas[idx] = { key, idx, type, option };
-      setArgMetasOnPrototype(prototype, key, argMetas);
-    };
-  };
-};
-const App = createArgMetaDecorator("App");
-const Lib = createArgMetaDecorator("Lib");
-const Sys = createArgMetaDecorator("Sys");
-const Exec = createArgMetaDecorator("Exec");
-const Pkg = createArgMetaDecorator("Pkg");
-const Module = createArgMetaDecorator("Module");
-const Workspace = createArgMetaDecorator("Workspace");
-export {
-  App,
-  Argument,
-  Exec,
-  Lib,
-  Module,
-  Option,
-  Pkg,
-  Sys,
-  Workspace,
-  argTypes,
-  getArgMetas,
-  internalArgTypes
-};

package/esm/src/commandDecorators/command.js

@@ -1,290 +0,0 @@
-import { Logger } from "@akanjs/common";
-import { confirm, input, select } from "@inquirer/prompts";
-import chalk from "chalk";
-import { program } from "commander";
-import fs from "fs";
-import { getDirname } from "..";
-import { AppExecutor, Executor, LibExecutor, ModuleExecutor, PkgExecutor, WorkspaceExecutor } from "../executors";
-import { getArgMetas } from "./argMeta";
-import { formatCommandHelp, formatHelp } from "./helpFormatter";
-import { getTargetMetas } from "./targetMeta";
-const camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
-const handleOption = (programCommand, argMeta) => {
-  const {
-    type,
-    flag = argMeta.name.slice(0, 1).toLowerCase(),
-    desc = argMeta.name,
-    example,
-    enum: enumChoices,
-    ask
-  } = argMeta.argsOption;
-  const kebabName = camelToKebabCase(argMeta.name);
-  const choices = enumChoices?.map(
-    (choice) => typeof choice === "object" ? { value: choice.value, name: choice.label } : { value: choice, name: choice.toString() }
-  );
-  programCommand.option(
-    `-${flag}, --${kebabName}${type === "boolean" ? " [boolean]" : ` <${kebabName}>`}`,
-    `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.map((choice) => choice.name).join(", ")})` : ""}`
-  );
-  return programCommand;
-};
-const handleArgument = (programCommand, argMeta) => {
-  const kebabName = camelToKebabCase(argMeta.name);
-  if ((argMeta.argsOption.type ?? "string") !== "string")
-    throw new Error(`Argument type must be string: ${argMeta.name}`);
-  programCommand.argument(
-    `[${kebabName}]`,
-    `${argMeta.argsOption.desc}${argMeta.argsOption.example ? ` (example: ${argMeta.argsOption.example})` : ""}`
-  );
-  return programCommand;
-};
-const convertOptionValue = (value, type) => {
-  if (type === "string")
-    return value;
-  else if (type === "number")
-    return Number(value);
-  else
-    return value === true || value === "true";
-};
-const getOptionValue = async (argMeta, opt) => {
-  const {
-    name,
-    argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask }
-  } = argMeta;
-  if (opt[argMeta.name] !== void 0)
-    return convertOptionValue(opt[argMeta.name], type ?? "string");
-  else if (defaultValue !== void 0)
-    return defaultValue;
-  else if (nullable)
-    return null;
-  if (enumChoices) {
-    const choices = enumChoices.map(
-      (choice2) => typeof choice2 === "object" ? { value: choice2.value, name: choice2.label } : { value: choice2, name: choice2.toString() }
-    );
-    const choice = await select({ message: ask ?? desc ?? `Select the ${name} value`, choices });
-    return choice;
-  } else if (type === "boolean") {
-    const message = ask ?? desc ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
-    return await confirm({ message });
-  } else {
-    const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
-    if (argMeta.argsOption.nullable)
-      return await input({ message });
-    else
-      return convertOptionValue(await input({ message }), type ?? "string");
-  }
-};
-const getArgumentValue = async (argMeta, value) => {
-  const {
-    name,
-    argsOption: { default: defaultValue, type, desc, nullable, example, ask }
-  } = argMeta;
-  if (value !== void 0)
-    return value;
-  else if (defaultValue !== void 0)
-    return defaultValue;
-  else if (nullable)
-    return null;
-  const message = ask ? `${ask}: ` : desc ? `${desc}: ` : `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
-  return await input({ message });
-};
-const getInternalArgumentValue = async (argMeta, value, workspace) => {
-  if (argMeta.type === "Workspace")
-    return workspace;
-  const sysType = argMeta.type.toLowerCase();
-  const [appNames, libNames, pkgNames] = await workspace.getExecs();
-  if (sysType === "sys") {
-    if (value && appNames.includes(value))
-      return AppExecutor.from(workspace, value);
-    else if (value && libNames.includes(value))
-      return LibExecutor.from(workspace, value);
-    else {
-      const sysName = await select({
-        message: `Select the App or Lib name`,
-        choices: [...appNames, ...libNames]
-      });
-      if (appNames.includes(sysName))
-        return AppExecutor.from(workspace, sysName);
-      else if (libNames.includes(sysName))
-        return LibExecutor.from(workspace, sysName);
-      else
-        throw new Error(`Invalid system name: ${sysName}`);
-    }
-  } else if (sysType === "exec") {
-    if (value && appNames.includes(value))
-      return AppExecutor.from(workspace, value);
-    else if (value && libNames.includes(value))
-      return LibExecutor.from(workspace, value);
-    else if (value && pkgNames.includes(value))
-      return PkgExecutor.from(workspace, value);
-    else {
-      const execName = await select({
-        message: `Select the App or Lib or Pkg name`,
-        choices: [...appNames, ...libNames, ...pkgNames]
-      });
-      if (appNames.includes(execName))
-        return AppExecutor.from(workspace, execName);
-      else if (libNames.includes(execName))
-        return LibExecutor.from(workspace, execName);
-      else if (pkgNames.includes(execName))
-        return PkgExecutor.from(workspace, execName);
-      else
-        throw new Error(`Invalid system name: ${execName}`);
-    }
-  } else if (sysType === "app") {
-    if (value && appNames.includes(value))
-      return AppExecutor.from(workspace, value);
-    const appName = await select({ message: `Select the ${sysType} name`, choices: appNames });
-    return AppExecutor.from(workspace, appName);
-  } else if (sysType === "lib") {
-    if (value && libNames.includes(value))
-      return LibExecutor.from(workspace, value);
-    const libName = await select({ message: `Select the ${sysType} name`, choices: libNames });
-    return LibExecutor.from(workspace, libName);
-  } else if (sysType === "pkg") {
-    const pkgs = await workspace.getPkgs();
-    if (value && pkgs.includes(value))
-      return PkgExecutor.from(workspace, value);
-    const pkgName = await select({ message: `Select the ${sysType} name`, choices: pkgs });
-    return PkgExecutor.from(workspace, pkgName);
-  } else if (sysType === "module") {
-    if (value) {
-      const [sysName, moduleName2] = value.split(":");
-      if (appNames.includes(sysName)) {
-        const app = AppExecutor.from(workspace, sysName);
-        const modules2 = await app.getModules();
-        if (modules2.includes(moduleName2))
-          return ModuleExecutor.from(app, moduleName2);
-        else
-          throw new Error(`Invalid module name: ${moduleName2}`);
-      } else if (libNames.includes(sysName)) {
-        const lib = LibExecutor.from(workspace, sysName);
-        const modules2 = await lib.getModules();
-        if (modules2.includes(moduleName2))
-          return ModuleExecutor.from(lib, moduleName2);
-      } else
-        throw new Error(`Invalid system name: ${sysName}`);
-    }
-    const { type, name } = await select({
-      message: `select the App or Lib name`,
-      choices: [
-        ...appNames.map((name2) => ({ name: name2, value: { type: "app", name: name2 } })),
-        ...libNames.map((name2) => ({ name: name2, value: { type: "lib", name: name2 } }))
-      ]
-    });
-    const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
-    const modules = await executor.getModules();
-    const moduleName = await select({
-      message: `Select the module name`,
-      choices: modules.map((name2) => ({ name: `${executor.name}:${name2}`, value: name2 }))
-    });
-    return ModuleExecutor.from(executor, moduleName);
-  } else
-    throw new Error(`Invalid system type: ${argMeta.type}`);
-};
-const runCommands = async (...commands) => {
-  process.on("unhandledRejection", (error) => {
-    process.exit(1);
-  });
-  const __dirname = getDirname(import.meta.url);
-  const hasPackageJson = fs.existsSync(`${__dirname}/../package.json`);
-  process.env.AKAN_VERSION = hasPackageJson ? JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
-  const hasHelpFlag = process.argv.includes("--help") || process.argv.includes("-h");
-  const hasCommand = process.argv.length > 2 && !process.argv[2].startsWith("-");
-  if (hasHelpFlag || !hasCommand) {
-    if (process.argv.length === 2 || process.argv.length === 3 && hasHelpFlag) {
-      Logger.rawLog(formatHelp(commands, process.env.AKAN_VERSION));
-      process.exit(0);
-    }
-  }
-  program.version(process.env.AKAN_VERSION).description("Akan CLI").configureHelp({
-    helpWidth: 100
-  });
-  const akanBasePackageJson = fs.existsSync("./node_modules/@akanjs/base/package.json") ? JSON.parse(fs.readFileSync("./node_modules/@akanjs/base/package.json", "utf8")) : null;
-  if (akanBasePackageJson && akanBasePackageJson.version !== process.env.AKAN_VERSION) {
-    Logger.rawLog(
-      chalk.yellow(
-        `
-Akan CLI version is mismatch with installed package. ${process.env.AKAN_VERSION} (global) vs ${akanBasePackageJson.version} (base)
-It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`
-      )
-    );
-  }
-  for (const command of commands) {
-    const targetMetas = getTargetMetas(command);
-    for (const targetMeta of targetMetas) {
-      const kebabKey = camelToKebabCase(targetMeta.key);
-      const commandNames = targetMeta.targetOption.short === true ? [
-        kebabKey,
-        typeof targetMeta.targetOption.short === "string" ? targetMeta.targetOption.short : kebabKey.split("-").map((s) => s.slice(0, 1)).join("")
-      ] : [kebabKey];
-      for (const commandName of commandNames) {
-        let programCommand = program.command(commandName, {
-          hidden: targetMeta.targetOption.devOnly
-        });
-        const [allArgMetas] = getArgMetas(command, targetMeta.key);
-        for (const argMeta of allArgMetas) {
-          if (argMeta.type === "Option")
-            programCommand = handleOption(programCommand, argMeta);
-          else if (argMeta.type === "Argument")
-            programCommand = handleArgument(programCommand, argMeta);
-          else if (argMeta.type === "Workspace")
-            continue;
-          else if (argMeta.type === "Module") {
-            programCommand = programCommand.argument(
-              `[sys-name:module-name]`,
-              `${argMeta.type} in this workspace (apps|libs)/<sys-name>/lib/<module-name>`
-            );
-          } else {
-            const sysType = argMeta.type.toLowerCase();
-            programCommand = programCommand.argument(
-              `[${sysType}]`,
-              `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
-            );
-          }
-        }
-        programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
-        programCommand.helpInformation = () => {
-          return formatCommandHelp(command, targetMeta.key);
-        };
-        programCommand.action(async (...args) => {
-          Logger.rawLog();
-          const cmdArgs = args.slice(0, args.length - 2);
-          const opt = args[args.length - 2];
-          const commandArgs = [];
-          const workspace = WorkspaceExecutor.fromRoot();
-          for (const argMeta of allArgMetas) {
-            if (argMeta.type === "Option")
-              commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
-            else if (argMeta.type === "Argument")
-              commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx]);
-            else
-              commandArgs[argMeta.idx] = await getInternalArgumentValue(
-                argMeta,
-                cmdArgs[argMeta.idx],
-                workspace
-              );
-            if (commandArgs[argMeta.idx] instanceof AppExecutor)
-              process.env.NEXT_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
-            if (opt.verbose)
-              Executor.setVerbose(true);
-          }
-          const cmd = new command();
-          try {
-            await cmd[targetMeta.key](...commandArgs);
-            Logger.rawLog();
-          } catch (e) {
-            const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
-            Logger.rawLog(`
-${chalk.red(errMsg)}`);
-            throw e;
-          }
-        });
-      }
-    }
-  }
-  await program.parseAsync(process.argv);
-};
-export {
-  runCommands
-};

package/esm/src/commandDecorators/commandMeta.js

@@ -1,7 +0,0 @@
-const Commands = () => {
-  return function(target) {
-  };
-};
-export {
-  Commands
-};

package/esm/src/commandDecorators/targetMeta.js

@@ -1,33 +0,0 @@
-const getTargetMetas = (command) => {
-  const targetMetaMap = Reflect.getMetadata("target", command.prototype);
-  if (!targetMetaMap)
-    throw new Error(`TargetMeta is not defined for ${command.name}`);
-  return [...targetMetaMap.values()];
-};
-const getTargetMetaMapOnPrototype = (prototype) => {
-  const targetMetaMap = Reflect.getMetadata("target", prototype);
-  return targetMetaMap ?? /* @__PURE__ */ new Map();
-};
-const setTargetMetaMapOnPrototype = (prototype, targetMetaMap) => {
-  Reflect.defineMetadata("target", targetMetaMap, prototype);
-};
-const getTarget = (type) => (targetOption = {}) => {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getTargetMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      key,
-      descriptor,
-      targetOption: { ...targetOption, type }
-    });
-    setTargetMetaMapOnPrototype(prototype, metadataMap);
-  };
-};
-const Target = {
-  Public: getTarget("public"),
-  Cloud: getTarget("cloud"),
-  Dev: getTarget("dev")
-};
-export {
-  Target,
-  getTargetMetas
-};

package/esm/src/constants.js

@@ -1,17 +0,0 @@
-import { homedir } from "os";
-const basePath = `${homedir()}/.akan`;
-const configPath = `${basePath}/config.json`;
-const akanCloudHost = process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? "http://localhost" : "https://cloud.akanjs.com";
-const akanCloudBackendUrl = `${akanCloudHost}${process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? ":8080" : ""}/backend`;
-const akanCloudClientUrl = `${akanCloudHost}${process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? ":4200" : ""}`;
-const defaultHostConfig = {};
-const defaultAkanGlobalConfig = { cloudHost: {}, llm: null };
-export {
-  akanCloudBackendUrl,
-  akanCloudClientUrl,
-  akanCloudHost,
-  basePath,
-  configPath,
-  defaultAkanGlobalConfig,
-  defaultHostConfig
-};

package/esm/src/createTunnel.js

@@ -1,26 +0,0 @@
-import { createTunnel as create } from "tunnel-ssh";
-const getSshTunnelOptions = (app, environment) => {
-  const { serveDomain, repoName } = app.workspace.getBaseDevEnv();
-  return {
-    host: `${app.name}-${environment}.${serveDomain}`,
-    port: process.env.SSH_TUNNEL_PORT ? parseInt(process.env.SSH_TUNNEL_PORT) : 32767,
-    username: process.env.SSH_TUNNEL_USERNAME ?? "root",
-    password: process.env.SSH_TUNNEL_PASSWORD ?? repoName
-  };
-};
-const createTunnel = async ({ app, environment, port = 27017 }) => {
-  const tunnelOptions = { autoClose: true, reconnectOnError: true };
-  const sshOptions = getSshTunnelOptions(app, environment);
-  const serverOptions = { port };
-  const forwardOptions = {
-    srcAddr: "0.0.0.0",
-    srcPort: port,
-    dstAddr: `mongo-0.mongo-svc.${app.name}-${environment}`,
-    dstPort: 27017
-  };
-  const [server, client] = await create(tunnelOptions, serverOptions, sshOptions, forwardOptions);
-  return `localhost:${port}`;
-};
-export {
-  createTunnel
-};