Merge branch fix/build-dependencies

Author: fabiendostie

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

@@ -5,15 +5,18 @@ import fs from "fs/promises";
 import path from "path";
 import os from "os";
 import { createRequire } from "module"; // Import createRequire
+import prettier from "prettier";
+import parserTypescript from "prettier/parser-typescript";
+// import { DocGenerator } from "json-schema-static-docs"; // Removed
 
 // Helper to resolve package paths
-const require = createRequire(import.meta.url);
+// const require = createRequire(import.meta.url);
 
 // Recursive copy function (fs.cp might not be available everywhere or handle nested dirs reliably)
 async function copyDirRecursive(src: string, dest: string) {
   await fs.mkdir(dest, { recursive: true });
   const entries = await fs.readdir(src, { withFileTypes: true });
-  for (let entry of entries) {
+  for (const entry of entries) {
     const srcPath = path.join(src, entry.name);
     const destPath = path.join(dest, entry.name);
     if (entry.isDirectory()) {
@@ -25,7 +28,7 @@ async function copyDirRecursive(src: string, dest: string) {
 }
 
 // Helper to create a temporary file
-async function writeTempSchemaFile(schema: any): Promise<string> {
+async function writeTempSchemaFile(schema: Record<string, unknown>): Promise<string> {
   const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "schema-"));
   const tempFilePath = path.join(tempDir, "schema.json");
   await fs.writeFile(tempFilePath, JSON.stringify(schema, null, 2));
@@ -69,14 +72,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 +192,59 @@ 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 first for the direct constructor case
+    if (isDocConstructor(LibraryModule)) {
+         Constructor = LibraryModule;
+    // Check if it's an object before checking properties
+    } else if (LibraryModule && typeof LibraryModule === 'object') { 
+        // Use 'in' operator for safer property checking
+        if ('default' in LibraryModule && LibraryModule.default && isDocConstructor(LibraryModule.default)) {
+            // Add type assertion
+            Constructor = LibraryModule.default as JsonSchemaStaticDocsConstructor;
+        } else if ('JsonSchemaStaticDocs' in LibraryModule && LibraryModule.JsonSchemaStaticDocs && isDocConstructor(LibraryModule.JsonSchemaStaticDocs)) {
+           // Add type assertion
+           Constructor = LibraryModule.JsonSchemaStaticDocs as JsonSchemaStaticDocsConstructor;
+        } else if ('DocGenerator' in LibraryModule && LibraryModule.DocGenerator && isDocConstructor(LibraryModule.DocGenerator)) {
+           // Add type assertion
+           Constructor = LibraryModule.DocGenerator as JsonSchemaStaticDocsConstructor;
+        }
+    }
 
-    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 +257,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

@@ -1,14 +1,26 @@
 import { NextResponse } from "next/server";
 import fs from "fs/promises";
 import path from "path";
+// Correct the import for the 'jsonc' library version 2.0.0
+import { jsonc } from "jsonc";
+
+// Remove the explicit RouteContext interface
+// interface RouteContext {
+//   params: {
+//     name: string;
+//   };
+// }
 
 export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ name: string }> },
+  _request: Request, // Prefix with _ if not used
+  // Use the correct Next.js 15 type signature with Promise
+  { params }: { params: Promise<{ name: string }> }, 
 ) {
+  // Remove the explicit destructuring added in the previous step
+  // const { params } = context;
   console.log("[API /api/schemas/[name]] Waiting for params...");
 
-  // Await the params promise
+  // Ensure params is awaited (was likely correct before, but confirming)
   const awaitedParams = await params;
   console.log(
     "[API /api/schemas/[name]] Incoming params resolved:",
@@ -52,30 +64,60 @@ export async function GET(
 
     const fileContent = await fs.readFile(filePath, "utf-8");
 
-    // Optionally validate if it's valid JSON before returning
+    // Parse JSONC (JSON with comments) for validation
     try {
-      JSON.parse(fileContent);
-    } catch (parseError) {
-      console.error(
-        `[API /api/schemas/${name}] File is not valid JSON: ${filePath}`,
-      );
+      // Use the imported jsonc object directly
+      if (typeof jsonc.parse === 'function') { 
+        // Call parse via the imported jsonc object
+        jsonc.parse(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}:`, 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

@@ -1,19 +1,32 @@
 import { NextResponse } from "next/server";
-import fs from "fs";
+import fs from "fs/promises";
 import path from "path";
 
 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: schemas });
+  } 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 },
+    );
   }
 }