@mokup/cli 0.0.0

package/dist/shared/cli.D0D0o7Rg.mjs

@@ -0,0 +1,714 @@
+import { promises } from 'node:fs';
+import { cwd } from 'node:process';
+import { join, normalize, dirname, resolve, isAbsolute, basename, extname, relative } from 'pathe';
+import { Buffer } from 'node:buffer';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { build } from 'esbuild';
+import { parseRouteTemplate, compareRouteScore } from '@mokup/runtime';
+import { parse } from 'jsonc-parser';
+
+async function writeBundle(outDir, hasHandlers) {
+  const lines = [
+    "import manifest from './mokup.manifest.mjs'"
+  ];
+  if (hasHandlers) {
+    lines.push(
+      "import { mokupModuleMap } from './mokup-handlers/index.mjs'",
+      "",
+      "const mokupBundle = {",
+      "  manifest,",
+      "  moduleMap: mokupModuleMap,",
+      "  moduleBase: './',",
+      "}"
+    );
+  } else {
+    lines.push(
+      "",
+      "const mokupBundle = {",
+      "  manifest,",
+      "}"
+    );
+  }
+  lines.push("", "export default mokupBundle", "export { mokupBundle }", "");
+  const dts = [
+    "import type { Manifest, ModuleMap } from '@mokup/runtime'",
+    "export interface MokupBundle {",
+    "  manifest: Manifest",
+    "  moduleMap?: ModuleMap",
+    "  moduleBase?: string | URL",
+    "}",
+    "declare const mokupBundle: MokupBundle",
+    "export default mokupBundle",
+    "export { mokupBundle }",
+    ""
+  ];
+  await promises.writeFile(join(outDir, "mokup.bundle.mjs"), lines.join("\n"), "utf8");
+  await promises.writeFile(join(outDir, "mokup.bundle.d.ts"), dts.join("\n"), "utf8");
+  await promises.writeFile(join(outDir, "mokup.bundle.d.mts"), dts.join("\n"), "utf8");
+}
+async function writeManifestModule(outDir, manifest) {
+  const lines = [
+    `const manifest = ${JSON.stringify(manifest, null, 2)}`,
+    "",
+    "export default manifest",
+    ""
+  ];
+  const dts = [
+    "import type { Manifest } from '@mokup/runtime'",
+    "declare const manifest: Manifest",
+    "export default manifest",
+    ""
+  ];
+  await promises.writeFile(join(outDir, "mokup.manifest.mjs"), lines.join("\n"), "utf8");
+  await promises.writeFile(join(outDir, "mokup.manifest.d.mts"), dts.join("\n"), "utf8");
+}
+
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+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);
+  if (!mod) {
+    return null;
+  }
+  const value = mod?.default ?? mod;
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  return value;
+}
+function normalizeMiddlewares(value, source, log) {
+  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 });
+  });
+  return middlewares;
+}
+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 = { middlewares: [] };
+  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;
+    }
+    const normalized = normalizeMiddlewares(config.middleware, configPath, log);
+    if (normalized.length > 0) {
+      merged.middlewares.push(...normalized);
+    }
+  }
+  return merged;
+}
+
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+
+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 testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = toPosix(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+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);
+}
+
+function getHandlerModulePath(file, handlersDir, root) {
+  const relFromRoot = relative(root, file);
+  const ext = extname(relFromRoot);
+  const relNoExt = `${relFromRoot.slice(0, relFromRoot.length - ext.length)}.mjs`;
+  const outputPath = join(handlersDir, relNoExt);
+  const relFromOutDir = relative(dirname(handlersDir), outputPath);
+  const normalized = toPosix(relFromOutDir);
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+async function writeHandlerIndex(handlerModuleMap, handlersDir, outDir) {
+  const modulePaths = Array.from(new Set(handlerModuleMap.values()));
+  if (modulePaths.length === 0) {
+    return;
+  }
+  const imports = [];
+  const entries = [];
+  modulePaths.forEach((modulePath, index) => {
+    const absolutePath = resolve(outDir, modulePath);
+    const relImport = toPosix(relative(handlersDir, absolutePath));
+    const importPath = relImport.startsWith(".") ? relImport : `./${relImport}`;
+    const name = `module${index}`;
+    imports.push(`import * as ${name} from '${importPath}'`);
+    entries.push({ key: modulePath, name });
+  });
+  const lines = [
+    ...imports,
+    "",
+    "export const mokupModuleMap = {",
+    ...entries.map((entry) => `  '${entry.key}': ${entry.name},`),
+    "}",
+    ""
+  ];
+  await promises.writeFile(join(handlersDir, "index.mjs"), lines.join("\n"), "utf8");
+  const dts = [
+    "export type MokupModuleMap = Record<string, Record<string, unknown>>",
+    "export declare const mokupModuleMap: MokupModuleMap",
+    ""
+  ];
+  await promises.writeFile(join(handlersDir, "index.d.ts"), dts.join("\n"), "utf8");
+  await promises.writeFile(join(handlersDir, "index.d.mts"), dts.join("\n"), "utf8");
+}
+function buildResponse(response, options) {
+  if (typeof response === "function") {
+    if (!options.handlers) {
+      return null;
+    }
+    const moduleRel = getHandlerModulePath(
+      options.file,
+      options.handlersDir,
+      options.root
+    );
+    options.handlerSources.add(options.file);
+    options.handlerModuleMap.set(options.file, moduleRel);
+    return {
+      type: "module",
+      module: moduleRel,
+      ruleIndex: options.ruleIndex
+    };
+  }
+  if (typeof response === "string") {
+    return {
+      type: "text",
+      body: response
+    };
+  }
+  if (response instanceof Uint8Array || response instanceof ArrayBuffer) {
+    return {
+      type: "binary",
+      body: Buffer.from(response).toString("base64"),
+      encoding: "base64"
+    };
+  }
+  if (Buffer.isBuffer(response)) {
+    return {
+      type: "binary",
+      body: response.toString("base64"),
+      encoding: "base64"
+    };
+  }
+  return {
+    type: "json",
+    body: response
+  };
+}
+async function bundleHandlers(files, root, handlersDir) {
+  await build({
+    entryPoints: files,
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "es2020",
+    outdir: handlersDir,
+    outbase: root,
+    entryNames: "[dir]/[name]",
+    outExtension: { ".js": ".mjs" },
+    logLevel: "silent"
+  });
+}
+
+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
+  };
+}
+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
+  };
+}
+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
+  };
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => {
+    if (a.method !== b.method) {
+      return a.method.localeCompare(b.method);
+    }
+    return compareRouteScore(a.score ?? [], b.score ?? []);
+  });
+}
+
+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 [
+      {
+        response: 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 [
+      {
+        response: value
+      }
+    ];
+  }
+  return [value];
+}
+
+async function buildManifest(options = {}) {
+  const root = options.root ?? cwd();
+  const outDir = resolve(root, options.outDir ?? ".mokup");
+  const handlersDir = join(outDir, "mokup-handlers");
+  const dirs = resolveDirs(options.dir, root);
+  const files = await 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();
+  for (const fileInfo of files) {
+    if (!isSupportedFile(fileInfo.file)) {
+      continue;
+    }
+    if (!matchesFilter(fileInfo.file, options.include, options.exclude)) {
+      continue;
+    }
+    const configParams = {
+      file: fileInfo.file,
+      rootDir: fileInfo.rootDir,
+      configCache,
+      fileCache: configFileCache
+    };
+    if (options.log) {
+      configParams.log = options.log;
+    }
+    const config = await resolveDirectoryConfig(configParams);
+    if (config.enabled === false) {
+      continue;
+    }
+    const derived = deriveRouteFromFile(fileInfo.file, fileInfo.rootDir, options.log);
+    if (!derived) {
+      continue;
+    }
+    const rules = await loadRules(fileInfo.file);
+    for (const [index, rule] of rules.entries()) {
+      if (!rule || typeof rule !== "object") {
+        continue;
+      }
+      if (typeof rule.response === "undefined") {
+        continue;
+      }
+      const resolveParams = {
+        rule,
+        derivedTemplate: derived.template,
+        derivedMethod: derived.method,
+        prefix: options.prefix ?? "",
+        file: fileInfo.file
+      };
+      if (options.log) {
+        resolveParams.log = options.log;
+      }
+      const resolved = resolveRule(resolveParams);
+      if (!resolved) {
+        continue;
+      }
+      const key = `${resolved.method} ${resolved.template}`;
+      if (seen.has(key)) {
+        options.log?.(`Duplicate mock route ${key} from ${fileInfo.file}`);
+      }
+      seen.add(key);
+      const response = buildResponse(
+        rule.response,
+        {
+          file: fileInfo.file,
+          handlers: options.handlers !== false,
+          handlerSources,
+          handlerModuleMap,
+          handlersDir,
+          root,
+          ruleIndex: index
+        }
+      );
+      if (!response) {
+        continue;
+      }
+      const source = toPosix(relative(root, fileInfo.file));
+      const middlewareRefs = options.handlers === false ? [] : config.middlewares.map((entry) => {
+        handlerSources.add(entry.file);
+        const modulePath = getHandlerModulePath(entry.file, handlersDir, root);
+        handlerModuleMap.set(entry.file, modulePath);
+        return {
+          module: modulePath,
+          ruleIndex: entry.index
+        };
+      });
+      const route = {
+        method: resolved.method,
+        url: resolved.template,
+        tokens: resolved.tokens,
+        score: resolved.score,
+        source,
+        response
+      };
+      if (typeof rule.status === "number") {
+        route.status = rule.status;
+      }
+      if (config.headers) {
+        route.headers = { ...config.headers };
+      }
+      if (rule.headers) {
+        route.headers = { ...route.headers ?? {}, ...rule.headers };
+      }
+      if (typeof rule.delay === "number") {
+        route.delay = rule.delay;
+      }
+      if (typeof route.status === "undefined" && typeof config.status === "number") {
+        route.status = config.status;
+      }
+      if (typeof route.delay === "undefined" && typeof config.delay === "number") {
+        route.delay = config.delay;
+      }
+      if (middlewareRefs.length > 0) {
+        route.middleware = middlewareRefs;
+      }
+      routes.push(route);
+    }
+  }
+  const manifest = {
+    version: 1,
+    routes: sortRoutes(routes)
+  };
+  await promises.mkdir(outDir, { recursive: true });
+  if (handlerSources.size > 0) {
+    await promises.mkdir(handlersDir, { recursive: true });
+    await bundleHandlers(Array.from(handlerSources), root, handlersDir);
+    await writeHandlerIndex(handlerModuleMap, handlersDir, outDir);
+  }
+  const manifestPath = join(outDir, "mokup.manifest.json");
+  await promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+  await writeManifestModule(outDir, manifest);
+  await writeBundle(outDir, handlerSources.size > 0);
+  options.log?.(`Manifest written to ${manifestPath}`);
+  return {
+    manifest,
+    manifestPath
+  };
+}
+
+export { buildManifest as b };