@mokup/runtime 0.0.0

package/dist/index.mjs

@@ -0,0 +1,583 @@
+const paramNamePattern = /^[\w-]+$/;
+const paramPattern = /^\[([^\]/]+)\]$/;
+const catchallPattern = /^\[\.\.\.([^\]/]+)\]$/;
+const optionalCatchallPattern = /^\[\[\.\.\.([^\]/]+)\]\]$/;
+const groupPattern = /^\([^)]+\)$/;
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function scoreToken(token) {
+  switch (token.type) {
+    case "static":
+      return 4;
+    case "param":
+      return 3;
+    case "catchall":
+      return 2;
+    case "optional-catchall":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function scoreRouteTokens(tokens) {
+  return tokens.map(scoreToken);
+}
+function compareRouteScore(a, b) {
+  const min = Math.min(a.length, b.length);
+  for (let i = 0; i < min; i += 1) {
+    const aValue = a[i] ?? 0;
+    const bValue = b[i] ?? 0;
+    if (aValue !== bValue) {
+      return bValue - aValue;
+    }
+  }
+  if (a.length !== b.length) {
+    return b.length - a.length;
+  }
+  return 0;
+}
+function normalizePathname(value) {
+  const withoutQuery = value.split("?")[0] ?? "";
+  const withoutHash = withoutQuery.split("#")[0] ?? "";
+  let normalized = withoutHash.startsWith("/") ? withoutHash : `/${withoutHash}`;
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function splitPath(value) {
+  return normalizePathname(value).split("/").filter(Boolean);
+}
+function parseRouteTemplate(template) {
+  const errors = [];
+  const warnings = [];
+  const normalized = normalizePathname(template);
+  const segments = splitPath(normalized);
+  const tokens = [];
+  const seenParams = /* @__PURE__ */ new Set();
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (!segment) {
+      continue;
+    }
+    if (groupPattern.test(segment)) {
+      errors.push(`Route groups are not supported: ${segment}`);
+      continue;
+    }
+    const optionalCatchallMatch = segment.match(optionalCatchallPattern);
+    if (optionalCatchallMatch) {
+      const name = optionalCatchallMatch[1];
+      if (!name) {
+        errors.push(`Invalid optional catch-all param name "${segment}"`);
+        continue;
+      }
+      if (!paramNamePattern.test(name)) {
+        errors.push(`Invalid optional catch-all param name "${name}"`);
+        continue;
+      }
+      if (index !== segments.length - 1) {
+        errors.push(`Optional catch-all "${segment}" must be the last segment`);
+        continue;
+      }
+      if (seenParams.has(name)) {
+        warnings.push(`Duplicate param name "${name}"`);
+      }
+      seenParams.add(name);
+      tokens.push({ type: "optional-catchall", name });
+      continue;
+    }
+    const catchallMatch = segment.match(catchallPattern);
+    if (catchallMatch) {
+      const name = catchallMatch[1];
+      if (!name) {
+        errors.push(`Invalid catch-all param name "${segment}"`);
+        continue;
+      }
+      if (!paramNamePattern.test(name)) {
+        errors.push(`Invalid catch-all param name "${name}"`);
+        continue;
+      }
+      if (index !== segments.length - 1) {
+        errors.push(`Catch-all "${segment}" must be the last segment`);
+        continue;
+      }
+      if (seenParams.has(name)) {
+        warnings.push(`Duplicate param name "${name}"`);
+      }
+      seenParams.add(name);
+      tokens.push({ type: "catchall", name });
+      continue;
+    }
+    const paramMatch = segment.match(paramPattern);
+    if (paramMatch) {
+      const name = paramMatch[1];
+      if (!name) {
+        errors.push(`Invalid param name "${segment}"`);
+        continue;
+      }
+      if (!paramNamePattern.test(name)) {
+        errors.push(`Invalid param name "${name}"`);
+        continue;
+      }
+      if (seenParams.has(name)) {
+        warnings.push(`Duplicate param name "${name}"`);
+      }
+      seenParams.add(name);
+      tokens.push({ type: "param", name });
+      continue;
+    }
+    if (segment.includes("[") || segment.includes("]") || segment.includes("(") || segment.includes(")")) {
+      errors.push(`Invalid route segment "${segment}"`);
+      continue;
+    }
+    tokens.push({ type: "static", value: segment });
+  }
+  return {
+    template: normalized,
+    tokens,
+    score: scoreRouteTokens(tokens),
+    errors,
+    warnings
+  };
+}
+function matchRouteTokens(tokens, pathname) {
+  const segments = splitPath(pathname);
+  const params = {};
+  let index = 0;
+  for (const token of tokens) {
+    if (token.type === "static") {
+      const segment = segments[index];
+      if (segment !== token.value) {
+        return null;
+      }
+      index += 1;
+      continue;
+    }
+    if (token.type === "param") {
+      const segment = segments[index];
+      if (!segment) {
+        return null;
+      }
+      params[token.name] = decodeSegment(segment);
+      index += 1;
+      continue;
+    }
+    if (token.type === "catchall") {
+      if (index >= segments.length) {
+        return null;
+      }
+      params[token.name] = segments.slice(index).map(decodeSegment);
+      index = segments.length;
+      continue;
+    }
+    if (token.type === "optional-catchall") {
+      params[token.name] = segments.slice(index).map(decodeSegment);
+      index = segments.length;
+      continue;
+    }
+  }
+  if (index !== segments.length) {
+    return null;
+  }
+  return { params };
+}
+
+function resolveModuleUrl(modulePath, moduleBase) {
+  if (/^(?:data|http|https|file):/.test(modulePath)) {
+    return modulePath;
+  }
+  if (!moduleBase) {
+    throw new Error("moduleBase is required for relative module paths.");
+  }
+  const base = typeof moduleBase === "string" ? moduleBase : moduleBase.href;
+  if (/^(?:data|http|https|file):/.test(base)) {
+    return new URL(modulePath, base).href;
+  }
+  const normalizedBase = base.endsWith("/") ? base : `${base}/`;
+  const normalizedModule = modulePath.startsWith("./") ? modulePath.slice(2) : modulePath.startsWith("/") ? modulePath.slice(1) : modulePath;
+  return `${normalizedBase}${normalizedModule}`;
+}
+function normalizeRules(value) {
+  if (!value) {
+    return [];
+  }
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (typeof value === "function") {
+    return [
+      {
+        response: value
+      }
+    ];
+  }
+  if (typeof value === "object") {
+    return [value];
+  }
+  return [
+    {
+      response: value
+    }
+  ];
+}
+async function executeRule(rule, req, responder, ctx) {
+  if (!rule) {
+    return void 0;
+  }
+  const value = rule.response;
+  if (typeof value === "function") {
+    const handler = value;
+    return handler(req, responder, ctx);
+  }
+  return value;
+}
+function extractMiddlewareSource(value) {
+  if (value && typeof value === "object" && "middleware" in value) {
+    return value.middleware;
+  }
+  return value;
+}
+function normalizeMiddleware(value) {
+  const resolved = extractMiddlewareSource(value);
+  if (!resolved) {
+    return [];
+  }
+  if (Array.isArray(resolved)) {
+    return resolved.filter((entry) => typeof entry === "function");
+  }
+  if (typeof resolved === "function") {
+    return [resolved];
+  }
+  return [];
+}
+async function loadModuleExport(modulePath, exportName, moduleBase, moduleMap) {
+  const directMapValue = moduleMap?.[modulePath];
+  const resolvedUrl = directMapValue ? void 0 : resolveModuleUrl(modulePath, moduleBase);
+  const resolvedMapValue = resolvedUrl ? moduleMap?.[resolvedUrl] : void 0;
+  const moduleValue = directMapValue ?? resolvedMapValue;
+  const module = moduleValue ?? await import(resolvedUrl ?? modulePath);
+  return module[exportName] ?? module.default ?? module;
+}
+function resolveModuleCacheKey(modulePath, exportName, moduleBase, moduleMap) {
+  if (moduleMap?.[modulePath]) {
+    return `${modulePath}::${exportName}`;
+  }
+  const resolvedUrl = resolveModuleUrl(modulePath, moduleBase);
+  return `${resolvedUrl}::${exportName}`;
+}
+async function loadModuleRule(response, moduleCache, moduleBase, moduleMap) {
+  const exportName = response.exportName ?? "default";
+  const cacheKey = resolveModuleCacheKey(
+    response.module,
+    exportName,
+    moduleBase,
+    moduleMap
+  );
+  let rules = moduleCache.get(cacheKey);
+  if (!rules) {
+    const exported = await loadModuleExport(
+      response.module,
+      exportName,
+      moduleBase,
+      moduleMap
+    );
+    rules = normalizeRules(exported);
+    moduleCache.set(cacheKey, rules);
+  }
+  if (typeof response.ruleIndex === "number") {
+    return rules[response.ruleIndex];
+  }
+  return rules[0];
+}
+async function loadModuleMiddleware(middleware, middlewareCache, moduleBase, moduleMap) {
+  const exportName = middleware.exportName ?? "default";
+  const cacheKey = resolveModuleCacheKey(
+    middleware.module,
+    exportName,
+    moduleBase,
+    moduleMap
+  );
+  let handlers = middlewareCache.get(cacheKey);
+  if (!handlers) {
+    const exported = await loadModuleExport(
+      middleware.module,
+      exportName,
+      moduleBase,
+      moduleMap
+    );
+    handlers = normalizeMiddleware(exported);
+    middlewareCache.set(cacheKey, handlers);
+  }
+  if (typeof middleware.ruleIndex === "number") {
+    return handlers[middleware.ruleIndex];
+  }
+  return handlers[0];
+}
+
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+function normalizeMethod(method) {
+  if (!method) {
+    return void 0;
+  }
+  const normalized = method.toUpperCase();
+  if (methodSet.has(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function mergeHeaders(base, override) {
+  if (!override) {
+    return base;
+  }
+  return {
+    ...base,
+    ...override
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class ResponseController {
+  statusCode = 200;
+  headers = /* @__PURE__ */ new Map();
+  setHeader(key, value) {
+    this.headers.set(key.toLowerCase(), value);
+  }
+  getHeader(key) {
+    return this.headers.get(key.toLowerCase());
+  }
+  removeHeader(key) {
+    this.headers.delete(key.toLowerCase());
+  }
+  toRecord() {
+    const record = {};
+    for (const [key, value] of this.headers.entries()) {
+      record[key] = value;
+    }
+    return record;
+  }
+}
+function normalizeBody(body, contentType) {
+  if (typeof body === "undefined") {
+    return { body: null };
+  }
+  if (typeof body === "string") {
+    return {
+      body,
+      contentType: contentType ?? "text/plain; charset=utf-8"
+    };
+  }
+  if (body instanceof Uint8Array) {
+    return {
+      body,
+      contentType: contentType ?? "application/octet-stream"
+    };
+  }
+  if (body instanceof ArrayBuffer) {
+    return {
+      body: new Uint8Array(body),
+      contentType: contentType ?? "application/octet-stream"
+    };
+  }
+  return {
+    body: JSON.stringify(body),
+    contentType: contentType ?? "application/json; charset=utf-8"
+  };
+}
+function decodeBase64(value) {
+  if (typeof atob === "function") {
+    const binary = atob(value);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  throw new Error("Base64 decoding is not supported in this runtime.");
+}
+function finalizeStatus(status, body) {
+  if (status === 200 && body === null) {
+    return 204;
+  }
+  return status;
+}
+
+async function executeRoute(route, req, moduleCache, middlewareCache, moduleBase, moduleMap) {
+  const responder = new ResponseController();
+  const ctx = {
+    delay,
+    json: (data) => data
+  };
+  const runHandler = async () => {
+    if (route.response.type === "json") {
+      return {
+        value: route.response.body,
+        contentType: "application/json; charset=utf-8"
+      };
+    }
+    if (route.response.type === "text") {
+      return {
+        value: route.response.body,
+        contentType: "text/plain; charset=utf-8"
+      };
+    }
+    if (route.response.type === "binary") {
+      return {
+        value: decodeBase64(route.response.body),
+        contentType: "application/octet-stream"
+      };
+    }
+    const rule = await loadModuleRule(
+      route.response,
+      moduleCache,
+      moduleBase,
+      moduleMap
+    );
+    const value = await executeRule(rule, req, responder, ctx);
+    return { value };
+  };
+  const runMiddlewares = async (middlewares) => {
+    let lastIndex = -1;
+    const dispatch = async (index) => {
+      if (index <= lastIndex) {
+        throw new Error("Middleware next() called multiple times.");
+      }
+      lastIndex = index;
+      const handler = middlewares[index];
+      if (!handler) {
+        return runHandler();
+      }
+      let nextResult;
+      const next = async () => {
+        nextResult = await dispatch(index + 1);
+        return nextResult.value;
+      };
+      const value = await handler(req, responder, ctx, next);
+      if (typeof value !== "undefined") {
+        return { value };
+      }
+      if (nextResult) {
+        return nextResult;
+      }
+      return { value: void 0 };
+    };
+    return dispatch(0);
+  };
+  const middlewareHandlers = [];
+  for (const entry of route.middleware ?? []) {
+    const handler = await loadModuleMiddleware(
+      entry,
+      middlewareCache,
+      moduleBase,
+      moduleMap
+    );
+    if (handler) {
+      middlewareHandlers.push(handler);
+    }
+  }
+  const result = middlewareHandlers.length > 0 ? await runMiddlewares(middlewareHandlers) : await runHandler();
+  const responseValue = result.value;
+  const contentType = result.contentType;
+  if (route.delay && route.delay > 0) {
+    await delay(route.delay);
+  }
+  const headers = mergeHeaders(responder.toRecord(), route.headers);
+  if (contentType && !headers["content-type"]) {
+    headers["content-type"] = contentType;
+  }
+  const normalized = normalizeBody(responseValue, headers["content-type"]);
+  const status = finalizeStatus(
+    route.status ?? responder.statusCode,
+    normalized.body
+  );
+  if (normalized.contentType && !headers["content-type"]) {
+    headers["content-type"] = normalized.contentType;
+  }
+  return {
+    status,
+    headers,
+    body: normalized.body
+  };
+}
+function createRuntime(options) {
+  let manifestCache = null;
+  let compiledRoutes = null;
+  const moduleCache = /* @__PURE__ */ new Map();
+  const middlewareCache = /* @__PURE__ */ new Map();
+  const getManifest = async () => {
+    if (!manifestCache) {
+      manifestCache = typeof options.manifest === "function" ? await options.manifest() : options.manifest;
+    }
+    return manifestCache;
+  };
+  const getRouteList = async () => {
+    if (compiledRoutes) {
+      return compiledRoutes;
+    }
+    const manifest = await getManifest();
+    const map = /* @__PURE__ */ new Map();
+    for (const route of manifest.routes) {
+      const method = normalizeMethod(route.method) ?? "GET";
+      const parsed = route.tokens ? { tokens: route.tokens, score: route.score ?? scoreRouteTokens(route.tokens), errors: [] } : parseRouteTemplate(route.url);
+      if (parsed.errors.length > 0) {
+        continue;
+      }
+      const tokens = route.tokens ?? parsed.tokens;
+      const score = route.score ?? parsed.score;
+      const list = map.get(method) ?? [];
+      list.push({ route, tokens, score });
+      map.set(method, list);
+    }
+    for (const list of map.values()) {
+      list.sort((a, b) => compareRouteScore(a.score, b.score));
+    }
+    compiledRoutes = map;
+    return compiledRoutes;
+  };
+  const handle = async (req) => {
+    const method = normalizeMethod(req.method) ?? "GET";
+    const map = await getRouteList();
+    const list = map.get(method);
+    if (!list || list.length === 0) {
+      return null;
+    }
+    for (const entry of list) {
+      const matched = matchRouteTokens(entry.tokens, req.path);
+      if (!matched) {
+        continue;
+      }
+      const requestWithParams = {
+        ...req,
+        params: matched.params
+      };
+      return executeRoute(
+        entry.route,
+        requestWithParams,
+        moduleCache,
+        middlewareCache,
+        options.moduleBase,
+        options.moduleMap
+      );
+    }
+    return null;
+  };
+  return {
+    handle
+  };
+}
+
+export { compareRouteScore, createRuntime, matchRouteTokens, normalizePathname, parseRouteTemplate, scoreRouteTokens };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mokup/runtime",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "Cross-runtime mock matching and response handling for mokup.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sonofmagic/mokup.git",
+    "directory": "packages/runtime"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.9.3",
+    "unbuild": "^3.6.1"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "unbuild --stub",
+    "lint": "eslint .",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}