Detect openapi definitions from hono-zod-openapi apps

.gitignore

@@ -4,6 +4,9 @@ shared/dist
 .envrc
 .cursorrules
 
+# Cursor
+.cursorrules
+
 # Fpx
 .fpxconfig
 

api/src/lib/ai/fp.ts

@@ -16,6 +16,7 @@ type GenerateRequestOptions = {
     path: string;
   }[];
   middlewareContext?: string;
+  prompt?: string;
 };
 
 export async function generateRequestWithFp({
@@ -29,6 +30,7 @@ export async function generateRequestWithFp({
   openApiSpec,
   middleware,
   middlewareContext,
+  prompt,
 }: GenerateRequestOptions) {
   logger.debug(
     "Generating request data with FP",
@@ -56,6 +58,7 @@ export async function generateRequestWithFp({
       openApiSpec,
       middleware,
       middlewareContext,
+      prompt,
     },
   });
 

api/src/lib/ai/index.ts

@@ -64,6 +64,7 @@ export async function generateRequestWithAiProvider({
   openApiSpec,
   middleware,
   middlewareContext,
+  prompt,
 }: {
   fpApiKey?: string;
   inferenceConfig: Settings;
@@ -80,6 +81,7 @@ export async function generateRequestWithAiProvider({
     path: string;
   }[];
   middlewareContext?: string;
+  prompt?: string;
 }) {
   const { aiProviderConfigurations, aiProvider } = inferenceConfig;
   const aiEnabled = hasValidAiConfig(inferenceConfig);
@@ -109,6 +111,7 @@ export async function generateRequestWithAiProvider({
       persona,
       method,
       path,
+      prompt,
     });
   }
 
@@ -166,6 +169,7 @@ Here is some additional context for the handler source code, if you need it:
       openApiSpec,
       middleware,
       middlewareContext,
+      prompt,
     });
 
     const systemPrompt = getSystemPrompt(persona, aiProvider);

api/src/lib/ai/prompts.ts

@@ -42,6 +42,7 @@ export const invokeRequestGenerationPrompt = async ({
   openApiSpec,
   middleware,
   middlewareContext,
+  prompt,
 }: {
   persona: string;
   method: string;
@@ -56,6 +57,7 @@ export const invokeRequestGenerationPrompt = async ({
     path: string;
   }[];
   middlewareContext?: string;
+  prompt?: string;
 }) => {
   const promptTemplate =
     persona === "QA" ? qaTesterPrompt : friendlyTesterPrompt;
@@ -68,6 +70,7 @@ export const invokeRequestGenerationPrompt = async ({
     openApiSpec: openApiSpec ?? "NO OPENAPI SPEC",
     middleware: formatMiddleware(middleware),
     middlewareContext: middlewareContext ?? "NO MIDDLEWARE CONTEXT",
+    prompt: prompt ?? "",
   });
   const userPrompt = userPromptInterface.value;
   return userPrompt;
@@ -107,6 +110,8 @@ Here is the code for the handler:
 Here is some additional context for the handler source code, if you need it:
 {handlerContext}
 
+Here are some additional instructions from the user:
+{prompt}
 `.trim(),
 );
 
@@ -139,6 +144,9 @@ Here is the code for the handler:
 Here is some additional context for the handler source code, if you need it:
 {handlerContext}
 
+Here are some additional instructions from the user:
+{prompt}
+
 REMEMBER YOU ARE A QA. MISUSE THE API. BUT DO NOT MISUSE YOURSELF.
 Keep your responses short-ish. Including your random data.
 `.trim(),

api/src/lib/app-routes.ts

@@ -6,12 +6,20 @@ import * as schema from "../db/schema.js";
 const { appRoutes } = schema;
 
 export const schemaProbedRoutes = z.object({
+  openApiSpec: z
+    .unknown()
+    .nullish()
+    .describe("OpenAPI spec for the entire api"),
   routes: z.array(
     z.object({
       method: z.string(),
       path: z.string(),
       handler: z.string(),
       handlerType: z.string(),
+      openApiSpec: z
+        .string()
+        .nullish()
+        .describe("OpenAPI spec for the singular route"),
     }),
   ),
 });
@@ -70,6 +78,8 @@ export async function reregisterRoutes(
             handler: route.handler,
             currentlyRegistered: true,
             registrationOrder: index,
+            openApiSpec:
+              route.handlerType === "route" ? route.openApiSpec : null,
           })
           .where(eq(appRoutes.id, routeToUpdate.id));
       } else {

api/src/lib/openapi/dereference.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it } from "vitest";
+import {
+  CircularReferenceError,
+  MissingReferenceError,
+  dereferenceSchema,
+  resolveRef,
+} from "./dereference.js";
+
+describe("resolveRef", () => {
+  const mockComponents = {
+    schemas: {
+      Pet: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+          age: { type: "number" },
+        },
+      },
+      Error: {
+        type: "object",
+        properties: {
+          code: { type: "integer" },
+          message: { type: "string" },
+        },
+      },
+    },
+  };
+
+  it("should resolve a simple reference", () => {
+    const result = resolveRef("#/components/schemas/Pet", mockComponents);
+    expect(result).toEqual(mockComponents.schemas.Pet);
+  });
+
+  it("should use cache for repeated references", () => {
+    const cache = new Map();
+    const ref = "#/components/schemas/Pet";
+
+    const result1 = resolveRef(ref, mockComponents, new Set(), cache);
+    const result2 = resolveRef(ref, mockComponents, new Set(), cache);
+
+    expect(result1).toEqual(result2);
+    expect(cache.get(ref)).toBeDefined();
+  });
+
+  it("should throw MissingReferenceError for non-existent reference", () => {
+    expect(() =>
+      resolveRef("#/components/schemas/NonExistent", mockComponents),
+    ).toThrow(MissingReferenceError);
+  });
+
+  it("should throw CircularReferenceError for circular references", () => {
+    const componentsWithCircular = {
+      schemas: {
+        A: { $ref: "#/components/schemas/B" },
+        B: { $ref: "#/components/schemas/A" },
+      },
+    };
+
+    expect(() =>
+      resolveRef("#/components/schemas/A", componentsWithCircular),
+    ).toThrow(CircularReferenceError);
+  });
+});
+
+describe("dereferenceSchema", () => {
+  const mockComponents = {
+    schemas: {
+      Pet: {
+        type: "object",
+        properties: {
+          name: { type: "string" },
+        },
+      },
+      Error: {
+        type: "object",
+        properties: {
+          code: { type: "integer" },
+        },
+      },
+    },
+  };
+
+  it("should dereference a simple schema", () => {
+    const input = {
+      type: "object",
+      properties: {
+        pet: { $ref: "#/components/schemas/Pet" },
+      },
+    };
+
+    const expected = {
+      type: "object",
+      properties: {
+        pet: mockComponents.schemas.Pet,
+      },
+    };
+
+    const result = dereferenceSchema(input, mockComponents);
+    expect(result).toEqual(expected);
+  });
+
+  it("should handle nested references", () => {
+    const input = {
+      type: "object",
+      properties: {
+        pet: { $ref: "#/components/schemas/Pet" },
+        error: { $ref: "#/components/schemas/Error" },
+      },
+    };
+
+    const result = dereferenceSchema(input, mockComponents);
+    expect(result.properties.pet).toEqual(mockComponents.schemas.Pet);
+    expect(result.properties.error).toEqual(mockComponents.schemas.Error);
+  });
+
+  it("should handle arrays of references", () => {
+    const input = {
+      type: "array",
+      items: [
+        { $ref: "#/components/schemas/Pet" },
+        { $ref: "#/components/schemas/Error" },
+      ],
+    };
+
+    const result = dereferenceSchema(input, mockComponents);
+    expect(result.items[0]).toEqual(mockComponents.schemas.Pet);
+    expect(result.items[1]).toEqual(mockComponents.schemas.Error);
+  });
+
+  it("should return primitive values as-is", () => {
+    const input = {
+      type: "string",
+      format: "email",
+    };
+
+    const result = dereferenceSchema(input, mockComponents);
+    expect(result).toEqual(input);
+  });
+
+  it("should handle empty objects", () => {
+    const input = {};
+    const result = dereferenceSchema(input, mockComponents);
+    expect(result).toEqual({});
+  });
+});