zudoku 0.0.0-f49e3ea → 0.0.0-f52e8af

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

@@ -0,0 +1,29 @@
+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 {
+  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 = {}) =>
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (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;
+    }) as OpenAPIDocument;

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

@@ -0,0 +1,182 @@
+import { describe, expect, it } from "vitest";
+import type { OpenAPIDocument } from "../../../oas/parser/index.js";
+import { removeParameters } from "./removeParameters.js";
+
+const baseDoc: OpenAPIDocument = {
+  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"],
+    })({
+      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"],
+    })({
+      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"),
+    })({
+      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",
+    })({
+      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", () => {
+    const docWithoutParams = {
+      openapi: "3.1.0",
+      paths: {
+        "/test": {
+          get: {
+            summary: "Test endpoint",
+          },
+        },
+      },
+    } as any;
+
+    const processed = removeParameters({
+      names: ["someParam"],
+    })({
+      schema: docWithoutParams,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    expect(processed).toEqual(docWithoutParams);
+  });
+
+  it("preserves non-parameter properties", () => {
+    const processed = removeParameters({
+      names: ["globalParam"],
+    })({
+      schema: baseDoc,
+      file: "/file.json",
+      dereference: async (id) => id,
+    });
+
+    expect(processed.openapi).toBe("3.1.0");
+    expect(processed.paths?.["/test"]?.get).toBeDefined();
+  });
+
+  it("removes parameters from components", () => {
+    const processed = removeParameters({
+      in: ["header"],
+    })({
+      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/processors/removeParameters.ts

@@ -0,0 +1,103 @@
+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 {
+  // 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 = {}) =>
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (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;
+    }) 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/processors/removePaths.ts

@@ -0,0 +1,57 @@
+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 {
+  // 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) =>
+  ({ schema }: ProcessorArg) =>
+    traverse(schema, (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 };
+    }) as OpenAPIDocument;

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,39 @@
+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" || typeof example === "boolean"
+              ? 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" ||
+            typeof defaultValue === "boolean"
+              ? JSON.stringify(defaultValue)
+              : defaultValue}
+          </SelectOnClick>
+        </div>
+      )}
+    </div>
+  );
+};