@mug-lab/cookie-auth-proxy 0.1.0

package/src/runtime/index.js

@@ -0,0 +1,671 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { compileSafeRegex } = require("../regex");
+
+/**
+ * プロキシプロセスの実行時ルール状態を扱うモジュール。
+ *
+ * API履歴、Stub、JSON Override、条件マッチ、Import/Export正規化など、
+ * ローカルデバッグ中だけ変化するデータをここに集約する。
+ * ネットワーク転送と管理APIルーティングはserver配下に分けている。
+ */
+
+/**
+ * 設定ファイル上のルールと起動時Importフォルダから、メモリ上の実行時状態を作る。
+ *
+ * @param {object} config マージ済みプロキシ設定。
+ * @returns {object} config.runtimeへ保持する可変の実行時状態。
+ */
+function createRuntimeState(config) {
+  const startupStubs = readStartupStubImports(config);
+  const configuredStubs = Array.isArray(config.stubs) ? config.stubs : [];
+  const startupJsonOverrides = readStartupJsonOverrideImports(config);
+  const configuredJsonOverrides = Array.isArray(config.jsonOverrides)
+    ? config.jsonOverrides
+    : [];
+
+  return {
+    history: [],
+    nextHistoryId: 1,
+    stubsEnabled: config.stubsEnabled === true,
+    stubs: [...configuredStubs, ...startupStubs]
+      .map(normalizeStub)
+      .filter(Boolean),
+    jsonOverridesEnabled: config.jsonOverridesEnabled === true,
+    jsonOverrides: [...configuredJsonOverrides, ...startupJsonOverrides]
+      .map(normalizeJsonOverride)
+      .filter(Boolean),
+    nextStubId: 1,
+  };
+}
+
+/**
+ * 起動時Stubインポートフォルダからルールを読み込む。
+ */
+function readStartupStubImports(config) {
+  return readStartupRuleImports({
+    config,
+    directory: config.startupStubImportDir,
+    label: "stub",
+    arrayName: "stubs",
+    aliases: ["stubs"],
+  });
+}
+
+/**
+ * 起動時Overrideインポートフォルダからルールを読み込む。
+ */
+function readStartupJsonOverrideImports(config) {
+  return readStartupRuleImports({
+    config,
+    directory: config.startupOverrideImportDir,
+    label: "JSON override",
+    arrayName: "jsonOverrides",
+    aliases: ["jsonOverrides", "overrides"],
+  });
+}
+
+/**
+ * 起動時Importフォルダからルールファイルを読み込む。
+ * ファイル名順で処理するため、010-base.jsonのようなprefixで優先順位を制御できる。
+ *
+ * @param {object} options Importオプション。
+ * @param {object} options.config マージ済みプロキシ設定。
+ * @param {string} options.directory process cwdから見たImportフォルダパス。
+ * @param {string} options.label ログ表示用のルール種別。
+ * @param {string} options.arrayName オブジェクト形式ファイルで期待する配列名。
+ * @param {string[]} options.aliases 受け付ける配列プロパティ名。
+ * @returns {object[]} runtime用IDを除いたImport済みルール。
+ */
+function readStartupRuleImports({
+  config,
+  directory,
+  label,
+  arrayName,
+  aliases,
+}) {
+  if (!directory) return [];
+
+  const importDir = path.resolve(process.cwd(), directory);
+  let entries;
+  try {
+    entries = fs.readdirSync(importDir, { withFileTypes: true });
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      runtimeLog(
+        config,
+        "error",
+        `Startup ${label} import directory is not readable: ${importDir}`,
+        error.message,
+      );
+    }
+    return [];
+  }
+
+  const files = entries
+    .filter(
+      (entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".json"),
+    )
+    .map((entry) => path.join(importDir, entry.name))
+    .sort((a, b) => a.localeCompare(b));
+
+  const rules = [];
+  for (const filePath of files) {
+    try {
+      const body = readJsonFile(filePath);
+      const imported = Array.isArray(body)
+        ? body
+        : aliases.map((alias) => body[alias]).find(Array.isArray);
+      if (!Array.isArray(imported)) {
+        runtimeLog(
+          config,
+          "error",
+          `Skipped startup ${label} import without ${arrayName} array: ${filePath}`,
+        );
+        continue;
+      }
+
+      rules.push(...imported.map((rule) => ({ ...rule, id: undefined })));
+      runtimeLog(
+        config,
+        "info",
+        `Loaded startup ${label}s: ${filePath} (${imported.length})`,
+      );
+    } catch (error) {
+      runtimeLog(
+        config,
+        "error",
+        `Failed to load startup ${label}s: ${filePath}`,
+        error.message,
+      );
+    }
+  }
+
+  return rules;
+}
+
+/**
+ * BOMを除去してJSONファイルを読み込む。
+ */
+function readJsonFile(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8").replace(/^\uFEFF/, ""));
+}
+
+/**
+ * 入力されたStub風オブジェクトを内部ルール形式へ正規化する。
+ *
+ * @param {object} stub ユーザー入力またはImportされたStub定義。
+ * @returns {object|null} 正規化済みStub。不正な入力ならnull。
+ */
+function normalizeStub(stub) {
+  if (!stub || typeof stub !== "object") return null;
+
+  const method = normalizeMethod(stub.method, "stub.method");
+  const pathPattern = String(stub.pathPattern || stub.path || "^/api(?:/|$)");
+  const queryParams = isPlainObject(stub.queryParams) ? stub.queryParams : {};
+  const requestBody = isPlainObject(stub.requestBody) ? stub.requestBody : {};
+  validateRulePatterns("stub", {
+    pathPattern,
+    queryParams,
+    requestBody,
+  });
+
+  const bodyEncoding = normalizeBodyEncoding(stub);
+  const headers =
+    stub.headers && typeof stub.headers === "object"
+      ? stub.headers
+      : { "content-type": "application/json; charset=utf-8" };
+
+  return {
+    id: createId(),
+    name: String(stub.name || "Untitled stub"),
+    enabled: stub.enabled !== false,
+    method,
+    pathPattern,
+    queryParams,
+    requestBody,
+    status: Number(stub.status || 200),
+    headers,
+    bodyEncoding,
+    body:
+      bodyEncoding === "base64"
+        ? ""
+        : normalizeTextStubBody(stub.body, bodyEncoding),
+    bodyBase64:
+      bodyEncoding === "base64"
+        ? String(
+            stub.bodyBase64 === undefined ? stub.body || "" : stub.bodyBase64,
+          )
+        : "",
+  };
+}
+
+/**
+ * Stub本文をHTTPレスポンス本文として扱う文字列へ正規化する。
+ * JSON Body Typeの本文は起動時Import/API更新時にも検証する。
+ */
+function normalizeTextStubBody(body, bodyEncoding) {
+  const text =
+    body === undefined
+      ? "{}"
+      : typeof body === "string"
+        ? body
+        : JSON.stringify(body, null, 2);
+
+  if (bodyEncoding !== "json") return text;
+
+  try {
+    return JSON.stringify(JSON.parse(text), null, 2);
+  } catch (parseError) {
+    const error = new Error(
+      `stub.body: invalid JSON body (${parseError.message})`,
+    );
+    error.statusCode = 400;
+    throw error;
+  }
+}
+
+/**
+ * Stub本文種別を内部表現へ正規化する。
+ */
+function normalizeBodyEncoding(stub) {
+  if (stub.bodyEncoding === "base64") return "base64";
+  if (stub.bodyEncoding === "text") return "text";
+  if (stub.bodyEncoding === "json") return "json";
+  if (stub.bodyBase64) return "base64";
+  return "json";
+}
+
+/**
+ * 内部Stubを共有しやすいExportファイル形式へ変換する。
+ * runtime専用IDは除外し、JSONテキスト本文は素のJSON値として出力する。
+ *
+ * @param {object} stub 内部形式のStub。
+ * @returns {object} Export可能なStub。
+ */
+function exportStub(stub) {
+  const { id, ...exported } = stub;
+  if (exported.bodyEncoding !== "json") return exported;
+
+  try {
+    const body = JSON.parse(exported.body);
+    if (isPlainObject(body) || Array.isArray(body)) {
+      return { ...exported, body };
+    }
+  } catch {
+    // Non-JSON text bodies stay as strings in the export file.
+  }
+
+  return exported;
+}
+
+/**
+ * 内部IDを除外したOverrideのExport用オブジェクトを作る。
+ */
+function exportJsonOverride(override) {
+  const { id, ...exported } = override;
+  return exported;
+}
+
+/**
+ * 画面操作中のルール識別に使う短いランダムIDを作る。
+ */
+function createId() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+/**
+ * 入力されたJSON Override風オブジェクトを内部ルール形式へ正規化する。
+ *
+ * @param {object} override ユーザー入力またはImportされたOverride定義。
+ * @returns {object|null} 正規化済みOverride。不正な入力ならnull。
+ */
+function normalizeJsonOverride(override) {
+  if (!override || typeof override !== "object") return null;
+
+  const method = normalizeMethod(override.method, "JSON override.method");
+  const pathPattern = String(
+    override.pathPattern || override.path || "^/api(?:/|$)",
+  );
+  const queryParams = isPlainObject(override.queryParams)
+    ? override.queryParams
+    : {};
+  const requestBody = isPlainObject(override.requestBody)
+    ? override.requestBody
+    : {};
+  validateRulePatterns("JSON override", {
+    pathPattern,
+    queryParams,
+    requestBody,
+  });
+  const value = override.value === undefined ? {} : override.value;
+  if (!isPlainObject(value)) {
+    const error = new Error("JSON override.value: object JSON is required.");
+    error.statusCode = 400;
+    throw error;
+  }
+
+  return {
+    id: createId(),
+    name: String(override.name || "Untitled override"),
+    enabled: override.enabled !== false,
+    method,
+    pathPattern,
+    queryParams,
+    requestBody,
+    value,
+  };
+}
+
+/**
+ * HTTPメソッドを許可リストで検証して正規化する。
+ */
+function normalizeMethod(method, label) {
+  const normalized = String(method || "GET").toUpperCase();
+  const allowed = ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "*"];
+  if (!allowed.includes(normalized)) {
+    const error = new Error(`${label}: unsupported HTTP method.`);
+    error.statusCode = 400;
+    throw error;
+  }
+
+  return normalized;
+}
+
+/**
+ * リクエスト条件に一致する最初の有効なStubを探す。
+ */
+function findStub(config, method, requestMatch) {
+  if (!config.runtime.stubsEnabled) return null;
+
+  return config.runtime.stubs.find((stub) => {
+    if (!stub.enabled) return false;
+    if (stub.method !== "*" && stub.method !== method.toUpperCase())
+      return false;
+
+    try {
+      return (
+        matchesPathPattern(stub.pathPattern, requestMatch.pathname) &&
+        matchesObjectSubset(requestMatch.queryParams, stub.queryParams) &&
+        matchesObjectSubset(requestMatch.requestBody, stub.requestBody)
+      );
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * リクエスト条件に一致する有効なJSON Overrideを優先順で抽出する。
+ */
+function findJsonOverrides(config, method, requestMatch) {
+  if (!config.runtime.jsonOverridesEnabled) return [];
+
+  return config.runtime.jsonOverrides.filter((override) => {
+    if (!override.enabled) return false;
+    if (override.method !== "*" && override.method !== method.toUpperCase())
+      return false;
+
+    try {
+      return (
+        matchesPathPattern(override.pathPattern, requestMatch.pathname) &&
+        matchesObjectSubset(requestMatch.queryParams, override.queryParams) &&
+        matchesObjectSubset(requestMatch.requestBody, override.requestBody)
+      );
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * リクエストパスがルールのパス正規表現に一致するか判定する。
+ */
+function matchesPathPattern(pathPattern, pathname) {
+  return compileSafeRegex(pathPattern, "pathPattern").test(pathname);
+}
+
+/**
+ * 期待オブジェクトの指定項目が実データに一致するか判定する。
+ */
+function matchesObjectSubset(actual, expected) {
+  if (!isPlainObject(expected) || Object.keys(expected).length === 0)
+    return true;
+  if (!isPlainObject(actual)) return false;
+
+  return Object.entries(expected).every(([key, expectedValue]) =>
+    matchesValue(actual[key], expectedValue),
+  );
+}
+
+/**
+ * ルール値を正規表現または文字列として実値と比較する。
+ */
+function matchesValue(actualValue, expectedValue) {
+  if (isPlainObject(expectedValue)) {
+    return matchesObjectSubset(actualValue, expectedValue);
+  }
+
+  if (Array.isArray(expectedValue)) {
+    const actualValues = Array.isArray(actualValue)
+      ? actualValue
+      : [actualValue];
+    return expectedValue.every((value) =>
+      actualValues.some((actual) => matchesValue(actual, value)),
+    );
+  }
+
+  if (expectedValue === null)
+    return actualValue === null || actualValue === undefined;
+  if (actualValue === undefined) return false;
+  const actualValues = Array.isArray(actualValue) ? actualValue : [actualValue];
+  try {
+    const pattern = compileSafeRegex(String(expectedValue), "value pattern");
+    return actualValues.some((actual) => pattern.test(String(actual)));
+  } catch {
+    return actualValues.some(
+      (actual) => String(actual) === String(expectedValue),
+    );
+  }
+}
+
+/**
+ * Stub/Overrideの条件正規表現を登録前に検査する。
+ */
+function validateRulePatterns(label, rule) {
+  compileSafeRegex(rule.pathPattern, `${label}.pathPattern`);
+  validateRegexObject(`${label}.queryParams`, rule.queryParams);
+  validateRegexObject(`${label}.requestBody`, rule.requestBody);
+}
+
+/**
+ * オブジェクト内の正規表現条件を再帰的に検査する。
+ */
+function validateRegexObject(label, value) {
+  if (!isPlainObject(value)) return;
+
+  Object.entries(value).forEach(([key, entry]) => {
+    const entryLabel = `${label}.${key}`;
+    if (Array.isArray(entry)) {
+      entry.forEach((item, index) => validateRegexValue(`${entryLabel}[${index}]`, item));
+      return;
+    }
+
+    validateRegexValue(entryLabel, entry);
+  });
+}
+
+/**
+ * 条件値として使われる正規表現文字列を検査する。
+ */
+function validateRegexValue(label, value) {
+  if (value === null || value === undefined) return;
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => validateRegexValue(`${label}[${index}]`, item));
+    return;
+  }
+
+  compileSafeRegex(String(value), label);
+}
+
+/**
+ * API通信履歴へ1件追加し、上限件数を超えた古い履歴を破棄する。
+ */
+function addHistory(config, entry) {
+  const item = {
+    id: config.runtime.nextHistoryId,
+    at: new Date().toISOString(),
+    ...entry,
+  };
+
+  config.runtime.nextHistoryId += 1;
+  config.runtime.history.push(item);
+  if (config.runtime.history.length > config.historyLimit) {
+    config.runtime.history.splice(
+      0,
+      config.runtime.history.length - config.historyLimit,
+    );
+  }
+}
+
+/**
+ * trimBodyを実行する。
+ */
+function trimBody(value) {
+  return Buffer.isBuffer(value) ? value.toString("utf8") : String(value || "");
+}
+
+/**
+ * Stub本文をレスポンス送信用Bufferへ変換する。
+ */
+function stubBodyBuffer(stub) {
+  return stub.bodyEncoding === "base64"
+    ? Buffer.from(stub.bodyBase64 || "", "base64")
+    : Buffer.from(stub.body || "", "utf8");
+}
+
+/**
+ * レスポンスBufferを履歴保存用の本文情報へ変換する。
+ */
+function historyBodyFromBuffer(buffer, encoding, maxBytes = Infinity) {
+  const truncated = Number.isFinite(maxBytes) && buffer.length > maxBytes;
+  const storedBuffer = truncated ? buffer.subarray(buffer.length - maxBytes) : buffer;
+  return historyBodyFromStoredBuffer(storedBuffer, buffer.length, encoding);
+}
+
+/**
+ * すでに上限内へ切り詰めたレスポンスBufferを履歴保存用の本文情報へ変換する。
+ */
+function historyBodyFromStoredBuffer(storedBuffer, totalBytes, encoding) {
+  const truncated = storedBuffer.length < totalBytes;
+
+  if (encoding === "base64") {
+    return {
+      responseBodyEncoding: "base64",
+      responseBody: "",
+      responseBodyBase64: storedBuffer.toString("base64"),
+      responseBodySize: totalBytes,
+      responseBodyStoredSize: storedBuffer.length,
+      responseBodyTruncated: truncated,
+    };
+  }
+
+  return {
+    responseBodyEncoding: "text",
+    responseBody: trimBody(storedBuffer),
+    responseBodyBase64: "",
+    responseBodySize: totalBytes,
+    responseBodyStoredSize: storedBuffer.length,
+    responseBodyTruncated: truncated,
+  };
+}
+
+/**
+ * 一致したJSON Override値をAPIのJSONレスポンス本文へ適用する。
+ *
+ * @param {Buffer} buffer レスポンス本文。
+ * @param {object[]} overrides 優先順に並んだ一致済みOverrideルール。
+ * @returns {{body: Buffer, appliedOverrideIds: string[]}} 書き換え後本文と適用ルールID。
+ */
+function applyJsonOverrides(buffer, overrides) {
+  if (overrides.length === 0) {
+    return { body: buffer, appliedOverrideIds: [] };
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(buffer.toString("utf8"));
+  } catch {
+    return { body: buffer, appliedOverrideIds: [] };
+  }
+
+  if (!isPlainObject(parsed)) {
+    return { body: buffer, appliedOverrideIds: [] };
+  }
+
+  for (const override of overrides) {
+    deepMerge(parsed, override.value);
+  }
+
+  return {
+    body: Buffer.from(JSON.stringify(parsed), "utf8"),
+    appliedOverrideIds: overrides.map((override) => override.id),
+  };
+}
+
+/**
+ * Override値を既存レスポンスJSONへ再帰的にマージする。
+ */
+function deepMerge(target, source) {
+  if (!isPlainObject(source)) return target;
+
+  for (const [key, value] of Object.entries(source)) {
+    if (isPlainObject(value) && isPlainObject(target[key])) {
+      deepMerge(target[key], value);
+    } else {
+      target[key] = value;
+    }
+  }
+
+  return target;
+}
+
+/**
+ * 配列ではない通常オブジェクトか判定する。
+ */
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * URLSearchParamsを重複キー対応のプレーンオブジェクトへ変換する。
+ */
+function queryParamsObject(searchParams) {
+  const params = {};
+  for (const [key, value] of searchParams.entries()) {
+    if (Object.prototype.hasOwnProperty.call(params, key)) {
+      params[key] = Array.isArray(params[key])
+        ? [...params[key], value]
+        : [params[key], value];
+    } else {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+
+/**
+ * JSONまたはフォーム形式のリクエストBodyを条件判定用オブジェクトへ変換する。
+ */
+function parseRequestBody(headers, body) {
+  if (!body || body.length === 0) return {};
+
+  const contentType = String(headers["content-type"] || "").toLowerCase();
+  const text = body.toString("utf8");
+
+  if (
+    contentType.includes("application/json") ||
+    /^[\s\r\n]*[\[{]/.test(text)
+  ) {
+    try {
+      const parsed = JSON.parse(text);
+      return isPlainObject(parsed) ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    return queryParamsObject(new URLSearchParams(text));
+  }
+
+  return {};
+}
+
+/**
+ * runtimeモジュール内の起動時読み込みログを出力する。
+ */
+function runtimeLog(config, level, ...parts) {
+  const rank = { silent: 0, error: 1, info: 2, debug: 3 };
+  if ((rank[config.logLevel] || rank.info) < rank[level]) return;
+
+  const stream = level === "error" ? console.error : console.log;
+  stream(`[${new Date().toISOString()}]`, ...parts);
+}
+
+module.exports = {
+  addHistory,
+  applyJsonOverrides,
+  createRuntimeState,
+  exportJsonOverride,
+  exportStub,
+  findJsonOverrides,
+  findStub,
+  historyBodyFromBuffer,
+  historyBodyFromStoredBuffer,
+  normalizeJsonOverride,
+  normalizeStub,
+  parseRequestBody,
+  queryParamsObject,
+  stubBodyBuffer,
+};