@mokup/cli 1.0.11 → 1.1.1

package/dist/index.cjs

@@ -3,18 +3,22 @@
 const node_fs = require('node:fs');
 const process = require('node:process');
 const pathe = require('@mokup/shared/pathe');
+const configUtils = require('@mokup/shared/config-utils');
+const moduleLoader = require('@mokup/shared/module-loader');
+const routeConstants = require('@mokup/shared/route-constants');
+const mockFiles = require('@mokup/shared/mock-files');
+const scanUtils = require('@mokup/shared/scan-utils');
+const pathUtils = require('@mokup/shared/path-utils');
 const node_buffer = require('node:buffer');
-const node_module = require('node:module');
-const node_url = require('node:url');
 const esbuild = require('@mokup/shared/esbuild');
-const pathUtils = require('@mokup/shared/path-utils');
 const runtime = require('@mokup/runtime');
-const jsoncParser = require('@mokup/shared/jsonc-parser');
+const routeUtils$1 = require('@mokup/shared/route-utils');
+const loadRules$1 = require('@mokup/shared/load-rules');
+const defineConfig$1 = require('@mokup/shared/define-config');
 const node = require('@mokup/server/node');
 const logger$1 = require('@mokup/shared/logger');
 const commander = require('commander');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const process__default = /*#__PURE__*/_interopDefaultCompat(process);
@@ -75,259 +79,48 @@ async function writeManifestModule(outDir, manifest) {
   await node_fs.promises.writeFile(pathe.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$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-    delete require$1.cache[file];
-    return require$1(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await esbuild.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,${node_buffer.Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
-  }
-  return null;
-}
-function getConfigFileCandidates(dir) {
-  return configExtensions.map((extension) => pathe.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 node_fs.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 moduleLoader.loadModule(file);
   if (!mod) {
     return null;
   }
-  const value = mod?.default ?? mod;
+  const raw = mod?.default ?? mod;
+  const value = configUtils.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 = pathe.normalize(rootDir);
-  const resolvedFileDir = pathe.normalize(pathe.dirname(file));
-  const chain = [];
-  let current = resolvedFileDir;
-  while (true) {
-    chain.push(current);
-    if (current === resolvedRoot) {
-      break;
-    }
-    const parent = pathe.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 configUtils.resolveDirectoryConfig({
+    file,
+    rootDir,
+    configExtensions: routeConstants.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 node_fs.promises.stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function walkDir(dir, rootDir, files) {
-  const entries = await node_fs.promises.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === "node_modules" || entry.name === ".git") {
-      continue;
-    }
-    const fullPath = pathe.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) => pathe.isAbsolute(entry) ? entry : pathe.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 (pathe.basename(file).startsWith("index.config.")) {
-    return false;
-  }
-  const ext = pathe.extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+  return scanUtils.resolveDirs(dir, root);
 }
 
 function getHandlerModulePath(file, handlersDir, root) {
@@ -429,119 +222,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 = routeUtils$1.createRouteUtils({
+  parseRouteTemplate: runtime.parseRouteTemplate,
+  compareRouteScore: runtime.compareRouteScore
+});
 function deriveRouteFromFile(file, rootDir, log) {
-  const rel = pathUtils.toPosix(pathe.relative(rootDir, file));
-  const ext = pathe.extname(rel);
-  const withoutExt = rel.slice(0, rel.length - ext.length);
-  const dir = pathe.dirname(withoutExt);
-  const base = pathe.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 : pathe.join(dir, name);
-  const segments = pathUtils.toPosix(joined).split("/");
-  if (segments.at(-1) === "index") {
-    segments.pop();
-  }
-  const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
-  const parsed = runtime.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 = runtime.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) => {
@@ -552,80 +254,8 @@ function sortRoutes(routes) {
   });
 }
 
-async function readJsonFile(file) {
-  try {
-    const content = await node_fs.promises.readFile(file, "utf8");
-    const errors = [];
-    const data = jsoncParser.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 = pathe.extname(file).toLowerCase();
-  if (ext === ".cjs") {
-    const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-    delete require$1.cache[file];
-    return require$1(file);
-  }
-  if (ext === ".js" || ext === ".mjs") {
-    return import(`${node_url.pathToFileURL(file).href}?t=${Date.now()}`);
-  }
-  if (ext === ".ts") {
-    const result = await esbuild.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,${node_buffer.Buffer.from(code).toString(
-      "base64"
-    )}`;
-    return import(`${dataUrl}#${Date.now()}`);
-  }
-  return null;
-}
 async function loadRules(file) {
-  const ext = pathe.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.loadRules(file, { loadModule: moduleLoader.loadModule });
 }
 
 async function buildManifest(options = {}) {
@@ -633,14 +263,14 @@ async function buildManifest(options = {}) {
   const outDir = pathe.resolve(root, options.outDir ?? ".mokup");
   const handlersDir = pathe.join(outDir, "mokup-handlers");
   const dirs = resolveDirs(options.dir, root);
-  const files = await collectFiles(dirs);
+  const files = await mockFiles.collectFiles(dirs);
   const routes = [];
   const seen = /* @__PURE__ */ new Set();
   const handlerSources = /* @__PURE__ */ new Set();
   const handlerModuleMap = /* @__PURE__ */ new Map();
   const configCache = /* @__PURE__ */ new Map();
   const configFileCache = /* @__PURE__ */ new Map();
-  const globalIgnorePrefix = normalizeIgnorePrefix(options.ignorePrefix);
+  const globalIgnorePrefix = scanUtils.normalizeIgnorePrefix(options.ignorePrefix);
   for (const fileInfo of files) {
     const configParams = {
       file: fileInfo.file,
@@ -655,11 +285,11 @@ async function buildManifest(options = {}) {
     if (config.enabled === false) {
       continue;
     }
-    const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
+    const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? scanUtils.normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
     if (pathUtils.hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix)) {
       continue;
     }
-    if (!isSupportedFile(fileInfo.file)) {
+    if (!mockFiles.isSupportedFile(fileInfo.file)) {
       continue;
     }
     const effectiveInclude = typeof config.include !== "undefined" ? config.include : options.include;
@@ -789,38 +419,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 = defineConfig$1.createDefineConfig({
+  logPrefix: "[@mokup/cli]"
+});
+const defineConfig = shared.defineConfig;
+const onBeforeAll = shared.onBeforeAll;
+const onAfterAll = shared.onAfterAll;
 
 const logger = logger$1.createLogger();
 function collectValues(value, previous) {
@@ -965,4 +569,6 @@ async function runCli(argv = process__default.argv) {
 exports.buildManifest = buildManifest;
 exports.createCli = createCli;
 exports.defineConfig = defineConfig;
+exports.onAfterAll = onAfterAll;
+exports.onBeforeAll = onBeforeAll;
 exports.runCli = runCli;

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import { Manifest } from '@mokup/runtime';
 import { MiddlewareHandler } from '@mokup/shared/hono';
+import * as _mokup_shared_define_config from '@mokup/shared/define-config';
 import { Command } from 'commander';
 
 /**
@@ -164,6 +165,12 @@ interface RouteDirectoryConfig {
      * @default undefined
      */
     middleware?: MiddlewareHandler | MiddlewareHandler[];
+    /**
+     * Error handling policy for defineConfig hooks.
+     *
+     * @default "warn"
+     */
+    hookError?: HookErrorPolicy;
 }
 /**
  * Middleware execution position.
@@ -174,6 +181,10 @@ interface RouteDirectoryConfig {
  * const position: MiddlewarePosition = 'pre'
  */
 type MiddlewarePosition = 'pre' | 'normal' | 'post';
+/**
+ * Error handling policy for config hooks.
+ */
+type HookErrorPolicy = 'throw' | 'warn' | 'silent';
 /**
  * Middleware registry used by defineConfig.
  *
@@ -202,39 +213,9 @@ declare function buildManifest(options?: BuildOptions): Promise<{
     manifestPath: string;
 }>;
 
-type DefineConfigFactory = (context: {
-    pre: MiddlewareRegistry;
-    normal: MiddlewareRegistry;
-    post: MiddlewareRegistry;
-}) => RouteDirectoryConfig | void;
-/**
- * Define a directory config with Hono-style middleware registration.
- *
- * @param input - Config object or factory callback.
- * @returns Route directory config with middleware metadata.
- *
- * @example
- * import { defineConfig } from '@mokup/cli'
- *
- * export default defineConfig(({ pre, normal, post }) => {
- *   pre.use(async (c, next) => {
- *     c.header('x-before', '1')
- *     await next()
- *   })
- *
- *   normal.use(async (_c, next) => {
- *     await next()
- *   })
- *
- *   post.use(async (c, next) => {
- *     await next()
- *     c.header('x-after', '1')
- *   })
- *
- *   return { delay: 120 }
- * })
- */
-declare function defineConfig(input: RouteDirectoryConfig | DefineConfigFactory): RouteDirectoryConfig;
+declare const defineConfig: (input: RouteDirectoryConfig | _mokup_shared_define_config.DefineConfigFactory<RouteDirectoryConfig, MiddlewareHandler>) => RouteDirectoryConfig | Promise<RouteDirectoryConfig>;
+declare const onBeforeAll: (handler: _mokup_shared_define_config.HookHandler) => void;
+declare const onAfterAll: (handler: _mokup_shared_define_config.HookHandler) => void;
 
 /**
  * Create the mokup CLI program instance.
@@ -260,5 +241,5 @@ declare function createCli(): Command;
  */
 declare function runCli(argv?: string[]): Promise<void>;
 
-export { buildManifest, createCli, defineConfig, runCli };
-export type { BuildOptions, MiddlewarePosition, MiddlewareRegistry, RouteDirectoryConfig, RouteRule };
+export { buildManifest, createCli, defineConfig, onAfterAll, onBeforeAll, runCli };
+export type { BuildOptions, HookErrorPolicy, MiddlewarePosition, MiddlewareRegistry, RouteDirectoryConfig, RouteRule };