zudoku 0.0.0-fb7d300 → 0.0.0-fc93837

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/post-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/post-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;
+    });

package/src/lib/plugins/openapi/post-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/post-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;
+    });