@mokup/cli 1.1.0 → 1.1.2

package/dist/index.mjs

@@ -1,13 +1,18 @@
 import { promises } from 'node:fs';
 import process, { cwd } from 'node:process';
-import { join, normalize, dirname, resolve, isAbsolute, basename, extname, relative } from '@mokup/shared/pathe';
+import { join, relative, extname, dirname, resolve } from '@mokup/shared/pathe';
+import { resolveDirectoryConfig as resolveDirectoryConfig$1, isPromise } from '@mokup/shared/config-utils';
+import { loadModule } from '@mokup/shared/module-loader';
+import { configExtensions } from '@mokup/shared/route-constants';
+import { collectFiles, isSupportedFile } from '@mokup/shared/mock-files';
+import { resolveDirs as resolveDirs$1, normalizeIgnorePrefix } from '@mokup/shared/scan-utils';
+import { toPosix, hasIgnoredPrefix, matchesFilter } from '@mokup/shared/path-utils';
 import { Buffer } from 'node:buffer';
-import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
 import { build } from '@mokup/shared/esbuild';
-import { toPosix, hasIgnoredPrefix, matchesFilter } from '@mokup/shared/path-utils';
-import { parseRouteTemplate, compareRouteScore } from '@mokup/runtime';
-import { parse } from '@mokup/shared/jsonc-parser';
+import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
+import { createRouteUtils } from '@mokup/shared/route-utils';
+import { loadRules as loadRules$1 } from '@mokup/shared/load-rules';
+import { createDefineConfig } from '@mokup/shared/define-config';
 import { createFetchServer, serve } from '@mokup/server/node';
 import { createLogger } from '@mokup/shared/logger';
 import { Command } from 'commander';
@@ -68,263 +73,48 @@ async function writeManifestModule(outDir, manifest) {
   await promises.writeFile(join(outDir, "mokup.manifest.d.mts"), dts.join("\n"), "utf8");
 }
 
-const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
-const middlewareSymbol$1 = Symbol.for("mokup.config.middlewares");
-async function loadModule$1(file) {
-  const ext = configExtensions.find((extension) => file.endsWith(extension));
-  if (ext === ".cjs") {
-    const require = createRequire(import.meta.url);
-    delete require.cache[file];
-    return require(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      sourcemap: "inline",
-      target: "es2020",
-      write: false
-    });
-    const output = result.outputFiles[0];
-    const code = output?.text ?? "";
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
-  }
-  return null;
-}
-function getConfigFileCandidates(dir) {
-  return configExtensions.map((extension) => join(dir, `index.config${extension}`));
-}
-async function findConfigFile(dir, cache) {
-  const cached = cache.get(dir);
-  if (cached !== void 0) {
-    return cached;
-  }
-  for (const candidate of getConfigFileCandidates(dir)) {
-    try {
-      await promises.stat(candidate);
-      cache.set(dir, candidate);
-      return candidate;
-    } catch {
-      continue;
-    }
-  }
-  cache.set(dir, null);
-  return null;
-}
 async function loadConfig(file) {
-  const mod = await loadModule$1(file);
+  const mod = await loadModule(file);
   if (!mod) {
     return null;
   }
   const raw = mod?.default ?? mod;
-  const value = isPromise$1(raw) ? await raw : raw;
+  const value = isPromise(raw) ? await raw : raw;
   if (!value || typeof value !== "object") {
     return null;
   }
   return value;
 }
-function isPromise$1(value) {
-  return !!value && typeof value.then === "function";
-}
-function normalizeMiddlewares(value, source, log, position) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  const middlewares = [];
-  list.forEach((entry, index) => {
-    if (typeof entry !== "function") {
-      log?.(`Invalid middleware in ${source}`);
-      return;
-    }
-    middlewares.push({ file: source, index, position });
-  });
-  return middlewares;
-}
-function readMiddlewareMeta(config) {
-  const value = config[middlewareSymbol$1];
-  if (!value || typeof value !== "object") {
-    return null;
-  }
-  const meta = value;
-  return {
-    pre: Array.isArray(meta.pre) ? meta.pre : [],
-    normal: Array.isArray(meta.normal) ? meta.normal : [],
-    post: Array.isArray(meta.post) ? meta.post : []
-  };
-}
 async function resolveDirectoryConfig(params) {
   const { file, rootDir, log, configCache, fileCache } = params;
-  const resolvedRoot = normalize(rootDir);
-  const resolvedFileDir = normalize(dirname(file));
-  const chain = [];
-  let current = resolvedFileDir;
-  while (true) {
-    chain.push(current);
-    if (current === resolvedRoot) {
-      break;
-    }
-    const parent = dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  chain.reverse();
-  const merged = {};
-  const preMiddlewares = [];
-  const normalMiddlewares = [];
-  const postMiddlewares = [];
-  for (const dir of chain) {
-    const configPath = await findConfigFile(dir, fileCache);
-    if (!configPath) {
-      continue;
-    }
-    let config = configCache.get(configPath);
-    if (config === void 0) {
-      config = await loadConfig(configPath);
-      configCache.set(configPath, config);
-    }
-    if (!config) {
-      log?.(`Invalid config in ${configPath}`);
-      continue;
-    }
-    if (config.headers) {
-      merged.headers = { ...merged.headers ?? {}, ...config.headers };
-    }
-    if (typeof config.status === "number") {
-      merged.status = config.status;
-    }
-    if (typeof config.delay === "number") {
-      merged.delay = config.delay;
-    }
-    if (typeof config.enabled === "boolean") {
-      merged.enabled = config.enabled;
-    }
-    if (typeof config.ignorePrefix !== "undefined") {
-      merged.ignorePrefix = config.ignorePrefix;
-    }
-    if (typeof config.include !== "undefined") {
-      merged.include = config.include;
-    }
-    if (typeof config.exclude !== "undefined") {
-      merged.exclude = config.exclude;
-    }
-    const meta = readMiddlewareMeta(config);
-    const normalizedPre = normalizeMiddlewares(
-      meta?.pre,
-      configPath,
-      log,
-      "pre"
-    );
-    const normalizedNormal = normalizeMiddlewares(
-      meta?.normal,
-      configPath,
-      log,
-      "normal"
-    );
-    const normalizedLegacy = normalizeMiddlewares(
-      config.middleware,
-      configPath,
-      log,
-      "normal"
-    );
-    const normalizedPost = normalizeMiddlewares(
-      meta?.post,
-      configPath,
-      log,
-      "post"
-    );
-    if (normalizedPre.length > 0) {
-      preMiddlewares.push(...normalizedPre);
-    }
-    if (normalizedNormal.length > 0) {
-      normalMiddlewares.push(...normalizedNormal);
-    }
-    if (normalizedLegacy.length > 0) {
-      normalMiddlewares.push(...normalizedLegacy);
-    }
-    if (normalizedPost.length > 0) {
-      postMiddlewares.push(...normalizedPost);
-    }
-  }
+  const resolved = await resolveDirectoryConfig$1({
+    file,
+    rootDir,
+    configExtensions,
+    configCache,
+    fileCache,
+    loadConfig,
+    warn: log,
+    mapMiddleware: (_handler, index, position, source) => ({
+      file: source,
+      index,
+      position
+    })
+  });
   return {
-    ...merged,
-    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares]
+    headers: resolved.headers,
+    status: resolved.status,
+    delay: resolved.delay,
+    enabled: resolved.enabled,
+    ignorePrefix: resolved.ignorePrefix,
+    include: resolved.include,
+    exclude: resolved.exclude,
+    middlewares: resolved.middlewares
   };
 }
 
-const supportedExtensions = /* @__PURE__ */ new Set([
-  ".json",
-  ".jsonc",
-  ".ts",
-  ".js",
-  ".mjs",
-  ".cjs"
-]);
-async function exists(path) {
-  try {
-    await promises.stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function walkDir(dir, rootDir, files) {
-  const entries = await promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === ".git") {
-      continue;
-    }
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      await walkDir(fullPath, rootDir, files);
-      continue;
-    }
-    if (entry.isFile()) {
-      files.push({ file: fullPath, rootDir });
-    }
-  }
-}
-async function collectFiles(dirs) {
-  const files = [];
-  for (const dir of dirs) {
-    if (!await exists(dir)) {
-      continue;
-    }
-    await walkDir(dir, dir, files);
-  }
-  return files;
-}
 function resolveDirs(dir, root) {
-  const raw = dir;
-  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
-  const normalized = resolved.map(
-    (entry) => isAbsolute(entry) ? entry : resolve(root, entry)
-  );
-  return Array.from(new Set(normalized));
-}
-function normalizeIgnorePrefix(value, fallback = ["."]) {
-  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
-  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
-}
-function isSupportedFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  if (basename(file).startsWith("index.config.")) {
-    return false;
-  }
-  const ext = extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+  return resolveDirs$1(dir, root);
 }
 
 function getHandlerModulePath(file, handlersDir, root) {
@@ -426,119 +216,28 @@ async function bundleHandlers(files, root, handlersDir) {
   });
 }
 
-const methodSet = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS",
-  "HEAD"
-]);
-const methodSuffixSet = new Set(
-  Array.from(methodSet, (method) => method.toLowerCase())
-);
-const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
-function normalizePrefix(prefix) {
-  if (!prefix) {
-    return "";
-  }
-  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function resolveTemplate(template, prefix) {
-  const normalized = template.startsWith("/") ? template : `/${template}`;
-  if (!prefix) {
-    return normalized;
-  }
-  const normalizedPrefix = normalizePrefix(prefix);
-  if (!normalizedPrefix) {
-    return normalized;
-  }
-  if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
-    return normalized;
-  }
-  if (normalized === "/") {
-    return `${normalizedPrefix}/`;
-  }
-  return `${normalizedPrefix}${normalized}`;
-}
-function stripMethodSuffix(base) {
-  const segments = base.split(".");
-  const last = segments.at(-1);
-  if (last && methodSuffixSet.has(last.toLowerCase())) {
-    segments.pop();
-    return {
-      name: segments.join("."),
-      method: last.toUpperCase()
-    };
-  }
-  return {
-    name: base,
-    method: void 0
-  };
-}
+const routeUtils = createRouteUtils({
+  parseRouteTemplate,
+  compareRouteScore
+});
 function deriveRouteFromFile(file, rootDir, log) {
-  const rel = toPosix(relative(rootDir, file));
-  const ext = extname(rel);
-  const withoutExt = rel.slice(0, rel.length - ext.length);
-  const dir = dirname(withoutExt);
-  const base = basename(withoutExt);
-  const { name, method } = stripMethodSuffix(base);
-  const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
-  if (!resolvedMethod) {
-    log?.(`Skip mock without method suffix: ${file}`);
-    return null;
-  }
-  if (!name) {
-    log?.(`Skip mock with empty route name: ${file}`);
-    return null;
-  }
-  const joined = dir === "." ? name : join(dir, name);
-  const segments = toPosix(joined).split("/");
-  if (segments.at(-1) === "index") {
-    segments.pop();
-  }
-  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      log?.(`${error} in ${file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    log?.(`${warning} in ${file}`);
-  }
-  return {
-    template: parsed.template,
-    method: resolvedMethod,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
+  return routeUtils.deriveRouteFromFile(file, rootDir, log);
 }
 function resolveRule(params) {
-  const method = params.derivedMethod;
-  if (!method) {
-    return null;
-  }
-  const template = resolveTemplate(params.derivedTemplate, params.prefix);
-  const parsed = parseRouteTemplate(template);
-  if (parsed.errors.length > 0) {
-    for (const error of parsed.errors) {
-      params.log?.(`${error} in ${params.file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    params.log?.(`${warning} in ${params.file}`);
-  }
-  return {
-    method,
-    template: parsed.template,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
+  return routeUtils.resolveRule({
+    rule: params.rule,
+    derivedTemplate: params.derivedTemplate,
+    derivedMethod: params.derivedMethod,
+    prefix: params.prefix,
+    file: params.file,
+    warn: params.log,
+    build: (base) => ({
+      method: base.method,
+      template: base.template,
+      tokens: base.tokens,
+      score: base.score
+    })
+  });
 }
 function sortRoutes(routes) {
   return routes.sort((a, b) => {
@@ -549,80 +248,8 @@ function sortRoutes(routes) {
   });
 }
 
-async function readJsonFile(file) {
-  try {
-    const content = await promises.readFile(file, "utf8");
-    const errors = [];
-    const data = parse(content, errors, {
-      allowTrailingComma: true,
-      disallowComments: false
-    });
-    if (errors.length > 0) {
-      return void 0;
-    }
-    return data;
-  } catch {
-    return void 0;
-  }
-}
-async function loadModule(file) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".cjs") {
-    const require = createRequire(import.meta.url);
-    delete require.cache[file];
-    return require(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await build({
-      entryPoints: [file],
-      bundle: true,
-      format: "esm",
-      platform: "node",
-      sourcemap: "inline",
-      target: "es2020",
-      write: false
-    });
-    const output = result.outputFiles[0];
-    const code = output?.text ?? "";
-    const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
-  }
-  return null;
-}
 async function loadRules(file) {
-  const ext = extname(file).toLowerCase();
-  if (ext === ".json" || ext === ".jsonc") {
-    const json = await readJsonFile(file);
-    if (typeof json === "undefined") {
-      return [];
-    }
-    return [
-      {
-        handler: json
-      }
-    ];
-  }
-  const mod = await loadModule(file);
-  const value = mod?.default ?? mod;
-  if (!value) {
-    return [];
-  }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "function") {
-    return [
-      {
-        handler: value
-      }
-    ];
-  }
-  return [value];
+  return loadRules$1(file, { loadModule });
 }
 
 async function buildManifest(options = {}) {
@@ -786,165 +413,12 @@ async function buildManifest(options = {}) {
   };
 }
 
-const middlewareSymbol = Symbol.for("mokup.config.middlewares");
-const contextStack = [];
-function getActiveContext() {
-  const context = contextStack[contextStack.length - 1];
-  if (!context) {
-    throw new Error("onBeforeAll/onAfterAll must be called inside defineConfig()");
-  }
-  return context;
-}
-function runWithContext(context, fn) {
-  contextStack.push(context);
-  try {
-    const result = fn();
-    if (isPromise(result)) {
-      return result.finally(() => {
-        contextStack.pop();
-      });
-    }
-    contextStack.pop();
-    return result;
-  } catch (error) {
-    contextStack.pop();
-    throw error;
-  }
-}
-function isPromise(value) {
-  return !!value && typeof value.then === "function";
-}
-function normalizeHookError(policy) {
-  if (policy === "throw" || policy === "silent") {
-    return policy;
-  }
-  return "warn";
-}
-function reportHookError(error, policy) {
-  if (policy === "silent") {
-    return;
-  }
-  if (policy === "warn") {
-    console.warn("[@mokup/cli] defineConfig hook failed:", error);
-  }
-}
-function runHookSequence(stage, hooks, policy, setStage) {
-  if (hooks.length === 0) {
-    return;
-  }
-  setStage(stage);
-  let chain = null;
-  const runHook = (hook) => {
-    try {
-      const result = hook();
-      if (isPromise(result)) {
-        return result.catch((error) => {
-          if (policy === "throw") {
-            throw error;
-          }
-          reportHookError(error, policy);
-        });
-      }
-      return void 0;
-    } catch (error) {
-      if (policy === "throw") {
-        throw error;
-      }
-      reportHookError(error, policy);
-      return void 0;
-    }
-  };
-  for (const hook of hooks) {
-    if (chain) {
-      chain = chain.then(() => runHook(hook));
-      continue;
-    }
-    const result = runHook(hook);
-    if (isPromise(result)) {
-      chain = result;
-    }
-  }
-  if (!chain) {
-    setStage("normal");
-    return;
-  }
-  return chain.finally(() => {
-    setStage("normal");
-  });
-}
-function attachMetadata(config, meta) {
-  Object.defineProperty(config, middlewareSymbol, {
-    value: meta,
-    enumerable: false
-  });
-  return config;
-}
-function normalizeConfig(value) {
-  return value && typeof value === "object" ? value : {};
-}
-function onBeforeAll(handler) {
-  if (typeof handler !== "function") {
-    throw new TypeError("onBeforeAll expects a function");
-  }
-  const context = getActiveContext();
-  context.hooks.pre.push(handler);
-}
-function onAfterAll(handler) {
-  if (typeof handler !== "function") {
-    throw new TypeError("onAfterAll expects a function");
-  }
-  const context = getActiveContext();
-  context.hooks.post.push(handler);
-}
-function defineConfig(input) {
-  if (typeof input === "function") {
-    const pre = [];
-    const normal = [];
-    const post = [];
-    let stage = "normal";
-    const app = {
-      use: (...handlers) => {
-        if (stage === "pre") {
-          pre.push(...handlers);
-          return;
-        }
-        if (stage === "post") {
-          post.push(...handlers);
-          return;
-        }
-        normal.push(...handlers);
-      }
-    };
-    const context = {
-      app,
-      hooks: { pre: [], post: [] },
-      setStage: (next) => {
-        stage = next;
-      }
-    };
-    const result = runWithContext(context, () => input({ app }));
-    const finalize = (value) => {
-      const config2 = normalizeConfig(value);
-      const policy = normalizeHookError(config2.hookError);
-      const preResult = runHookSequence("pre", context.hooks.pre, policy, context.setStage);
-      const runPost = () => runHookSequence("post", context.hooks.post, policy, context.setStage);
-      if (isPromise(preResult)) {
-        return preResult.then(runPost).then(() => attachMetadata(config2, { pre, normal, post }));
-      }
-      const postResult = runPost();
-      if (isPromise(postResult)) {
-        return postResult.then(() => attachMetadata(config2, { pre, normal, post }));
-      }
-      return attachMetadata(config2, { pre, normal, post });
-    };
-    if (isPromise(result)) {
-      return result.then(finalize);
-    }
-    return finalize(result);
-  }
-  const config = normalizeConfig(input);
-  return attachMetadata(config, { pre: [], normal: [], post: [] });
-}
+const shared = createDefineConfig({
+  logPrefix: "[@mokup/cli]"
+});
+const defineConfig = shared.defineConfig;
+const onBeforeAll = shared.onBeforeAll;
+const onAfterAll = shared.onAfterAll;
 
 const logger = createLogger();
 function collectValues(value, previous) {