@echojs-ecosystem/architect 0.1.0

package/dist/index.js

@@ -0,0 +1,711 @@
+#!/usr/bin/env node
+import * as fs2 from 'fs';
+import { parse, sep, join, extname, resolve, dirname, relative, basename } from 'path';
+import { minimatch } from 'minimatch';
+import ts from 'typescript';
+import { loadConfig, watchConfig as watchConfig$1 } from 'c12';
+import { from, map, switchMap, Observable, filter, debounceTime } from 'rxjs';
+import * as process from 'process';
+import { fromError } from 'zod-validation-error';
+import { z } from 'zod';
+import precinct from 'precinct';
+import { parse as parse$1 } from 'tsconfck';
+import chokidar from 'chokidar';
+import { isGitIgnored } from 'globby';
+import { produce } from 'immer';
+import isGlob from 'is-glob';
+
+var normalizeFileTemplate = (fileTemplate, fileTemplateUrl) => {
+  if (fileTemplateUrl) {
+    return () => fs2.readFileSync(fileTemplateUrl, "utf-8");
+  }
+  if (!fileTemplate) {
+    return void 0;
+  }
+  if (typeof fileTemplate === "string") {
+    return () => fileTemplate;
+  }
+  return fileTemplate;
+};
+var abstraction = (optionsOrName, optionalConfig) => {
+  if (typeof optionsOrName === "string") {
+    return {
+      name: optionsOrName,
+      children: optionalConfig?.children ?? {},
+      rules: optionalConfig?.rules ?? [],
+      fractal: optionalConfig?.fractal,
+      fileTemplate: normalizeFileTemplate(
+        optionalConfig?.fileTemplate,
+        optionalConfig?.fileTemplateUrl
+      )
+    };
+  }
+  return {
+    name: optionsOrName.name,
+    children: optionsOrName.children ?? {},
+    rules: optionsOrName.rules ?? [],
+    fractal: optionsOrName.fractal,
+    fileTemplate: normalizeFileTemplate(
+      optionsOrName.fileTemplate,
+      optionsOrName?.fileTemplateUrl
+    )
+  };
+};
+var getAbstractionInstanceLabel = (instance) => {
+  const { name } = parse(instance.path);
+  if (name === instance.abstraction.name) {
+    return name;
+  }
+  return `${name} (${instance.abstraction.name})`;
+};
+
+// src/shared/memoize.ts
+var memoize = (fn) => {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return function(arg) {
+    if (cache.has(arg)) {
+      return cache.get(arg);
+    }
+    const result = fn.call(this, arg);
+    cache.set(arg, result);
+    return result;
+  };
+};
+var resolveImport = (importedPath, importerPath, tsCompilerOptions, fileExists, directoryExists) => {
+  return ts.resolveModuleName(
+    importedPath,
+    importerPath,
+    normalizeCompilerOptions(tsCompilerOptions),
+    {
+      ...ts.sys,
+      fileExists,
+      directoryExists
+    }
+  ).resolvedModule?.resolvedFileName?.replaceAll("/", sep) ?? null;
+};
+var imperfectKeys = {
+  module: ts.ModuleKind,
+  moduleResolution: {
+    ...ts.ModuleResolutionKind,
+    node: ts.ModuleResolutionKind.Node10
+  },
+  moduleDetection: ts.ModuleDetectionKind,
+  newLine: ts.NewLineKind,
+  target: ts.ScriptTarget
+};
+var normalizeCompilerOptions = (compilerOptions) => {
+  return Object.fromEntries(
+    Object.entries(compilerOptions).map(([key, value]) => {
+      if (Object.keys(imperfectKeys).includes(key) && typeof value === "string") {
+        for (const [enumKey, enumValue] of Object.entries(
+          imperfectKeys[key]
+        )) {
+          if (enumKey.toLowerCase() === value.toLowerCase()) {
+            return [key, enumValue];
+          }
+        }
+      }
+      return [key, value];
+    })
+  );
+};
+
+// src/abstraction/instance/parse.ts
+var parseAbstractionInstance = memoize(
+  (abstraction2) => memoize((node) => {
+    if (node.type === "file") {
+      return {
+        abstraction: abstraction2,
+        path: node.path,
+        children: [],
+        childNodes: []
+      };
+    }
+    const children = {};
+    for (const [pattern, childAbstraction] of Object.entries(
+      abstraction2.children
+    )) {
+      const nodeAbstractionInstance = parseAbstractionInstance(childAbstraction);
+      const nodesStack = [node];
+      while (nodesStack.length) {
+        const currentNode = nodesStack.pop();
+        if (minimatch(relative(node.path, currentNode.path), pattern)) {
+          children[currentNode.path] = nodeAbstractionInstance(currentNode);
+          continue;
+        }
+        if (children[currentNode.path]) {
+          continue;
+        }
+        if (currentNode.type === "folder") {
+          nodesStack.push(...currentNode.children);
+        }
+      }
+    }
+    const childNodes = [];
+    const childrenNodesStack = [node];
+    while (childrenNodesStack.length) {
+      const currentNode = childrenNodesStack.pop();
+      if (children[currentNode.path]) {
+        continue;
+      }
+      if (currentNode.path !== node.path) {
+        childNodes.push(currentNode.path);
+      }
+      if (currentNode.type === "folder") {
+        childrenNodesStack.push(...currentNode.children);
+      }
+    }
+    return {
+      abstraction: abstraction2,
+      path: node.path,
+      childNodes: Object.values(childNodes),
+      children: Object.values(children)
+    };
+  })
+);
+
+// src/config/define-config.ts
+var defineConfig = (config) => config;
+var ConfigurationNotFoundError = class extends Error {
+  constructor() {
+    super(`Configuration not found in ${process.cwd()}`);
+  }
+};
+var ConfigurationInvalidError = class extends Error {
+  constructor(error, filepath) {
+    super(
+      fromError(error, {
+        prefix: `Invalid configuration in ${relative(process.cwd(), filepath)}`
+      }).toString()
+    );
+    this.error = error;
+  }
+  error;
+};
+var RuleSchema = z.object({
+  name: z.string(),
+  check: z.custom(),
+  severity: z.enum(["off", "warn", "error"]),
+  descriptionUrl: z.string().optional()
+});
+var AbstractionSchema = z.object({
+  name: z.string(),
+  children: z.record(z.lazy(() => AbstractionSchema)),
+  rules: z.array(RuleSchema),
+  fractal: z.string().optional(),
+  fileTemplate: z.custom()
+});
+var EvolutionConfigSchema = z.object({
+  root: AbstractionSchema,
+  baseUrl: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  ignores: z.array(z.string()).optional()
+});
+
+// src/config/load.ts
+var CONFIG_NAME = "architect";
+var parseConfigResult = (filepath, data) => {
+  const parseResult = EvolutionConfigSchema.safeParse(data);
+  if (!parseResult.success) {
+    throw new ConfigurationInvalidError(parseResult.error, filepath);
+  }
+  return {
+    config: parseResult.data,
+    configPath: filepath
+  };
+};
+var watchConfig = ({
+  cwd: cwd2,
+  onlyOne
+}) => {
+  const config$ = from(
+    loadConfig({
+      cwd: cwd2,
+      name: CONFIG_NAME
+    })
+  ).pipe(
+    map(({ configFile, config }) => {
+      if (!configFile) {
+        throw new ConfigurationNotFoundError();
+      }
+      return parseConfigResult(configFile, config);
+    })
+  );
+  if (onlyOne) {
+    return config$;
+  }
+  return config$.pipe(
+    switchMap(
+      ({ configPath, config }) => new Observable((subscriber) => {
+        subscriber.next({ configPath, config });
+        let unwatchCallback = () => {
+        };
+        watchConfig$1({
+          cwd: cwd2,
+          name: CONFIG_NAME,
+          onUpdate: (config2) => {
+            subscriber.next(
+              parseConfigResult(configPath, config2.newConfig.config)
+            );
+          }
+        }).then(({ unwatch }) => {
+          unwatchCallback = unwatch;
+        });
+        return () => unwatchCallback();
+      })
+    )
+  );
+};
+
+// src/vfs/get-flatten-files.ts
+var getFlattenFiles = memoize((node) => {
+  if (node.type === "file") {
+    return [node];
+  }
+  return node.children.reduce((acc, child) => {
+    if (child.type === "file") {
+      return [...acc, child];
+    }
+    return [...acc, ...getFlattenFiles(child)];
+  }, []);
+});
+
+// src/dependencies/parse.ts
+var { paperwork } = precinct;
+var parseDependenciesMap = async (vfs) => {
+  const dependenciesMap = {
+    dependencies: {},
+    dependencyFor: {}
+  };
+  const basePath = vfs.path;
+  const { tsconfig } = await parse$1(basePath);
+  const files = getFlattenFiles(vfs);
+  for (const file of files) {
+    const dependencies = paperwork(file.path, {
+      includeCore: false,
+      fileSystem: fs2
+    });
+    const resolvedDependencies = dependencies.map(
+      (dependency) => resolveImport(
+        dependency,
+        file.path,
+        tsconfig?.compilerOptions ?? {},
+        fs2.existsSync,
+        fs2.existsSync
+      )
+    ).filter((dependency) => dependency !== null);
+    dependenciesMap.dependencies[file.path] = new Set(resolvedDependencies);
+    for (const dependency of resolvedDependencies) {
+      if (!dependenciesMap.dependencyFor[dependency]) {
+        dependenciesMap.dependencyFor[dependency] = /* @__PURE__ */ new Set();
+      }
+      dependenciesMap.dependencyFor[dependency].add(file.path);
+    }
+  }
+  return dependenciesMap;
+};
+
+// src/rule/rule.ts
+var rule = (config) => {
+  const defaultCheck = () => ({ diagnostics: [] });
+  if (typeof config === "string") {
+    return {
+      name: config,
+      severity: "error",
+      descriptionUrl: void 0,
+      check: defaultCheck
+    };
+  }
+  return {
+    name: config.name,
+    severity: config.severity ?? "error",
+    descriptionUrl: config.descriptionUrl,
+    check: config.check ?? defaultCheck
+  };
+};
+
+// src/vfs/get-nodes-record.ts
+var getNodesRecord = memoize(
+  (node) => {
+    if (node.type === "file") {
+      return { [node.path]: node };
+    }
+    return node.children.reduce(
+      (acc, child) => {
+        if (child.type === "file") {
+          return { ...acc, [child.path]: child };
+        }
+        return { ...acc, [child.path]: child, ...getNodesRecord(child) };
+      },
+      {}
+    );
+  }
+);
+var addDirectory = (tree, newDirectoryPath) => {
+  const rootPath = tree.path;
+  return produce(tree, (draft) => {
+    const pathSegments = relative(rootPath, newDirectoryPath).split(sep);
+    let currentFolder = draft;
+    for (const pathSegment of pathSegments.slice(0, -1)) {
+      const existingChild = currentFolder.children.find(
+        (child) => child.type === "folder" && basename(child.path) === pathSegment
+      );
+      if (existingChild === void 0) {
+        currentFolder.children.push({
+          type: "folder",
+          path: join(currentFolder.path, pathSegment),
+          children: []
+        });
+        currentFolder = currentFolder.children[currentFolder.children.length - 1];
+      } else {
+        currentFolder = existingChild;
+      }
+    }
+    currentFolder.children.push({
+      type: "folder",
+      path: newDirectoryPath,
+      children: []
+    });
+  });
+};
+var addFile = (tree, newFilePath) => {
+  const rootPath = tree.path;
+  return produce(tree, (draft) => {
+    const pathSegments = relative(rootPath, newFilePath).split(sep);
+    let currentFolder = draft;
+    for (const pathSegment of pathSegments.slice(0, -1)) {
+      const existingChild = currentFolder.children.find(
+        (child) => child.type === "folder" && basename(child.path) === pathSegment
+      );
+      if (existingChild === void 0) {
+        currentFolder.children.push({
+          type: "folder",
+          path: join(currentFolder.path, pathSegment),
+          children: []
+        });
+        currentFolder = currentFolder.children[currentFolder.children.length - 1];
+      } else {
+        currentFolder = existingChild;
+      }
+    }
+    currentFolder.children.push({ type: "file", path: newFilePath });
+  });
+};
+
+// src/vfs/create-root.ts
+var createVfsRoot = (path) => ({
+  type: "folder",
+  path,
+  children: []
+});
+var removeNode = (tree, removedNodePath) => {
+  const rootPath = tree.path;
+  return produce(tree, (draft) => {
+    const pathSegments = relative(rootPath, removedNodePath).split(sep);
+    let currentFolder = draft;
+    for (const pathSegment of pathSegments.slice(0, -1)) {
+      const existingChild = currentFolder.children.find(
+        (child) => child.type === "folder" && basename(child.path) === pathSegment
+      );
+      if (existingChild === void 0) {
+        return tree;
+      } else {
+        currentFolder = existingChild;
+      }
+    }
+    const removedNodeIndex = currentFolder.children.findIndex(
+      (child) => child.path === removedNodePath
+    );
+    if (removedNodeIndex === -1) {
+      return tree;
+    }
+    currentFolder.children.splice(removedNodeIndex, 1);
+  });
+};
+
+// src/vfs/watch-fs.ts
+var watchFs = (path, { onlyReady } = {}) => {
+  const isIgnored$ = from(isGitIgnored({ cwd: path }));
+  let vfs$ = isIgnored$.pipe(
+    switchMap((isIgnored) => createWatcherObservable({ path, isIgnored }))
+  );
+  if (onlyReady) {
+    vfs$ = vfs$.pipe(filter((e) => e.type === "ready"));
+  }
+  return vfs$;
+};
+var createWatcherObservable = ({
+  path,
+  isIgnored
+}) => {
+  return new Observable((observer) => {
+    let vfs = createVfsRoot(path);
+    const watcher = chokidar.watch(path, {
+      ignored: (path2) => path2.split(sep).includes("node_modules") || isIgnored(path2),
+      ignoreInitial: false,
+      alwaysStat: true,
+      awaitWriteFinish: true,
+      disableGlobbing: true,
+      cwd: path
+    });
+    watcher.on("add", async (relativePath) => {
+      vfs = addFile(vfs, join(path, relativePath));
+      observer.next({ type: "add", vfs });
+    });
+    watcher.on("addDir", async (relativePath) => {
+      vfs = addDirectory(vfs, join(path, relativePath));
+      observer.next({ type: "addDir", vfs });
+    });
+    watcher.on("change", async () => {
+      observer.next({ type: "change", vfs });
+    });
+    watcher.on("unlink", async (relativePath) => {
+      vfs = removeNode(vfs, join(path, relativePath));
+      observer.next({ type: "unlink", vfs });
+    });
+    watcher.on("unlinkDir", async (relativePath) => {
+      vfs = removeNode(vfs, join(path, relativePath));
+      observer.next({ type: "unlinkDir", vfs });
+    });
+    watcher.on("ready", () => {
+      observer.next({ type: "ready", vfs });
+    });
+    return () => {
+      watcher.close();
+    };
+  });
+};
+var matchesAllowDownward = (dependencyPath, patterns) => {
+  const normalized = dependencyPath.replace(/\\/g, "/");
+  return patterns.some(
+    (pattern) => minimatch(normalized, pattern) || minimatch(normalized, `**/${pattern}`)
+  );
+};
+var off = (rule2) => {
+  if (Array.isArray(rule2)) {
+    return rule2.map((r) => ({ ...r, severity: "off" }));
+  }
+  return { ...rule2, severity: "off" };
+};
+var warn = (rule2) => {
+  if (Array.isArray(rule2)) {
+    return rule2.map((r) => ({ ...r, severity: "warn" }));
+  }
+  return { ...rule2, severity: "warn" };
+};
+var requiredChildren = (abstractions) => rule({
+  name: "default/required-children",
+  severity: "error",
+  check: ({ instance, root }) => {
+    const diagnostics = [];
+    const nodesRecord = getNodesRecord(root);
+    const reuqiredAbstractions = Object.entries(instance.abstraction.children).filter(([ext]) => !isGlob(ext)).filter(
+      ([, abstraction2]) => !abstractions || abstractions.includes(abstraction2.name)
+    );
+    for (const [ext, abstraction2] of reuqiredAbstractions) {
+      const path = join(instance.path, ext);
+      const instanceNode = nodesRecord[path];
+      if (instanceNode !== void 0) {
+        continue;
+      }
+      const message = `Required abstraction "${abstraction2.name}" in "${getAbstractionInstanceLabel(instance)}"`;
+      if (extname(path) === "") {
+        diagnostics.push({
+          message,
+          location: { path },
+          fixes: [
+            {
+              type: "create-folder",
+              path
+            }
+          ]
+        });
+      } else {
+        diagnostics.push({
+          message,
+          location: { path },
+          fixes: [
+            {
+              type: "create-file",
+              path,
+              content: abstraction2.fileTemplate?.(path) ?? ""
+            }
+          ]
+        });
+      }
+    }
+    return {
+      diagnostics
+    };
+  }
+});
+var noUnabstractionFiles = () => rule({
+  name: "default/no-unabstraction-files",
+  severity: "error",
+  check: ({ instance, root }) => {
+    const record = getNodesRecord(root);
+    const files = instance.childNodes.filter(
+      (node) => record[node]?.type === "file"
+    );
+    if (files.length > 0) {
+      return {
+        diagnostics: files.map((node) => ({
+          message: ` 'Unabstraction files are not allowed in ${instance.abstraction.name}'`,
+          location: { path: node }
+        }))
+      };
+    }
+    return {
+      diagnostics: []
+    };
+  }
+});
+var publicAbstraction = (name) => ({
+  name: "default/public-abstraction",
+  severity: "error",
+  check: ({ instance, dependenciesMap, root }) => {
+    const diagnostics = [];
+    const nodesRecord = getNodesRecord(root);
+    const childFilesEntires = instance.children.flatMap((childInstance) => {
+      const instanceNode = nodesRecord[childInstance.path];
+      const files = getFlattenFiles(instanceNode);
+      return files.map((file) => [file.path, childInstance]);
+    });
+    const childFilesIndex = Object.fromEntries(childFilesEntires);
+    for (const [path, childInstance] of childFilesEntires) {
+      const importers = dependenciesMap.dependencyFor[path];
+      if (!importers) {
+        continue;
+      }
+      if (childInstance.abstraction.name === name) {
+        continue;
+      }
+      for (const importer of importers) {
+        const dependencyInstance = childFilesIndex[importer];
+        if (dependencyInstance === void 0) {
+          diagnostics.push({
+            message: `Imports of "${getAbstractionInstanceLabel(instance)}" bypassing the public api are forbidden`,
+            location: { path }
+          });
+        }
+      }
+    }
+    return { diagnostics };
+  }
+});
+var restrictCrossImports = () => rule({
+  name: "default/restrict-cross-imports",
+  severity: "error",
+  check: async ({ root, instance, dependenciesMap }) => {
+    const diagnostics = [];
+    const nodesRecord = getNodesRecord(root);
+    const childFilesEntires = instance.children.flatMap((childInstance) => {
+      const instanceNode = nodesRecord[childInstance.path];
+      const files = getFlattenFiles(instanceNode);
+      return files.map((file) => [file.path, childInstance]);
+    });
+    const childFilesIndex = Object.fromEntries(childFilesEntires);
+    for (const [path, instance2] of childFilesEntires) {
+      const dependencies = dependenciesMap.dependencies[path];
+      for (const dependency of dependencies) {
+        const dependencyInstance = childFilesIndex[dependency];
+        if (dependencyInstance === void 0) {
+          continue;
+        }
+        if (dependencyInstance.path !== instance2.path) {
+          diagnostics.push({
+            message: `Forbidden dependency "${getAbstractionInstanceLabel(instance2)}" <= "${getAbstractionInstanceLabel(dependencyInstance)}".
+cross imports are not allowed!`,
+            location: { path }
+          });
+        }
+      }
+    }
+    return { diagnostics };
+  }
+});
+var dependenciesDirection = (order, options) => rule({
+  name: `default/dependencies-direction`,
+  severity: "error",
+  check: async ({ root, instance, dependenciesMap }) => {
+    const diagnostics = [];
+    const nodesRecord = getNodesRecord(root);
+    const allowDownward = options?.allowDownward ?? [];
+    const childFilesEntires = instance.children.flatMap((childInstance) => {
+      const instanceNode = nodesRecord[childInstance.path];
+      const files = getFlattenFiles(instanceNode);
+      return files.map((file) => [file.path, childInstance]);
+    });
+    const childFilesIndex = Object.fromEntries(childFilesEntires);
+    for (const [path, instance2] of childFilesEntires) {
+      const dependencies = dependenciesMap.dependencies[path];
+      const instanceNameIndex = order.indexOf(instance2.abstraction.name);
+      for (const dependency of dependencies) {
+        if (allowDownward.length > 0 && matchesAllowDownward(dependency, allowDownward)) {
+          continue;
+        }
+        const dependencyInstance = childFilesIndex[dependency];
+        if (dependencyInstance === void 0) {
+          continue;
+        }
+        const dependencyInstanceNameIndex = order.indexOf(
+          dependencyInstance.abstraction.name
+        );
+        if (dependencyInstanceNameIndex < instanceNameIndex) {
+          diagnostics.push({
+            message: `Forbidden dependency "${instance2.abstraction.name}" <= "${dependencyInstance.abstraction.name}".
+allowed dependencies order: ${order.join(" <= ")}`,
+            location: { path }
+          });
+        }
+      }
+    }
+    return { diagnostics };
+  }
+});
+
+// src/linter/run-rules.ts
+var runRules = async ({
+  root,
+  instance,
+  dependenciesMap
+}) => {
+  const ruleDiagnostics = (currentInstance) => async (rule2) => {
+    if (rule2.severity === "off") {
+      return [];
+    }
+    const { diagnostics } = await rule2.check({
+      root,
+      instance: currentInstance,
+      dependenciesMap
+    });
+    return diagnostics.map((d) => ({ ...d, rule: rule2 }));
+  };
+  const runAbstractionRules = (currentInstance) => {
+    return currentInstance.abstraction.rules.map(ruleDiagnostics(currentInstance)).concat(...currentInstance.children.flatMap(runAbstractionRules));
+  };
+  return await Promise.all(runAbstractionRules(instance)).then((r) => r.flat());
+};
+
+// src/linter/lint.ts
+var lint = ({
+  watch,
+  config,
+  configPath
+}) => {
+  const rootPath = resolve(dirname(configPath), config.baseUrl ?? "./");
+  const parseNode = parseAbstractionInstance(config.root);
+  return watchFs(rootPath, { onlyReady: !watch }).pipe(
+    debounceTime(500),
+    switchMap(async ({ vfs }) => ({
+      root: vfs,
+      instance: parseNode(vfs),
+      dependenciesMap: await parseDependenciesMap(vfs)
+    })),
+    switchMap(runRules)
+  );
+};
+
+export { abstraction, defineConfig, dependenciesDirection, getAbstractionInstanceLabel, getFlattenFiles, getNodesRecord, lint, noUnabstractionFiles, off, parseAbstractionInstance, parseDependenciesMap, publicAbstraction, requiredChildren, restrictCrossImports, rule, warn, watchConfig, watchFs };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map