@akanjs/devkit 0.9.41 → 0.9.42

package/cjs/src/scanInfo.js

@@ -0,0 +1,487 @@
+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 scanInfo_exports = {};
+__export(scanInfo_exports, {
+  AppInfo: () => AppInfo,
+  LibInfo: () => LibInfo,
+  PkgInfo: () => PkgInfo,
+  WorkspaceInfo: () => WorkspaceInfo
+});
+module.exports = __toCommonJS(scanInfo_exports);
+var import_path = __toESM(require("path"));
+var import_dependencyScanner = require("./dependencyScanner");
+var import_executors = require("./executors");
+const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"];
+const serviceFileTypes = [
+  "dictionary",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+const databaseFileTypes = [
+  "constant",
+  "dictionary",
+  "document",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+class ScanInfo {
+  scanResult;
+  name;
+  scalar = /* @__PURE__ */ new Map();
+  service = /* @__PURE__ */ new Map();
+  database = /* @__PURE__ */ new Map();
+  file = Object.fromEntries(
+    databaseFileTypes.map((type) => [
+      type,
+      { all: /* @__PURE__ */ new Set(), databases: /* @__PURE__ */ new Set(), services: /* @__PURE__ */ new Set(), scalars: /* @__PURE__ */ new Set() }
+    ])
+  );
+  constants = /* @__PURE__ */ new Set();
+  dictionaries = /* @__PURE__ */ new Set();
+  documents = /* @__PURE__ */ new Set();
+  services = /* @__PURE__ */ new Set();
+  signals = /* @__PURE__ */ new Set();
+  stores = /* @__PURE__ */ new Set();
+  templates = /* @__PURE__ */ new Set();
+  units = /* @__PURE__ */ new Set();
+  utils = /* @__PURE__ */ new Set();
+  views = /* @__PURE__ */ new Set();
+  zones = /* @__PURE__ */ new Set();
+  static async getScanResult(exec) {
+    const akanConfig = await exec.getConfig();
+    const tsconfig = exec.getTsConfig();
+    const rootPackageJson = exec.workspace.getPackageJson();
+    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(exec.cwdPath, { tsconfig, rootPackageJson });
+    const { pkgDeps, libDeps, npmDeps } = await scanner.getMonorepoDependencies(exec.name);
+    const files = {
+      constant: { databases: [], scalars: [] },
+      dictionary: { databases: [], services: [], scalars: [] },
+      document: { databases: [], scalars: [] },
+      service: { databases: [], services: [] },
+      signal: { databases: [], services: [] },
+      store: { databases: [], services: [] },
+      template: { databases: [], services: [], scalars: [] },
+      unit: { databases: [], services: [], scalars: [] },
+      util: { databases: [], services: [], scalars: [] },
+      view: { databases: [], services: [], scalars: [] },
+      zone: { databases: [], services: [], scalars: [] }
+    };
+    const [{ dirs: dirnames }, scalarDirs] = await Promise.all([
+      exec.getFilesAndDirs("lib"),
+      exec.readdir("lib/__scalar")
+    ]);
+    const databaseDirs = [];
+    const serviceDirs = [];
+    dirnames.forEach((name) => {
+      if (name.startsWith("_")) {
+        if (name.startsWith("__"))
+          return;
+        else
+          serviceDirs.push(name);
+      } else
+        databaseDirs.push(name);
+    });
+    await Promise.all([
+      ...databaseDirs.map(async (name) => {
+        const filenames = await exec.readdir(import_path.default.join("lib", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts"))
+            files.constant.databases.push(name);
+          else if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.databases.push(name);
+          else if (filename.endsWith(".document.ts"))
+            files.document.databases.push(name);
+          else if (filename.endsWith(".service.ts"))
+            files.service.databases.push(name);
+          else if (filename.endsWith(".signal.ts"))
+            files.signal.databases.push(name);
+          else if (filename.endsWith(".store.ts"))
+            files.store.databases.push(name);
+          else if (filename.endsWith(".Template.tsx"))
+            files.template.databases.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.databases.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.databases.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.databases.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.databases.push(name);
+        });
+      }),
+      ...serviceDirs.map(async (dirname) => {
+        const name = dirname.slice(1);
+        const filenames = await exec.readdir(import_path.default.join("lib", dirname));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.services.push(name);
+          else if (filename.endsWith(".service.ts"))
+            files.service.services.push(name);
+          else if (filename.endsWith(".signal.ts"))
+            files.signal.services.push(name);
+          else if (filename.endsWith(".store.ts"))
+            files.store.services.push(name);
+          else if (filename.endsWith(".Template.tsx"))
+            files.template.services.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.services.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.services.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.services.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.services.push(name);
+        });
+      }),
+      ...scalarDirs.map(async (name) => {
+        const filenames = await exec.readdir(import_path.default.join("lib/__scalar", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts"))
+            files.constant.scalars.push(name);
+          else if (filename.endsWith(".dictionary.ts"))
+            files.dictionary.scalars.push(name);
+          else if (filename.endsWith(".document.ts"))
+            files.document.scalars.push(name);
+          else if (filename.endsWith(".Template.tsx"))
+            files.template.scalars.push(name);
+          else if (filename.endsWith(".Unit.tsx"))
+            files.unit.scalars.push(name);
+          else if (filename.endsWith(".Util.tsx"))
+            files.util.scalars.push(name);
+          else if (filename.endsWith(".View.tsx"))
+            files.view.scalars.push(name);
+          else if (filename.endsWith(".Zone.tsx"))
+            files.zone.scalars.push(name);
+        });
+      })
+    ]);
+    const missingLibDeps = [];
+    libDeps.forEach((libName) => {
+      if (!akanConfig.libs.includes(libName))
+        missingLibDeps.push(libName);
+    });
+    if (missingLibDeps.length)
+      throw new Error(
+        `Missing libs: ${missingLibDeps.join(", ")}, add these dependencies in akan.config.ts as { libs: [...other deps, ${missingLibDeps.join(", ")}] }`
+      );
+    const scanResult = {
+      name: exec.name,
+      type: exec.type,
+      repoName: exec.workspace.repoName,
+      serveDomain: exec.workspace.getBaseDevEnv().serveDomain,
+      akanConfig,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: npmDeps.filter((dep) => !dep.startsWith("@akanjs"))
+    };
+    return scanResult;
+  }
+  constructor(scanResult) {
+    this.name = scanResult.name;
+    this.scanResult = scanResult;
+    Object.entries(scanResult.files).forEach(
+      ([key, value]) => {
+        const { databases, services, scalars } = value;
+        databases.forEach((modelName) => {
+          const model = this.database.get(modelName) ?? /* @__PURE__ */ new Set();
+          model.add(key);
+          this.database.set(modelName, model);
+          this.file[key].all.add(modelName);
+          this.file[key].databases.add(modelName);
+        });
+        services?.forEach((serviceName) => {
+          const service = this.service.get(serviceName) ?? /* @__PURE__ */ new Set();
+          service.add(key);
+          this.service.set(serviceName, service);
+          this.file[key].all.add(serviceName);
+          this.file[key].services.add(serviceName);
+        });
+        scalars?.forEach((scalarName) => {
+          const scalar = this.scalar.get(scalarName) ?? /* @__PURE__ */ new Set();
+          scalar.add(key);
+          this.scalar.set(scalarName, scalar);
+          this.file[key].all.add(scalarName);
+          this.file[key].scalars.add(scalarName);
+        });
+      }
+    );
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  getDatabaseModules() {
+    return [...this.database.keys()];
+  }
+  getServiceModules() {
+    return [...this.service.keys()];
+  }
+  getScalarModules() {
+    return [...this.scalar.keys()];
+  }
+}
+class AppInfo extends ScanInfo {
+  type = "app";
+  exec;
+  akanConfig;
+  static appInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingAppInfo = this.appInfos.get(exec.name);
+    if (existingAppInfo && !options.refresh)
+      return existingAppInfo;
+    const scanResult = await super.getScanResult(exec);
+    await Promise.all(
+      scanResult.libDeps.map(async (libName) => {
+        LibInfo.loadedLibs.add(libName);
+        const libExecutor = import_executors.LibExecutor.from(exec, libName);
+        LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+      })
+    );
+    const appInfo = new AppInfo(exec, scanResult);
+    this.appInfos.set(exec.name, appInfo);
+    return appInfo;
+  }
+  constructor(exec, scanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(libName))
+      throw new Error(`LibInfo is invalid: ${libName}`);
+    return LibInfo.libInfos.get(libName);
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo)
+          throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      })
+    );
+  }
+}
+class LibInfo extends ScanInfo {
+  type = "lib";
+  exec;
+  akanConfig;
+  static loadedLibs = /* @__PURE__ */ new Set();
+  static libInfos = /* @__PURE__ */ new Map();
+  static #sortedLibIndices = null;
+  static getSortedLibIndices() {
+    if (this.#sortedLibIndices)
+      return this.#sortedLibIndices;
+    this.#sortedLibIndices = new Map(
+      [...this.libInfos.entries()].sort(([_, libInfoA], [__, libInfoB]) => libInfoA.akanConfig.libs.includes(libInfoB.name) ? 1 : -1).map(([libName], index) => [libName, index])
+    );
+    return this.#sortedLibIndices;
+  }
+  static async fromExecutor(exec, { refresh } = {}) {
+    const existingLibInfo = this.libInfos.get(exec.name);
+    if (existingLibInfo && !refresh)
+      return existingLibInfo;
+    const scanResult = await super.getScanResult(exec);
+    await Promise.all(
+      scanResult.libDeps.filter((libName) => !this.loadedLibs.has(libName)).map(async (libName) => {
+        this.loadedLibs.add(libName);
+        this.libInfos.set(libName, await LibInfo.fromExecutor(exec));
+      })
+    );
+    const libInfo = new LibInfo(exec, scanResult);
+    this.libInfos.set(exec.name, libInfo);
+    this.#sortedLibIndices = null;
+    return libInfo;
+  }
+  constructor(exec, scanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libs = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libs.get(libNameA);
+      const indexB = libs.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    if (!this.getScanResult().akanConfig.libs.includes(libName))
+      return void 0;
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(libName))
+      throw new Error(`LibInfo is invalid: ${libName}`);
+    return LibInfo.libInfos.get(libName);
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo)
+          throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      })
+    );
+  }
+}
+class PkgInfo {
+  exec;
+  name;
+  scanResult;
+  static async getScanResult(exec) {
+    const tsconfig = exec.getTsConfig();
+    const rootPackageJson = exec.workspace.getPackageJson();
+    const scanner = new import_dependencyScanner.TypeScriptDependencyScanner(exec.cwdPath, { tsconfig, rootPackageJson });
+    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("/*", ""))
+    );
+    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return (tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((pkg) => pkg !== this.name);
+    const pkgScanResult = {
+      name: this.name,
+      pkgDeps,
+      dependencies: [...npmDepSet]
+    };
+    return pkgScanResult;
+  }
+  static #pkgInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingPkgInfo = this.#pkgInfos.get(exec.name);
+    if (existingPkgInfo && !options.refresh)
+      return existingPkgInfo;
+    const scanResult = await this.getScanResult(exec);
+    const pkgInfo = new PkgInfo(exec, scanResult);
+    this.#pkgInfos.set(exec.name, pkgInfo);
+    return pkgInfo;
+  }
+  constructor(exec, scanResult) {
+    this.exec = exec;
+    this.name = exec.name;
+    this.scanResult = scanResult;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+}
+class WorkspaceInfo {
+  constructor(appInfos = /* @__PURE__ */ new Map(), libInfos = /* @__PURE__ */ new Map(), pkgInfos = /* @__PURE__ */ new Map()) {
+    this.appInfos = appInfos;
+    this.libInfos = libInfos;
+    this.pkgInfos = pkgInfos;
+  }
+  static #workspaceInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec, options = {}) {
+    const existingWorkspaceInfo = this.#workspaceInfos.get(exec.name);
+    if (existingWorkspaceInfo && !options.refresh)
+      return existingWorkspaceInfo;
+    const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
+    const [appInfos, libInfos, pkgInfos] = await Promise.all([
+      Promise.all(
+        appNames.map(async (appName) => {
+          const app = import_executors.AppExecutor.from(exec, appName);
+          return await app.scan();
+        })
+      ),
+      Promise.all(
+        libNames.map(async (libName) => {
+          const lib = import_executors.LibExecutor.from(exec, libName);
+          return await lib.scan();
+        })
+      ),
+      Promise.all(
+        pkgNames.map(async (pkgName) => {
+          return await import_executors.PkgExecutor.from(exec, pkgName).scan();
+        })
+      )
+    ]);
+    const workspaceInfo = new WorkspaceInfo(
+      new Map(appInfos.map((app) => [app.exec.name, app])),
+      new Map(libInfos.map((lib) => [lib.exec.name, lib])),
+      new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg]))
+    );
+    this.#workspaceInfos.set(exec.name, workspaceInfo);
+    return workspaceInfo;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppInfo,
+  LibInfo,
+  PkgInfo,
+  WorkspaceInfo
+});

package/esm/src/builder.js

@@ -72,8 +72,8 @@ class Builder {
       }
     };
     buildResult.outputFiles.map((file) => this.#distExecutor.writeFile(file.path, file.text));
-    this.#distExecutor.writeJson("package.json", pkgPackageJson);
-    this.#executor.writeJson("package.json", pkgPackageJson);
+    this.#distExecutor.setPackageJson(pkgPackageJson);
+    this.#executor.setPackageJson(pkgPackageJson);
   }
 }
 export {

package/esm/src/commandDecorators/command.js

@@ -184,8 +184,18 @@ const runCommands = async (...commands) => {
   });
   const __dirname = getDirname(import.meta.url);
   const hasPackageJson = fs.existsSync(`${__dirname}/../package.json`);
-  const version = hasPackageJson ? JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
-  program.version(version).description("Akan CLI");
+  process.env.AKAN_VERSION = hasPackageJson ? JSON.parse(fs.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
+  program.version(process.env.AKAN_VERSION).description("Akan CLI");
+  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) {
@@ -248,7 +258,8 @@ const runCommands = async (...commands) => {
             Logger.rawLog();
           } catch (e) {
             const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
-            Logger.error(`Command Error: ${chalk.red(errMsg)}`);
+            Logger.rawLog(`
+${chalk.red(errMsg)}`);
             throw e;
           }
         });

package/esm/src/dependencyScanner.js

@@ -2,11 +2,37 @@ import * as fs from "fs";
 import * as path from "path";
 import * as ts from "typescript";
 class TypeScriptDependencyScanner {
-  constructor(directory) {
-    this.directory = directory;
-  }
   #fileDependencies = /* @__PURE__ */ new Map();
   #visitedFiles = /* @__PURE__ */ new Set();
+  directory;
+  tsconfig;
+  rootPackageJson;
+  constructor(directory, { tsconfig, rootPackageJson }) {
+    this.directory = directory;
+    this.tsconfig = tsconfig;
+    this.rootPackageJson = rootPackageJson;
+  }
+  async getMonorepoDependencies(projectName) {
+    const npmSet = new Set(
+      Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies })
+    );
+    const pkgPathSet = new Set(
+      Object.keys(this.tsconfig.compilerOptions.paths ?? {}).filter((path2) => this.tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
+    );
+    const libPathSet = new Set(
+      Object.keys(this.tsconfig.compilerOptions.paths ?? {}).filter((path2) => this.tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("libs/"))).map((path2) => path2.replace("/*", ""))
+    );
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await this.getImportSets([npmSet, pkgPathSet, libPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    });
+    const libDeps = [...libPathDepSet].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((libName) => libName !== projectName);
+    return { pkgDeps, libDeps, npmDeps: [...npmDepSet] };
+  }
   async getImportSets(depSets) {
     const fileDependencies = await this.getDependencies();
     const importedDepSets = new Array(depSets.length);