quickbase-js 0.1.0-beta.10

package/open-api/post-process-generated.ts

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const GENERATED_DIR = join(__dirname, "..", "src", "generated");
+const MODELS_DIR = join(GENERATED_DIR, "models");
+const SPEC_FILE = join(__dirname, "output", "quickbase-fixed.json");
+
+function toPascalCase(str: string): string {
+  return str.replace(/(^\w|_\w)/g, (match) =>
+    match.replace("_", "").toUpperCase()
+  );
+}
+
+function ensureDir(dir: string) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+function mapOpenApiTypeToTs(openApiType: string): string {
+  switch (openApiType) {
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "object":
+      return "object";
+    default:
+      return "any";
+  }
+}
+
+function generateItemsInnerInterface(
+  itemSchema: any,
+  itemName: string
+): string {
+  const properties = itemSchema?.properties || {};
+  const propsStr = Object.entries(properties)
+    .map(([key, prop]: [string, any]) => {
+      let type;
+      if (key === "permissions" && prop.type === "array") {
+        type = "Permission[]";
+      } else if (key === "properties" && prop.type === "object") {
+        type = "{ [key: string]: any }";
+      } else {
+        type = mapOpenApiTypeToTs(prop.type);
+      }
+      const isRequired = itemSchema.required?.includes(key);
+      const description = prop.description ? ` * ${prop.description}` : "";
+      return `  /**
+${description}
+ * @type {${type}}
+ */
+  ${key}${isRequired ? "" : "?"}: ${type};`;
+    })
+    .join("\n");
+
+  const additionalProps =
+    itemSchema.additionalProperties === true
+      ? `  /**
+   * Allows additional unspecified properties
+   * @type {any}
+   */
+  [key: string]: any;`
+      : "";
+
+  return `
+/* Auto-generated by post-process-generated.ts */
+import { mapValues } from '../runtime';
+import { Permission } from './Permission';
+
+/**
+ * Auto-generated model for ${itemName}
+ */
+export interface ${itemName} {
+${propsStr}
+${additionalProps}
+}
+
+export function ${itemName}FromJSON(json: any): ${itemName} {
+  return json || {};
+}
+
+export function ${itemName}ToJSON(value?: ${itemName} | null): any {
+  return value || {};
+}
+  `.trim();
+}
+
+function postProcessGeneratedFiles() {
+  console.log("Starting post-processing...");
+  console.log("Spec file path:", SPEC_FILE);
+
+  try {
+    if (!existsSync(SPEC_FILE)) {
+      console.error(
+        `Spec file ${SPEC_FILE} not found. Run 'npm run fix-spec' first.`
+      );
+      process.exit(1);
+    }
+
+    const spec = JSON.parse(readFileSync(SPEC_FILE, "utf8"));
+    console.log("Spec loaded successfully.");
+
+    const responseMap: Record<string, string> = {};
+    for (const pathKey in spec.paths) {
+      const pathObj = spec.paths[pathKey];
+      if (!pathObj || typeof pathObj !== "object") continue;
+      for (const method in pathObj) {
+        const operation = pathObj[method];
+        const opId =
+          operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+        const response = operation.responses?.["200"];
+        if (response && response.schema?.$ref) {
+          const refName = response.schema.$ref.split("/").pop() || "";
+          responseMap[opId] = refName;
+          console.log(`Mapped ${opId} to ${refName}`);
+        }
+      }
+    }
+
+    for (const [opId, refName] of Object.entries(responseMap)) {
+      try {
+        const def = spec.definitions[refName];
+        if (!def) {
+          console.log(`Definition for ${refName} not found; skipping`);
+          continue;
+        }
+
+        const responseFile = join(MODELS_DIR, `${toPascalCase(refName)}.ts`);
+
+        if (def.type === "array") {
+          const itemRef = def.items?.$ref
+            ? def.items.$ref.split("/").pop()
+            : `${toPascalCase(refName)}ItemsInner`;
+          const itemsFile = join(MODELS_DIR, `${itemRef}.ts`);
+
+          if (!existsSync(itemsFile)) {
+            console.log(`Creating missing ${itemRef}.ts`);
+            const content = def.items?.$ref
+              ? `
+/* Auto-generated by post-process-generated.ts */
+import { mapValues } from '../runtime';
+
+/**
+ * Auto-generated model for ${itemRef}
+ */
+export interface ${itemRef} {
+  [key: string]: any; // Placeholder; refine as needed
+}
+
+export function ${itemRef}FromJSON(json: any): ${itemRef} {
+  return json || {};
+}
+
+export function ${itemRef}ToJSON(value?: ${itemRef} | null): any {
+  return value || {};
+}
+            `
+              : generateItemsInnerInterface(def.items || {}, itemRef);
+            ensureDir(MODELS_DIR);
+            writeFileSync(itemsFile, content.trim(), "utf8");
+          }
+
+          if (existsSync(responseFile)) {
+            console.log(`Rewriting ${refName}.ts as array`);
+            const content = `
+/* Auto-generated by post-process-generated.ts */
+import { ${itemRef}, ${itemRef}FromJSON, ${itemRef}ToJSON } from './${itemRef}';
+
+/**
+ * Response for ${opId}
+ */
+export type ${toPascalCase(refName)} = ${itemRef}[];
+
+/**
+ * Convert JSON to ${toPascalCase(refName)}
+ */
+export function ${toPascalCase(refName)}FromJSON(json: any): ${toPascalCase(
+              refName
+            )} {
+  if (!json) return [];
+  return json.map(${itemRef}FromJSON);
+}
+
+/**
+ * Convert ${toPascalCase(refName)} to JSON
+ */
+export function ${toPascalCase(refName)}ToJSON(value?: ${toPascalCase(
+              refName
+            )} | null): any {
+  if (!value) return [];
+  return value.map(${itemRef}ToJSON);
+}
+            `;
+            writeFileSync(responseFile, content.trim(), "utf8");
+          }
+        } else if (def.type === "object") {
+          console.log(`Processing ${refName}.ts as object`);
+          const content = generateItemsInnerInterface(
+            def,
+            toPascalCase(refName)
+          );
+          ensureDir(MODELS_DIR);
+          writeFileSync(responseFile, content.trim(), "utf8");
+        }
+      } catch (error) {
+        console.error(`Error processing ${refName}:`, error);
+      }
+    }
+
+    console.log("Post-processing complete.");
+  } catch (error) {
+    console.error("Error in post-processing:", error);
+    process.exit(1);
+  }
+}
+
+postProcessGeneratedFiles();

package/open-api/regenerate-client.ts

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import fetch from "node-fetch";
+import readline from "readline";
+
+const CURRENT_JAR_VERSION = "7.12.0";
+const MAVEN_METADATA_URL =
+  "https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/maven-metadata.xml";
+const CODEGEN_DIR = join(fileURLToPath(import.meta.url), "..");
+const JARS_DIR = join(CODEGEN_DIR, "..", "tools", "openapi-jars");
+const SPEC_INPUT = join(CODEGEN_DIR, "output", "quickbase-fixed.json");
+const OUTPUT_DIR = join(CODEGEN_DIR, "..", "src", "generated");
+
+async function getLatestVersion(): Promise<string> {
+  const response = await fetch(MAVEN_METADATA_URL);
+  if (!response.ok)
+    throw new Error(`Failed to fetch Maven metadata: ${response.statusText}`);
+  const text = await response.text();
+  const match = text.match(/<latest>(.*?)<\/latest>/);
+  if (!match)
+    throw new Error("Couldn’t parse latest version from Maven metadata");
+  return match[1];
+}
+
+async function checkAndPromptForUpdate(messages: string[]): Promise<string> {
+  const latestVersion = await getLatestVersion();
+  if (latestVersion === CURRENT_JAR_VERSION) {
+    messages.push(`Current version (${CURRENT_JAR_VERSION}) is the latest.`);
+    return CURRENT_JAR_VERSION;
+  }
+
+  messages.push(
+    `Newer version available: ${latestVersion} (current: ${CURRENT_JAR_VERSION})`
+  );
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    const prompt = "Do you want to update to the latest version? (y/n): ";
+    messages.push(prompt);
+    rl.question(prompt, (answer) => {
+      rl.close();
+      if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+        messages.push(`Switching to version ${latestVersion}...`);
+        resolve(latestVersion);
+      } else {
+        messages.push(`Sticking with version ${CURRENT_JAR_VERSION}.`);
+        resolve(CURRENT_JAR_VERSION);
+      }
+    });
+  });
+}
+
+async function ensureJarExists(
+  version: string,
+  messages: string[]
+): Promise<string> {
+  const jarPath = join(JARS_DIR, `openapi-generator-cli-${version}.jar`);
+  const jarUrl = `https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/${version}/openapi-generator-cli-${version}.jar`;
+
+  if (!existsSync(jarPath)) {
+    messages.push(`Downloading OpenAPI Generator CLI v${version}...`);
+    try {
+      execSync(`curl -L -o ${jarPath} ${jarUrl}`, { stdio: "inherit" });
+      messages.push(`Downloaded ${jarPath}`);
+    } catch (error) {
+      messages.push("Failed to download JAR.");
+      throw error;
+    }
+  } else {
+    messages.push(`Using existing ${jarPath}`);
+  }
+  return jarPath;
+}
+
+function regenerateClient(jarPath: string, messages: string[]) {
+  messages.push("Regenerating client from spec...");
+  const command = `java -jar ${jarPath} generate -i ${SPEC_INPUT} -g typescript-fetch -o ${OUTPUT_DIR} --additional-properties=generateAliasAsModel=true,withInterfaces=true,supportsES6=true,modelPropertyNaming=original`;
+  try {
+    execSync(command, { stdio: "inherit" });
+    messages.push("Client regeneration complete.");
+  } catch (error) {
+    messages.push("Regeneration failed.");
+    throw error;
+  }
+}
+
+async function main() {
+  const messages: string[] = [];
+  try {
+    if (!existsSync(SPEC_INPUT)) {
+      console.error(
+        `Spec file ${SPEC_INPUT} does not exist. Run 'npm run fix-spec' first.`
+      );
+      process.exit(1);
+    }
+    const versionToUse = await checkAndPromptForUpdate(messages);
+    const jarPath = await ensureJarExists(versionToUse, messages);
+    regenerateClient(jarPath, messages);
+  } catch (error) {
+    console.error("Error occurred during process:", error);
+  } finally {
+    console.log("\n--- Key Messages ---");
+    messages.forEach((msg) => console.log(msg));
+  }
+}
+
+main().catch((error) => {
+  console.error("Error in regeneration process:", error);
+  process.exit(1);
+});

package/open-api/schema/enhance-general.ts

@@ -0,0 +1,111 @@
+import { Operation, Parameter, Spec } from "../types/spec.ts";
+import { inferSchema } from "../utils/infer-schema.ts";
+
+export function enhanceGeneral(spec: Spec): void {
+  spec.definitions = spec.definitions || {};
+
+  if (!spec.definitions["Record"]) {
+    spec.definitions["Record"] = {
+      type: "object",
+      additionalProperties: {
+        type: "object",
+        properties: { value: { type: "string" } },
+        required: ["value"],
+      },
+      description: "A generic QuickBase record with field ID-value pairs",
+    };
+    console.log("Added Record to definitions");
+  }
+
+  if (!spec.definitions["Permission"]) {
+    spec.definitions["Permission"] = {
+      type: "object",
+      properties: {
+        role: { type: "string", description: "The role name" },
+        permissionType: {
+          type: "string",
+          description: "Permission type (e.g., View, Modify)",
+        },
+        roleId: { type: "integer", description: "The role identifier" },
+      },
+      required: ["role", "permissionType", "roleId"],
+      description: "A single permission entry for a field",
+    };
+    console.log("Added Permission to definitions");
+  }
+
+  for (const pathKey in spec.paths) {
+    for (const method in spec.paths[pathKey]) {
+      const operation: Operation = spec.paths[pathKey][method];
+      const opId =
+        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+
+      if (operation.parameters) {
+        operation.parameters.forEach((param: Parameter) => {
+          if (param.in !== "body" && !param.type && !param.schema) {
+            param.type = param.name.includes("Id") ? "string" : "string";
+            console.log(
+              `Set default type 'string' for ${pathKey}(${method}).${param.name}`
+            );
+          }
+        });
+      }
+
+      if (operation.responses) {
+        for (const status in operation.responses) {
+          const response = operation.responses[status];
+          if (response.schema) {
+            const cleanStatus = status.replace("/", "_");
+            const responseName = `${opId}${cleanStatus}Response`;
+            if (!spec.definitions[responseName]) {
+              console.log(
+                `Adding ${responseName} to definitions for ${pathKey}(${method})`
+              );
+              let schemaToUse = response.schema;
+              // Only infer from example if schema is truly empty
+              if (
+                !schemaToUse.type &&
+                !schemaToUse.items &&
+                !schemaToUse.properties
+              ) {
+                if (response["x-amf-mediaType"]) {
+                  const mediaType = response["x-amf-mediaType"];
+                  if (mediaType === "application/octet-stream") {
+                    schemaToUse = {
+                      type: "object",
+                      properties: {
+                        data: { type: "string", format: "binary" },
+                      },
+                      description:
+                        schemaToUse?.description || "Binary file content",
+                    };
+                  } else if (mediaType === "application/x-yaml") {
+                    schemaToUse = {
+                      type: "object",
+                      properties: {
+                        content: { type: "string", format: "yaml" },
+                      },
+                      description: "YAML-formatted data",
+                    };
+                  } else if (
+                    mediaType === "application/json" &&
+                    schemaToUse.example
+                  ) {
+                    schemaToUse = inferSchema(
+                      schemaToUse.example,
+                      responseName
+                    );
+                    schemaToUse.description =
+                      response.description || `Response for ${opId}`;
+                  }
+                }
+              }
+              spec.definitions[responseName] = schemaToUse;
+            }
+            response.schema = { $ref: `#/definitions/${responseName}` };
+          }
+        }
+      }
+    }
+  }
+}

package/open-api/schema/fix-arrays.ts

@@ -0,0 +1,68 @@
+// schema/fix-arrays.ts
+import { Parameter, Spec } from "../types/spec.ts";
+
+export function fixArrays(spec: Spec): void {
+  for (const pathKey in spec.paths) {
+    for (const method in spec.paths[pathKey]) {
+      const operation = spec.paths[pathKey][method];
+      if (operation.parameters) {
+        operation.parameters.forEach((param: Parameter) => {
+          if (param.schema?.type === "array" && !param.schema.items) {
+            console.log(
+              `Fixing array schema for ${pathKey}(${method}).${param.name}`
+            );
+            param.schema.items = { type: "string" };
+          }
+          if (param.schema?.properties) {
+            for (const propKey in param.schema.properties) {
+              const prop = param.schema.properties[propKey];
+              if (prop.type === "array" && !prop.items) {
+                console.log(
+                  `Fixing nested array for ${pathKey}(${method}).${param.name}.${propKey}`
+                );
+                prop.items = { type: "string" };
+              }
+            }
+          }
+        });
+      }
+      if (operation.responses) {
+        for (const status in operation.responses) {
+          const response = operation.responses[status];
+          if (response.schema?.type === "array" && !response.schema.items) {
+            console.log(
+              `Fixing array schema for ${pathKey}(${method}).responses.${status}`
+            );
+            response.schema.items = { type: "string" };
+          }
+          if (response.schema?.properties) {
+            for (const propKey in response.schema.properties) {
+              const prop = response.schema.properties[propKey];
+              if (prop.type === "array" && !prop.items) {
+                console.log(
+                  `Fixing nested array for ${pathKey}(${method}).responses.${status}.${propKey}`
+                );
+                prop.items = { type: "string" };
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  console.log("Fixing array schemas in definitions...");
+  const definitions = spec.definitions || {};
+  for (const defKey in definitions) {
+    const def = definitions[defKey];
+    if (def.properties) {
+      for (const propKey in def.properties) {
+        const prop = def.properties[propKey];
+        if (prop.type === "array" && !prop.items) {
+          console.log(`Fixing missing items in ${defKey}.${propKey}`);
+          prop.items = { type: "string" };
+        }
+      }
+    }
+  }
+}

package/open-api/schema/tags/apps.ts

@@ -0,0 +1,90 @@
+// schema/tags/apps.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+
+export function enhanceApps(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (operation.parameters && operation.tags?.includes("Apps")) {
+    operation.parameters.forEach((param: Parameter) => {
+      if (param.in === "body") {
+        if (!param.schema) param.schema = {};
+        let requestName =
+          param.schema.$ref?.split("/").pop() || `${opId}Request`;
+        requestName = normalizeDefinitionName(requestName);
+
+        if (
+          !spec.definitions[requestName] ||
+          !spec.definitions[requestName].type ||
+          Object.keys(spec.definitions[requestName]?.properties || {})
+            .length === 0
+        ) {
+          console.log(
+            `Defining schema for ${requestName} in ${pathKey}(${method})`
+          );
+          let properties;
+          if (pathKey.includes("/copy") && method === "post") {
+            properties = {
+              name: { type: "string", description: "The name of the new app." },
+              description: {
+                type: "string",
+                description: "A description for the new app.",
+              },
+              properties: {
+                type: "object",
+                properties: {
+                  keepData: {
+                    type: "boolean",
+                    description: "Whether to copy data.",
+                  },
+                  excludeFiles: {
+                    type: "boolean",
+                    description: "Whether to exclude files.",
+                  },
+                  usersAndRoles: {
+                    type: "boolean",
+                    description: "Whether to copy users and roles.",
+                  },
+                  assignUserToken: {
+                    type: "boolean",
+                    description: "Whether to assign the user token.",
+                  },
+                },
+                description: "Options for customizing the app copy process.",
+              },
+            };
+          } else {
+            properties = {
+              name: { type: "string", description: "The name of the app." },
+              description: {
+                type: "string",
+                description: "A description for the app.",
+              },
+              assignToken: {
+                type: "boolean",
+                description: "Whether to assign the user token.",
+              },
+            };
+          }
+          spec.definitions[requestName] = {
+            type: "object",
+            properties,
+            required: Object.keys(properties).filter(
+              (key) => key !== "description" && key !== "properties"
+            ),
+            description: operation.summary || `Request body for ${opId}`,
+          };
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}