zudoku 0.0.0-fd8f8ad → 0.0.0-feda542

package/src/lib/plugins/openapi/playground/result-panel/ResponseTab.tsx

@@ -0,0 +1,230 @@
+import { useQuery } from "@tanstack/react-query";
+import { ChevronRightIcon } from "lucide-react";
+import { Fragment, useState } from "react";
+import { Callout } from "zudoku/ui/Callout.js";
+import {
+  Collapsible,
+  CollapsibleContent,
+  CollapsibleTrigger,
+} from "zudoku/ui/Collapsible.js";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "zudoku/ui/Select.js";
+import { Card } from "../../../../ui/Card.js";
+import { SyntaxHighlight } from "../../../../ui/SyntaxHighlight.js";
+import { convertToTypes } from "./convertToTypes.js";
+
+const statusCodeMap: Record<number, string> = {
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  500: "Internal Server Error",
+};
+
+const humanFileSize = (bytes: number) => {
+  const exponent = Math.floor(Math.log(bytes) / Math.log(1000.0));
+  const decimal = (bytes / Math.pow(1000.0, exponent)).toFixed(
+    exponent ? 2 : 0,
+  );
+  return `${decimal} ${exponent ? `${"kMGTPEZY"[exponent - 1]}B` : "B"}`;
+};
+
+const mimeTypeToLanguage = (mimeType: string) => {
+  const mimeTypeMapping = {
+    "application/json": "json",
+    "text/json": "json",
+    "text/html": "html",
+    "text/css": "css",
+    "text/javascript": "javascript",
+    "application/xml": "xml",
+    "application/xhtml+xml": "xhtml",
+  };
+
+  return Object.entries(mimeTypeMapping).find(([mime]) =>
+    mimeType.includes(mime),
+  )?.[1];
+};
+
+const detectLanguage = (headers: Array<[string, string]>) => {
+  const contentType =
+    headers.find(([key, value]) => key === "Content-Type")?.[1] || "";
+  return mimeTypeToLanguage(contentType);
+};
+
+const tryParseJson = (body: string) => {
+  try {
+    return JSON.stringify(JSON.parse(body), null, 2);
+  } catch {
+    return null;
+  }
+};
+
+const sortHeadersByRelevance = (
+  headers: Array<[string, string]>,
+): Array<[string, string]> => {
+  const priorityOrder = [
+    "Content-Type",
+    "Content-Length",
+    "Authorization",
+    "X-RateLimit-Remaining",
+    "X-RateLimit-Limit",
+    "Cache-Control",
+    "ETag",
+  ].map((key) => key.toLowerCase());
+
+  return [...headers].sort(([keyA], [keyB]) => {
+    const indexA = priorityOrder.indexOf(keyA.toLowerCase());
+    const indexB = priorityOrder.indexOf(keyB.toLowerCase());
+    if (indexA === indexB) return 0;
+    if (indexA === -1) return 1;
+    if (indexB === -1) return -1;
+    return indexA - indexB;
+  });
+};
+
+const SYNTAX_HIGHLIGHT_MAX_SIZE_THRESHOLD = 64_000;
+
+export const ResponseTab = ({
+  body = "",
+  headers,
+  status,
+  time,
+  size,
+  url,
+}: {
+  body?: string;
+  headers: Array<[string, string]>;
+  status: number;
+  time: number;
+  size: number;
+  url: string;
+}) => {
+  const detectedLanguage = detectLanguage(headers);
+  const jsonContent = tryParseJson(body);
+  const beautifiedBody = jsonContent || body;
+  const [view, setView] = useState<"formatted" | "raw" | "types">(
+    jsonContent ? "formatted" : "raw",
+  );
+
+  const types = useQuery({
+    queryKey: ["types", beautifiedBody],
+    queryFn: async () => {
+      return convertToTypes(JSON.parse(beautifiedBody));
+    },
+    enabled: view === "types",
+  });
+
+  const sortedHeaders = sortHeadersByRelevance([...headers]);
+  const shouldDisableHighlighting = size > SYNTAX_HIGHLIGHT_MAX_SIZE_THRESHOLD;
+
+  return (
+    <div className="flex flex-col gap-2 h-full overflow-auto max-h-[calc(100vh-220px)] ">
+      <Collapsible defaultOpen>
+        <CollapsibleTrigger className="flex items-center gap-2 hover:text-primary group">
+          <ChevronRightIcon className="h-4 w-4 transition-transform duration-200 group-data-[state=open]:rotate-[90deg]" />
+          <span className="font-semibold">Headers</span>
+        </CollapsibleTrigger>
+        <CollapsibleContent>
+          <div className="grid grid-cols-[auto,1fr] gap-x-8 gap-y-1 pl-1.5 pt-2 font-mono text-xs">
+            {sortedHeaders.slice(0, 5).map(([key, value]) => (
+              <Fragment key={key}>
+                <div className="text-primary whitespace-pre">{key}</div>
+                <div className="break-all">{value}</div>
+              </Fragment>
+            ))}
+            {sortedHeaders.length > 5 && (
+              <Collapsible className="col-span-full grid-cols-subgrid grid">
+                <CollapsibleTrigger className="col-span-2 text-xs text-muted-foreground hover:text-primary flex items-center gap-1 py-1">
+                  <ChevronRightIcon className="h-3 w-3 transition-transform duration-200 group-data-[state=open]:rotate-[90deg]" />
+                  Show {sortedHeaders.length - 5} more headers
+                </CollapsibleTrigger>
+                <CollapsibleContent className="col-span-full grid grid-cols-subgrid gap-x-8 gap-y-1 ">
+                  {sortedHeaders.slice(5).map(([key, value]) => (
+                    <Fragment key={key}>
+                      <div className="text-primary whitespace-pre">{key}</div>
+                      <div className="break-all">{value}</div>
+                    </Fragment>
+                  ))}
+                </CollapsibleContent>
+              </Collapsible>
+            )}
+          </div>
+        </CollapsibleContent>
+      </Collapsible>
+
+      <Card className="shadow-none">
+        {shouldDisableHighlighting && (
+          <Callout type="info" className="my-0 p-2">
+            Code highlight is disabled for responses larger than{" "}
+            {humanFileSize(SYNTAX_HIGHLIGHT_MAX_SIZE_THRESHOLD)}
+          </Callout>
+        )}
+        <SyntaxHighlight
+          language={
+            view === "types"
+              ? "typescript"
+              : view === "raw"
+                ? jsonContent
+                  ? "plain"
+                  : detectedLanguage
+                : "json"
+          }
+          showCopy="always"
+          disabled={shouldDisableHighlighting}
+          noBackground
+          className="overflow-x-auto p-4 text-xs max-h-[calc(83.333vh-180px)]"
+          code={
+            (view === "raw"
+              ? body
+              : view === "types"
+                ? types.data?.lines.join("\n")
+                : beautifiedBody) ?? ""
+          }
+        />
+      </Card>
+      <div className="flex gap-2 justify-between items-center">
+        <div className="flex text-xs gap-2 border bg-muted rounded-md p-2 items-center h-8 font-mono divide-x">
+          <div>
+            <span className="text-muted-foreground">Status</span> {status}{" "}
+            {statusCodeMap[status] ?? ""}
+          </div>
+          <div>
+            <span className="text-muted-foreground">Time</span>{" "}
+            {time.toFixed(0)}ms
+          </div>
+          <div>
+            <span className="text-muted-foreground">Size</span>{" "}
+            {humanFileSize(size)}
+          </div>
+        </div>
+        {jsonContent && (
+          <div>
+            <Select
+              value={view}
+              onValueChange={(value) => setView(value as "formatted" | "raw")}
+            >
+              <SelectTrigger className="min-w-32">
+                <SelectValue placeholder="View" />
+              </SelectTrigger>
+              <SelectContent>
+                <SelectItem value="formatted">Formatted</SelectItem>
+                <SelectItem value="raw">Raw</SelectItem>
+                <SelectItem value="types">Types</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+};

package/src/lib/plugins/openapi/playground/result-panel/ResultPanel.tsx

@@ -0,0 +1,123 @@
+import { type UseMutationResult } from "@tanstack/react-query";
+import { Spinner } from "../../../../components/Spinner.js";
+import { Button } from "../../../../ui/Button.js";
+import { Callout } from "../../../../ui/Callout.js";
+import {
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+} from "../../../../ui/Card.js";
+import {
+  Tabs,
+  TabsContent,
+  TabsList,
+  TabsTrigger,
+} from "../../../../ui/Tabs.js";
+import { cn } from "../../../../util/cn.js";
+import { type PlaygroundResult } from "../Playground.js";
+import { RequestTab } from "./RequestTab.js";
+import { ResponseTab } from "./ResponseTab.js";
+
+export const ResultPanel = ({
+  queryMutation,
+  showPathParamsWarning,
+  showLongRunningWarning,
+  onCancel,
+}: {
+  queryMutation: UseMutationResult<PlaygroundResult, Error, any>;
+  showPathParamsWarning: boolean;
+  showLongRunningWarning?: boolean;
+  onCancel?: () => void;
+}) => {
+  const status = ((queryMutation.data?.status ?? 0) / 100).toFixed(0);
+  return (
+    <div className="min-w-0 p-4 py-8 bg-muted/50">
+      {queryMutation.error ? (
+        <div className="flex flex-col gap-2">
+          {showPathParamsWarning && (
+            <Callout type="caution">
+              Some path parameters are missing values. Please fill them in to
+              ensure the request is sent correctly.
+            </Callout>
+          )}
+          <Card>
+            <CardHeader>
+              <CardTitle>Request failed</CardTitle>
+            </CardHeader>
+            <CardContent>
+              Error:{" "}
+              {queryMutation.error.message ||
+                String(queryMutation.error) ||
+                "Unexpected error"}
+            </CardContent>
+          </Card>
+        </div>
+      ) : queryMutation.data ? (
+        <Tabs defaultValue="response">
+          <TabsList>
+            <TabsTrigger value="request">Request</TabsTrigger>
+            <TabsTrigger value="response">
+              Response
+              <span
+                className={cn(
+                  "text-xs font-mono ml-1",
+                  status === "2" && "text-green-500",
+                  status === "3" && "text-blue-500",
+                  status === "4" && "text-yellow-500",
+                  status === "5" && "text-red-500",
+                )}
+              >
+                ({queryMutation.data.status})
+              </span>
+            </TabsTrigger>
+          </TabsList>
+          <TabsContent value="request">
+            <RequestTab {...queryMutation.data.request} />
+          </TabsContent>
+          <TabsContent value="response">
+            <ResponseTab
+              status={queryMutation.data.status}
+              time={queryMutation.data.time}
+              size={queryMutation.data.size}
+              headers={queryMutation.data.headers}
+              body={queryMutation.data.body}
+              url={queryMutation.data.request.url}
+            />
+          </TabsContent>
+        </Tabs>
+      ) : (
+        <div className="grid place-items-center h-full">
+          {queryMutation.isPending ? (
+            <div className="flex flex-col gap-2 items-center mt-20">
+              <Spinner size={20} />
+              <div
+                className={cn(
+                  "opacity-0 pointer-events-none transition-opacity h-20 text-sm text-muted-foreground duration-300 flex flex-col gap-2 items-center",
+                  showLongRunningWarning && "opacity-100 pointer-events-auto",
+                )}
+              >
+                Looks like the request is taking longer than expected.
+                <Button
+                  type="button"
+                  onClick={onCancel}
+                  size="sm"
+                  className="w-fit"
+                  variant="outline"
+                >
+                  Cancel
+                </Button>
+              </div>
+            </div>
+          ) : (
+            <span className="text-[16px] font-semibold text-muted-foreground">
+              Send a request first to see the response here
+            </span>
+          )}
+        </div>
+      )}
+    </div>
+  );
+};
+
+export default ResultPanel;

package/src/lib/plugins/openapi/playground/result-panel/convertToTypes.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+import { generateInterface } from "./convertToTypes.js";
+
+describe("generateInterface", () => {
+  it("should handle primitive types", () => {
+    const input = {
+      string: "hello",
+      number: 42,
+      boolean: true,
+      null: null,
+    };
+
+    const expected = [
+      "{",
+      "  string: string;",
+      "  number: number;",
+      "  boolean: boolean;",
+      "  null: null;",
+      "}",
+    ].join("\n");
+
+    expect(generateInterface(input)).toBe(expected);
+  });
+
+  it("should handle nested objects", () => {
+    const input = {
+      user: {
+        name: "John",
+        age: 30,
+      },
+    };
+
+    const expected = [
+      "{",
+      "  user: {",
+      "  name: string;",
+      "  age: number;",
+      "};",
+      "}",
+    ].join("\n");
+
+    expect(generateInterface(input)).toBe(expected);
+  });
+
+  it("should handle arrays", () => {
+    const input = {
+      numbers: [1, 2, 3],
+      empty: [],
+      objects: [{ id: 1 }],
+    };
+
+    const expected = [
+      "{",
+      "  numbers: number[];",
+      "  empty: any[];",
+      "  objects: {",
+      "  id: number;",
+      "}[];",
+      "}",
+    ].join("\n");
+
+    expect(generateInterface(input)).toBe(expected);
+  });
+});

package/src/lib/plugins/openapi/playground/result-panel/convertToTypes.ts

@@ -0,0 +1,36 @@
+type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+type JsonObject = { [key: string]: JsonValue };
+type JsonArray = JsonValue[];
+
+function inferType(value: JsonValue): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "any[]";
+    const firstValue = value[0];
+    if (firstValue === undefined) return "any[]";
+    const elementType = inferType(firstValue);
+    return `${elementType}[]`;
+  }
+  if (typeof value === "object") {
+    return generateInterface(value);
+  }
+  return typeof value;
+}
+
+export function generateInterface(obj: JsonObject, indentation = ""): string {
+  const lines: string[] = ["{"];
+
+  for (const [key, value] of Object.entries(obj)) {
+    const propertyType = inferType(value);
+    lines.push(`  ${key}: ${propertyType};`);
+  }
+
+  lines.push("}");
+  return lines.join("\n");
+}
+
+export function convertToTypes(json: JsonValue): { lines: string[] } {
+  const typeDefinition = inferType(json);
+  const lines = [`type GeneratedType = ${typeDefinition};`];
+  return { lines };
+}

package/src/lib/plugins/openapi/processors/removeExtensions.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, it } from "vitest";
+import { removeExtensions } from "./removeExtensions.js";
+
+const baseDoc = {
+  openapi: "3.1.0",
+  "x-root-ext": "remove me",
+  "x-zuplo-ext": "remove me too",
+  info: {
+    title: "Test API",
+    version: "1.0.0",
+    "x-info-ext": "remove me",
+    "x-zuplo-info": "remove me too",
+  },
+  paths: {
+    "/test": {
+      "x-path-ext": "remove me",
+      "x-zuplo-path": "remove me too",
+      parameters: [
+        {
+          name: "param1",
+          in: "query",
+          schema: { type: "string" },
+          "x-param-ext": "remove me",
+          "x-zuplo-param": "remove me too",
+        },
+      ],
+      get: {
+        "x-operation-ext": "remove me",
+        "x-zuplo-route": "remove me too",
+        responses: {
+          "200": {
+            description: "OK",
+            "x-response-ext": "remove me",
+            "x-zuplo-response": "remove me too",
+          },
+        },
+        parameters: [
+          {
+            name: "opParam1",
+            in: "header",
+            schema: { type: "string" },
+            "x-op-param-ext": "remove me",
+            "x-zuplo-param": "remove me too",
+          },
+        ],
+      },
+    },
+  },
+  tags: [
+    {
+      name: "example",
+      "x-tag-ext": "remove me",
+      "x-zuplo-tag": "remove me too",
+    },
+  ],
+  components: {
+    securitySchemes: {
+      ApiKeyAuth: {
+        type: "apiKey",
+        name: "api_key",
+        in: "header",
+        "x-security-ext": "remove me",
+        "x-zuplo-security": "remove me too",
+      },
+    },
+  },
+};
+
+describe("removeExtensions", () => {
+  it("removes all x- extensions by default", () => {
+    const processed = removeExtensions()(baseDoc);
+
+    const removedExtensions = [
+      "x-root-ext",
+      "info.x-info-ext",
+      "paths./test.x-path-ext",
+      "paths./test.parameters[0].x-param-ext",
+      "paths./test.get.x-operation-ext",
+      "paths./test.get.responses.200.x-response-ext",
+      "paths./test.get.parameters[0].x-op-param-ext",
+      "tags[0].x-tag-ext",
+      "components.securitySchemes.ApiKeyAuth.x-security-ext",
+    ];
+
+    removedExtensions.forEach((ext) => {
+      expect(processed).not.toHaveProperty(ext.split("."));
+    });
+
+    // Assert that non-x- fields remain unchanged
+    expect(processed.openapi).toBe("3.1.0");
+    expect(processed.info.title).toBe("Test API");
+    expect(processed).toHaveProperty(
+      ["paths", "/test", "get", "responses", "200", "description"],
+      "OK",
+    );
+    expect(processed.tags[0].name).toBe("example");
+  });
+
+  it("removes only specified x- extensions when names are provided", () => {
+    const docWithExtraExtensions = {
+      ...baseDoc,
+      info: { ...baseDoc.info, "x-other-ext": "keep me" },
+    };
+
+    const processed = removeExtensions({
+      keys: ["x-path-ext", "x-param-ext"],
+    })(docWithExtraExtensions);
+
+    // Assert specified extensions are removed
+    expect(processed.paths["/test"]["x-path-ext"]).toBeUndefined();
+    expect(
+      processed.paths["/test"].parameters[0]["x-param-ext"],
+    ).toBeUndefined();
+
+    // Assert other x- fields remain
+    expect(processed["x-root-ext"]).toBe("remove me");
+    expect(processed.info["x-info-ext"]).toBe("remove me");
+    expect(processed.info["x-other-ext"]).toBe("keep me");
+  });
+
+  it("handles deeply nested extensions", () => {
+    const deeplyNested = {
+      a: {
+        b: {
+          c: {
+            "x-deep-ext": "remove me",
+            d: {
+              e: "value",
+              "x-another-ext": "remove me",
+            },
+          },
+        },
+      },
+    };
+
+    const processed = removeExtensions()(deeplyNested);
+
+    expect(processed.a.b.c["x-deep-ext"]).toBeUndefined();
+    expect(processed.a.b.c.d["x-another-ext"]).toBeUndefined();
+    expect(processed.a.b.c.d.e).toBe("value");
+  });
+
+  it("does nothing if no x- extensions are present", () => {
+    const docWithoutExtensions = {
+      openapi: "3.1.0",
+      info: { title: "API without extensions" },
+    };
+
+    const processed = removeExtensions()(docWithoutExtensions);
+
+    expect(processed).toEqual(docWithoutExtensions);
+  });
+
+  it("removes extensions based on shouldRemove callback", () => {
+    const processed = removeExtensions({
+      shouldRemove: (key) => key.startsWith("x-zuplo"),
+    })(baseDoc);
+
+    // Should remove x-zuplo extensions
+    const removedExtensions = [
+      "x-zuplo-ext",
+      "info.x-zuplo-info",
+      "paths./test.x-zuplo-path",
+      "paths./test.parameters.0.x-zuplo-param",
+      "paths./test.get.x-zuplo-route",
+      "paths./test.get.responses.200.x-zuplo-response",
+      "paths./test.get.parameters.0.x-zuplo-param",
+      "tags.0.x-zuplo-tag",
+      "components.securitySchemes.ApiKeyAuth.x-zuplo-security",
+    ];
+
+    // Should keep other x- extensions
+    const keptExtensions = [
+      "x-root-ext",
+      "info.x-info-ext",
+      "paths./test.x-path-ext",
+      "paths./test.parameters.0.x-param-ext",
+      "paths./test.get.x-operation-ext",
+      "paths./test.get.responses.200.x-response-ext",
+      "paths./test.get.parameters.0.x-op-param-ext",
+      "tags.0.x-tag-ext",
+      "components.securitySchemes.ApiKeyAuth.x-security-ext",
+    ];
+
+    removedExtensions.forEach((ext) => {
+      expect(processed).not.toHaveProperty(ext.split("."));
+    });
+
+    keptExtensions.forEach((ext) => {
+      expect(processed).toHaveProperty(ext.split("."));
+    });
+
+    // Assert that non-x- fields remain unchanged
+    expect(processed).toHaveProperty("openapi", "3.1.0");
+    expect(processed).toHaveProperty("info.title", "Test API");
+    expect(processed).toHaveProperty(
+      "paths./test.get.responses.200.description",
+      "OK",
+    );
+    expect(processed).toHaveProperty("tags.0.name", "example");
+  });
+});

package/src/lib/plugins/openapi/processors/removeExtensions.ts

@@ -0,0 +1,27 @@
+import { type RecordAny, traverse } from "./traverse.js";
+
+interface RemoveExtensionsOptions {
+  keys?: string[];
+  shouldRemove?: (key: string) => boolean;
+}
+
+// Remove all `x-` prefixed key/value pairs, or filter by names if provided
+export const removeExtensions =
+  ({ keys, shouldRemove }: RemoveExtensionsOptions = {}) =>
+  (doc: RecordAny): RecordAny =>
+    traverse(doc, (spec) => {
+      const result: RecordAny = {};
+
+      for (const [key, value] of Object.entries(spec)) {
+        const isExtension = key.startsWith("x-");
+        const shouldBeRemoved =
+          isExtension &&
+          (keys === undefined || keys.includes(key)) &&
+          (!shouldRemove || shouldRemove(key));
+
+        if (shouldBeRemoved) continue;
+
+        result[key] = value;
+      }
+      return result;
+    });