@mokup/cli 1.0.11 → 1.1.1

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,259 +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 value = mod?.default ?? mod;
+  const raw = mod?.default ?? mod;
+  const value = isPromise(raw) ? await raw : raw;
   if (!value || typeof value !== "object") {
     return null;
   }
   return value;
 }
-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) {
@@ -422,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) => {
@@ -545,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 = {}) {
@@ -782,38 +413,12 @@ async function buildManifest(options = {}) {
   };
 }
 
-const middlewareSymbol = Symbol.for("mokup.config.middlewares");
-function createRegistry(list) {
-  return {
-    use: (...handlers) => {
-      list.push(...handlers);
-    }
-  };
-}
-function attachMetadata(config, meta) {
-  Object.defineProperty(config, middlewareSymbol, {
-    value: meta,
-    enumerable: false
-  });
-  return config;
-}
-function defineConfig(input) {
-  if (typeof input === "function") {
-    const pre = [];
-    const normal = [];
-    const post = [];
-    const context = {
-      pre: createRegistry(pre),
-      normal: createRegistry(normal),
-      post: createRegistry(post)
-    };
-    const result = input(context);
-    const config2 = result && typeof result === "object" ? result : {};
-    return attachMetadata(config2, { pre, normal, post });
-  }
-  const config = input && typeof input === "object" ? 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) {
@@ -955,4 +560,4 @@ async function runCli(argv = process.argv) {
   await program.parseAsync(argv);
 }
 
-export { buildManifest, createCli, defineConfig, runCli };
+export { buildManifest, createCli, defineConfig, onAfterAll, onBeforeAll, runCli };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mokup/cli",
   "type": "module",
-  "version": "1.0.11",
+  "version": "1.1.1",
   "description": "CLI for building mokup manifests and handlers.",
   "license": "MIT",
   "homepage": "https://mokup.icebreaker.top",
@@ -28,19 +28,15 @@
   ],
   "dependencies": {
     "commander": "^14.0.0",
-    "@mokup/runtime": "1.0.6",
-    "@mokup/server": "1.1.8",
-    "@mokup/shared": "1.1.1"
-  },
-  "devDependencies": {
-    "@types/node": "^25.0.10",
-    "typescript": "^5.9.3",
-    "unbuild": "^3.6.1"
+    "@mokup/runtime": "1.0.7",
+    "@mokup/server": "1.2.1",
+    "@mokup/shared": "1.1.2"
   },
   "scripts": {
     "build": "unbuild",
     "dev": "unbuild --stub",
     "lint": "eslint .",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test:types": "tsd"
   }
 }