zudoku 0.0.0-fd8f8ad → 0.0.0-feda542

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

@@ -0,0 +1,148 @@
+import { type OpenAPIV3_1 } from "openapi-types";
+import { describe, expect, it } from "vitest";
+import { removeParameters } from "./removeParameters.js";
+
+const baseDoc: OpenAPIV3_1.Document = {
+  openapi: "3.1.0",
+  info: {
+    title: "Test API",
+    version: "1.0.0",
+  },
+  components: {
+    parameters: {
+      commonParam: {
+        name: "commonParam",
+        in: "query",
+        schema: { type: "string" },
+      },
+      headerParam: {
+        name: "headerParam",
+        in: "header",
+        schema: { type: "string" },
+      },
+    },
+  },
+  paths: {
+    "/test": {
+      parameters: [
+        {
+          name: "pathParam",
+          in: "path",
+          schema: { type: "string" },
+          required: true,
+        },
+        {
+          name: "pathHeader",
+          in: "header",
+          schema: { type: "string" },
+          required: true,
+        },
+      ],
+      get: {
+        parameters: [
+          {
+            name: "opParam",
+            in: "query",
+            schema: { type: "string" },
+            required: true,
+          },
+          {
+            name: "opHeader",
+            in: "header",
+            schema: { type: "string" },
+            required: true,
+          },
+        ],
+        responses: {
+          "200": {
+            description: "OK",
+          },
+        },
+      },
+    },
+  },
+};
+
+describe("removeParameters", () => {
+  it("removes parameters by name", () => {
+    const processed = removeParameters({
+      names: ["pathParam", "opParam"],
+    })(baseDoc);
+
+    expect(processed.paths["/test"].parameters).toHaveLength(1);
+    expect(processed.paths["/test"].parameters[0].name).toBe("pathHeader");
+    expect(processed.paths["/test"].get.parameters).toHaveLength(1);
+    expect(processed.paths["/test"].get.parameters[0].name).toBe("opHeader");
+  });
+
+  it("removes parameters by location", () => {
+    const processed = removeParameters({
+      in: ["header"],
+    })(baseDoc);
+
+    expect(processed.paths["/test"].parameters).toHaveLength(1);
+    expect(processed.paths["/test"].parameters[0].in).toBe("path");
+    expect(processed.paths["/test"].get.parameters).toHaveLength(1);
+    expect(processed.paths["/test"].get.parameters[0].in).toBe("query");
+  });
+
+  it("removes parameters using shouldRemove callback", () => {
+    const processed = removeParameters({
+      shouldRemove: ({ parameter }) =>
+        parameter.in === "header" && parameter.name.includes("op"),
+    })(baseDoc);
+
+    expect(processed.paths["/test"].parameters).toHaveLength(2);
+    expect(processed.paths["/test"].get.parameters).toHaveLength(1);
+    expect(processed.paths["/test"].get.parameters[0].name).toBe("opParam");
+  });
+
+  it("combines multiple removal criteria", () => {
+    const processed = removeParameters({
+      in: ["query", "header"],
+      shouldRemove: ({ parameter }) => parameter.name === "pathHeader",
+    })(baseDoc);
+
+    expect(processed.paths["/test"].parameters).toHaveLength(1);
+    expect(processed.paths["/test"].parameters[0].name).toBe("pathParam");
+    expect(processed.paths["/test"].get.parameters).toHaveLength(0);
+  });
+
+  it("handles missing parameters arrays", () => {
+    const docWithoutParams = {
+      openapi: "3.1.0",
+      paths: {
+        "/test": {
+          get: {
+            summary: "Test endpoint",
+          },
+        },
+      },
+    };
+
+    const processed = removeParameters({
+      names: ["someParam"],
+    })(docWithoutParams);
+
+    expect(processed).toEqual(docWithoutParams);
+  });
+
+  it("preserves non-parameter properties", () => {
+    const processed = removeParameters({
+      names: ["globalParam"],
+    })(baseDoc);
+
+    expect(processed.openapi).toBe("3.1.0");
+    expect(processed.paths["/test"].get).toBeDefined();
+  });
+
+  it("removes parameters from components", () => {
+    const processed = removeParameters({
+      in: ["header"],
+    })(baseDoc);
+
+    expect(Object.keys(processed.components.parameters)).toHaveLength(1);
+    expect(processed.components.parameters.commonParam).toBeDefined();
+    expect(processed.components.parameters.headerParam).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,101 @@
+import { type RecordAny, traverse } from "./traverse.js";
+
+interface RemoveParametersOptions {
+  // Names of parameters to remove
+  names?: string[];
+  // Specific locations to remove parameters from ('query', 'header', 'path', 'cookie')
+  in?: string[];
+  // Custom filter function
+  shouldRemove?: ({ parameter }: { parameter: RecordAny }) => boolean;
+}
+
+export const removeParameters =
+  ({ names, in: locations, shouldRemove }: RemoveParametersOptions = {}) =>
+  (doc: RecordAny): RecordAny =>
+    traverse(doc, (spec) => {
+      // Helper function to filter parameters
+      const filterParameters = (parameters: RecordAny[]) =>
+        parameters.filter((p) => {
+          if (names?.includes(p.name)) return false;
+          if (locations?.includes(p.in)) return false;
+          if (shouldRemove?.({ parameter: p })) return false;
+          return true;
+        });
+
+      // Handle components.parameters
+      if (spec.components?.parameters) {
+        spec = {
+          ...spec,
+          components: {
+            ...spec.components,
+            parameters: Object.fromEntries(
+              Object.entries(spec.components.parameters).filter(
+                ([_, param]) => {
+                  const p = param as RecordAny;
+                  if (p.$ref) return true; // Skip references
+                  return (
+                    !names?.includes(p.name) &&
+                    !locations?.includes(p.in) &&
+                    !shouldRemove?.({ parameter: p })
+                  );
+                },
+              ),
+            ),
+          },
+        };
+      }
+
+      // Handle paths
+      if (spec.paths) {
+        const updatedPaths: RecordAny = {};
+
+        for (const [path, pathItem] of Object.entries(spec.paths)) {
+          if (typeof pathItem !== "object" || pathItem === null) {
+            updatedPaths[path] = pathItem;
+            continue;
+          }
+
+          let updatedPathItem = { ...pathItem };
+
+          // Handle path-level parameters
+          if (
+            "parameters" in updatedPathItem &&
+            Array.isArray(updatedPathItem.parameters)
+          ) {
+            updatedPathItem.parameters = filterParameters(
+              updatedPathItem.parameters,
+            );
+          }
+
+          // Handle operation-level parameters
+          for (const method of Object.keys(updatedPathItem)) {
+            const pathItemWithMethods = updatedPathItem as Record<
+              string,
+              RecordAny
+            >;
+
+            if (
+              method === "parameters" ||
+              typeof pathItemWithMethods[method] !== "object"
+            ) {
+              continue;
+            }
+
+            const operation = pathItemWithMethods[method];
+            if (Array.isArray(operation.parameters)) {
+              pathItemWithMethods[method] = {
+                ...operation,
+                parameters: filterParameters(operation.parameters),
+              };
+              updatedPathItem = pathItemWithMethods;
+            }
+          }
+
+          updatedPaths[path] = updatedPathItem;
+        }
+
+        spec = { ...spec, paths: updatedPaths };
+      }
+
+      return spec;
+    });

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

@@ -0,0 +1,126 @@
+import { describe, expect, it } from "vitest";
+import { removePaths } from "./removePaths.js";
+
+const baseDoc = {
+  openapi: "3.0.3",
+  paths: {
+    "/example": {
+      get: { summary: "Get example" },
+      post: { summary: "Post example" },
+    },
+    "/remove-me": {
+      delete: { summary: "Delete example" },
+    },
+    "/another": {
+      get: { summary: "Another example" },
+    },
+  },
+};
+
+describe("removePaths", () => {
+  it("removes paths specified in the paths option", () => {
+    const processed = removePaths({
+      paths: {
+        "/remove-me": true,
+      },
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeUndefined();
+    expect(processed.paths["/example"]).toBeDefined();
+    expect(processed.paths["/another"]).toBeDefined();
+  });
+
+  it("removes specific methods in the paths option", () => {
+    const processed = removePaths({
+      paths: {
+        "/example": ["get"],
+      },
+    })(baseDoc);
+
+    expect(processed.paths["/example"].get).toBeUndefined();
+    expect(processed.paths["/example"].post).toBeDefined();
+    expect(processed.paths["/remove-me"]).toBeDefined();
+  });
+
+  it("removes paths and methods using paths and shouldRemove together", () => {
+    const processed = removePaths({
+      paths: {
+        "/example": ["post"],
+      },
+      shouldRemove: ({ path }) => path.startsWith("/remove"),
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeUndefined();
+    expect(processed.paths["/example"].get).toBeDefined();
+    expect(processed.paths["/example"].post).toBeUndefined();
+    expect(processed.paths["/another"]).toBeDefined();
+  });
+
+  it("removes paths based on shouldRemove callback", () => {
+    const processed = removePaths({
+      shouldRemove: ({ path }) => path.startsWith("/remove"),
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeUndefined();
+    expect(processed.paths["/example"]).toBeDefined();
+    expect(processed.paths["/another"]).toBeDefined();
+  });
+
+  it("removes methods based on shouldRemove callback", () => {
+    const processed = removePaths({
+      shouldRemove: ({ method }) => method === "post",
+    })(baseDoc);
+
+    expect(processed.paths["/example"].post).toBeUndefined();
+    expect(processed.paths["/example"].get).toBeDefined();
+    expect(processed.paths["/remove-me"]).toBeDefined();
+  });
+
+  it("removes both paths and methods based on shouldRemove callback", () => {
+    const processed = removePaths({
+      shouldRemove: ({ path, method }) =>
+        path.startsWith("/remove") || method === "post",
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeUndefined();
+    expect(processed.paths["/example"].post).toBeUndefined();
+    expect(processed.paths["/example"].get).toBeDefined();
+    expect(processed.paths["/another"]).toBeDefined();
+  });
+
+  it("does nothing if shouldRemove always returns false", () => {
+    const processed = removePaths({
+      shouldRemove: () => false,
+    })(baseDoc);
+
+    expect(processed).toEqual(baseDoc);
+  });
+
+  it("removes everything if shouldRemove always returns true", () => {
+    const processed = removePaths({
+      shouldRemove: () => true,
+    })(baseDoc);
+
+    expect(processed.paths).toEqual({});
+  });
+
+  it("removes entire paths via shouldRemove callback", () => {
+    const processed = removePaths({
+      shouldRemove: ({ path, method }) =>
+        method === true && path === "/remove-me",
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeUndefined();
+    expect(processed.paths["/example"]).toBeDefined();
+    expect(processed.paths["/another"]).toBeDefined();
+  });
+
+  it("removes specific methods while keeping paths", () => {
+    const processed = removePaths({
+      shouldRemove: ({ method }) => method === "delete",
+    })(baseDoc);
+
+    expect(processed.paths["/remove-me"]).toBeDefined();
+    expect(processed.paths["/remove-me"].delete).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,55 @@
+import { type RecordAny, traverse } from "./traverse.js";
+
+interface RemovePathsOptions {
+  // Path definitions, e.g., { '/path': true, '/path-2': ['get'] }
+  paths?: Record<string, true | string[]>;
+  shouldRemove?: (options: {
+    path: string;
+    method: true | string;
+    operation: RecordAny;
+  }) => boolean;
+}
+
+export const removePaths =
+  ({ paths = {}, shouldRemove }: RemovePathsOptions) =>
+  (doc: RecordAny): RecordAny =>
+    traverse(doc, (spec) => {
+      if (!spec.paths) return spec;
+
+      const updatedPaths: RecordAny = {};
+
+      for (const [path, methods] of Object.entries(spec.paths)) {
+        const operations = spec.paths[path];
+
+        // If the path is explicitly marked for removal in `paths`
+        if (paths[path] === true) continue;
+
+        // If the path should be removed via `shouldRemove`
+        if (shouldRemove?.({ path, method: true, operation: operations }))
+          continue;
+
+        if (typeof methods === "object" && methods !== null) {
+          const filteredPath = Object.fromEntries(
+            Object.entries(methods).filter(([method]) => {
+              const operations = spec.paths[path][method];
+              const isMethodToRemove =
+                Array.isArray(paths[path]) && paths[path].includes(method);
+
+              const isMethodFiltered = shouldRemove?.({
+                path,
+                method,
+                operation: operations,
+              });
+
+              return !isMethodToRemove && !isMethodFiltered;
+            }),
+          );
+
+          updatedPaths[path] = filteredPath;
+        } else {
+          updatedPaths[path] = methods;
+        }
+      }
+
+      return { ...spec, paths: updatedPaths };
+    });

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

@@ -0,0 +1 @@
+export { traverse, type RecordAny } from "../../../util/traverse.js";

package/src/lib/plugins/openapi/schema/LogicalGroup/LogicalGroup.tsx

@@ -15,14 +15,12 @@ export const LogicalGroup = ({
   schemas,
   type,
   isOpen,
-  level,
   toggleOpen,
 }: {
   schemas: SchemaObject[];
   type: LogicalGroupType;
   isOpen: boolean;
   toggleOpen: () => void;
-  level: number;
 }) => (
   <Collapsible.Root open={isOpen} onOpenChange={toggleOpen} asChild>
     <Card className="px-6">
@@ -34,12 +32,7 @@ export const LogicalGroup = ({
       <Collapsible.Content className="pb-4">
         {schemas.map((subSchema, index) => (
           // eslint-disable-next-line react/no-array-index-key
-          <LogicalGroupItem
-            key={index}
-            type={type}
-            schema={subSchema}
-            level={level}
-          />
+          <LogicalGroupItem key={index} type={type} schema={subSchema} />
         ))}
       </Collapsible.Content>
     </Card>

package/src/lib/plugins/openapi/schema/LogicalGroup/LogicalGroupConnector.tsx

@@ -24,10 +24,12 @@ export const LogicalGroupConnector = ({
   type,
   isOpen,
   className,
+  schemeName,
 }: {
   type: LogicalGroupType;
   isOpen: boolean;
   className?: string;
+  schemeName?: string;
 }) => {
   return (
     <div
@@ -48,6 +50,7 @@ export const LogicalGroupConnector = ({
         >
           <ChevronDownIcon size={16} />
         </div>
+        <span className="text-sm text-foreground">{schemeName}</span>
       </div>
     </div>
   );

package/src/lib/plugins/openapi/schema/LogicalGroup/LogicalGroupItem.tsx

@@ -8,7 +8,6 @@ import { LogicalGroupConnector } from "./LogicalGroupConnector.js";
 export const LogicalGroupItem = (props: {
   type: LogicalGroupType;
   schema: SchemaObject;
-  level: number;
 }) => {
   const [isOpen, setIsOpen] = useState(true);
 
@@ -19,11 +18,15 @@ export const LogicalGroupItem = (props: {
       className="group"
     >
       <Collapsible.Trigger>
-        <LogicalGroupConnector type={props.type} isOpen={isOpen} />
+        <LogicalGroupConnector
+          type={props.type}
+          isOpen={isOpen}
+          schemeName={props.schema.title}
+        />
       </Collapsible.Trigger>
       {!isOpen && <div className="wavy-line bg-border translate-y-1" />}
       <Collapsible.Content>
-        <SchemaView schema={props.schema} level={props.level + 1} />
+        <SchemaView schema={props.schema} />
       </Collapsible.Content>
     </Collapsible.Root>
   );

package/src/lib/plugins/openapi/schema/SchemaExampleAndDefault.tsx

@@ -0,0 +1,36 @@
+import type { SchemaObject } from "../../../oas/parser/index.js";
+import { SelectOnClick } from "../components/SelectOnClick.js";
+
+export const SchemaExampleAndDefault = ({
+  schema,
+}: {
+  schema: SchemaObject;
+}) => {
+  const example = schema.examples?.at(0);
+  const defaultValue = schema.default;
+
+  if (!example && !defaultValue) return null;
+
+  return (
+    <div className="flex flex-col gap-1 text-xs">
+      {example && (
+        <div>
+          <span className="text-muted-foreground">Example: </span>
+          <SelectOnClick className="border rounded px-1 font-mono">
+            {typeof example === "object" ? JSON.stringify(example) : example}
+          </SelectOnClick>
+        </div>
+      )}
+      {defaultValue && (
+        <div>
+          <span className="text-muted-foreground">Default: </span>
+          <SelectOnClick className="border rounded px-1 font-mono">
+            {typeof defaultValue === "object"
+              ? JSON.stringify(defaultValue)
+              : defaultValue}
+          </SelectOnClick>
+        </div>
+      )}
+    </div>
+  );
+};

package/src/lib/plugins/openapi/schema/SchemaPropertyItem.tsx

@@ -0,0 +1,148 @@
+import * as Collapsible from "@radix-ui/react-collapsible";
+import { MinusIcon, PlusIcon, RefreshCcwDotIcon } from "lucide-react";
+import { useCallback, useState } from "react";
+import { InlineCode } from "../../../components/InlineCode.js";
+import { Markdown, ProseClasses } from "../../../components/Markdown.js";
+import type { SchemaObject } from "../../../oas/parser/index.js";
+import { Button } from "../../../ui/Button.js";
+import { cn } from "../../../util/cn.js";
+import { objectEntries } from "../../../util/objectEntries.js";
+import { EnumValues } from "../components/EnumValues.js";
+import { SelectOnClick } from "../components/SelectOnClick.js";
+import { ParamInfos } from "../ParamInfos.js";
+import { LogicalGroup } from "./LogicalGroup/LogicalGroup.js";
+import { SchemaExampleAndDefault } from "./SchemaExampleAndDefault.js";
+import { SchemaView } from "./SchemaView.js";
+import {
+  hasLogicalGroupings,
+  isCircularRef,
+  isComplexType,
+  LogicalSchemaTypeMap,
+} from "./utils.js";
+
+export const SchemaLogicalGroup = ({ schema }: { schema: SchemaObject }) => {
+  const [isOpen, setIsOpen] = useState(true);
+  const toggleOpen = useCallback(() => setIsOpen((prev) => !prev), []);
+
+  for (const [key, type] of objectEntries(LogicalSchemaTypeMap)) {
+    if (!schema[key]) continue;
+
+    return (
+      <LogicalGroup
+        schemas={schema[key]}
+        type={type}
+        isOpen={isOpen}
+        toggleOpen={toggleOpen}
+      />
+    );
+  }
+};
+
+const RecursiveIndicator = () => (
+  <InlineCode
+    className="inline-flex items-center gap-1.5 italic text-xs translate-y-0.5"
+    selectOnClick={false}
+  >
+    <RefreshCcwDotIcon size={13} />
+    <span>circular</span>
+  </InlineCode>
+);
+
+export const SchemaPropertyItem = ({
+  name,
+  schema,
+  group,
+  defaultOpen = false,
+  showCollapseButton = true,
+}: {
+  name: string;
+  schema: SchemaObject;
+  group: "required" | "optional" | "deprecated";
+  defaultOpen?: boolean;
+  showCollapseButton?: boolean;
+}) => {
+  const [isOpen, setIsOpen] = useState(defaultOpen);
+
+  if (isCircularRef(schema)) {
+    return (
+      <li className="p-4 bg-border/20 hover:bg-border/30">
+        <div className="flex flex-col gap-2.5 justify-between text-sm">
+          <div className="space-x-2">
+            <code>{name}</code>
+            <ParamInfos
+              schema={schema}
+              extraItems={[<RecursiveIndicator key="circular-ref" />]}
+            />
+          </div>
+          <SchemaExampleAndDefault schema={schema} />
+        </div>
+      </li>
+    );
+  }
+
+  return (
+    <li className="p-4 bg-border/20 hover:bg-border/30">
+      <div className="flex flex-col gap-2.5 justify-between text-sm">
+        <div className="space-x-2">
+          <SelectOnClick asChild>
+            <code>{name}</code>
+          </SelectOnClick>
+          <ParamInfos
+            schema={schema}
+            extraItems={[
+              group !== "optional" && (
+                <span className="text-primary">required</span>
+              ),
+              schema.type === "array" &&
+                "items" in schema &&
+                isCircularRef(schema.items) && <RecursiveIndicator />,
+            ]}
+          />
+        </div>
+        {schema.description && (
+          <Markdown
+            className={cn(ProseClasses, "text-sm leading-normal line-clamp-4")}
+            content={schema.description}
+          />
+        )}
+        {schema.type === "array" && "items" in schema && schema.items.enum && (
+          <EnumValues values={schema.items.enum} />
+        )}
+        {schema.enum && <EnumValues values={schema.enum} />}
+        <SchemaExampleAndDefault schema={schema} />
+        {(hasLogicalGroupings(schema) || isComplexType(schema)) && (
+          <Collapsible.Root
+            defaultOpen={defaultOpen}
+            open={isOpen}
+            onOpenChange={() => setIsOpen(!isOpen)}
+          >
+            {showCollapseButton && (
+              <Collapsible.Trigger asChild>
+                <Button variant="expand" size="sm" className="h-7">
+                  {isOpen ? <MinusIcon size={12} /> : <PlusIcon size={12} />}
+                  {!isOpen ? "Show properties" : "Hide properties"}
+                </Button>
+              </Collapsible.Trigger>
+            )}
+            <Collapsible.Content>
+              <div className="mt-2">
+                {hasLogicalGroupings(schema) ? (
+                  <SchemaLogicalGroup schema={schema} />
+                ) : schema.type === "object" ? (
+                  <SchemaView schema={schema} />
+                ) : (
+                  schema.type === "array" &&
+                  "items" in schema &&
+                  typeof schema.items === "object" &&
+                  !isCircularRef(schema.items) && (
+                    <SchemaView schema={schema.items} />
+                  )
+                )}
+              </div>
+            </Collapsible.Content>
+          </Collapsible.Root>
+        )}
+      </div>
+    </li>
+  );
+};