@mokup/server 1.2.0 → 1.2.2

package/dist/fetch-server.cjs

@@ -5,20 +5,19 @@ const node_fs = require('node:fs');
 const node_module = require('node:module');
 const playgroundGrouping = require('@mokup/shared/playground-grouping');
 const runtime = require('@mokup/runtime');
+const routeUtils$1 = require('@mokup/shared/route-utils');
+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 loadRules$1 = require('@mokup/shared/load-rules');
+const scanUtils = require('@mokup/shared/scan-utils');
 const pathUtils = require('@mokup/shared/path-utils');
 const timing = require('@mokup/shared/timing');
-const node_buffer = require('node:buffer');
-const node_url = require('node:url');
-const esbuild = require('@mokup/shared/esbuild');
-const process = require('node:process');
-const jsoncParser = require('@mokup/shared/jsonc-parser');
 const hono = require('@mokup/shared/hono');
+const node_process = require('node:process');
 
 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);
-
 const silentLogger$1 = {
   info: () => {
   },
@@ -274,583 +273,98 @@ function registerPlaygroundRoutes(params) {
   });
 }
 
-const methodSet = /* @__PURE__ */ new Set([
-  "GET",
-  "POST",
-  "PUT",
-  "PATCH",
-  "DELETE",
-  "OPTIONS",
-  "HEAD"
-]);
-const methodSuffixSet = new Set(
-  Array.from(methodSet, (method) => method.toLowerCase())
-);
-const supportedExtensions = /* @__PURE__ */ new Set([
-  ".json",
-  ".jsonc",
-  ".ts",
-  ".js",
-  ".mjs",
-  ".cjs"
-]);
-const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
-
-function normalizePrefix(prefix) {
-  if (!prefix) {
-    return "";
-  }
-  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
-  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-}
-function resolveDirs(dir, root) {
-  const raw = typeof dir === "function" ? dir(root) : 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);
-}
-
-const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
-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, logger) {
-  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) {
-    logger.warn(`Skip mock without method suffix: ${file}`);
-    return null;
-  }
-  if (!name) {
-    logger.warn(`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) {
-      logger.warn(`${error} in ${file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    logger.warn(`${warning} in ${file}`);
-  }
-  return {
-    template: parsed.template,
-    method: resolvedMethod,
-    tokens: parsed.tokens,
-    score: parsed.score
-  };
+  return routeUtils.deriveRouteFromFile(file, rootDir, (message) => logger.warn(message));
 }
 function resolveRule(params) {
-  const method = params.derivedMethod;
-  if (!method) {
-    params.logger.warn(`Skip mock without method suffix: ${params.file}`);
-    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.logger.warn(`${error} in ${params.file}`);
-    }
-    return null;
-  }
-  for (const warning of parsed.warnings) {
-    params.logger.warn(`${warning} in ${params.file}`);
-  }
-  const route = {
+  return routeUtils.resolveRule({
+    rule: params.rule,
+    derivedTemplate: params.derivedTemplate,
+    derivedMethod: params.derivedMethod,
+    prefix: params.prefix,
     file: params.file,
-    template: parsed.template,
-    method,
-    tokens: parsed.tokens,
-    score: parsed.score,
-    handler: params.rule.handler
-  };
-  if (typeof params.rule.status === "number") {
-    route.status = params.rule.status;
-  }
-  if (params.rule.headers) {
-    route.headers = params.rule.headers;
-  }
-  if (typeof params.rule.delay === "number") {
-    route.delay = params.rule.delay;
-  }
-  return route;
-}
-function sortRoutes(routes) {
-  return routes.sort((a, b) => {
-    if (a.method !== b.method) {
-      return a.method.localeCompare(b.method);
-    }
-    const scoreCompare = runtime.compareRouteScore(a.score, b.score);
-    if (scoreCompare !== 0) {
-      return scoreCompare;
-    }
-    return a.template.localeCompare(b.template);
-  });
-}
-
-let registerPromise = null;
-let hasLoggedFailure = false;
-async function ensureTsxRegister(logger) {
-  if (registerPromise) {
-    return registerPromise;
-  }
-  registerPromise = (async () => {
-    try {
-      const mod = await import('tsx/esm/api');
-      const setSourceMapsEnabled = process__default.setSourceMapsEnabled;
-      if (typeof setSourceMapsEnabled === "function") {
-        setSourceMapsEnabled(true);
-      }
-      if (typeof mod.register === "function") {
-        mod.register();
+    warn: (message) => params.logger.warn(message),
+    build: (base, rule) => {
+      const route = {
+        file: params.file,
+        template: base.template,
+        method: base.method,
+        tokens: base.tokens,
+        score: base.score,
+        handler: rule.handler
+      };
+      if (typeof rule.status === "number") {
+        route.status = rule.status;
       }
-      return true;
-    } catch (error) {
-      if (!hasLoggedFailure && logger) {
-        logger.warn(
-          "Failed to register tsx loader; falling back to bundled TS loader.",
-          error
-        );
-        hasLoggedFailure = true;
+      if (rule.headers) {
+        route.headers = rule.headers;
       }
-      return false;
-    }
-  })();
-  return registerPromise;
-}
-
-const middlewareSymbol = Symbol.for("mokup.config.middlewares");
-function isUnknownFileExtensionError$1(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const code = error.code;
-  if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
-    return true;
-  }
-  const message = error.message;
-  return typeof message === "string" && message.includes("Unknown file extension");
-}
-async function loadTsModule$1(file, logger) {
-  const cacheBust = Date.now();
-  const fileUrl = `${node_url.pathToFileURL(file).href}?t=${cacheBust}`;
-  const registered = await ensureTsxRegister(logger);
-  if (registered) {
-    try {
-      return await import(fileUrl);
-    } catch (error) {
-      if (!isUnknownFileExtensionError$1(error)) {
-        throw error;
+      if (typeof rule.delay === "number") {
+        route.delay = rule.delay;
       }
+      return route;
     }
-  }
-  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}#${cacheBust}`);
 }
-async function loadModule$1(file, logger) {
-  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('fetch-server.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") {
-    return loadTsModule$1(file, logger);
-  }
-  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;
+function sortRoutes(routes) {
+  return routeUtils.sortRoutes(routes);
 }
-async function loadConfig(file, logger) {
-  const mod = await loadModule$1(file, logger);
+
+const configExtensions = routeConstants.configExtensions;
+
+async function loadConfig(file) {
+  const mod = await moduleLoader.loadModule(file);
   if (!mod) {
     return null;
   }
   const raw = mod?.default ?? mod;
-  const value = isPromise(raw) ? await raw : raw;
+  const value = configUtils.isPromise(raw) ? await raw : raw;
   if (!value || typeof value !== "object") {
     return null;
   }
   return value;
 }
-function isPromise(value) {
-  return !!value && typeof value.then === "function";
-}
-function normalizeMiddlewares(value, source, logger, position) {
-  if (!value) {
-    return [];
-  }
-  const list = Array.isArray(value) ? value : [value];
-  const middlewares = [];
-  for (const [index, entry] of list.entries()) {
-    if (typeof entry !== "function") {
-      logger.warn(`Invalid middleware in ${source}`);
-      continue;
-    }
-    middlewares.push({
-      handle: entry,
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, logger, configCache, fileCache } = params;
+  const resolved = await configUtils.resolveDirectoryConfig({
+    file,
+    rootDir,
+    configExtensions,
+    configCache,
+    fileCache,
+    loadConfig,
+    warn: (message) => logger.warn(message),
+    mapMiddleware: (handler, index, position, source) => ({
+      handle: handler,
       source,
       index,
       position
-    });
-  }
-  return middlewares;
-}
-function readMiddlewareMeta(config) {
-  const value = config[middlewareSymbol];
-  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, logger, 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, logger);
-      configCache.set(configPath, config);
-    }
-    if (!config) {
-      logger.warn(`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,
-      logger,
-      "pre"
-    );
-    const normalizedNormal = normalizeMiddlewares(
-      meta?.normal,
-      configPath,
-      logger,
-      "normal"
-    );
-    const normalizedLegacy = normalizeMiddlewares(
-      config.middleware,
-      configPath,
-      logger,
-      "normal"
-    );
-    const normalizedPost = normalizeMiddlewares(
-      meta?.post,
-      configPath,
-      logger,
-      "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);
-    }
-  }
+    })
+  });
   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
   };
 }
 
-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 exists(path) {
-  try {
-    await node_fs.promises.stat(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function collectFiles(dirs) {
-  const files = [];
-  for (const dir of dirs) {
-    if (!await exists(dir)) {
-      continue;
-    }
-    await walkDir(dir, dir, files);
-  }
-  return files;
-}
-function isConfigFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  const base = pathe.basename(file);
-  if (!base.startsWith("index.config.")) {
-    return false;
-  }
-  const ext = pathe.extname(file).toLowerCase();
-  return configExtensions.includes(ext);
-}
-function isSupportedFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  if (isConfigFile(file)) {
-    return false;
-  }
-  const ext = pathe.extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+async function loadRules(file, logger) {
+  return loadRules$1.loadRules(file, { loadModule: moduleLoader.loadModule, logger });
 }
 
-function isUnknownFileExtensionError(error) {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-  const code = error.code;
-  if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
-    return true;
-  }
-  const message = error.message;
-  return typeof message === "string" && message.includes("Unknown file extension");
-}
-async function loadTsModule(file, logger) {
-  const cacheBust = Date.now();
-  const fileUrl = `${node_url.pathToFileURL(file).href}?t=${cacheBust}`;
-  const registered = await ensureTsxRegister(logger);
-  if (registered) {
-    try {
-      return await import(fileUrl);
-    } catch (error) {
-      if (!isUnknownFileExtensionError(error)) {
-        throw error;
-      }
-    }
-  }
-  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}#${cacheBust}`);
-}
-async function loadModule(file, logger) {
-  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('fetch-server.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") {
-    return loadTsModule(file, logger);
-  }
-  return null;
-}
-async function readJsonFile(file, logger) {
-  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) {
-      logger.warn(`Invalid JSONC in ${file}`);
-      return void 0;
-    }
-    return data;
-  } catch (error) {
-    logger.warn(`Failed to read ${file}: ${String(error)}`);
-    return void 0;
-  }
-}
-async function loadRules(file, logger) {
-  const ext = pathe.extname(file).toLowerCase();
-  if (ext === ".json" || ext === ".jsonc") {
-    const json = await readJsonFile(file, logger);
-    if (typeof json === "undefined") {
-      return [];
-    }
-    return [
-      {
-        handler: json
-      }
-    ];
-  }
-  const mod = await loadModule(file, logger);
-  const value = mod?.default ?? mod;
-  if (!value) {
-    return [];
-  }
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (typeof value === "function") {
-    return [
-      {
-        handler: value
-      }
-    ];
-  }
-  return [value];
+function resolveDirs(dir, root) {
+  return scanUtils.resolveDirs(dir, root);
 }
+const normalizeIgnorePrefix = scanUtils.normalizeIgnorePrefix;
 
 const silentLogger = {
   info: () => {
@@ -894,7 +408,7 @@ function buildSkipInfo(file, reason, resolved) {
 async function scanRoutes(params) {
   const routes = [];
   const seen = /* @__PURE__ */ new Set();
-  const files = await collectFiles(params.dirs);
+  const files = await mockFiles.collectFiles(params.dirs);
   const globalIgnorePrefix = normalizeIgnorePrefix(params.ignorePrefix);
   const configCache = /* @__PURE__ */ new Map();
   const fileCache = /* @__PURE__ */ new Map();
@@ -902,7 +416,7 @@ async function scanRoutes(params) {
   const shouldCollectIgnore = typeof params.onIgnore === "function";
   const shouldCollectConfig = typeof params.onConfig === "function";
   for (const fileInfo of files) {
-    if (isConfigFile(fileInfo.file)) {
+    if (mockFiles.isConfigFile(fileInfo.file)) {
       if (shouldCollectConfig) {
         const config2 = await resolveDirectoryConfig({
           file: fileInfo.file,
@@ -923,7 +437,7 @@ async function scanRoutes(params) {
       fileCache
     });
     if (config.enabled === false) {
-      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+      if (shouldCollectSkip && mockFiles.isSupportedFile(fileInfo.file)) {
         const resolved = resolveSkipRoute({
           file: fileInfo.file,
           rootDir: fileInfo.rootDir,
@@ -935,7 +449,7 @@ async function scanRoutes(params) {
     }
     const effectiveIgnorePrefix = typeof config.ignorePrefix !== "undefined" ? normalizeIgnorePrefix(config.ignorePrefix, []) : globalIgnorePrefix;
     if (pathUtils.hasIgnoredPrefix(fileInfo.file, fileInfo.rootDir, effectiveIgnorePrefix)) {
-      if (shouldCollectSkip && isSupportedFile(fileInfo.file)) {
+      if (shouldCollectSkip && mockFiles.isSupportedFile(fileInfo.file)) {
         const resolved = resolveSkipRoute({
           file: fileInfo.file,
           rootDir: fileInfo.rootDir,
@@ -945,7 +459,7 @@ async function scanRoutes(params) {
       }
       continue;
     }
-    if (!isSupportedFile(fileInfo.file)) {
+    if (!mockFiles.isSupportedFile(fileInfo.file)) {
       if (shouldCollectIgnore) {
         params.onIgnore?.({ file: fileInfo.file, reason: "unsupported" });
       }
@@ -1239,7 +753,7 @@ function resolveRoot(list) {
   if (deno?.cwd) {
     return deno.cwd();
   }
-  return process.cwd();
+  return node_process.cwd();
 }
 function resolveAllDirs(list, root) {
   const dirs = [];