quickbase-js 0.1.0-beta.12 → 0.1.0-beta.14

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

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

@@ -1,117 +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), "..");
-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

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

@@ -1,68 +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) {
-              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})`
-        );
-      }
-    });
-  }
-}