@mokup/server 1.1.8 → 1.2.1

package/dist/fetch-server.d.cts

@@ -1,4 +1,4 @@
-import { d as RouteTable } from './shared/server.CyVIKPsp.cjs';
+import { d as RouteTable } from './shared/server.DLPB_I9q.cjs';
 import { MockEntryOptions, PlaygroundOptionsInput } from '@mokup/shared';
 import '@mokup/runtime';
 import '@mokup/shared/hono';

package/dist/fetch-server.d.mts

@@ -1,4 +1,4 @@
-import { d as RouteTable } from './shared/server.CyVIKPsp.mjs';
+import { d as RouteTable } from './shared/server.DLPB_I9q.mjs';
 import { MockEntryOptions, PlaygroundOptionsInput } from '@mokup/shared';
 import '@mokup/runtime';
 import '@mokup/shared/hono';

package/dist/fetch-server.d.ts

@@ -1,4 +1,4 @@
-import { d as RouteTable } from './shared/server.CyVIKPsp.js';
+import { d as RouteTable } from './shared/server.DLPB_I9q.js';
 import { MockEntryOptions, PlaygroundOptionsInput } from '@mokup/shared';
 import '@mokup/runtime';
 import '@mokup/shared/hono';

package/dist/fetch-server.mjs

@@ -1,16 +1,19 @@
-import { join, normalize, extname, resolve, isAbsolute, relative, dirname, basename } from '@mokup/shared/pathe';
+import { join, normalize, extname } from '@mokup/shared/pathe';
 import { promises } from 'node:fs';
 import { createRequire } from 'node:module';
 import { resolveRouteGroup, formatRouteFile, resolveGroupRoot, resolveGroups } from '@mokup/shared/playground-grouping';
 import { compareRouteScore, parseRouteTemplate } from '@mokup/runtime';
-import { toPosix, hasIgnoredPrefix, matchesFilter, isInDirs } from '@mokup/shared/path-utils';
+import { createRouteUtils } from '@mokup/shared/route-utils';
+import { resolveDirectoryConfig as resolveDirectoryConfig$1, isPromise } from '@mokup/shared/config-utils';
+import { loadModule } from '@mokup/shared/module-loader';
+import { configExtensions as configExtensions$1 } from '@mokup/shared/route-constants';
+import { collectFiles, isConfigFile, isSupportedFile } from '@mokup/shared/mock-files';
+import { loadRules as loadRules$1 } from '@mokup/shared/load-rules';
+import { resolveDirs as resolveDirs$1, normalizeIgnorePrefix as normalizeIgnorePrefix$1 } from '@mokup/shared/scan-utils';
+import { hasIgnoredPrefix, matchesFilter, isInDirs } from '@mokup/shared/path-utils';
 import { delay, createDebouncer } from '@mokup/shared/timing';
-import { Buffer } from 'node:buffer';
-import { pathToFileURL } from 'node:url';
-import { build } from '@mokup/shared/esbuild';
-import process, { cwd } from 'node:process';
-import { parse } from '@mokup/shared/jsonc-parser';
 import { Hono, PatternRouter } from '@mokup/shared/hono';
+import { cwd } from 'node:process';
 
 const silentLogger$1 = {
   info: () => {
@@ -267,579 +270,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) => 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);
-}
-
-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 = createRouteUtils({
+  parseRouteTemplate,
+  compareRouteScore
+});
 function deriveRouteFromFile(file, rootDir, logger) {
-  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) {
-    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 : 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) {
-      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 = 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 = 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.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 = `${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 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}#${cacheBust}`);
-}
-async function loadModule$1(file, logger) {
-  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") {
-    return loadTsModule$1(file, logger);
-  }
-  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;
+function sortRoutes(routes) {
+  return routeUtils.sortRoutes(routes);
 }
-async function loadConfig(file, logger) {
-  const mod = await loadModule$1(file, logger);
+
+const configExtensions = configExtensions$1;
+
+async function loadConfig(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, 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 resolveDirectoryConfig$1({
+    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 = 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, 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 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 exists(path) {
-  try {
-    await 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 = basename(file);
-  if (!base.startsWith("index.config.")) {
-    return false;
-  }
-  const ext = extname(file).toLowerCase();
-  return configExtensions.includes(ext);
-}
-function isSupportedFile(file) {
-  if (file.endsWith(".d.ts")) {
-    return false;
-  }
-  if (isConfigFile(file)) {
-    return false;
-  }
-  const ext = extname(file).toLowerCase();
-  return supportedExtensions.has(ext);
+async function loadRules(file, logger) {
+  return loadRules$1(file, { 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 = `${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 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}#${cacheBust}`);
-}
-async function loadModule(file, logger) {
-  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") {
-    return loadTsModule(file, logger);
-  }
-  return null;
-}
-async function readJsonFile(file, logger) {
-  try {
-    const content = await promises.readFile(file, "utf8");
-    const errors = [];
-    const data = 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 = 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 resolveDirs$1(dir, root);
 }
+const normalizeIgnorePrefix = normalizeIgnorePrefix$1;
 
 const silentLogger = {
   info: () => {

package/dist/fetch.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const runtime = require('@mokup/runtime');
-const runtime$1 = require('./shared/server.aaygIV2Q.cjs');
+const runtime$1 = require('./shared/server.D0X6h49r.cjs');
 
 function createFetchHandler(options) {
   const runtime$2 = runtime.createRuntime(runtime$1.toRuntimeOptions(options));