@autoview/cli 0.1.0

package/src/fromSwagger.test.ts

@@ -0,0 +1,269 @@
+import { OpenApi } from "@typia/interface";
+import { describe, expect, it } from "vitest";
+
+import { extractBackendFromSwagger, fromSwagger } from "./fromSwagger";
+import { toEndpoints } from "./utils/toEndpoints";
+
+/** Resolve the (possibly `$ref`-promoted) application/json schema of a response. */
+function jsonSchemaOf(
+  doc: OpenApi.IDocument,
+  path: string,
+  method: "get" | "post",
+  status: string,
+): Record<string, unknown> {
+  const op = (doc.paths?.[path] as Record<string, unknown> | undefined)?.[
+    method
+  ] as { responses?: Record<string, { content?: Record<string, { schema?: unknown }> }> } | undefined;
+  const schema = op?.responses?.[status]?.content?.["application/json"]?.schema as
+    | Record<string, unknown>
+    | undefined;
+  if (schema === undefined) return {};
+  if (typeof schema.$ref === "string") {
+    const name = schema.$ref.split("/").pop()!;
+    return ((doc.components?.schemas ?? {})[name] ?? {}) as Record<string, unknown>;
+  }
+  return schema;
+}
+
+describe("fromSwagger — strips #/paths/ JSON-pointer allOf members (DigitalOcean)", () => {
+  it("keeps the data member when an allOf mixes it with unresolvable path-pointer refs", () => {
+    // DO's list responses are allOf:[{properties:{droplets}}, <links-ref>, <meta-ref>]
+    // where the refs point into another operation's inline schema. upgradeDocument
+    // discards the whole allOf, losing the data — stripping the path refs recovers it.
+    const responseSchema = {
+      allOf: [
+        { properties: { droplets: { type: "array", items: { $ref: "#/components/schemas/Droplet" } } } },
+        { $ref: "#/paths/~1other/get/responses/200/content/application~1json/schema/allOf/1" },
+      ],
+    };
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/droplets": {
+          get: {
+            operationId: "i",
+            responses: { 200: { description: "ok", content: { "application/json": { schema: responseSchema } } } },
+          },
+        },
+      },
+      components: {
+        schemas: { Droplet: { type: "object", properties: { id: { type: "integer" }, name: { type: "string" } }, required: ["id"] } },
+      },
+    };
+    const doc = fromSwagger(raw as never);
+    const e = toEndpoints(doc).find((x) => x.path === "/droplets");
+    expect(e).toBeDefined();
+    // the response survived the upgrade with its droplets array (not an empty schema)
+    expect(JSON.stringify(jsonSchemaOf(doc, "/droplets", "get", "200"))).toContain("droplets");
+  });
+
+  it("flattens an INLINE allOf in an operation response (DigitalOcean droplets)", () => {
+    // DO's `GET /v2/droplets` response is `allOf:[{properties:{droplets}}, {$ref:Pagination}]`
+    // INLINE in the operation — not a component schema, so the components-only
+    // flatten pass missed it. nestia then emits `Response = any` for the route,
+    // `typia.random<any>()` yields nothing, and the simulate-mode list renders
+    // empty forever. The flatten must walk the whole document.
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/droplets": {
+          get: {
+            operationId: "list",
+            responses: {
+              200: {
+                description: "ok",
+                content: {
+                  "application/json": {
+                    schema: {
+                      allOf: [
+                        { properties: { droplets: { type: "array", items: { type: "object", properties: { id: { type: "integer" } } } } } },
+                        { $ref: "#/components/schemas/Pagination" },
+                      ],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      components: {
+        schemas: { Pagination: { type: "object", properties: { total: { type: "integer" } } } },
+      },
+    };
+    const doc = fromSwagger(raw as never);
+    const flat = jsonSchemaOf(doc, "/droplets", "get", "200");
+    // the inline allOf was merged into plain properties — both members survive
+    expect(flat.allOf).toBeUndefined();
+    const props = (flat.properties ?? {}) as Record<string, unknown>;
+    expect(Object.keys(props).sort()).toEqual(["droplets", "total"]);
+  });
+
+  it("flattens an allOf nested INSIDE a property (DigitalOcean databases.connection)", () => {
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/databases": {
+          get: {
+            operationId: "list",
+            responses: {
+              200: {
+                description: "ok",
+                content: {
+                  "application/json": {
+                    schema: {
+                      type: "object",
+                      properties: {
+                        connection: { allOf: [{ type: "object", properties: { host: { type: "string" } } }, { type: "object", properties: { port: { type: "integer" } } }] },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      components: { schemas: {} },
+    };
+    const doc = fromSwagger(raw as never);
+    const flat = jsonSchemaOf(doc, "/databases", "get", "200");
+    const connection = ((flat.properties ?? {}) as Record<string, Record<string, unknown>>)
+      .connection ?? {};
+    expect(connection.allOf).toBeUndefined();
+    expect(Object.keys((connection.properties ?? {}) as object).sort()).toEqual(["host", "port"]);
+  });
+
+  it("resolves a #/paths/ JSON-pointer $ref OUTSIDE an allOf (DigitalOcean metrics/apps)", () => {
+    // DO also DRYs whole schemas as `$ref: "#/paths/~1v2~1bandwidth/get/..."` at
+    // the schema ROOT or inside a property — not as an allOf member, so the
+    // allOf-stripping pass never sees it. nestia cannot chase the pointer and
+    // emits `Response = any`. Resolve the pointer against the document itself.
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/v2/bandwidth": {
+          get: { operationId: "bw", responses: { 200: { description: "ok", content: { "application/json": { schema: { type: "object", properties: { metrics: { type: "array", items: { type: "object", properties: { value: { type: "number" } } } } } } } } } } },
+        },
+        "/v2/cpu": {
+          get: { operationId: "cpu", responses: { 200: { description: "ok", content: { "application/json": { schema: { $ref: "#/paths/~1v2~1bandwidth/get/responses/200/content/application~1json/schema" } } } } } },
+        },
+      },
+      components: { schemas: {} },
+    };
+    const doc = fromSwagger(raw as never);
+    const cpu = jsonSchemaOf(doc, "/v2/cpu", "get", "200");
+    // the pointer was resolved to the bandwidth schema's real shape
+    expect(JSON.stringify(cpu)).toContain("metrics");
+    const e = toEndpoints(doc).find((x) => x.path === "/v2/cpu");
+    expect(e?.responseBody ?? e?.responseSchema).not.toBeNull();
+  });
+
+  it("promotes colliding inline responses so a parent list and child detail both stay typed", () => {
+    // nestia derives the promoted component name from the path with `{param}`
+    // segments dropped, so `/v2/droplets` and `/v2/droplets/{droplet_id}` both
+    // claim `IApiV2Droplets.GetResponse` — the loser's SDK function comes out
+    // `Response = any` and its simulate screen renders empty forever (38 of
+    // DigitalOcean's 148 SDK files). Promoting each inline OBJECT body to a
+    // unique named component before nestia sees it removes the collision.
+    const inlineObj = (props: Record<string, unknown>) => ({
+      type: "object",
+      properties: props,
+    });
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/v2/droplets": {
+          get: { operationId: "list", responses: { 200: { description: "ok", content: { "application/json": { schema: inlineObj({ droplets: { type: "array", items: inlineObj({ id: { type: "integer" } }) } }) } } } } },
+        },
+        "/v2/droplets/{droplet_id}": {
+          get: { operationId: "at", parameters: [{ name: "droplet_id", in: "path", required: true, schema: { type: "integer" } }], responses: { 200: { description: "ok", content: { "application/json": { schema: inlineObj({ droplet: inlineObj({ id: { type: "integer" } }) }) } } } } },
+        },
+      },
+      components: { schemas: {} },
+    };
+    const doc = fromSwagger(raw as never);
+    const eps = toEndpoints(doc);
+    const list = eps.find((e) => e.path === "/v2/droplets");
+    const detail = eps.find((e) => e.path === "/v2/droplets/{droplet_id}");
+    // BOTH carry a named response type that resolves in the document — neither
+    // collapsed to an untyped (any) body.
+    for (const e of [list, detail]) {
+      expect(e?.responseBody).not.toBeNull();
+      expect((doc.components?.schemas ?? {})[e!.responseBody!.typeName]).toBeDefined();
+    }
+    expect(list!.responseBody!.typeName).not.toBe(detail!.responseBody!.typeName);
+  });
+
+  it("drops a path whose {param} name is not a valid identifier (GitHub's {enterprise-team})", () => {
+    // nestia derives the SDK accessor from the param name and crashes on a
+    // hyphenated one — taking the WHOLE generation down. Drop just that path.
+    const raw = {
+      openapi: "3.0.0",
+      info: { title: "t", version: "1" },
+      paths: {
+        "/teams/{teamId}": { get: { operationId: "ok", parameters: [{ name: "teamId", in: "path", required: true, schema: { type: "string" } }], responses: { 200: { description: "ok" } } } },
+        "/teams/{enterprise-team}/members": { get: { operationId: "bad", parameters: [{ name: "enterprise-team", in: "path", required: true, schema: { type: "string" } }], responses: { 200: { description: "ok" } } } },
+      },
+      components: { schemas: {} },
+    };
+    const doc = fromSwagger(raw as never);
+    expect(doc.paths["/teams/{teamId}"]).toBeDefined(); // the valid one survives
+    expect(doc.paths["/teams/{enterprise-team}/members"]).toBeUndefined(); // the hyphen one is dropped
+  });
+});
+
+describe("extractBackendFromSwagger", () => {
+  it("returns null for non-object payloads", () => {
+    expect(extractBackendFromSwagger(null)).toBeNull();
+    expect(extractBackendFromSwagger(undefined)).toBeNull();
+    expect(extractBackendFromSwagger("")).toBeNull();
+    expect(extractBackendFromSwagger(42)).toBeNull();
+  });
+
+  it("returns null when servers is missing", () => {
+    expect(extractBackendFromSwagger({})).toBeNull();
+    expect(extractBackendFromSwagger({ openapi: "3.0.0" })).toBeNull();
+  });
+
+  it("returns null when servers is empty or not an array", () => {
+    expect(extractBackendFromSwagger({ servers: [] })).toBeNull();
+    expect(
+      extractBackendFromSwagger({ servers: "http://x" } as unknown),
+    ).toBeNull();
+  });
+
+  it("returns the first server with a non-empty url", () => {
+    expect(
+      extractBackendFromSwagger({
+        servers: [{ url: "https://api.example.com" }],
+      }),
+    ).toEqual({ host: "https://api.example.com" });
+  });
+
+  it("skips entries with missing or empty url and picks the next valid one", () => {
+    expect(
+      extractBackendFromSwagger({
+        servers: [
+          {},
+          { url: "" },
+          { url: 42 },
+          { url: "https://api.example.com" },
+        ],
+      }),
+    ).toEqual({ host: "https://api.example.com" });
+  });
+
+  it("returns null when no server has a usable url", () => {
+    expect(
+      extractBackendFromSwagger({
+        servers: [{}, { url: "" }, { url: null }],
+      }),
+    ).toBeNull();
+  });
+});