quickbase-js 0.1.0-beta.7

package/open-api/regenerate-client.ts

@@ -0,0 +1,116 @@
+#!/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

@@ -0,0 +1,100 @@
+// 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

@@ -0,0 +1,69 @@
+// 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

@@ -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})`
+        );
+      }
+    });
+  }
+}

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

@@ -0,0 +1,156 @@
+// schema/tags/fields.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+
+export function enhanceFields(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (operation.parameters && operation.tags?.includes("Fields")) {
+    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 (method === "delete") {
+            properties = {
+              fieldIds: { type: "array", items: { type: "integer" } },
+            };
+          } else {
+            properties = {
+              label: { type: "string", description: "The label of the field" },
+              fieldType: {
+                type: "string",
+                description: "The type of the field",
+                enum: [
+                  "text",
+                  "text-multiple-choice",
+                  "text-multi-line",
+                  "rich-text",
+                  "numeric",
+                  "currency",
+                  "percent",
+                  "rating",
+                  "date",
+                  "date-time",
+                  "time-of-day",
+                  "duration",
+                  "checkbox",
+                  "user",
+                  "multi-user",
+                  "address",
+                  "email",
+                  "phone",
+                  "url",
+                  "file",
+                  "record-id",
+                ],
+              },
+              fieldHelp: {
+                type: "string",
+                description: "Help text for the field",
+                nullable: true,
+              },
+              addToForms: {
+                type: "boolean",
+                description: "Whether to add the field to forms",
+                nullable: true,
+              },
+              permissions: {
+                anyOf: [
+                  {
+                    type: "array",
+                    items: { $ref: "#/definitions/Permission" },
+                  },
+                  { type: "null" },
+                ],
+                description: "Custom permissions for the field",
+              },
+              required: {
+                type: "boolean",
+                description: "Whether the field is required",
+                nullable: true,
+              },
+              unique: {
+                type: "boolean",
+                description: "Whether the field must have unique values",
+                nullable: true,
+              },
+              noWrap: {
+                type: "boolean",
+                description: "Whether text wrapping is disabled",
+                nullable: true,
+              },
+              bold: {
+                type: "boolean",
+                description: "Whether the field is bolded",
+                nullable: true,
+              },
+              appearsByDefault: {
+                type: "boolean",
+                description: "Whether the field appears by default in reports",
+                nullable: true,
+              },
+              findEnabled: {
+                type: "boolean",
+                description: "Whether the field is searchable",
+                nullable: true,
+              },
+              doesDataCopy: {
+                type: "boolean",
+                description: "Whether the field copies data",
+                nullable: true,
+              },
+              audited: {
+                type: "boolean",
+                description: "Whether changes to the field are audited",
+                nullable: true,
+              },
+            };
+          }
+          spec.definitions[requestName] = {
+            type: "object",
+            properties,
+            required: Object.keys(properties).filter(
+              (key) =>
+                ![
+                  "fieldHelp",
+                  "addToForms",
+                  "permissions",
+                  "required",
+                  "unique",
+                  "noWrap",
+                  "bold",
+                  "appearsByDefault",
+                  "findEnabled",
+                  "doesDataCopy",
+                  "audited",
+                ].includes(key)
+            ),
+            description: operation.summary || `Request body for ${opId}`,
+          };
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}

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

@@ -0,0 +1,51 @@
+// schema/tags/groups.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+
+export function enhanceGroups(
+  spec: Spec,
+  pathKey: string,
+  method: string,
+  operation: Operation
+): void {
+  const opId =
+    operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+  if (
+    operation.parameters &&
+    operation.tags?.includes("Groups") &&
+    operation.summary?.toLowerCase().includes("subgroup")
+  ) {
+    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})`
+          );
+          const properties = {
+            groupIds: { type: "array", items: { type: "string" } },
+          };
+          spec.definitions[requestName] = {
+            type: "object",
+            properties,
+            required: Object.keys(properties),
+            description: operation.summary || `Request body for ${opId}`,
+          };
+        }
+        param.schema = { $ref: `#/definitions/${requestName}` };
+        console.log(
+          `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+        );
+      }
+    });
+  }
+}

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

@@ -0,0 +1,68 @@
+// schema/tags/index.ts
+import { Operation, Parameter, Spec } from "../../types/spec.ts";
+import { normalizeDefinitionName } from "../../utils/naming.ts";
+import { enhanceUsers } from "./users.ts";
+import { enhanceGroups } from "./groups.ts";
+import { enhanceRecords } from "./records.ts";
+import { enhanceApps } from "./apps.ts";
+import { enhanceFields } from "./fields.ts";
+import { enhanceTables } from "./tables.ts";
+
+export function enhanceTags(spec: Spec): void {
+  spec.definitions = spec.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, "")}`;
+
+      // Handle array schemas
+      if (operation.parameters) {
+        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]?.type === "array") {
+              console.log(
+                `Wrapping array schema for ${requestName} in ${pathKey}(${method})`
+              );
+              const arraySchema = spec.definitions[requestName];
+              let wrapperPropName = operation.tags?.includes("Users")
+                ? "userIds"
+                : "items";
+              if (
+                operation.tags?.includes("Groups") &&
+                operation.summary?.toLowerCase().includes("subgroup")
+              ) {
+                wrapperPropName = "groupIds";
+              }
+              spec.definitions[requestName] = {
+                type: "object",
+                properties: { [wrapperPropName]: arraySchema },
+                required: arraySchema.minItems > 0 ? [wrapperPropName] : [],
+                description:
+                  arraySchema.description || `Request body for ${opId}`,
+              };
+              param.schema = { $ref: `#/definitions/${requestName}` };
+              console.log(
+                `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+              );
+            }
+          }
+        });
+      }
+
+      // Apply tag-specific enhancements
+      enhanceUsers(spec, pathKey, method, operation);
+      enhanceGroups(spec, pathKey, method, operation);
+      enhanceRecords(spec, pathKey, method, operation);
+      enhanceApps(spec, pathKey, method, operation);
+      enhanceFields(spec, pathKey, method, operation);
+      enhanceTables(spec, pathKey, method, operation);
+    }
+  }
+}