zudoku 0.0.0-f471fb8 → 0.0.0-f52e8af

package/src/lib/plugins/openapi/playground/IdentitySelector.tsx

@@ -12,43 +12,30 @@ const IdentitySelector = ({
   identities?: ApiIdentity[];
   setValue: (value: string) => void;
   value?: string;
-}) => {
-  return (
-    <Card className="w-full overflow-hidden">
-      <RadioGroup
-        onValueChange={(value) => setValue(value)}
-        value={value}
-        defaultValue={NO_IDENTITY}
-        className="gap-0"
-        disabled={identities?.length === 0}
-      >
+}) => (
+  <Card className="w-full overflow-hidden">
+    <RadioGroup
+      onValueChange={(value) => setValue(value)}
+      value={value}
+      defaultValue={NO_IDENTITY}
+      className="gap-0"
+      disabled={identities?.length === 0}
+    >
+      <Label className="h-12 border-b items-center flex gap-2 p-4 cursor-pointer hover:bg-accent">
+        <RadioGroupItem value={NO_IDENTITY} id="none" />
+        <span>None</span>
+      </Label>
+      {identities?.map((identity) => (
         <Label
-          className="h-12 border-b items-center flex p-4 cursor-pointer hover:bg-accent"
-          htmlFor="none"
+          key={identity.id}
+          className="h-12 border-b items-center flex gap-2 p-4 cursor-pointer hover:bg-accent"
         >
-          <RadioGroupItem value={NO_IDENTITY} id="none">
-            None
-          </RadioGroupItem>
-          <Label htmlFor="none" className="ml-2">
-            None
-          </Label>
+          <RadioGroupItem value={identity.id} id={identity.id} />
+          <span>{identity.label}</span>
         </Label>
-        {identities?.map((identity) => (
-          <Label
-            key={identity.id}
-            className="h-12 border-b items-center flex p-4 cursor-pointer hover:bg-accent"
-          >
-            <RadioGroupItem value={identity.id} id={identity.id}>
-              {identity.label}
-            </RadioGroupItem>
-            <Label htmlFor={identity.id} className="ml-2">
-              {identity.label}
-            </Label>
-          </Label>
-        ))}
-      </RadioGroup>
-    </Card>
-  );
-};
+      ))}
+    </RadioGroup>
+  </Card>
+);
 
 export default IdentitySelector;

package/src/lib/plugins/openapi/playground/Playground.tsx

@@ -379,7 +379,7 @@ export const Playground = ({
         />
 
         <div className="grid grid-cols-2 text-sm h-full">
-          <div className="flex flex-col gap-4 p-4 after:bg-muted-foreground/20 relative after:absolute after:w-px after:inset-0 after:left-auto">
+          <div className="flex flex-col gap-4 p-4 after:bg-muted-foreground/20 relative after:absolute after:w-px after:inset-0 after:start-auto">
             <div className="flex gap-2 items-stretch">
               <div className="flex flex-1 items-center w-full border rounded-md">
                 <div className="border-r p-2 bg-muted rounded-l-md self-stretch font-semibold font-mono flex items-center">
@@ -406,25 +406,25 @@ export const Playground = ({
                     Parameters
                     {(formState.pathParams.some((p) => p.value !== "") ||
                       formState.queryParams.some((p) => p.active)) && (
-                      <div className="w-2 h-2 rounded-full bg-blue-400 ml-2" />
+                      <div className="w-2 h-2 rounded-full bg-blue-400 ms-2" />
                     )}
                   </TabsTrigger>
                   <TabsTrigger value="headers">
                     Headers
                     {formState.headers.filter((h) => h.active).length > 0 && (
-                      <div className="w-2 h-2 rounded-full bg-blue-400 ml-2" />
+                      <div className="w-2 h-2 rounded-full bg-blue-400 ms-2" />
                     )}
                   </TabsTrigger>
                   <TabsTrigger value="auth">
                     Auth
                     {formState.identity !== NO_IDENTITY && (
-                      <div className="w-2 h-2 rounded-full bg-blue-400 ml-2" />
+                      <div className="w-2 h-2 rounded-full bg-blue-400 ms-2" />
                     )}
                   </TabsTrigger>
                   <TabsTrigger value="body">
                     Body
                     {formState.body && (
-                      <div className="w-2 h-2 rounded-full bg-blue-400 ml-2" />
+                      <div className="w-2 h-2 rounded-full bg-blue-400 ms-2" />
                     )}
                   </TabsTrigger>
                 </TabsList>

package/src/lib/plugins/openapi/playground/QueryParams.tsx

@@ -1,5 +1,5 @@
 import {
-  Control,
+  type Control,
   Controller,
   useFieldArray,
   useFormContext,
@@ -44,7 +44,7 @@ export const QueryParams = ({
                     render={({ field }) => (
                       <Checkbox
                         id={`queryParams.${i}.active`}
-                        className="mr-2"
+                        className="me-2"
                         checked={field.value}
                         onCheckedChange={field.onChange}
                       />
@@ -60,7 +60,7 @@ export const QueryParams = ({
                           onChange={(e) => {
                             field.onChange(e);
                           }}
-                          className="border-0 font-mono text-xs bg-transparent hover:bg-transparent"
+                          className="border-0 shadow-none focus-visible:ring-0 bg-transparent hover:bg-transparent text-xs font-mono"
                         />
                       ) : (
                         <InlineInput asChild>
@@ -111,7 +111,7 @@ export const QueryParams = ({
                             field.onChange(e);
                             form.setValue(`queryParams.${i}.active`, true);
                           }}
-                          className="font-mono text-xs border-0 ring-1 ring-ring"
+                          className="border-0 shadow-none focus-visible:ring-0 bg-transparent hover:bg-transparent text-xs font-mono"
                         />
                       );
                     }}

package/src/lib/plugins/openapi/playground/SubmitButton.tsx

@@ -9,7 +9,7 @@ import {
   DropdownMenuTrigger,
 } from "zudoku/ui/DropdownMenu.js";
 import { RadioGroup, RadioGroupItem } from "zudoku/ui/RadioGroup.js";
-import { ApiIdentity } from "../../../core/ZudokuContext.js";
+import { type ApiIdentity } from "../../../core/ZudokuContext.js";
 import { NO_IDENTITY } from "./Playground.js";
 
 const SubmitButton = ({
@@ -59,7 +59,7 @@ const SubmitButton = ({
                   onMouseEnter={() => setDropdownValue(identity.id)}
                   onMouseLeave={() => setDropdownValue(undefined)}
                 >
-                  <RadioGroupItem value={identity.id} className="mr-2" />
+                  <RadioGroupItem value={identity.id} className="me-2" />
 
                   {identity.label}
                 </DropdownMenuItem>

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

@@ -36,7 +36,7 @@ export const RequestTab = ({
             <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">
+            <div className="grid grid-cols-[auto,1fr] gap-x-8 gap-y-1 ps-1.5 pt-2">
               {headers.map(([key, value]) => (
                 <Fragment key={key}>
                   <div className="text-primary">{key}</div>
@@ -53,7 +53,7 @@ export const RequestTab = ({
             <span className="font-semibold">Body</span>
           </CollapsibleTrigger>
           <CollapsibleContent>
-            <div className="pl-0 pt-2">
+            <div className="ps-0 pt-2">
               <div
                 className={cn(
                   "whitespace-pre-wrap break-all bg-muted p-2 rounded-md",

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

@@ -135,7 +135,7 @@ export const ResponseTab = ({
           <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">
+          <div className="grid grid-cols-[auto,1fr] gap-x-8 gap-y-1 ps-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>

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

@@ -61,7 +61,7 @@ export const ResultPanel = ({
               Response
               <span
                 className={cn(
-                  "text-xs font-mono ml-1",
+                  "text-xs font-mono ms-1",
                   status === "2" && "text-green-500",
                   status === "3" && "text-blue-500",
                   status === "4" && "text-yellow-500",

package/src/lib/plugins/openapi/{post-processors → processors}/removeExtensions.test.ts

@@ -64,11 +64,15 @@ const baseDoc = {
       },
     },
   },
-};
+} as any;
 
 describe("removeExtensions", () => {
   it("removes all x- extensions by default", () => {
-    const processed = removeExtensions()(baseDoc);
+    const processed = removeExtensions()({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
 
     const removedExtensions = [
       "x-root-ext",
@@ -93,7 +97,7 @@ describe("removeExtensions", () => {
       ["paths", "/test", "get", "responses", "200", "description"],
       "OK",
     );
-    expect(processed.tags[0].name).toBe("example");
+    expect(processed.tags?.[0]?.name).toBe("example");
   });
 
   it("removes only specified x- extensions when names are provided", () => {
@@ -104,7 +108,11 @@ describe("removeExtensions", () => {
 
     const processed = removeExtensions({
       keys: ["x-path-ext", "x-param-ext"],
-    })(docWithExtraExtensions);
+    })({
+      schema: docWithExtraExtensions,
+      file: "/file.json",
+      dereference: async (id) => id,
+    }) as any;
 
     // Assert specified extensions are removed
     expect(processed.paths["/test"]["x-path-ext"]).toBeUndefined();
@@ -131,9 +139,13 @@ describe("removeExtensions", () => {
           },
         },
       },
-    };
+    } as any;
 
-    const processed = removeExtensions()(deeplyNested);
+    const processed = removeExtensions()({
+      schema: deeplyNested,
+      file: "/file.json",
+      dereference: async (id) => id,
+    }) as any;
 
     expect(processed.a.b.c["x-deep-ext"]).toBeUndefined();
     expect(processed.a.b.c.d["x-another-ext"]).toBeUndefined();
@@ -144,9 +156,13 @@ describe("removeExtensions", () => {
     const docWithoutExtensions = {
       openapi: "3.1.0",
       info: { title: "API without extensions" },
-    };
+    } as any;
 
-    const processed = removeExtensions()(docWithoutExtensions);
+    const processed = removeExtensions()({
+      schema: docWithoutExtensions,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
 
     expect(processed).toEqual(docWithoutExtensions);
   });
@@ -154,7 +170,11 @@ describe("removeExtensions", () => {
   it("removes extensions based on shouldRemove callback", () => {
     const processed = removeExtensions({
       shouldRemove: (key) => key.startsWith("x-zuplo"),
-    })(baseDoc);
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
 
     // Should remove x-zuplo extensions
     const removedExtensions = [

package/src/lib/plugins/openapi/{post-processors → processors}/removeExtensions.ts

@@ -1,3 +1,5 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
 import { type RecordAny, traverse } from "./traverse.js";
 
 interface RemoveExtensionsOptions {
@@ -8,8 +10,8 @@ interface RemoveExtensionsOptions {
 // 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) => {
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (spec) => {
       const result: RecordAny = {};
 
       for (const [key, value] of Object.entries(spec)) {
@@ -24,4 +26,4 @@ export const removeExtensions =
         result[key] = value;
       }
       return result;
-    });
+    }) as OpenAPIDocument;

package/src/lib/plugins/openapi/{post-processors → processors}/removeParameters.test.ts

@@ -1,8 +1,8 @@
-import { type OpenAPIV3_1 } from "openapi-types";
 import { describe, expect, it } from "vitest";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
 import { removeParameters } from "./removeParameters.js";
 
-const baseDoc: OpenAPIV3_1.Document = {
+const baseDoc: OpenAPIDocument = {
   openapi: "3.1.0",
   info: {
     title: "Test API",
@@ -67,45 +67,67 @@ 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");
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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");
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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");
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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);
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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", () => {
@@ -118,11 +140,15 @@ describe("removeParameters", () => {
           },
         },
       },
-    };
+    } as any;
 
     const processed = removeParameters({
       names: ["someParam"],
-    })(docWithoutParams);
+    })({
+      schema: docWithoutParams,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
 
     expect(processed).toEqual(docWithoutParams);
   });
@@ -130,19 +156,27 @@ describe("removeParameters", () => {
   it("preserves non-parameter properties", () => {
     const processed = removeParameters({
       names: ["globalParam"],
-    })(baseDoc);
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
 
     expect(processed.openapi).toBe("3.1.0");
-    expect(processed.paths["/test"].get).toBeDefined();
+    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();
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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/{post-processors → processors}/removeParameters.ts

@@ -1,3 +1,5 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
 import { type RecordAny, traverse } from "./traverse.js";
 
 interface RemoveParametersOptions {
@@ -11,8 +13,8 @@ interface RemoveParametersOptions {
 
 export const removeParameters =
   ({ names, in: locations, shouldRemove }: RemoveParametersOptions = {}) =>
-  (doc: RecordAny): RecordAny =>
-    traverse(doc, (spec) => {
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (spec) => {
       // Helper function to filter parameters
       const filterParameters = (parameters: RecordAny[]) =>
         parameters.filter((p) => {
@@ -98,4 +100,4 @@ export const removeParameters =
       }
 
       return spec;
-    });
+    }) as OpenAPIDocument;

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

@@ -0,0 +1,167 @@
+import { describe, expect, it } from "vitest";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
+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" },
+    },
+  },
+} as unknown as OpenAPIDocument;
+
+describe("removePaths", () => {
+  it("removes paths specified in the paths option", () => {
+    const processed = removePaths({
+      paths: {
+        "/remove-me": true,
+      },
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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"],
+      },
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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"),
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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"),
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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",
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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",
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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,
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    expect(processed).toEqual(baseDoc);
+  });
+
+  it("removes everything if shouldRemove always returns true", () => {
+    const processed = removePaths({
+      shouldRemove: () => true,
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    expect(processed.paths).toEqual({});
+  });
+
+  it("removes entire paths via shouldRemove callback", () => {
+    const processed = removePaths({
+      shouldRemove: ({ path, method }) =>
+        method === true && path === "/remove-me",
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    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",
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    expect(processed.paths?.["/remove-me"]).toBeDefined();
+    expect(processed.paths?.["/remove-me"]?.delete).toBeUndefined();
+  });
+});

package/src/lib/plugins/openapi/{post-processors → processors}/removePaths.ts

@@ -1,3 +1,5 @@
+import type { ProcessorArg } from "../../../../config/validators/BuildSchema.js";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
 import { type RecordAny, traverse } from "./traverse.js";
 
 interface RemovePathsOptions {
@@ -12,8 +14,8 @@ interface RemovePathsOptions {
 
 export const removePaths =
   ({ paths = {}, shouldRemove }: RemovePathsOptions) =>
-  (doc: RecordAny): RecordAny =>
-    traverse(doc, (spec) => {
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (spec) => {
       if (!spec.paths) return spec;
 
       const updatedPaths: RecordAny = {};
@@ -52,4 +54,4 @@ export const removePaths =
       }
 
       return { ...spec, paths: updatedPaths };
-    });
+    }) as OpenAPIDocument;