refactor: better schema resolver

fix: compute dependency graphs early & always use the deep one
fix: prop names with special characters
fix: schema names with special characters

lib/src/CodeMeta.ts

@@ -1,11 +1,11 @@
 import type { ReferenceObject, SchemaObject } from "openapi3-ts";
 
 import { isReferenceObject } from "./isReferenceObject";
+import type { DocumentResolver } from "./makeSchemaResolver";
 import { getSchemaComplexity } from "./schema-complexity";
-import { getRefName } from "./utils";
 
 export type ConversionTypeContext = {
-    getSchemaByRef: ($ref: string) => SchemaObject;
+    resolver: DocumentResolver;
     zodSchemaByName: Record<string, string>;
     schemaByName: Record<string, string>;
 };
@@ -49,7 +49,7 @@ export class CodeMeta {
     get codeString(): string {
         if (this.code) return this.code;
 
-        return getRefName(this.ref!);
+        return this.ctx ? this.ctx.resolver.resolveRef(this.ref!).normalized : this.ref!;
     }
 
     get complexity(): number {

lib/src/generateZodClientFromOpenAPI.test.ts

@@ -1489,14 +1489,6 @@ test("with optional, partial, all required objects", async () => {
 
       const VeryDeeplyNested = z.enum(["aaa", "bbb", "ccc"]);
       const DeeplyNested = z.array(VeryDeeplyNested);
-      const Nested2: z.ZodType<Nested2> = z.lazy(() =>
-        z.object({
-          nested_prop: z.boolean().optional(),
-          deeplyNested: DeeplyNested.optional(),
-          circularToRoot: Root2.optional(),
-          requiredProp: z.string(),
-        })
-      );
       const PartialObject = z
         .object({ something: z.string(), another: z.number() })
         .partial();
@@ -1509,6 +1501,14 @@ test("with optional, partial, all required objects", async () => {
           optionalProp: z.string().optional(),
         })
       );
+      const Nested2: z.ZodType<Nested2> = z.lazy(() =>
+        z.object({
+          nested_prop: z.boolean().optional(),
+          deeplyNested: DeeplyNested.optional(),
+          circularToRoot: Root2.optional(),
+          requiredProp: z.string(),
+        })
+      );
 
       const endpoints = makeApi([
         {

lib/src/getOpenApiDependencyGraph.test.ts

@@ -4,12 +4,13 @@ import { get } from "pastable/server";
 import { expect, test } from "vitest";
 import { getOpenApiDependencyGraph } from "./getOpenApiDependencyGraph";
 import { topologicalSort } from "./topologicalSort";
+import { asComponentSchema } from "./utils";
 
 test("petstore.yaml", async () => {
     const openApiDoc = (await SwaggerParser.parse("./tests/petstore.yaml")) as OpenAPIObject;
     const getSchemaByRef = (ref: string) => get(openApiDoc, ref.replace("#/", "").replaceAll("/", ".")) as SchemaObject;
     const { refsDependencyGraph: result, deepDependencyGraph } = getOpenApiDependencyGraph(
-        Object.keys(openApiDoc.components?.schemas || {}).map((name) => `#/components/schemas/${name}`),
+        Object.keys(openApiDoc.components?.schemas || {}).map((name) => asComponentSchema(name)),
         getSchemaByRef
     );
     expect(result).toMatchInlineSnapshot(`

lib/src/getZodiosEndpointDefinitionList.test.ts

@@ -122,12 +122,16 @@ test("getZodiosEndpointDefinitionList /store/order", () => {
                   "response": "Order",
               },
           ],
-          "getSchemaByRef": [Function],
           "issues": {
               "ignoredFallbackResponse": [],
               "ignoredGenericError": [],
           },
           "refsDependencyGraph": {},
+          "resolver": {
+              "getSchemaByRef": [Function],
+              "resolveRef": [Function],
+              "resolveSchemaName": [Function],
+          },
           "schemaByName": {},
           "zodSchemaByName": {
               "Order": "z.object({ id: z.number().int(), petId: z.number().int(), quantity: z.number().int(), shipDate: z.string(), status: z.enum(["placed", "approved", "delivered"]), complete: z.boolean() }).partial()",
@@ -266,7 +270,6 @@ test("getZodiosEndpointDefinitionList /pet", () => {
                   "response": "Pet",
               },
           ],
-          "getSchemaByRef": [Function],
           "issues": {
               "ignoredFallbackResponse": [],
               "ignoredGenericError": [],
@@ -277,6 +280,11 @@ test("getZodiosEndpointDefinitionList /pet", () => {
                   "#/components/schemas/Tag",
               },
           },
+          "resolver": {
+              "getSchemaByRef": [Function],
+              "resolveRef": [Function],
+              "resolveSchemaName": [Function],
+          },
           "schemaByName": {},
           "zodSchemaByName": {
               "Category": "z.object({ id: z.number().int(), name: z.string() }).partial()",
@@ -457,7 +465,6 @@ test("getZodiosEndpointDefinitionList /pet/findXXX", () => {
                   "response": "z.array(Pet)",
               },
           ],
-          "getSchemaByRef": [Function],
           "issues": {
               "ignoredFallbackResponse": [],
               "ignoredGenericError": [],
@@ -468,6 +475,11 @@ test("getZodiosEndpointDefinitionList /pet/findXXX", () => {
                   "#/components/schemas/Tag",
               },
           },
+          "resolver": {
+              "getSchemaByRef": [Function],
+              "resolveRef": [Function],
+              "resolveSchemaName": [Function],
+          },
           "schemaByName": {},
           "zodSchemaByName": {
               "Category": "z.object({ id: z.number().int(), name: z.string() }).partial()",
@@ -941,7 +953,6 @@ test("petstore.yaml", async () => {
                   "response": "",
               },
           ],
-          "getSchemaByRef": [Function],
           "issues": {
               "ignoredFallbackResponse": [
                   "createUsersWithListInput",
@@ -961,6 +972,11 @@ test("petstore.yaml", async () => {
                   "#/components/schemas/Tag",
               },
           },
+          "resolver": {
+              "getSchemaByRef": [Function],
+              "resolveRef": [Function],
+              "resolveSchemaName": [Function],
+          },
           "schemaByName": {},
           "zodSchemaByName": {
               "ApiResponse": "z.object({ code: z.number().int(), type: z.string(), message: z.string() }).partial()",

lib/src/getZodiosEndpointDefinitionList.ts

@@ -8,31 +8,27 @@ import type {
     ResponseObject,
     SchemaObject,
 } from "openapi3-ts";
-import { get } from "pastable/server";
 import { match } from "ts-pattern";
 import { sync } from "whence";
 
 import type { CodeMeta, ConversionTypeContext } from "./CodeMeta";
 import { getOpenApiDependencyGraph } from "./getOpenApiDependencyGraph";
 import { isReferenceObject } from "./isReferenceObject";
+import { makeSchemaResolver } from "./makeSchemaResolver";
 import { getZodChain, getZodSchema } from "./openApiToZod";
 import { getSchemaComplexity } from "./schema-complexity";
 import type { TemplateContext } from "./template-context";
-import { getRefFromName, normalizeString, pathToVariableName } from "./utils";
+import { asComponentSchema, normalizeString, pathToVariableName } from "./utils";
 
 const voidSchema = "z.void()";
 
 // eslint-disable-next-line sonarjs/cognitive-complexity
 export const getZodiosEndpointDefinitionList = (doc: OpenAPIObject, options?: TemplateContext["options"]) => {
-    const getSchemaByRef: ConversionTypeContext["getSchemaByRef"] = (ref: string) => {
-        const correctRef = ref[1] === "/" ? ref : "#/" + ref;
-        const split = correctRef.split("/");
-        const path = split.slice(1, split.length - 1).join("/")!;
-        const map = get(doc, path.replace("#/", "").replace("#", "").replaceAll("/", ".")) ?? ({} as any);
-        const name = split[split.length - 1]!;
-
-        return map[name] as SchemaObject;
-    };
+    const resolver = makeSchemaResolver(doc);
+    const graphs = getOpenApiDependencyGraph(
+        Object.keys(doc.components?.schemas ?? {}).map((name) => asComponentSchema(name)),
+        resolver.getSchemaByRef
+    );
 
     const endpoints = [];
 
@@ -60,7 +56,7 @@ export const getZodiosEndpointDefinitionList = (doc: OpenAPIObject, options?: Te
                 : options.isMediaTypeAllowed;
     }
 
-    const ctx: ConversionTypeContext = { getSchemaByRef, zodSchemaByName: {}, schemaByName: {} };
+    const ctx: ConversionTypeContext = { resolver, zodSchemaByName: {}, schemaByName: {} };
     const complexityThreshold = options?.complexityThreshold ?? 4;
     const getZodVarName = (input: CodeMeta, fallbackName?: string) => {
         const result = input.toString();
@@ -101,7 +97,7 @@ export const getZodiosEndpointDefinitionList = (doc: OpenAPIObject, options?: Te
 
         // result is a reference to another schema
         if (input.ref && ctx.zodSchemaByName[result]) {
-            const complexity = getSchemaComplexity({ current: 0, schema: getSchemaByRef(input.ref) });
+            const complexity = getSchemaComplexity({ current: 0, schema: ctx.resolver.getSchemaByRef(input.ref) });
 
             // ref result is simple enough that it doesn't need to be assigned to a variable
             if (complexity < complexityThreshold) {
@@ -185,7 +181,9 @@ export const getZodiosEndpointDefinitionList = (doc: OpenAPIObject, options?: Te
             }
 
             for (const param of parameters) {
-                const paramItem = (isReferenceObject(param) ? getSchemaByRef(param.$ref) : param) as ParameterObject;
+                const paramItem = (
+                    isReferenceObject(param) ? ctx.resolver.getSchemaByRef(param.$ref) : param
+                ) as ParameterObject;
                 if (allowedPathInValues.includes(paramItem.in)) {
                     const paramSchema = (isReferenceObject(param) ? param.$ref : param.schema) as SchemaObject;
                     const paramCode = getZodSchema({
@@ -309,11 +307,6 @@ export const getZodiosEndpointDefinitionList = (doc: OpenAPIObject, options?: Te
         }
     }
 
-    const graphs = getOpenApiDependencyGraph(
-        Object.keys(doc.components?.schemas ?? {}).map((name) => getRefFromName(name)),
-        ctx.getSchemaByRef
-    );
-
     return {
         ...(ctx as Required<ConversionTypeContext>),
         ...graphs,

lib/src/makeSchemaResolver.ts

@@ -0,0 +1,51 @@
+import type { OpenAPIObject, SchemaObject } from "openapi3-ts";
+import { get } from "pastable/server";
+import { normalizeString } from "./utils";
+
+const autocorrectRef = (ref: string) => (ref[1] === "/" ? ref : "#/" + ref.slice(1));
+
+type RefInfo = {
+    ref: string;
+    name: string;
+    normalized: string;
+};
+
+export const makeSchemaResolver = (doc: OpenAPIObject) => {
+    const nameByRef = new Map<string, string>();
+    const refByName = new Map<string, string>();
+
+    const byRef = new Map<string, RefInfo>();
+    const byNormalized = new Map<string, RefInfo>();
+
+    const getSchemaByRef = (ref: string) => {
+        // #components -> #/components
+        const correctRef = autocorrectRef(ref);
+        const split = correctRef.split("/");
+
+        // "#/components/schemas/Something.jsonld" -> #/components/schemas
+        const path = split.slice(1, split.length - 1).join("/")!;
+        const map = get(doc, path.replace("#/", "").replace("#", "").replaceAll("/", ".")) ?? ({} as any);
+
+        // "#/components/schemas/Something.jsonld" -> "Something.jsonld"
+        const name = split[split.length - 1]!;
+        const normalized = normalizeString(name);
+
+        nameByRef.set(correctRef, normalized);
+        refByName.set(normalized, correctRef);
+
+        const infos = { ref: correctRef, name, normalized };
+        byRef.set(infos.ref, infos);
+        byNormalized.set(infos.normalized, infos);
+
+        // doc.components.schemas["Something.jsonld"]
+        return map[name] as SchemaObject;
+    };
+
+    return {
+        getSchemaByRef,
+        resolveRef: (ref: string) => byRef.get(autocorrectRef(ref))!,
+        resolveSchemaName: (normalized: string) => byNormalized.get(normalized)!,
+    };
+};
+
+export type DocumentResolver = ReturnType<typeof makeSchemaResolver>;

lib/src/openApiToTypescript.test.ts

@@ -3,6 +3,8 @@ import { getTypescriptFromOpenApi, TsConversionContext } from "./openApiToTypesc
 import type { SchemaObject, SchemasObject } from "openapi3-ts";
 import { ts } from "tanu";
 import { describe, expect, test } from "vitest";
+import { makeSchemaResolver } from "./makeSchemaResolver";
+import { asComponentSchema } from "./utils";
 
 const makeSchema = (schema: SchemaObject) => schema;
 const getSchemaAsTsString = (schema: SchemaObject, meta?: { name: string }) =>
@@ -297,8 +299,9 @@ describe("getSchemaAsTsString with context", () => {
         const ctx: TsConversionContext = {
             nodeByRef: {},
             visitedsRefs: {},
-            getSchemaByRef: (ref) => schemas[ref.split("/").at(-1)!]!,
+            resolver: makeSchemaResolver({ components: { schemas } } as any),
         };
+        Object.keys(schemas).forEach((key) => ctx.resolver.getSchemaByRef(asComponentSchema(key)));
         expect(printTs(getTypescriptFromOpenApi({ schema: schemas["Root"]!, meta: { name: "Root" }, ctx }) as ts.Node))
             .toMatchInlineSnapshot(`
               "export type Root = Partial<{
@@ -339,8 +342,9 @@ describe("getSchemaAsTsString with context", () => {
         const ctx: TsConversionContext = {
             nodeByRef: {},
             visitedsRefs: {},
-            getSchemaByRef: (ref) => schemas[ref.split("/").at(-1)!]!,
+            resolver: makeSchemaResolver({ components: { schemas } } as any),
         };
+        Object.keys(schemas).forEach((key) => ctx.resolver.getSchemaByRef(asComponentSchema(key)));
         expect(
             printTs(getTypescriptFromOpenApi({ schema: schemas["Root2"]!, meta: { name: "Root2" }, ctx }) as ts.Node)
         ).toMatchInlineSnapshot(`
@@ -375,8 +379,9 @@ describe("getSchemaAsTsString with context", () => {
         const ctx: TsConversionContext = {
             nodeByRef: {},
             visitedsRefs: {},
-            getSchemaByRef: (ref) => schemas[ref.split("/").at(-1)!]!,
+            resolver: makeSchemaResolver({ components: { schemas } } as any),
         };
+        Object.keys(schemas).forEach((key) => ctx.resolver.getSchemaByRef(asComponentSchema(key)));
 
         expect(
             printTs(
@@ -420,8 +425,9 @@ describe("getSchemaAsTsString with context", () => {
         const ctx: TsConversionContext = {
             nodeByRef: {},
             visitedsRefs: {},
-            getSchemaByRef: (ref) => schemas[ref.split("/").at(-1)!]!,
+            resolver: makeSchemaResolver({ components: { schemas } } as any),
         };
+        Object.keys(schemas).forEach((key) => ctx.resolver.getSchemaByRef(asComponentSchema(key)));
         const result = getTypescriptFromOpenApi({
             schema: schemas["Root4"]!,
             meta: { name: "Root4", $ref: "#/components/schemas/Root4" },
@@ -468,8 +474,9 @@ describe("getSchemaAsTsString with context", () => {
         const ctx: TsConversionContext = {
             nodeByRef: {},
             visitedsRefs: {},
-            getSchemaByRef: (ref) => schemas[ref.split("/").at(-1)!]!,
+            resolver: makeSchemaResolver({ components: { schemas } } as any),
         };
+        Object.keys(schemas).forEach((key) => ctx.resolver.getSchemaByRef(asComponentSchema(key)));
         const result = getTypescriptFromOpenApi({
             schema: schemas["Root"]!,
             meta: { name: "Root", $ref: "#/components/schemas/Root" },