@akanjs/devkit 0.0.52 → 0.0.54

package/src/createTunnel.js

@@ -1,30 +1,8 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var createTunnel_exports = {};
-__export(createTunnel_exports, {
-  createTunnel: () => createTunnel
-});
-module.exports = __toCommonJS(createTunnel_exports);
-var import_tunnel_ssh = require("tunnel-ssh");
-var import_baseDevEnv = require("./baseDevEnv");
+import { createTunnel as create } from "tunnel-ssh";
+import { getSshTunnelOptions } from "./baseDevEnv";
 const createTunnel = async ({ appName, environment, port = 27017 }) => {
   const tunnelOptions = { autoClose: true, reconnectOnError: true };
-  const sshOptions = (0, import_baseDevEnv.getSshTunnelOptions)(appName, environment);
+  const sshOptions = getSshTunnelOptions(appName, environment);
   const serverOptions = { port };
   const forwardOptions = {
     srcAddr: "0.0.0.0",
@@ -32,6 +10,9 @@ const createTunnel = async ({ appName, environment, port = 27017 }) => {
     dstAddr: `mongo-0.mongo-svc.${appName}-${environment}`,
     dstPort: 27017
   };
-  const [server, client] = await (0, import_tunnel_ssh.createTunnel)(tunnelOptions, serverOptions, sshOptions, forwardOptions);
+  const [server, client] = await create(tunnelOptions, serverOptions, sshOptions, forwardOptions);
   return `localhost:${port}`;
 };
+export {
+  createTunnel
+};

package/src/dependencyScanner.js

@@ -1,39 +1,7 @@
 #!/usr/bin/env ts-node
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dependencyScanner_exports = {};
-__export(dependencyScanner_exports, {
-  TypeScriptDependencyScanner: () => TypeScriptDependencyScanner
-});
-module.exports = __toCommonJS(dependencyScanner_exports);
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var ts = __toESM(require("typescript"));
+import * as fs from "fs";
+import * as path from "path";
+import * as ts from "typescript";
 class TypeScriptDependencyScanner {
   constructor(directory) {
     this.directory = directory;
@@ -157,3 +125,6 @@ class TypeScriptDependencyScanner {
     return graph;
   }
 }
+export {
+  TypeScriptDependencyScanner
+};

package/src/executors.js

@@ -1,67 +1,31 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var executors_exports = {};
-__export(executors_exports, {
-  AppExecutor: () => AppExecutor,
-  DistAppExecutor: () => DistAppExecutor,
-  DistLibExecutor: () => DistLibExecutor,
-  DistPkgExecutor: () => DistPkgExecutor,
-  Executor: () => Executor,
-  LibExecutor: () => LibExecutor,
-  PkgExecutor: () => PkgExecutor,
-  SysExecutor: () => SysExecutor,
-  WorkspaceExecutor: () => WorkspaceExecutor
-});
-module.exports = __toCommonJS(executors_exports);
-var import_common = require("@akanjs/common");
-var import_config = require("@akanjs/config");
-var import_child_process = require("child_process");
-var import_fs = __toESM(require("fs"));
-var import_promises = __toESM(require("fs/promises"));
-var import_path = __toESM(require("path"));
-var import_baseDevEnv = require("./baseDevEnv");
-var import_dependencyScanner = require("./dependencyScanner");
+import { Logger } from "@akanjs/common";
+import {
+  getAppConfig,
+  getDefaultFileScan,
+  getLibConfig
+} from "@akanjs/config";
+import { exec, fork, spawn } from "child_process";
+import fs from "fs";
+import fsPromise from "fs/promises";
+import path from "path";
+import { getBaseDevEnv } from "./baseDevEnv";
+import { TypeScriptDependencyScanner } from "./dependencyScanner";
 class Executor {
   logger;
   cwdPath;
   constructor(name, cwdPath) {
-    this.logger = new import_common.Logger(name);
+    this.logger = new Logger(name);
     this.cwdPath = cwdPath;
-    if (!import_fs.default.existsSync(cwdPath))
-      import_fs.default.mkdirSync(cwdPath, { recursive: true });
+    if (!fs.existsSync(cwdPath))
+      fs.mkdirSync(cwdPath, { recursive: true });
   }
   exec(command, options = {}) {
-    const proc = (0, import_child_process.exec)(command, { cwd: this.cwdPath, ...options });
+    const proc = exec(command, { cwd: this.cwdPath, ...options });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -73,9 +37,9 @@ class Executor {
     });
   }
   spawn(command, args = [], options = {}) {
-    const proc = (0, import_child_process.spawn)(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
+    const proc = spawn(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -87,16 +51,16 @@ class Executor {
     });
   }
   fork(modulePath, args = [], options = {}) {
-    const proc = (0, import_child_process.fork)(modulePath, args, {
+    const proc = fork(modulePath, args, {
       cwd: this.cwdPath,
       stdio: ["ignore", "inherit", "inherit", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     proc.stderr?.on("data", (data) => {
-      import_common.Logger.raw(data.toString());
+      Logger.raw(data.toString());
     });
     return new Promise((resolve, reject) => {
       proc.on("exit", (code, signal) => {
@@ -108,28 +72,28 @@ class Executor {
     });
   }
   mkdir(dirPath) {
-    const writePath = import_path.default.isAbsolute(dirPath) ? dirPath : `${this.cwdPath}/${dirPath}`;
-    if (!import_fs.default.existsSync(writePath))
-      import_fs.default.mkdirSync(writePath, { recursive: true });
+    const writePath = path.isAbsolute(dirPath) ? dirPath : `${this.cwdPath}/${dirPath}`;
+    if (!fs.existsSync(writePath))
+      fs.mkdirSync(writePath, { recursive: true });
     this.logger.verbose(`Make directory ${writePath}`);
     return this;
   }
   writeFile(filePath, content) {
-    const writePath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
-    const dir = import_path.default.dirname(writePath);
-    if (!import_fs.default.existsSync(dir))
-      import_fs.default.mkdirSync(dir, { recursive: true });
+    const writePath = path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    const dir = path.dirname(writePath);
+    if (!fs.existsSync(dir))
+      fs.mkdirSync(dir, { recursive: true });
     const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-    if (import_fs.default.existsSync(writePath)) {
-      const currentContent = import_fs.default.readFileSync(writePath, "utf8");
+    if (fs.existsSync(writePath)) {
+      const currentContent = fs.readFileSync(writePath, "utf8");
       if (currentContent === contentStr)
         this.logger.verbose(`File ${writePath} is unchanged`);
       else {
-        import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+        fs.writeFileSync(writePath, contentStr, "utf8");
         this.logger.verbose(`File ${writePath} is changed`);
       }
     } else {
-      import_fs.default.writeFileSync(writePath, contentStr, "utf8");
+      fs.writeFileSync(writePath, contentStr, "utf8");
       this.logger.verbose(`File ${writePath} is created`);
     }
     return this;
@@ -139,17 +103,17 @@ class Executor {
     return this;
   }
   readFile(filePath) {
-    const readPath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
-    return import_fs.default.readFileSync(readPath, "utf8");
+    const readPath = path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return fs.readFileSync(readPath, "utf8");
   }
   readJson(filePath) {
-    const readPath = import_path.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
-    return JSON.parse(import_fs.default.readFileSync(readPath, "utf8"));
+    const readPath = path.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+    return JSON.parse(fs.readFileSync(readPath, "utf8"));
   }
   async cp(srcPath, destPath) {
-    const src = import_path.default.isAbsolute(srcPath) ? srcPath : `${this.cwdPath}/${srcPath}`;
-    const dest = import_path.default.isAbsolute(destPath) ? destPath : `${this.cwdPath}/${destPath}`;
-    await import_promises.default.cp(src, dest, { recursive: true });
+    const src = path.isAbsolute(srcPath) ? srcPath : `${this.cwdPath}/${srcPath}`;
+    const dest = path.isAbsolute(destPath) ? destPath : `${this.cwdPath}/${destPath}`;
+    await fsPromise.cp(src, dest, { recursive: true });
   }
   log(msg) {
     this.logger.info(msg);
@@ -188,7 +152,7 @@ class Executor {
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
       this.writeFile(convertedTargetPath, content);
     } else if (targetPath.endsWith(".template")) {
-      const content = await import_promises.default.readFile(templatePath, "utf8");
+      const content = await fsPromise.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
         (path2, [key, value]) => path2.replace(new RegExp(`__${key}__`, "g"), value),
         targetPath.slice(0, -9)
@@ -208,25 +172,25 @@ class Executor {
     dict = {}
   }) {
     const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
-    if (import_fs.default.statSync(templatePath).isFile()) {
-      const filename = import_path.default.basename(templatePath);
-      await this.#applyTemplateFile({ templatePath, targetPath: import_path.default.join(basePath, filename), scanResult }, dict);
+    if (fs.statSync(templatePath).isFile()) {
+      const filename = path.basename(templatePath);
+      await this.#applyTemplateFile({ templatePath, targetPath: path.join(basePath, filename), scanResult }, dict);
     } else {
-      if (!import_fs.default.existsSync(basePath))
-        await import_promises.default.mkdir(basePath, { recursive: true });
-      const subdirs = await import_promises.default.readdir(templatePath);
+      if (!fs.existsSync(basePath))
+        await fsPromise.mkdir(basePath, { recursive: true });
+      const subdirs = await fsPromise.readdir(templatePath);
       await Promise.all(
         subdirs.map(async (subdir) => {
-          const subpath = import_path.default.join(templatePath, subdir);
-          if (import_fs.default.statSync(subpath).isFile())
+          const subpath = path.join(templatePath, subdir);
+          if (fs.statSync(subpath).isFile())
             await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanResult },
+              { templatePath: subpath, targetPath: path.join(basePath, subdir), scanResult },
               dict
             );
           else
             await this.applyTemplate({
-              basePath: import_path.default.join(basePath, subdir),
-              template: import_path.default.join(template, subdir),
+              basePath: path.join(basePath, subdir),
+              template: path.join(template, subdir),
               scanResult,
               dict
             });
@@ -244,7 +208,7 @@ class WorkspaceExecutor extends Executor {
     this.repoName = repoName;
   }
   static fromRoot() {
-    const repoName = import_path.default.basename(process.cwd());
+    const repoName = path.basename(process.cwd());
     return new WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
   }
   async scan() {
@@ -295,14 +259,14 @@ class WorkspaceExecutor extends Executor {
   async #getDirHasFile(basePath, targetFilename) {
     const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
     const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
-      const dirs = await import_promises.default.readdir(dirname);
+      const dirs = await fsPromise.readdir(dirname);
       await Promise.all(
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
             return;
-          const dirPath = import_path.default.join(dirname, dir);
-          if (import_fs.default.lstatSync(dirPath).isDirectory()) {
-            const hasTargetFile = import_fs.default.existsSync(import_path.default.join(dirPath, targetFilename));
+          const dirPath = path.join(dirname, dir);
+          if (fs.lstatSync(dirPath).isDirectory()) {
+            const hasTargetFile = fs.existsSync(path.join(dirPath, targetFilename));
             if (hasTargetFile)
               results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -326,7 +290,7 @@ class SysExecutor extends Executor {
     this.type = type;
   }
   async getConfig(command) {
-    return this.type === "app" ? await (0, import_config.getAppConfig)(this.cwdPath, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command }) : await (0, import_config.getLibConfig)(this.cwdPath, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command });
+    return this.type === "app" ? await getAppConfig(this.cwdPath, { ...getBaseDevEnv(), appName: this.name, command }) : await getLibConfig(this.cwdPath, { ...getBaseDevEnv(), appName: this.name, command });
   }
   async scan({
     tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`),
@@ -335,7 +299,7 @@ class SysExecutor extends Executor {
     if (libScanResults[this.name])
       return libScanResults[this.name];
     const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
     const pkgPathSet = new Set(
       Object.keys(tsconfig.compilerOptions.paths).filter((path2) => tsconfig.compilerOptions.paths[path2].some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
@@ -352,17 +316,17 @@ class SysExecutor extends Executor {
       const pathSplitLength = path2.split("/").length;
       return tsconfig.compilerOptions.paths[path2][0].split("/").slice(1, 1 + pathSplitLength).join("/");
     }).filter((libName) => libName !== this.name);
-    if (!import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar`))
-      import_fs.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = (0, import_config.getDefaultFileScan)();
-    const dirnames = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter(
-      (name) => import_fs.default.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
+    if (!fs.existsSync(`${this.cwdPath}/lib/__scalar`))
+      fs.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
+    const files = getDefaultFileScan();
+    const dirnames = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter(
+      (name) => fs.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
     );
     const databaseDirs = dirnames.filter((name) => !name.startsWith("_"));
     const serviceDirs = dirnames.filter((name) => name.startsWith("_") && !name.startsWith("__"));
     await Promise.all(
       databaseDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", name));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.databases.push(name);
@@ -384,7 +348,7 @@ class SysExecutor extends Executor {
     await Promise.all(
       serviceDirs.map(async (dirname) => {
         const name = dirname.slice(1);
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib", dirname));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib", dirname));
         filenames.forEach((filename) => {
           if (filename.endsWith(".dictionary.ts"))
             files.dictionary.services.push(name);
@@ -399,12 +363,12 @@ class SysExecutor extends Executor {
         });
       })
     );
-    const scalarDirs = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
+    const scalarDirs = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
       (name) => !name.startsWith("_")
     );
     await Promise.all(
       scalarDirs.map(async (name) => {
-        const filenames = await import_promises.default.readdir(import_path.default.join(this.cwdPath, "lib/__scalar", name));
+        const filenames = await fsPromise.readdir(path.join(this.cwdPath, "lib/__scalar", name));
         filenames.forEach((filename) => {
           if (filename.endsWith(".constant.ts"))
             files.constants.scalars.push(name);
@@ -458,15 +422,15 @@ class SysExecutor extends Executor {
     return scanResult;
   }
   async getDatabaseModules() {
-    const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
+    const databaseModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
     return databaseModules;
   }
   async getServiceModules() {
-    const serviceModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
+    const serviceModules = (await fsPromise.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
     return serviceModules;
   }
   async getScalarModules() {
-    const scalarModules = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+    const scalarModules = (await fsPromise.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => fs.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
     return scalarModules;
   }
 }
@@ -480,17 +444,17 @@ class AppExecutor extends SysExecutor {
     return new AppExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await (0, import_config.getAppConfig)(this.cwdPath, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command });
+    return await getAppConfig(this.cwdPath, { ...getBaseDevEnv(), appName: this.name, command });
   }
   async syncAssets(libDeps) {
     const projectPublicLibPath = `${this.cwdPath}/public/libs`;
-    if (import_fs.default.existsSync(projectPublicLibPath))
-      await import_promises.default.rm(projectPublicLibPath, { recursive: true });
-    const targetDeps = libDeps.filter((dep) => import_fs.default.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
-    await Promise.all(targetDeps.map((dep) => import_promises.default.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })));
+    if (fs.existsSync(projectPublicLibPath))
+      await fsPromise.rm(projectPublicLibPath, { recursive: true });
+    const targetDeps = libDeps.filter((dep) => fs.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
+    await Promise.all(targetDeps.map((dep) => fsPromise.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })));
     await Promise.all(
       targetDeps.map(
-        (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+        (dep) => fsPromise.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
           recursive: true
         })
       )
@@ -521,7 +485,7 @@ class LibExecutor extends SysExecutor {
     return new LibExecutor({ workspace: executor.workspace, name });
   }
   async getConfig(command) {
-    return await (0, import_config.getLibConfig)(this.cwdPath, { ...(0, import_baseDevEnv.getBaseDevEnv)(), appName: this.name, command });
+    return await getLibConfig(this.cwdPath, { ...getBaseDevEnv(), appName: this.name, command });
   }
 }
 class DistLibExecutor extends Executor {
@@ -554,7 +518,7 @@ class PkgExecutor extends Executor {
     tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`)
   } = {}) {
     const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(this.cwdPath);
+    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
     const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
     const pkgPathSet = new Set(
       Object.keys(tsconfig.compilerOptions.paths).filter((path2) => tsconfig.compilerOptions.paths[path2].some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
@@ -590,3 +554,14 @@ class DistPkgExecutor extends Executor {
     });
   }
 }
+export {
+  AppExecutor,
+  DistAppExecutor,
+  DistLibExecutor,
+  DistPkgExecutor,
+  Executor,
+  LibExecutor,
+  PkgExecutor,
+  SysExecutor,
+  WorkspaceExecutor
+};

package/src/extractDeps.js

@@ -1,25 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var extractDeps_exports = {};
-__export(extractDeps_exports, {
-  extractDependencies: () => extractDependencies
-});
-module.exports = __toCommonJS(extractDeps_exports);
 const NODE_NATIVE_MODULE_SET = /* @__PURE__ */ new Set([
   "assert",
   "async_hooks",
@@ -97,3 +75,6 @@ const extractDependencies = (filepaths, pacakgeJson, defaultDependencies = []) =
     })
   );
 };
+export {
+  extractDependencies
+};

package/src/getCredentials.js

@@ -1,40 +1,11 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getCredentials_exports = {};
-__export(getCredentials_exports, {
-  getCredentials: () => getCredentials
-});
-module.exports = __toCommonJS(getCredentials_exports);
-var import_fs = __toESM(require("fs"));
-var import_js_yaml = __toESM(require("js-yaml"));
+import fs from "fs";
+import yaml from "js-yaml";
 const getCredentials = (app, environment) => {
-  const secret = import_js_yaml.default.load(
-    import_fs.default.readFileSync(`${app.workspace.workspaceRoot}/infra/app/values/${app.name}-secret.yaml`, "utf-8")
+  const secret = yaml.load(
+    fs.readFileSync(`${app.workspace.workspaceRoot}/infra/app/values/${app.name}-secret.yaml`, "utf-8")
   );
   return secret[environment];
 };
+export {
+  getCredentials
+};

package/src/getDependencies.js

@@ -1,26 +1,4 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var getDependencies_exports = {};
-__export(getDependencies_exports, {
-  getDependencies: () => getDependencies
-});
-module.exports = __toCommonJS(getDependencies_exports);
-var import_devkit = require("@nx/devkit");
+import { createProjectGraphAsync } from "@nx/devkit";
 const addLibDepSet = (depName, { libDepSet, npmDepSet, dependencies }) => {
   const deps = dependencies[depName];
   if (!deps)
@@ -37,7 +15,7 @@ const addLibDepSet = (depName, { libDepSet, npmDepSet, dependencies }) => {
   }
 };
 const getDependencies = async (projectName) => {
-  const graph = await (0, import_devkit.createProjectGraphAsync)();
+  const graph = await createProjectGraphAsync();
   const [libDepSet, npmDepSet] = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
   const dependencies = graph.dependencies;
   const projectDeps = dependencies[projectName];
@@ -49,3 +27,6 @@ const getDependencies = async (projectName) => {
     npmDeps: [...npmDepSet.values()].map((depName) => depName.replace("npm:", ""))
   };
 };
+export {
+  getDependencies
+};