@akanjs/devkit 0.0.39 → 0.0.40

package/src/dependencyScanner.js

@@ -0,0 +1,171 @@
+#!/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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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"));
+class TypeScriptDependencyScanner {
+  static {
+    __name(this, "TypeScriptDependencyScanner");
+  }
+  directory;
+  #fileDependencies;
+  #visitedFiles;
+  constructor(directory) {
+    this.directory = directory;
+    this.#fileDependencies = /* @__PURE__ */ new Map();
+    this.#visitedFiles = /* @__PURE__ */ new Set();
+  }
+  async getImportSets(depSets) {
+    const fileDependencies = await this.getDependencies();
+    const importedDepSets = new Array(depSets.length);
+    for (let i = 0; i < depSets.length; i++) importedDepSets[i] = /* @__PURE__ */ new Set();
+    fileDependencies.forEach((imps) => {
+      imps.forEach((imp) => {
+        if (imp.startsWith(".")) return;
+        const moduleName = imp;
+        const moduleNameParts = moduleName.split("/");
+        const subModuleLength = moduleNameParts.length;
+        for (let i = 0; i < subModuleLength; i++) {
+          const importName = moduleNameParts.slice(0, i + 1).join("/");
+          for (let j = 0; j < depSets.length; j++) {
+            if (depSets[j].has(importName)) {
+              importedDepSets[j].add(importName);
+              return;
+            }
+          }
+        }
+      });
+    });
+    return importedDepSets;
+  }
+  async getDependencies() {
+    this.#fileDependencies.clear();
+    this.#visitedFiles.clear();
+    const files = await this.#findTypeScriptFiles(this.directory);
+    for (const file of files) await this.#analyzeFile(file, this.directory);
+    return this.#fileDependencies;
+  }
+  async #findTypeScriptFiles(directory) {
+    const files = [];
+    const processDirectory = /* @__PURE__ */ __name(async (dir) => {
+      const entries = await fs.promises.readdir(dir, {
+        withFileTypes: true
+      });
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (![
+            "node_modules",
+            "dist",
+            "build",
+            ".git",
+            ".next",
+            "public",
+            "ios",
+            "android"
+          ].includes(entry.name)) await processDirectory(fullPath);
+        } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) files.push(fullPath);
+      }
+    }, "processDirectory");
+    await processDirectory(directory);
+    return files;
+  }
+  async #analyzeFile(filePath, baseDir) {
+    if (this.#visitedFiles.has(filePath)) return;
+    this.#visitedFiles.add(filePath);
+    try {
+      const fileContent = await fs.promises.readFile(filePath, "utf-8");
+      const imports = this.#extractImports(fileContent, filePath);
+      const resolvedImports = imports.map((importPath) => {
+        if (importPath.startsWith(".")) {
+          const resolvedPath = "./" + path.join(path.relative(baseDir, filePath), importPath);
+          return this.#ensureExtension(resolvedPath);
+        }
+        return importPath;
+      });
+      const relativePath = path.relative(baseDir, filePath);
+      this.#fileDependencies.set(relativePath, resolvedImports);
+    } catch (error) {
+    }
+  }
+  #ensureExtension(filePath) {
+    if (fs.existsSync(`${filePath}.ts`)) return `${filePath}.ts`;
+    else if (fs.existsSync(`${filePath}.tsx`)) return `${filePath}.tsx`;
+    else if (fs.existsSync(filePath)) return filePath;
+    return `${filePath}.ts`;
+  }
+  #extractImports(source, filePath) {
+    const imports = [];
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true);
+    const visit = /* @__PURE__ */ __name((node) => {
+      if (ts.isImportDeclaration(node)) {
+        const moduleSpecifier = node.moduleSpecifier;
+        if (ts.isStringLiteral(moduleSpecifier)) imports.push(moduleSpecifier.text);
+      }
+      ts.forEachChild(node, visit);
+    }, "visit");
+    visit(sourceFile);
+    return imports;
+  }
+  generateDependencyGraph() {
+    let graph = "Dependency Graph:\n\n";
+    for (const [file, imports] of this.#fileDependencies.entries()) {
+      graph += `${file}:
+`;
+      const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
+      const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
+      if (projectImports.length > 0) {
+        graph += "  Project dependencies:\n";
+        projectImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      if (externalImports.length > 0) {
+        graph += "  External dependencies:\n";
+        externalImports.forEach((imp) => {
+          graph += `    \u2192 ${imp}
+`;
+        });
+      }
+      graph += "\n";
+    }
+    return graph;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeScriptDependencyScanner
+});

package/src/executors.d.ts

@@ -0,0 +1,279 @@
+import { NextConfig } from 'next';
+import { ExecOptions, SpawnOptions, ForkOptions } from 'child_process';
+import { TsConfigJson, PackageJson } from './types.js';
+
+declare const logLevels: readonly ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+type LogLevel = (typeof logLevels)[number];
+declare class Logger {
+    #private;
+    static level: LogLevel;
+    static setLevel(level: LogLevel): void;
+    name?: string;
+    constructor(name?: string);
+    trace(msg: string, context?: string): void;
+    verbose(msg: string, context?: string): void;
+    debug(msg: string, context?: string): void;
+    log(msg: string, context?: string): void;
+    info(msg: string, context?: string): void;
+    warn(msg: string, context?: string): void;
+    error(msg: string, context?: string): void;
+    raw(msg: string, method?: "console" | "process"): void;
+    rawLog(msg: string, method?: "console" | "process"): void;
+    static trace(msg: string, context?: string): void;
+    static verbose(msg: string, context?: string): void;
+    static debug(msg: string, context?: string): void;
+    static log(msg: string, context?: string): void;
+    static info(msg: string, context?: string): void;
+    static warn(msg: string, context?: string): void;
+    static error(msg: string, context?: string): void;
+    static rawLog(msg: string, method?: "console" | "process"): void;
+    static raw(msg: string, method?: "console" | "process"): void;
+}
+
+type Arch = "amd64" | "arm64";
+type ExplicitDependencies = string[] | {
+    [key in Arch]: string[];
+};
+interface AppConfigResult {
+    rootLib?: string;
+    libs: string[];
+    backend: {
+        dockerfile: string;
+        explicitDependencies: ExplicitDependencies;
+    };
+    frontend: {
+        dockerfile: string;
+        nextConfig: NextConfig | (() => Promise<NextConfig> | NextConfig);
+        routes?: {
+            basePath?: string;
+            domains: {
+                main?: string[];
+                develop?: string[];
+                debug?: string[];
+            };
+        }[];
+        explicitDependencies: ExplicitDependencies;
+    };
+}
+interface LibConfigResult {
+    rootLib?: string;
+    libs: string[];
+    backend: {
+        explicitDependencies: ExplicitDependencies;
+    };
+    frontend: {
+        explicitDependencies: ExplicitDependencies;
+    };
+}
+interface FileConventionScanResult {
+    constants: {
+        databases: string[];
+        scalars: string[];
+    };
+    dictionary: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    documents: {
+        databases: string[];
+        scalars: string[];
+    };
+    services: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    signal: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    store: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+    components: {
+        databases: string[];
+        services: string[];
+        scalars: string[];
+    };
+}
+interface AppScanResult {
+    name: string;
+    type: "app" | "lib";
+    akanConfig: AppConfigResult;
+    files: FileConventionScanResult;
+    libDeps: string[];
+    pkgDeps: string[];
+    dependencies: string[];
+    libs: {
+        [key: string]: LibScanResult;
+    };
+}
+interface LibScanResult {
+    name: string;
+    type: "app" | "lib";
+    akanConfig: LibConfigResult;
+    files: FileConventionScanResult;
+    libDeps: string[];
+    pkgDeps: string[];
+    dependencies: string[];
+    libs: {
+        [key: string]: LibScanResult;
+    };
+}
+interface PkgScanResult {
+    name: string;
+    pkgDeps: string[];
+    dependencies: string[];
+}
+interface WorkspaceScanResult {
+    appNames: string[];
+    libNames: string[];
+    pkgNames: string[];
+    apps: {
+        [key: string]: AppScanResult;
+    };
+    libs: {
+        [key: string]: LibScanResult;
+    };
+    pkgs: {
+        [key: string]: PkgScanResult;
+    };
+}
+
+declare class Executor {
+    #private;
+    logger: Logger;
+    cwdPath: string;
+    constructor(name: string, cwdPath: string);
+    exec(command: string, options?: ExecOptions): Promise<unknown>;
+    spawn(command: string, args?: string[], options?: SpawnOptions): Promise<{
+        code: number | null;
+        signal: string | null;
+    }>;
+    fork(modulePath: string, args?: string[], options?: ForkOptions): Promise<unknown>;
+    mkdir(dirPath: string): this;
+    writeFile(filePath: string, content: string | object): this;
+    writeJson(filePath: string, content: object): this;
+    readFile(filePath: string): string;
+    readJson(filePath: string): object;
+    cp(srcPath: string, destPath: string): Promise<void>;
+    log(msg: string): this;
+    verbose(msg: string): this;
+    getTsConfig(pathname: string): TsConfigJson;
+    applyTemplate({ basePath, template, scanResult, dict, }: {
+        basePath: string;
+        template: string;
+        scanResult?: AppScanResult | LibScanResult | null;
+        dict?: {
+            [key: string]: string;
+        };
+    }): Promise<void>;
+}
+interface ExecutorOptions {
+    workspaceRoot: string;
+    repoName: string;
+}
+declare class WorkspaceExecutor extends Executor {
+    #private;
+    workspaceRoot: string;
+    repoName: string;
+    constructor({ workspaceRoot, repoName }: ExecutorOptions);
+    static fromRoot(): WorkspaceExecutor;
+    scan(): Promise<WorkspaceScanResult>;
+    getApps(): Promise<string[]>;
+    getLibs(): Promise<string[]>;
+    getSyss(): Promise<[string[], string[]]>;
+    getPkgs(): Promise<string[]>;
+}
+interface SysExecutorOptions {
+    workspace?: WorkspaceExecutor;
+    name: string;
+    type: "app" | "lib";
+}
+declare class SysExecutor extends Executor {
+    workspace: WorkspaceExecutor;
+    name: string;
+    type: "app" | "lib";
+    constructor({ workspace, name, type }: SysExecutorOptions);
+    getConfig(command?: string): Promise<LibConfigResult>;
+    scan({ tsconfig, akanConfig, }: {
+        tsconfig?: TsConfigJson;
+        akanConfig: AppConfigResult | LibConfigResult;
+    }, libScanResults?: {
+        [key: string]: LibScanResult;
+    }): Promise<AppScanResult | LibScanResult>;
+    getDatabaseModules(): Promise<string[]>;
+    getServiceModules(): Promise<string[]>;
+    getScalarModules(): Promise<string[]>;
+}
+interface AppExecutorOptions {
+    workspace?: WorkspaceExecutor;
+    name: string;
+}
+declare class AppExecutor extends SysExecutor {
+    constructor({ workspace, name }: AppExecutorOptions);
+    static from(executor: SysExecutor | WorkspaceExecutor, name: string): AppExecutor;
+    getConfig(command?: string): Promise<AppConfigResult>;
+    syncAssets(libDeps: string[]): Promise<void>;
+}
+interface DistAppExecutorOptions {
+    workspace: WorkspaceExecutor;
+    name: string;
+}
+declare class DistAppExecutor extends Executor {
+    name: string;
+    constructor({ workspace, name }: DistAppExecutorOptions);
+    static from(executor: SysExecutor | WorkspaceExecutor, name: string): DistAppExecutor;
+}
+interface LibExecutorOptions {
+    workspace?: WorkspaceExecutor;
+    name: string;
+}
+declare class LibExecutor extends SysExecutor {
+    workspaceRoot: string;
+    repoName: string;
+    constructor({ workspace, name }: LibExecutorOptions);
+    static from(executor: SysExecutor | WorkspaceExecutor, name: string): LibExecutor;
+    getConfig(command?: string): Promise<LibConfigResult>;
+}
+interface DistLibExecutorOptions {
+    workspace: WorkspaceExecutor;
+    name: string;
+}
+declare class DistLibExecutor extends Executor {
+    name: string;
+    constructor({ workspace, name }: DistLibExecutorOptions);
+    static from(executor: SysExecutor | WorkspaceExecutor, name: string): DistAppExecutor | DistLibExecutor;
+}
+interface PkgExecutorOptions {
+    workspace?: WorkspaceExecutor;
+    name: string;
+}
+declare class PkgExecutor extends Executor {
+    workspace: WorkspaceExecutor;
+    name: string;
+    constructor({ workspace, name }: PkgExecutorOptions);
+    static from(executor: SysExecutor | WorkspaceExecutor, name: string): PkgExecutor;
+    scan({ packageJson, tsconfig, }?: {
+        packageJson?: PackageJson;
+        tsconfig?: TsConfigJson;
+    }): Promise<PkgScanResult>;
+}
+interface DistPkgExecutorOptions {
+    workspaceRoot: string;
+    repoName: string;
+    name: string;
+}
+declare class DistPkgExecutor extends Executor {
+    workspaceRoot: string;
+    repoName: string;
+    name: string;
+    constructor({ workspaceRoot, repoName, name }: DistPkgExecutorOptions);
+    static from(workspaceExecutor: WorkspaceExecutor, name: string): DistPkgExecutor;
+}
+
+export { AppExecutor, DistAppExecutor, DistLibExecutor, DistPkgExecutor, Executor, LibExecutor, PkgExecutor, SysExecutor, WorkspaceExecutor };