@mokup/runtime 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,590 @@
+'use strict';
+
+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
+  };
+}
+
+exports.compareRouteScore = compareRouteScore;
+exports.createRuntime = createRuntime;
+exports.matchRouteTokens = matchRouteTokens;
+exports.normalizePathname = normalizePathname;
+exports.parseRouteTemplate = parseRouteTemplate;
+exports.scoreRouteTokens = scoreRouteTokens;

package/dist/index.d.cts

@@ -0,0 +1,102 @@
+type RouteToken = {
+    type: 'static';
+    value: string;
+} | {
+    type: 'param';
+    name: string;
+} | {
+    type: 'catchall';
+    name: string;
+} | {
+    type: 'optional-catchall';
+    name: string;
+};
+interface ParsedRouteTemplate {
+    template: string;
+    tokens: RouteToken[];
+    score: number[];
+    errors: string[];
+    warnings: string[];
+}
+declare function scoreRouteTokens(tokens: RouteToken[]): (4 | 3 | 2 | 1 | 0)[];
+declare function compareRouteScore(a: number[], b: number[]): number;
+declare function normalizePathname(value: string): string;
+declare function parseRouteTemplate(template: string): ParsedRouteTemplate;
+declare function matchRouteTokens(tokens: RouteToken[], pathname: string): {
+    params: Record<string, string | string[]>;
+} | null;
+
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';
+interface Manifest {
+    version: 1;
+    routes: ManifestRoute[];
+}
+interface ManifestRoute {
+    method: HttpMethod;
+    url: string;
+    tokens?: RouteToken[];
+    score?: number[];
+    source?: string;
+    status?: number;
+    headers?: Record<string, string>;
+    delay?: number;
+    middleware?: ManifestModuleRef[];
+    response: ManifestResponse;
+}
+interface ManifestModuleRef {
+    module: string;
+    exportName?: string;
+    ruleIndex?: number;
+}
+type ManifestResponse = {
+    type: 'json';
+    body: unknown;
+} | {
+    type: 'text';
+    body: string;
+} | {
+    type: 'binary';
+    body: string;
+    encoding: 'base64';
+} | ({
+    type: 'module';
+} & ManifestModuleRef);
+interface RuntimeRequest {
+    method: string;
+    path: string;
+    query: Record<string, string | string[]>;
+    headers: Record<string, string>;
+    body: unknown;
+    rawBody?: string;
+    params?: Record<string, string | string[]>;
+}
+interface RuntimeResult {
+    status: number;
+    headers: Record<string, string>;
+    body: string | Uint8Array | null;
+}
+interface MockContext {
+    delay: (ms: number) => Promise<void>;
+    json: <T>(data: T) => T;
+}
+interface MockResponder {
+    statusCode: number;
+    setHeader: (key: string, value: string) => void;
+    getHeader: (key: string) => string | undefined;
+    removeHeader: (key: string) => void;
+}
+type MockMiddleware = (req: RuntimeRequest, res: MockResponder, ctx: MockContext, next: () => Promise<unknown>) => unknown | Promise<unknown>;
+type MockResponseHandler = (req: RuntimeRequest, res: MockResponder, ctx: MockContext) => unknown | Promise<unknown>;
+interface RuntimeOptions {
+    manifest: Manifest | (() => Promise<Manifest>);
+    moduleBase?: string | URL;
+    moduleMap?: ModuleMap;
+}
+type ModuleMap = Record<string, Record<string, unknown>>;
+
+declare function createRuntime(options: RuntimeOptions): {
+    handle: (req: RuntimeRequest) => Promise<RuntimeResult | null>;
+};
+
+export { compareRouteScore, createRuntime, matchRouteTokens, normalizePathname, parseRouteTemplate, scoreRouteTokens };
+export type { HttpMethod, Manifest, ManifestModuleRef, ManifestResponse, ManifestRoute, MockContext, MockMiddleware, MockResponder, MockResponseHandler, ModuleMap, ParsedRouteTemplate, RouteToken, RuntimeOptions, RuntimeRequest, RuntimeResult };