Fix ESLint errors and improve type safety

Author: fabiendostie

app/api/generate-schema-doc/route.ts

@@ -4,6 +4,8 @@ import * as JsonSchemaStaticDocsLib from "json-schema-static-docs"; // Use names
 import fs from "fs/promises";
 import path from "path";
 import os from "os";
+import prettier from "prettier";
+import parserTypescript from "prettier/parser-typescript";
 // import { DocGenerator } from "json-schema-static-docs"; // Removed
 
 // Helper to resolve package paths
@@ -69,14 +71,73 @@ async function cleanupTempDirs(pathsToClean: string[]) {
   }
 }
 
+// Define an interface for the expected structure of the imported library module if possible
+// If the exact structure is unknown, we might have to keep `any` casts but minimize them.
+interface JsonSchemaStaticDocsOptions {
+  inputPath: string;
+  outputPath: string;
+  templatePath: string;
+  createIndex: boolean;
+  addFrontMatter: boolean;
+  // Replace 'any' with 'unknown' for stricter checking
+  [key: string]: unknown; 
+}
+
+interface JsonSchemaStaticDocsInstance {
+  generate: () => Promise<void>;
+  // Add other known methods/properties if available
+  [key: string]: unknown; 
+}
+
+// Type for the constructor, assuming it's the default export or the module itself
+type JsonSchemaStaticDocsConstructor = new (
+  options: JsonSchemaStaticDocsOptions,
+) => JsonSchemaStaticDocsInstance;
+
+// Type for the dynamically imported module
+type JsonSchemaStaticDocsModule =
+  | JsonSchemaStaticDocsConstructor // Case: Module is the constructor
+  | { default: JsonSchemaStaticDocsConstructor } // Case: Constructor is default export
+  | { JsonSchemaStaticDocs: JsonSchemaStaticDocsConstructor } // Case: Constructor is named export 'JsonSchemaStaticDocs'
+  | { DocGenerator: JsonSchemaStaticDocsConstructor } // Case: Constructor is named export 'DocGenerator'
+  | { [key: string]: unknown }; // Fallback for other structures
+
+// Custom Type Guard for the Constructor
+function isDocConstructor(obj: unknown): obj is JsonSchemaStaticDocsConstructor {
+  return typeof obj === 'function' && obj.prototype !== undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function formatMarkdown(markdown: string): Promise<string> {
+  try {
+    const result: string = await prettier.format(markdown, { 
+      parser: "markdown",
+      plugins: [parserTypescript], 
+      printWidth: 80,
+      proseWrap: "always",
+    });
+    return result;
+  } catch (error: unknown) { // Type error as unknown
+    console.warn("Could not parse error response from generate-schema-doc");
+    // Safe access to properties
+    let statusText = "Unknown status";
+    if (typeof error === 'object' && error !== null && 'statusText' in error) {
+        statusText = String((error as { statusText: unknown }).statusText);
+    }
+    const errorDetails = `: ${statusText}`; // Use const as errorDetails is not reassigned after this block
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Markdown formatting failed${errorDetails}. Original error: ${message}`);
+  }
+}
+
 export async function POST(request: Request) {
   let tempInputPath: string | undefined;
   let tempOutputPath: string | undefined;
   let tempTemplatePath: string | undefined; // Path for copied templates
   const cleanupPaths: string[] = []; // Keep track of all paths to clean
 
   try {
-    const { schema } = await request.json();
+    const { schema } = (await request.json()) as { schema: Record<string, unknown> }; // Added type assertion
 
     if (!schema) {
       return NextResponse.json(
@@ -130,25 +191,52 @@ export async function POST(request: Request) {
     console.log(`API: Finished copying templates.`);
 
     // 4. Instantiate and run json-schema-static-docs
-    const Constructor =
-      JsonSchemaStaticDocsLib.default || JsonSchemaStaticDocsLib;
+    // Attempt to find the constructor more safely
+    const LibraryModule: JsonSchemaStaticDocsModule = JsonSchemaStaticDocsLib; 
+    let Constructor: JsonSchemaStaticDocsConstructor | null = null;
+
+    // Use the type guard
+    if (isDocConstructor(LibraryModule)) {
+         Constructor = LibraryModule;
+    } else if (LibraryModule && typeof LibraryModule === 'object' && LibraryModule.default && isDocConstructor(LibraryModule.default)) {
+        Constructor = LibraryModule.default;
+    } else if (LibraryModule && typeof LibraryModule === 'object' && LibraryModule.JsonSchemaStaticDocs && isDocConstructor(LibraryModule.JsonSchemaStaticDocs)) {
+       Constructor = LibraryModule.JsonSchemaStaticDocs;
+    } else if (LibraryModule && typeof LibraryModule === 'object' && LibraryModule.DocGenerator && isDocConstructor(LibraryModule.DocGenerator)) {
+       Constructor = LibraryModule.DocGenerator;
+    }
 
-    const generator = new Constructor({
+    if (!Constructor) {
+        console.error("API: Could not find JsonSchemaStaticDocs constructor in the imported module.", LibraryModule);
+        throw new Error("Failed to load the documentation generator library correctly.");
+    }
+
+    // Instantiate using the found constructor
+    // Cast options object at point of use due to [key: string]: unknown
+    const options: JsonSchemaStaticDocsOptions = {
       inputPath: tempInputDirectory,
       outputPath: tempOutputPath,
-      templatePath: tempTemplatePath, // <-- Use the path with copied templates
-      createIndex: false, // We only want the single doc
-      addFrontMatter: false, // No frontmatter needed
-      // Add any other options needed for styling/generation
-      // ajvOptions: { allowUnionTypes: true }, // Example ajv option
-      // enableMetaEnum: true, // Example meta enum option
-    });
+      templatePath: tempTemplatePath,
+      createIndex: false,
+      addFrontMatter: false,
+    };
+    const generator: JsonSchemaStaticDocsInstance = new Constructor(options);
 
     console.log(
       `API: Running generator. Input: ${tempInputDirectory}, Output: ${tempOutputPath}, Templates: ${tempTemplatePath}`,
     );
-    await generator.generate();
-    console.log("API: Generator finished.");
+    // Wrap generate call in try-catch
+    try {
+      // Call generate method (type safety from interface)
+      await generator.generate();
+      console.log("API: Generator finished.");
+    } catch (genError: unknown) { // Ensure genError is unknown
+      console.error("API: Error during generator.generate():", genError);
+      // Use type guard for message
+      const message = genError instanceof Error ? genError.message : "Generator failed";
+        
+        throw new Error(`Schema documentation generation failed: ${message}`); 
+    }
 
     // 5. Read the generated Markdown file
     const markdown = await readGeneratedMarkdown(
@@ -161,16 +249,18 @@ export async function POST(request: Request) {
 
     // 7. Return the Markdown content
     return NextResponse.json({ markdown });
-  } catch (error: any) {
+  } catch (error: unknown) { // Changed to unknown
     console.error("API Error generating schema doc:", error);
 
     // Ensure cleanup happens even on error
     await cleanupTempDirs(cleanupPaths);
 
+    // Add type guard before accessing message
+    const details = error instanceof Error ? error.message : "Unknown error";
     return NextResponse.json(
       {
         error: "Failed to generate schema documentation",
-        details: error.message,
+        details: details, // Use guarded details
       },
       { status: 500 },
     );

app/api/schemas/[name]/route.ts

@@ -3,14 +3,21 @@ import fs from "fs/promises";
 import path from "path";
 import jsonc from "jsonc";
 
+// Define the expected structure of the context parameter
+interface GetContext {
+  params: {
+    name: string;
+  };
+}
+
 export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ name: string }> },
+  _request: Request, // Prefix with _ if not used
+  { params }: GetContext, // Use the defined interface
 ) {
   console.log("[API /api/schemas/[name]] Waiting for params...");
 
-  // Await the params promise
-  const awaitedParams = await params;
+  // Remove await: params is not a promise here
+  const awaitedParams = params;
   console.log(
     "[API /api/schemas/[name]] Incoming params resolved:",
     awaitedParams,
@@ -55,27 +62,59 @@ export async function GET(
 
     // Parse JSONC (JSON with comments) for validation
     try {
-      jsonc.parse(fileContent); // Validate syntax
-    } catch (parseError: any) {
+      // Check if jsonc.parse is a function before calling
+      if (typeof jsonc?.parse === 'function') {
+        // Cast jsonc.parse to a generic function type before calling
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (jsonc.parse as (text: string, reviver?: (key: any, value: any) => any) => any)(fileContent);
+      } else {
+        // Handle the case where jsonc or jsonc.parse is not loaded correctly
+        console.error(`[API /api/schemas/${name}] jsonc.parse function not found.`);
+        throw new Error("JSONC parsing library failed to load.");
+      }
+    } catch (parseError: unknown) { // Catch specific parsing error
       // Handle JSON parsing errors
-      console.error(`Error parsing schema file: ${name}`);
+      console.error(`Error parsing schema file ${name}:`, parseError);
+      // Provide a more specific error message
+      // const message = parseError instanceof Error ? parseError.message : "Invalid JSONC format"; // Removed unused variable
+      // Check if parseError has a relevant property like 'message' before using it
+      let details = "Invalid JSONC format";
+      if (parseError instanceof Error) {
+        details = parseError.message;
+      } else if (typeof parseError === 'object' && parseError !== null && 'message' in parseError) {
+        // Handle cases where it might be an error-like object but not an Error instance
+        details = String((parseError as { message: unknown }).message);
+      }
       return NextResponse.json(
-        { error: "Schema file is not valid JSON" },
+        { error: "Schema file is not valid JSON", details: details }, // Use checked details
         { status: 500 },
       );
     }
     // Return the original content if parsing succeeded
     return NextResponse.json({ content: fileContent });
-  } catch (error: any) {
+  } catch (error: unknown) {
     console.error(
       `[API /api/schemas/${name}] Error reading schema file:`,
       error,
     );
-    if (error.code === "ENOENT") {
+    // Add type guards for accessing properties
+    let errorCode: string | undefined;
+    let errorMessage: string | undefined = "Unknown error reading file";
+
+    if (typeof error === 'object' && error !== null) {
+      if ('code' in error) {
+        errorCode = String(error.code); // Convert potential non-string code
+      }
+      if (error instanceof Error) {
+        errorMessage = error.message;
+      }
+    }
+
+    if (errorCode === "ENOENT") {
       return NextResponse.json({ error: "Schema not found" }, { status: 404 });
     }
     return NextResponse.json(
-      { error: "Failed to read schema file", details: error.message },
+      { error: "Failed to read schema file", details: errorMessage }, // Use guarded message
       { status: 500 },
     );
   }

app/api/schemas/route.ts

@@ -2,18 +2,31 @@ import { NextResponse } from "next/server";
 import fs from "fs/promises";
 import path from "path";
 
-export function GET() {
+export async function GET() {
   try {
     const schemasDir = path.join(process.cwd(), "schemas", "v1");
-    const files = fs.readdirSync(schemasDir).filter((f) => f.endsWith(".json"));
-    const schemas = files.map((filename) => ({
+    console.log(`[API /api/schemas] Reading directory: ${schemasDir}`);
+
+    const allFiles = await fs.readdir(schemasDir);
+    console.log(`[API /api/schemas] Found files: ${allFiles.join(', ')}`);
+
+    const jsonFiles = allFiles.filter((f) => typeof f === 'string' && f.endsWith(".json"));
+    console.log(`[API /api/schemas] Filtered JSON files: ${jsonFiles.join(', ')}`);
+
+    const schemas = jsonFiles.map((filename) => ({
       name: filename.replace(/\.json$/, ""),
       filename,
-      path: `/schemas/v1/${filename}`,
     }));
-    return NextResponse.json({ schemas });
-  } catch (error) {
+
+    console.log(`[API /api/schemas] Mapped schemas:`, schemas);
+
+    return NextResponse.json({ schemas: jsonFiles });
+  } catch (error: unknown) {
+    console.error("[API /api/schemas] Error:", error);
     const message = error instanceof Error ? error.message : String(error);
-    return NextResponse.json({ error: message }, { status: 500 });
+    return NextResponse.json(
+      { error: "Failed to retrieve schemas", details: message },
+      { status: 500 },
+    );
   }
 }

app/layout.tsx

@@ -15,10 +15,7 @@ export default function RootLayout({
     <html lang="en" suppressHydrationWarning className="dark">
       <body className={inter.className}>
         <ThemeProvider
-          attribute="class"
           defaultTheme="dark"
-          enableSystem
-          disableTransitionOnChange
         >
           {children}
           <Toaster />