callman-mcp 0.7.1 → 0.8.0

package/dist-cjs/tools/mockShared.js

@@ -0,0 +1,414 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logView = exports.resolveLocalMock = exports.localCalls = exports.localMockView = exports.localRouteView = exports.localBaseUrl = exports.toLocalRoute = exports.LOCAL_DELAY_MAX_MS = exports.LOCAL_BODY_MAX_BYTES = exports.resolveRoute = exports.findMock = exports.resolveMock = exports.loadMocks = exports.requireTarget = exports.targetArg = exports.mockRefArg = exports.curlLine = exports.sampleRoutePath = exports.mockDetailView = exports.routesView = exports.routeView = exports.alternativeUrl = exports.mockSummaryView = exports.mockListView = exports.duplicateRoutes = exports.toServerRoutePatch = exports.toServerRoute = exports.assertRoutePath = exports.mockRoutePatchSchema = exports.mockRouteInputSchema = exports.mockResponseSchema = exports.MOCK_METHODS = void 0;
+const zod_1 = require("zod");
+const errors_js_1 = require("../client/errors.js");
+const resolve_js_1 = require("../domain/resolve.js");
+const ids_js_1 = require("../lib/ids.js");
+const strict_js_1 = require("../lib/strict.js");
+const truncate_js_1 = require("../lib/truncate.js");
+const lookups_js_1 = require("./lookups.js");
+const shared_js_1 = require("./shared.js");
+// Shared by the mock tools: the route input schema (typed, but the backend
+// stays the validator), conversion to the server's route body, the shape of a
+// mock as the model reads it, reference resolution (mock by name / slug / id,
+// route by id / "METHOD /path" / name) and the ready-to-run curl lines.
+exports.MOCK_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "ANY"];
+const strictObject = (shape, where) => zod_1.z.object(shape, { errorMap: (0, strict_js_1.unknownKeysErrorMap)("field", Object.keys(shape), where) }).strict();
+const statusCode = zod_1.z.coerce.number().int().min(100).max(599);
+const headersSchema = zod_1.z.record(zod_1.z.string().max(8192));
+// ── route input ─────────────────────────────────────────────────────────
+const delaySchema = zod_1.z.discriminatedUnion("mode", [
+    strictObject({ mode: zod_1.z.literal("none") }, "delay"),
+    strictObject({ mode: zod_1.z.literal("fixed"), ms: zod_1.z.number().int().min(0).max(60_000) }, "delay"),
+    strictObject({ mode: zod_1.z.literal("random"), minMs: zod_1.z.number().int().min(0).max(60_000), maxMs: zod_1.z.number().int().min(0).max(60_000) }, "delay"),
+]);
+const staticOrTemplateResponse = (type) => strictObject({
+    type: zod_1.z.literal(type),
+    statusCode,
+    headers: headersSchema.optional(),
+    body: zod_1.z.unknown().optional().describe(type === "template" ? 'JSON value; every string may contain {{request.params.id}}, {{request.query.x}}, {{request.body.x}}, {{state.key}}, {{faker.email}}, {{random.int(1,9)}}, {{now}} …' : "Any JSON value (object, array, string, number, null). Omit for an empty body."),
+}, `${type} response`);
+const builderResponse = strictObject({
+    type: zod_1.z.literal("builder"),
+    preset: zod_1.z.enum(["list", "detail", "create", "update", "delete", "echo", "custom"]),
+    config: zod_1.z.record(zod_1.z.unknown()).describe("The preset's config; config.preset must equal preset. See callman://docs/mocks"),
+}, "builder response");
+exports.mockResponseSchema = zod_1.z.discriminatedUnion("type", [staticOrTemplateResponse("static"), staticOrTemplateResponse("template"), builderResponse]);
+const variantSchema = strictObject({
+    variantId: zod_1.z.string().max(64).optional(),
+    priority: zod_1.z.number().int().min(0).max(10_000).describe("Lower runs first; the first matching variant wins"),
+    condition: strictObject({
+        type: zod_1.z.enum(["all", "any"]),
+        rules: zod_1.z
+            .array(strictObject({
+            field: zod_1.z.string().min(1).max(200).describe("headers.<name>, params.<name>, query.<name> or body.<dotted.path>"),
+            operator: zod_1.z.enum(["exists", "not-exists", "equals", "not-equals", "contains", "starts-with", "matches"]),
+            value: zod_1.z.string().max(2000).optional(),
+        }, "condition rule"))
+            .min(1)
+            .max(20),
+    }, "condition"),
+    response: exports.mockResponseSchema,
+}, "variant");
+const requestValidationSchema = strictObject({ mode: zod_1.z.enum(["any", "schema"]), schema: zod_1.z.unknown().optional().describe("JSON Schema (draft-07) the request body must match when mode is schema; a mismatch answers 400") }, "requestValidation");
+const routeShape = {
+    method: zod_1.z.enum(exports.MOCK_METHODS),
+    path: zod_1.z.string().min(1).max(256).describe("Starts with /; :name segments are path parameters, a trailing /* is a catch-all. Example: /api/users/:id"),
+    name: zod_1.z.string().max(120).optional(),
+    response: exports.mockResponseSchema.optional().describe("The response. Shorthand instead: statusCode / headers / body (a static response)"),
+    statusCode: statusCode.optional().describe("Shorthand for a static response (default 200)"),
+    headers: headersSchema.optional().describe("Shorthand: static response headers"),
+    body: zod_1.z.unknown().optional().describe("Shorthand: static response body (any JSON value; on target desktop a string is sent as is and anything else as formatted JSON)"),
+    variants: zod_1.z.array(variantSchema).max(20).optional().describe("Server mocks only: other responses chosen by a condition on the request"),
+    delay: delaySchema.optional().describe("Wait before answering (server: ≤ 60 s, desktop: ≤ 30 s)"),
+    requestValidation: requestValidationSchema.nullish().describe("Server mocks only: validate the request body against a JSON Schema"),
+};
+exports.mockRouteInputSchema = strictObject(routeShape, "route").describe("One mock route");
+exports.mockRoutePatchSchema = exports.mockRouteInputSchema.partial().describe("The fields to change; the rest of the route is kept");
+// ── path / response validation (early, readable errors) ────────────────
+const PATH_PATTERN = /^\/[A-Za-z0-9/_\-:*.]*$/;
+const assertRoutePath = (path, where) => {
+    const problem = !PATH_PATTERN.test(path)
+        ? "must start with / and use only letters, digits and / _ - : * ."
+        : path.includes("..")
+            ? "may not contain '..'"
+            : path.split("/").some((segment) => segment.startsWith(":") && !/^:[A-Za-z_][A-Za-z0-9_]*$/.test(segment))
+                ? "path parameters are :name with letters, digits or underscore (e.g. :userId)"
+                : null;
+    if (problem)
+        throw new errors_js_1.ToolInputError("MOCK_ROUTE_PATH_INVALID", `${where}: path "${path}" ${problem}.`, { path });
+};
+exports.assertRoutePath = assertRoutePath;
+const SHORTHAND = ["statusCode", "headers", "body"];
+const hasShorthand = (route) => SHORTHAND.some((key) => route[key] !== undefined);
+// A route as the server's createRouteSchema takes it.
+const toServerRoute = (input, where) => {
+    (0, exports.assertRoutePath)(input.path, where);
+    if (input.response && hasShorthand(input)) {
+        throw new errors_js_1.ToolInputError("MOCK_ROUTE_RESPONSE_CONFLICT", `${where}: give either \`response\` or the shorthand statusCode / headers / body, not both.`);
+    }
+    const response = input.response ?? { type: "static", statusCode: input.statusCode ?? 200, headers: input.headers ?? {}, ...(input.body !== undefined ? { body: input.body } : {}) };
+    return {
+        method: input.method,
+        path: input.path,
+        ...(input.name ? { name: input.name } : {}),
+        response,
+        ...(input.variants ? { variants: input.variants } : {}),
+        behavior: { delay: input.delay ?? { mode: "none" } },
+        ...(input.requestValidation ? { requestValidation: input.requestValidation } : {}),
+    };
+};
+exports.toServerRoute = toServerRoute;
+// A patch as the server's updateRouteSchema takes it. Shorthand fields are
+// merged over the route's current static/template response so that
+// `{ statusCode: 404 }` alone keeps the body.
+const toServerRoutePatch = (patch, current, where) => {
+    if (patch.path !== undefined)
+        (0, exports.assertRoutePath)(patch.path, where);
+    if (patch.response && hasShorthand(patch)) {
+        throw new errors_js_1.ToolInputError("MOCK_ROUTE_RESPONSE_CONFLICT", `${where}: give either \`response\` or the shorthand statusCode / headers / body, not both.`);
+    }
+    const body = {};
+    if (patch.method !== undefined)
+        body.method = patch.method;
+    if (patch.path !== undefined)
+        body.path = patch.path;
+    if (patch.name !== undefined)
+        body.name = patch.name;
+    if (patch.response)
+        body.response = patch.response;
+    else if (hasShorthand(patch)) {
+        const base = current.response.type === "static" || current.response.type === "template" ? current.response : { type: "static", statusCode: 200, headers: {} };
+        if (current.response.type === "builder") {
+            throw new errors_js_1.ToolInputError("MOCK_ROUTE_RESPONSE_CONFLICT", `${where}: this route uses a builder response; pass a complete \`response\` to replace it.`);
+        }
+        body.response = { ...base, ...(patch.statusCode !== undefined ? { statusCode: patch.statusCode } : {}), ...(patch.headers !== undefined ? { headers: patch.headers } : {}), ...(patch.body !== undefined ? { body: patch.body } : {}) };
+    }
+    if (patch.variants !== undefined)
+        body.variants = patch.variants;
+    if (patch.delay !== undefined)
+        body.behavior = { delay: patch.delay };
+    if (patch.requestValidation !== undefined)
+        body.requestValidation = patch.requestValidation ?? { mode: "any" };
+    if (Object.keys(body).length === 0)
+        throw new errors_js_1.ToolInputError("NOTHING_TO_UPDATE", `${where}: no field to change was given.`);
+    return body;
+};
+exports.toServerRoutePatch = toServerRoutePatch;
+const duplicateRoutes = (routes) => {
+    const seen = new Set();
+    const duplicates = [];
+    for (const route of routes) {
+        const key = `${route.method} ${route.path}`;
+        if (seen.has(key))
+            duplicates.push(key);
+        seen.add(key);
+    }
+    return duplicates;
+};
+exports.duplicateRoutes = duplicateRoutes;
+// ── views ───────────────────────────────────────────────────────────────
+// The summary rows of GET /api/mocks come without routes and state, so their
+// routeCount / stateSizeBytes are always 0 — a list shows neither (get_mock does).
+const mockListView = (mock) => ({
+    mockId: mock.mockId,
+    id: mock.id,
+    name: mock.name,
+    ...(mock.description ? { description: mock.description } : {}),
+    auth: mock.auth.type,
+    publicUrl: mock.publicUrl,
+    requestCount: mock.requestCount,
+    expiresAt: mock.expiresAt,
+    expired: Date.parse(mock.expiresAt) < Date.now(),
+    createdAt: mock.createdAt,
+});
+exports.mockListView = mockListView;
+const mockSummaryView = (mock) => ({
+    ...(0, exports.mockListView)(mock),
+    routeCount: mock.routeCount,
+    stateSizeBytes: mock.stateSizeBytes,
+});
+exports.mockSummaryView = mockSummaryView;
+// The server announces its own public address (MOCK_PUBLIC_BASE_URL); an
+// installation that left it at the default announces a host nobody can reach.
+// When it differs from the API address we were configured with, offer the
+// address that certainly answers from here.
+const alternativeUrl = (apiUrl, mock) => {
+    try {
+        if (new URL(mock.publicUrl).origin === new URL(apiUrl).origin)
+            return {};
+    }
+    catch {
+        return {};
+    }
+    return { alternativeUrl: `${apiUrl.replace(/\/+$/, "")}/mock/${mock.mockId}`, urlNote: "publicUrl is the address the server announces; if it does not answer from here, the same mock is served at alternativeUrl (the API address)." };
+};
+exports.alternativeUrl = alternativeUrl;
+const routeView = (route) => ({
+    routeId: route.routeId,
+    method: route.method,
+    path: route.path,
+    ...(route.name ? { name: route.name } : {}),
+    response: route.response,
+    ...(route.variants?.length ? { variants: route.variants } : {}),
+    delay: route.behavior?.delay ?? { mode: "none" },
+    ...(route.requestValidation ? { requestValidation: route.requestValidation } : {}),
+});
+exports.routeView = routeView;
+const routeBrief = (route) => ({
+    routeId: route.routeId,
+    method: route.method,
+    path: route.path,
+    ...(route.name ? { name: route.name } : {}),
+    responseType: route.response?.type,
+    ...(typeof route.response?.statusCode === "number" ? { statusCode: route.response.statusCode } : {}),
+    ...(route.variants?.length ? { variants: route.variants.length } : {}),
+});
+const ROUTES_INLINE_LIMIT = 128 * 1024;
+// Full routes while they fit, one line per route beyond that.
+const routesView = (routes) => {
+    const full = routes.map(exports.routeView);
+    if ((0, truncate_js_1.safeStringify)(full).length <= ROUTES_INLINE_LIMIT)
+        return { routes: full };
+    return { routes: routes.map(routeBrief), routesTruncated: true, routesNote: "Routes are shown without their response bodies (too large); read one with get_mock { route }… or change it with update_mock_route." };
+};
+exports.routesView = routesView;
+const mockDetailView = (mock, apiUrl, auth) => ({
+    ...(0, exports.mockSummaryView)(mock),
+    ...(0, exports.alternativeUrl)(apiUrl, mock),
+    auth,
+    limits: mock.limits,
+    ...(0, exports.routesView)(mock.routes ?? []),
+});
+exports.mockDetailView = mockDetailView;
+// ── curl ────────────────────────────────────────────────────────────────
+const shellQuote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
+const sampleValue = (schema) => {
+    const type = schema?.type;
+    switch (Array.isArray(type) ? type[0] : type) {
+        case "number":
+        case "integer":
+            return 1;
+        case "boolean":
+            return true;
+        case "array":
+            return [];
+        case "object":
+            return sampleObject(schema);
+        default:
+            return "example";
+    }
+};
+const sampleObject = (schema) => {
+    const properties = schema?.properties ?? {};
+    const required = schema?.required;
+    const keys = Array.isArray(required) ? required.filter((key) => typeof key === "string") : Object.keys(properties).slice(0, 5);
+    return Object.fromEntries(keys.map((key) => [key, sampleValue(properties[key])]));
+};
+// A request body that the route will accept: from its JSON Schema gate, or a
+// create builder's required fields; `{}` otherwise.
+const sampleBody = (route) => {
+    if (route.requestValidation?.mode === "schema")
+        return sampleObject(route.requestValidation.schema);
+    const config = route.response?.type === "builder" ? route.response.config : undefined;
+    if (config?.preset === "create" && Array.isArray(config.requiredFields))
+        return Object.fromEntries(config.requiredFields.map((field) => [String(field), "example"]));
+    return {};
+};
+const sampleRoutePath = (path) => path
+    .split("/")
+    .map((segment) => (segment.startsWith(":") ? "1" : segment === "*" || segment === "**" ? "example" : segment))
+    .join("/");
+exports.sampleRoutePath = sampleRoutePath;
+const curlLine = (baseUrl, route, token) => {
+    const method = route.method === "ANY" ? "GET" : route.method;
+    const parts = ["curl -sS", `-X ${method}`];
+    if (token !== undefined)
+        parts.push(`-H ${shellQuote(`X-Mock-Token: ${token ?? "<token>"}`)}`);
+    if (method === "POST" || method === "PUT" || method === "PATCH")
+        parts.push("-H 'Content-Type: application/json'", `-d ${shellQuote((0, truncate_js_1.safeStringify)(sampleBody(route)))}`);
+    parts.push(shellQuote(`${baseUrl.replace(/\/+$/, "")}${(0, exports.sampleRoutePath)(route.path)}`));
+    return parts.join(" ");
+};
+exports.curlLine = curlLine;
+const mockRefArg = (what) => (0, shared_js_1.refArg)(what, "(its name, slug or id)");
+exports.mockRefArg = mockRefArg;
+exports.targetArg = zod_1.z
+    .enum(["server", "desktop"])
+    .optional()
+    .describe('"server" (default): a mock on the Callman server with a public URL. "desktop": a local mock inside the user\'s Callman desktop app, reachable at http://127.0.0.1:<port> on their computer only (needs the app open with "Let AI tools manage local mock APIs on this computer" on).');
+// An argument that belongs to the other target is an error, not a silent no-op.
+const requireTarget = (target, args, only, hint) => {
+    const given = Object.entries(args).filter(([, value]) => value !== undefined).map(([key]) => key);
+    if (given.length > 0 && target !== only) {
+        throw new errors_js_1.ToolInputError("ARG_TARGET_MISMATCH", `${given.join(", ")} ${given.length === 1 ? "applies" : "apply"} to ${only} mocks only — ${hint}`, { target });
+    }
+};
+exports.requireTarget = requireTarget;
+const loadMocks = (ctx, ws) => ctx.cache.getOrSet(`mocks:${ws}`, () => ctx.api.listAllMocks(ws));
+exports.loadMocks = loadMocks;
+// `id` of a MockRef is the slug (mockId) — what every /api/mocks route takes.
+const resolveMock = async (ctx, ws, ref, options = {}) => {
+    const mocks = await (0, exports.loadMocks)(ctx, ws);
+    const items = mocks.map((summary) => ({ id: summary.mockId, name: summary.name, summary }));
+    return (0, resolve_js_1.resolveRef)("mock", ref, items, { aliases: (item) => [item.summary.id], describe: (item) => ({ publicUrl: item.summary.publicUrl }), ...options });
+};
+exports.resolveMock = resolveMock;
+const findMock = (ctx, workspace, ref, options = {}) => (0, lookups_js_1.findInWorkspaces)(ctx, workspace, "mock", ref, (ws) => (0, exports.resolveMock)(ctx, ws.id, ref, options), {
+    matchOf: (resolved) => resolved.matched,
+    describe: (resolved) => ({ mockId: resolved.item.id, name: resolved.item.name }),
+});
+exports.findMock = findMock;
+// A route of a mock: routeId, "METHOD /path", the path alone (when unique) or its name.
+const resolveRoute = (mock, ref) => {
+    const routes = mock.routes ?? [];
+    const reference = ref.trim();
+    const candidates = () => routes.slice(0, 20).map((route) => ({ routeId: route.routeId, method: route.method, path: route.path, ...(route.name ? { name: route.name } : {}) }));
+    const byId = routes.find((route) => route.routeId === reference);
+    if (byId)
+        return byId;
+    const combined = /^(GET|POST|PUT|DELETE|PATCH|ANY)\s+(\S+)$/i.exec(reference);
+    if (combined) {
+        const hit = routes.find((route) => route.method === combined[1].toUpperCase() && route.path === combined[2]);
+        if (hit)
+            return hit;
+    }
+    else {
+        const byPath = routes.filter((route) => route.path === reference);
+        if (byPath.length === 1)
+            return byPath[0];
+        if (byPath.length > 1)
+            throw new errors_js_1.ToolInputError("REF_AMBIGUOUS", `Several routes use the path "${reference}" — say "METHOD ${reference}" or pass the routeId.`, { kind: "route", ref: reference, candidates: byPath.map((route) => ({ routeId: route.routeId, method: route.method, path: route.path })) });
+        const byName = routes.filter((route) => route.name && (0, ids_js_1.normalizeName)(route.name) === (0, ids_js_1.normalizeName)(reference));
+        if (byName.length === 1)
+            return byName[0];
+    }
+    throw new errors_js_1.ToolInputError("REF_NOT_FOUND", `No route of mock "${mock.name}" matches "${reference}".`, { kind: "route", ref: reference, candidates: candidates() });
+};
+exports.resolveRoute = resolveRoute;
+// ── local mocks (the desktop app's own mock servers) ───────────────────
+exports.LOCAL_BODY_MAX_BYTES = 256 * 1024;
+exports.LOCAL_DELAY_MAX_MS = 30_000;
+const localUnsupported = (where, what) => new errors_js_1.ToolInputError("LOCAL_MOCK_FEATURE_UNSUPPORTED", `${where}: local mocks on the desktop answer with static responses only — ${what} is not available.`, {
+    hint: 'Use target: "server" for templates, builders, variants, request validation and state, or describe the response as a static one.',
+});
+// A route as the desktop's local mock manager stores it.
+const toLocalRoute = (input, where) => {
+    (0, exports.assertRoutePath)(input.path, where);
+    if (input.variants?.length)
+        throw localUnsupported(where, "variants");
+    if (input.requestValidation)
+        throw localUnsupported(where, "requestValidation");
+    if (input.response && hasShorthand(input)) {
+        throw new errors_js_1.ToolInputError("MOCK_ROUTE_RESPONSE_CONFLICT", `${where}: give either \`response\` or the shorthand statusCode / headers / body, not both.`);
+    }
+    if (input.response && input.response.type !== "static")
+        throw localUnsupported(where, `a ${input.response.type} response`);
+    const source = input.response ?? { statusCode: input.statusCode ?? 200, headers: input.headers, body: input.body };
+    const body = source.body === undefined || source.body === null ? "" : typeof source.body === "string" ? source.body : JSON.stringify(source.body, null, 2);
+    if (Buffer.byteLength(body, "utf8") > exports.LOCAL_BODY_MAX_BYTES) {
+        throw new errors_js_1.ToolInputError("LOCAL_MOCK_BODY_TOO_LARGE", `${where}: the response body is larger than ${exports.LOCAL_BODY_MAX_BYTES / 1024} KB, the limit of a local mock route.`);
+    }
+    const delay = input.delay ?? { mode: "none" };
+    if ((delay.mode === "fixed" && delay.ms > exports.LOCAL_DELAY_MAX_MS) || (delay.mode === "random" && (delay.maxMs > exports.LOCAL_DELAY_MAX_MS || delay.minMs > delay.maxMs))) {
+        throw new errors_js_1.ToolInputError("LOCAL_MOCK_DELAY_INVALID", `${where}: a local mock delay is at most ${exports.LOCAL_DELAY_MAX_MS / 1000} s (random: minMs ≤ maxMs).`);
+    }
+    return { method: input.method, path: input.path, ...(input.name ? { name: input.name } : {}), statusCode: source.statusCode, headers: source.headers ?? {}, body, delay };
+};
+exports.toLocalRoute = toLocalRoute;
+const localBaseUrl = (mock) => `http://127.0.0.1:${mock.port}`;
+exports.localBaseUrl = localBaseUrl;
+const localRouteView = (route) => ({
+    ...(route.routeId ? { routeId: route.routeId } : {}),
+    method: route.method,
+    path: route.path,
+    ...(route.name ? { name: route.name } : {}),
+    statusCode: route.statusCode,
+    headers: route.headers,
+    body: route.body,
+    delay: route.delay,
+});
+exports.localRouteView = localRouteView;
+const localMockView = (mock, options = { routes: true }) => {
+    const routes = (mock.routes ?? []).map(exports.localRouteView);
+    const inline = (0, truncate_js_1.safeStringify)(routes).length <= ROUTES_INLINE_LIMIT;
+    return {
+        id: mock.id,
+        name: mock.name,
+        port: mock.port,
+        running: mock.running,
+        baseUrl: (0, exports.localBaseUrl)(mock),
+        autoStart: mock.autoStart,
+        ...(mock.source ? { source: mock.source } : {}),
+        ...(mock.lastError ? { lastError: mock.lastError } : {}),
+        requestCount: mock.requestCount ?? 0,
+        routeCount: routes.length,
+        ...(options.routes
+            ? inline
+                ? { routes }
+                : { routes: routes.map(({ body: _body, headers: _headers, ...rest }) => rest), routesTruncated: true }
+            : {}),
+    };
+};
+exports.localMockView = localMockView;
+const localCalls = (mock) => (mock.routes ?? []).map((route) => ({ route: `${route.method} ${route.path}`, curl: (0, exports.curlLine)((0, exports.localBaseUrl)(mock), route, undefined) }));
+exports.localCalls = localCalls;
+const resolveLocalMock = (mocks, ref, options = {}) => (0, resolve_js_1.resolveRef)("local mock", ref, mocks.map((record) => ({ id: record.id, name: record.name, record })), { describe: (item) => ({ port: item.record.port, running: item.record.running }), ...options });
+exports.resolveLocalMock = resolveLocalMock;
+const logView = (entry) => ({
+    id: String(entry._id),
+    at: entry.createdAt,
+    method: entry.request?.method,
+    path: entry.request?.path,
+    ...(entry.request?.query && Object.keys(entry.request.query).length > 0 ? { query: entry.request.query } : {}),
+    ...(entry.request?.body !== undefined ? { requestBody: (0, truncate_js_1.jsonPreview)(entry.request.body, truncate_js_1.LIMITS.BODY_PREVIEW) } : {}),
+    statusCode: entry.response?.statusCode,
+    durationMs: entry.response?.durationMs,
+    ...(entry.response?.body !== undefined ? { responseBody: (0, truncate_js_1.jsonPreview)(entry.response.body, truncate_js_1.LIMITS.BODY_PREVIEW) } : {}),
+    matched: entry.matchInfo?.matched ?? false,
+    ...(entry.matchInfo?.matchedRouteId ? { routeId: entry.matchInfo.matchedRouteId } : {}),
+    ...(entry.matchInfo?.matchedVariantId ? { variantId: entry.matchInfo.matchedVariantId } : {}),
+    ...(entry.matchInfo?.failureReason ? { failureReason: entry.matchInfo.failureReason } : {}),
+});
+exports.logView = logView;