quickbase-js 0.1.0-beta.8 → 1.0.0

package/open-api/regenerate-client.ts

@@ -1,116 +0,0 @@
-#!/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), ".."); // open-api/
-const JARS_DIR = join(CODEGEN_DIR, "..", "tools", "openapi-jars"); // Updated to tools/openapi-jars/
-const SPEC_INPUT = join(CODEGEN_DIR, "output", "quickbase-fixed.json"); // Relative to open-api/
-const OUTPUT_DIR = join(CODEGEN_DIR, "..", "src", "generated"); // Up to root, then into 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`;
-  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

@@ -1,100 +0,0 @@
-// schema/enhance-general.ts
-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})`
-              );
-              if (!response.schema.type && response["x-amf-mediaType"]) {
-                const mediaType = response["x-amf-mediaType"];
-                if (mediaType === "application/octet-stream") {
-                  response.schema = {
-                    type: "object",
-                    properties: { data: { type: "string", format: "binary" } },
-                    description:
-                      response.schema?.description || "Binary file content",
-                  };
-                } else if (mediaType === "application/x-yaml") {
-                  response.schema = {
-                    type: "object",
-                    properties: { content: { type: "string", format: "yaml" } },
-                    description: "YAML-formatted data",
-                  };
-                } else if (
-                  mediaType === "application/json" &&
-                  response.schema.example
-                ) {
-                  response.schema = inferSchema(
-                    response.schema.example,
-                    responseName
-                  );
-                  response.schema.description =
-                    response.description || `Response for ${opId}`;
-                }
-              }
-              spec.definitions[responseName] = response.schema;
-            }
-            response.schema = { $ref: `#/definitions/${responseName}` };
-          }
-        }
-      }
-    }
-  }
-}

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

@@ -1,69 +0,0 @@
-// 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) {
-              // Fixed: Changed param to response
-              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

@@ -1,90 +0,0 @@
-// 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})`
-        );
-      }
-    });
-  }
-}