quickbase-js 0.1.0-beta.7 → 0.1.0-beta.9

package/open-api/fix-spec-main.ts

@@ -1,94 +1,95 @@
 #!/usr/bin/env node
-
 import { promises as fs } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import * as glob from "glob";
-import { enhanceTags } from "./schema/tags/index.ts";
-import { enhanceGeneral } from "./schema/enhance-general.ts";
-import { fixArrays } from "./schema/fix-arrays.ts";
 import { Spec } from "./types/spec.ts";
 import { toCamelCase } from "./utils/naming.ts";
 
-// Removed FixSpecConfig since applyOverrides is no longer needed
 async function fixQuickBaseSpec(): Promise<void> {
-  try {
-    const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
-    const SPECS_DIR = path.join(CODEGEN_DIR, "..", "specs");
-    const OUTPUT_DIR = path.join(CODEGEN_DIR, "output");
-    console.log("Finding latest QuickBase RESTful API spec...");
-    const specFiles = glob.sync(
-      path.join(SPECS_DIR, "QuickBase_RESTful_*.json")
+  const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
+  const SPECS_DIR = path.join(CODEGEN_DIR, "..", "specs");
+  const OUTPUT_DIR = path.join(CODEGEN_DIR, "output");
+  console.log("Finding latest QuickBase RESTful API spec...");
+  const specFiles = glob.sync(path.join(SPECS_DIR, "QuickBase_RESTful_*.json"));
+  console.log("Spec files:", specFiles);
+
+  if (specFiles.length === 0) {
+    throw new Error(
+      "No QuickBase_RESTful_*.json files found in specs/ folder."
     );
-    if (specFiles.length === 0) {
-      throw new Error(
-        "No QuickBase_RESTful_*.json files found in specs/ folder."
-      );
-    }
-    const inputFile = specFiles.sort().pop() as string;
-    const outputFile = path.join(OUTPUT_DIR, "quickbase-fixed.json");
+  }
+
+  const inputFile = specFiles.sort().pop() as string;
+  const outputFile = path.join(OUTPUT_DIR, "quickbase-fixed.json");
 
-    console.log(`Reading ${path.basename(inputFile)} from specs/...`);
-    const specContent = await fs.readFile(inputFile, "utf8");
-    const spec: Spec = JSON.parse(specContent);
+  console.log(`Reading ${path.basename(inputFile)} from specs/...`);
+  const specContent = await fs.readFile(inputFile, "utf8");
+  console.log("File read successfully");
+  const spec: Spec = JSON.parse(specContent);
+  console.log("JSON parsed successfully");
 
-    console.log("Fixing parameters...");
-    for (const pathKey in spec.paths) {
-      for (const method in spec.paths[pathKey]) {
-        const operation = spec.paths[pathKey][method];
-        if (operation.parameters) {
-          operation.parameters = operation.parameters
-            .filter(
-              (param) =>
-                !["QB-Realm-Hostname", "Authorization", "User-Agent"].includes(
-                  param.name
-                )
-            )
-            .map((param) => {
-              param.name = toCamelCase(param.name);
-              if ("example" in param) delete param.example;
-              if ("schema" in param && param.in !== "body") delete param.schema;
-              if (!param.type && param.in !== "body") {
-                param.type = param.name.includes("Id") ? "string" : "string";
-                console.log(
-                  `Set default type 'string' for ${pathKey}(${method}).${param.name} in initial pass`
-                );
-              }
-              return param;
-            });
-        }
+  if (!spec.definitions || typeof spec.definitions !== "object") {
+    spec.definitions = {};
+  }
+  console.log("Spec definitions after initialization:", spec.definitions);
+
+  console.log("Fixing parameters...");
+  for (const pathKey in spec.paths) {
+    for (const method in spec.paths[pathKey]) {
+      const operation = spec.paths[pathKey][method];
+      if (operation.parameters) {
+        operation.parameters = operation.parameters
+          .filter(
+            (param) =>
+              !["QB-Realm-Hostname", "Authorization", "User-Agent"].includes(
+                param.name
+              )
+          )
+          .map((param) => {
+            param.name = toCamelCase(param.name);
+            if ("example" in param) delete param.example;
+            if ("schema" in param && param.in !== "body") delete param.schema;
+            if (!param.type && param.in !== "body") {
+              param.type = param.name.includes("Id") ? "string" : "string";
+              console.log(
+                `Set default type 'string' for ${pathKey}(${method}).${param.name}`
+              );
+            }
+            return param;
+          });
       }
     }
+  }
 
-    // Removed applyOverrides conditional logic
-    console.log("Enhancing raw spec with tags...");
-    enhanceTags(spec);
-    console.log("Enhancing raw spec with general enhancements...");
-    enhanceGeneral(spec);
-
-    console.log("Fixing array schemas...");
-    fixArrays(spec);
+  console.log("Spec definitions before enhanceTags:", spec.definitions);
+  console.log("Enhancing raw spec with tags...");
+  const { enhanceTags } = await import("./schema/tags/index.ts"); // Updated to index.ts
+  enhanceTags(spec);
+  console.log("Enhancing raw spec with general enhancements...");
+  const { enhanceGeneral } = await import("./schema/enhance-general.ts");
+  enhanceGeneral(spec);
+  console.log("Fixing array schemas...");
+  const { fixArrays } = await import("./schema/fix-arrays.ts");
+  fixArrays(spec);
 
-    console.log("Removing unexpected top-level attributes...");
-    delete spec.operations;
-    delete spec.groups;
-    delete spec.components;
+  console.log("Removing unexpected top-level attributes...");
+  delete spec.operations;
+  delete spec.groups;
+  delete spec.components;
 
-    console.log(`Writing fixed spec to ${path.basename(outputFile)}...`);
-    await fs.mkdir(OUTPUT_DIR, { recursive: true });
-    await fs.writeFile(outputFile, JSON.stringify(spec, null, 2), "utf8");
-    console.log("Spec fixed successfully! Output written to:", outputFile);
-  } catch (error) {
-    console.error("Failed to fix spec:", error);
-    process.exit(1);
-  }
+  console.log(`Writing fixed spec to ${path.basename(outputFile)}...`);
+  await fs.mkdir(OUTPUT_DIR, { recursive: true });
+  await fs.writeFile(outputFile, JSON.stringify(spec, null, 2), "utf8");
+  console.log("Spec fixed successfully! Output written to:", outputFile);
 }
 
 async function main() {
   try {
+    console.log("Starting...");
     await fixQuickBaseSpec();
   } catch (error) {
-    console.error("Fatal error in script execution:", error);
+    console.error("Error:", error);
     process.exit(1);
   }
 }

package/open-api/generate-override-report.ts

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import { promises as fs } from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import fastJsonPatch, { AddOperation } from "fast-json-patch";
+import { Spec } from "./types/spec";
+
+const { compare, applyPatch } = fastJsonPatch;
+
+// Basic CSS for readability
+const HTML_STYLE = `
+  <style>
+    .jsondiffpatch-delta { font-family: monospace; }
+    .jsondiffpatch-added { background-color: #e6ffe6; color: #006400; }
+    .jsondiffpatch-deleted { background-color: #ffe6e6; color: #8b0000; text-decoration: line-through; }
+    .jsondiffpatch-modified { background-color: #fff3e6; }
+    .jsondiffpatch-unchanged { color: #666; }
+    .jsondiffpatch-key { font-weight: bold; }
+    .jsondiffpatch-tags { color: purple; font-style: italic; }
+  </style>
+`;
+
+// Helper to decode JSON Pointer paths
+function decodeJsonPointer(jsonPointerSegment: string): string {
+  // Split the full path and decode each segment
+  const segments = jsonPointerSegment.split("/").filter(Boolean);
+  const decodedSegments = segments.map((seg) =>
+    seg.replace("~1", "/").replace("~0", "~")
+  );
+  // Remove "paths" prefix and join with a single leading slash
+  const pathIndex = decodedSegments.indexOf("paths");
+  const relevantSegments =
+    pathIndex !== -1 && pathIndex + 1 < decodedSegments.length
+      ? decodedSegments.slice(pathIndex + 1)
+      : decodedSegments;
+  return "/" + relevantSegments.join("/"); // Ensure single leading slash
+}
+
+// Enhanced HTML formatter with clean paths, tags, and old vs. new values
+function formatPatchToHtml(patch: any[], spec: Spec): string {
+  let html = `<html><head><title>Override Report Diff</title>${HTML_STYLE}</head><body><h1>Override Report Diff</h1>`;
+  patch.forEach((op) => {
+    const pathParts = op.path.split("/").filter(Boolean);
+    const lastPart = pathParts[pathParts.length - 1];
+    let oldValue = "N/A";
+    let context = decodeJsonPointer(op.path);
+    let method = op.method ? op.method.toUpperCase() : "";
+
+    if (method) context = context.replace(`/${method}`, "") + ` [${method}]`;
+
+    if (op.op === "replace" || op.op === "remove") {
+      const reversePatch: AddOperation<any>[] = [
+        { op: "add", path: op.path, value: op.value },
+      ];
+      const tempSpec = JSON.parse(JSON.stringify(spec));
+      applyPatch(tempSpec, reversePatch);
+      const pathSegments = op.path.split("/").slice(1);
+      oldValue =
+        pathSegments.reduce((obj: any, key: string) => obj?.[key], tempSpec) ||
+        "N/A";
+      oldValue = JSON.stringify(oldValue);
+    }
+
+    const tagDisplay =
+      op.tags && op.tags.length > 0 ? ` (Tags: ${op.tags.join(", ")})` : "";
+
+    if (op.op === "replace") {
+      html += `<h2>Path: ${context}${tagDisplay}</h2><p>Modified: <span class="jsondiffpatch-deleted">${oldValue}</span> → <span class="jsondiffpatch-added">${JSON.stringify(
+        op.value
+      )}</span></p>`;
+    } else if (op.op === "add") {
+      html += `<h2>Path: ${context}${tagDisplay}</h2><p>Added: <span class="jsondiffpatch-added">${JSON.stringify(
+        op.value
+      )}</span></p>`;
+    } else if (op.op === "remove") {
+      html += `<h2>Path: ${context}${tagDisplay}</h2><p>Removed: <span class="jsondiffpatch-deleted">${oldValue}</span></p>`;
+    }
+  });
+  html += "</body></html>";
+  return html;
+}
+
+async function generateOverrideReport(): Promise<void> {
+  try {
+    const CODEGEN_DIR: string = path.dirname(fileURLToPath(import.meta.url));
+    const SPECS_DIR: string = path.join(CODEGEN_DIR, "..", "specs");
+    const OUTPUT_DIR: string = path.join(CODEGEN_DIR, "output");
+    const RAW_SPEC: string = path.join(
+      SPECS_DIR,
+      "QuickBase_RESTful_API_2025-03-04T06_22_39.725Z.json"
+    );
+    const FIXED_SPEC: string = path.join(OUTPUT_DIR, "quickbase-fixed.json");
+    const JSON_OUTPUT_FILE: string = path.join(
+      OUTPUT_DIR,
+      "override-report.json"
+    );
+    const HTML_OUTPUT_FILE: string = path.join(
+      OUTPUT_DIR,
+      "override-report.html"
+    );
+
+    console.log("Cleaning up old override report...");
+    if (
+      await fs
+        .stat(JSON_OUTPUT_FILE)
+        .then(() => true)
+        .catch(() => false)
+    ) {
+      await fs.unlink(JSON_OUTPUT_FILE);
+      console.log(`Removed ${JSON_OUTPUT_FILE}`);
+    }
+    if (
+      await fs
+        .stat(HTML_OUTPUT_FILE)
+        .then(() => true)
+        .catch(() => false)
+    ) {
+      await fs.unlink(HTML_OUTPUT_FILE);
+      console.log(`Removed ${HTML_OUTPUT_FILE}`);
+    } else {
+      console.log("No old override reports found to remove.");
+    }
+
+    if (
+      !(await fs
+        .stat(RAW_SPEC)
+        .then(() => true)
+        .catch(() => false))
+    ) {
+      console.error(`Raw spec ${RAW_SPEC} not found.`);
+      process.exit(1);
+    }
+    if (
+      !(await fs
+        .stat(FIXED_SPEC)
+        .then(() => true)
+        .catch(() => false))
+    ) {
+      console.error(
+        `Fixed spec ${FIXED_SPEC} not found. Run 'npm run fix-spec' first.`
+      );
+      process.exit(1);
+    }
+
+    console.log(`Reading raw spec from ${RAW_SPEC}...`);
+    const rawContent = await fs.readFile(RAW_SPEC, "utf8");
+    const rawSpec: Spec = JSON.parse(rawContent);
+
+    console.log(`Reading fixed spec from ${FIXED_SPEC}...`);
+    const fixedContent = await fs.readFile(FIXED_SPEC, "utf8");
+    const fixedSpec: Spec = JSON.parse(fixedContent);
+
+    console.log("Generating patch...");
+    const patch = compare(rawSpec, fixedSpec);
+
+    // Enhance patch with decoded paths and tags inferred from parent operation
+    const enhancedPatch = patch.map((op) => {
+      let decodedPath = decodeJsonPointer(op.path);
+      let tags: string[] = [];
+      let method: string = "";
+
+      if (op.path.startsWith("/paths")) {
+        const pathParts = op.path.split("/").filter(Boolean);
+        if (
+          pathParts.length >= 3 &&
+          ["get", "post", "put", "delete"].includes(pathParts[2].toLowerCase())
+        ) {
+          const fullPathSegment = "/paths/" + pathParts[1];
+          const basePath = decodeJsonPointer(fullPathSegment);
+          method = pathParts[2];
+          console.log(`Debug: basePath=${basePath}, method=${method}`); // Debug log
+          if (rawSpec.paths[basePath]?.[method]?.tags) {
+            tags = rawSpec.paths[basePath][method].tags || [];
+          } else if (rawSpec.paths[basePath]?.[method]) {
+            console.log(`No tags found for ${basePath} [${method}]`);
+          } else {
+            console.log(`Operation not found: ${basePath} [${method}]`);
+          }
+        }
+      }
+
+      return {
+        ...op,
+        decodedPath,
+        tags: tags.length > 0 ? tags : undefined,
+        method,
+      };
+    });
+
+    console.log("Writing JSON override report...");
+    await fs.mkdir(OUTPUT_DIR, { recursive: true });
+    await fs.writeFile(
+      JSON_OUTPUT_FILE,
+      JSON.stringify(enhancedPatch, null, 2),
+      "utf8"
+    );
+
+    console.log("Writing HTML override report...");
+    const htmlContent = formatPatchToHtml(enhancedPatch, rawSpec);
+    await fs.writeFile(HTML_OUTPUT_FILE, htmlContent, "utf8");
+
+    console.log("Override report generated successfully!");
+  } catch (error) {
+    console.error("Failed to generate override report:", error);
+    process.exit(1);
+  }
+}
+
+async function main() {
+  await generateOverrideReport();
+}
+
+main();