quickbase-js 0.1.0-beta.10

package/examples/quicbase-jsCDN.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+    <title>Quickbase</title>
+    <script src="https://cdn.jsdelivr.net/npm/quickbase-js@1.1.0-beta.6/dist/umd/quickbase.umd.min.js"></script>
+</head>
+
+<body>
+    <div>
+        <h1>Quickbase-js CDN Example</h1>
+        <p id="result">Loading...</p>
+    </div>
+    <script>
+        var realm = "xxxxxxxxxxxxxxxxxxxx"; // replace with your realm
+        var appId = "xxxxxxxxxxxxxxxxxxxx"; // replace with your app ID
+        if (typeof QuickbaseJS === "undefined") {
+            document.getElementById("result").textContent = "Error: Failed to load QuickbaseJS library.";
+        } else {
+            var qbClient = QuickbaseJS.quickbase({
+                realm,
+                useTempTokens: true
+            });
+
+            qbClient.getApp({ appId })
+                .then(function (app) {
+                    document.getElementById("result").textContent = "App Name: " + app.name;
+                })
+                .catch(function (err) {
+                    document.getElementById("result").textContent = "Error: " + (err.message || "Failed to load app");
+                });
+        }
+    </script>
+</body>
+
+</html>

package/examples/react.js

@@ -0,0 +1,48 @@
+import React, { useState, useEffect } from "react";
+import { quickbase } from "quickbase-js";
+
+const App = () => {
+  const [appName, setAppName] = useState < string > "Loading...";
+  const [error, setError] = (useState < string) | (null > null);
+
+  useEffect(() => {
+    // Initialize the QuickBase client
+    const qb = quickbase({
+      realm: "your-realm", // Replace with actual QuickBase realm
+      // ## ------------------------------
+      // ## Authentication Options
+      // ## ------------------------------
+      // ## OPTION 1: User Token Authentication
+      // ## - Use this if you have a QuickBase user token (get it from "My Profile" > "Manage User Tokens")
+      // ## - Works in Node.js or browsers, ideal for standalone apps or testing outside QuickBase
+      // ## - Use the line below and replace with your token; comment out 'useTempTokens'
+      // userToken: "your-user-token",
+
+      // ## ------------------------------
+      // ## OPTION 2: Temporary Token Authentication
+      // ## - Use this for QuickBase code pages, leveraging the browser’s authenticated session
+      // ## - No user token needed; requires running in a QuickBase browser context
+      // ## - Uncomment the line below and comment out 'userToken' if using this option
+      // useTempTokens: true,
+    });
+
+    // Fetch the app
+    qb.getApp({ appId: "your-app-id" }) // Replace with actual app ID
+      .then((app) => {
+        setAppName(app.name);
+      })
+      .catch((err) => {
+        console.error("Error fetching app:", err);
+        setError("Failed to load app");
+      });
+  }, []); // Empty dependency array to run once on mount
+
+  return (
+    <div>
+      <h1>Quickbase Test</h1>
+      {error ? <p>{error}</p> : <p>App Name: {appName}</p>}
+    </div>
+  );
+};
+
+export default App;

package/examples/vanillajs.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <title>Quickbase Test</title>
+</head>
+
+<body>
+  <div>
+    <h1>Quickbase Test</h1>
+    <p id="result">Loading...</p>
+  </div>
+  <script type="module">
+    import { quickbase } from 'quickbase-js';
+    // Initalize the QuickBase client
+    const qb = quickbase({
+      realm: 'your-realm', // Replace with actual QuickBase realm
+      // ## ------------------------------
+      // ## Authentication Options
+      // ## ----------------------------
+      // ## OPTION 1: User Token Authentication
+      // ## - Use this if you have a QuickBase user token (get it from "My Profile" > "Manage User Tokens")
+      // ## - Works in Node.js or browsers, ideal for standalone apps or testing outside QuickBase
+      // ## - Uncomment the line below and replace with your token; comment out 'useTempTokens'
+      // userToken: "your-user-token",
+
+      // ## ----------------------------
+      // ## OPTION 2: Temporary Token Authentication
+      // ## - Use this for QuickBase code pages, leveraging the browser’s authenticated session
+      // ## - No user token needed; requires running in a QuickBase browser context
+      // ## - Uncomment the line below and comment out 'userToken' if using this option
+      // useTempTokens: true,
+    });
+
+    // Fetch the app
+    qb.getApp({ appId: 'your-app-id' }) // Replace with actual app ID
+      .then((app) => {
+        document.getElementById('result').textContent = `App Name: ${app.name}`;
+      })
+      .catch((err) => {
+        console.error('Error fetching app:', err);
+        document.getElementById('result').textContent = err.message || 'Failed to load app';
+      });
+  </script>
+</body>
+
+</html>

package/index.md

@@ -0,0 +1,25 @@
+---
+# https://vitepress.dev/reference/default-theme-home-page
+layout: home
+
+hero:
+  name: "Quickbase JS API Docs"
+  text: "Documentation for quickbase-js library"
+  tagline: My great project tagline
+  actions:
+    - theme: brand
+      text: Markdown Examples
+      link: /markdown-examples
+    - theme: alt
+      text: API Examples
+      link: /api-examples
+
+features:
+  - title: Feature A
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+  - title: Feature B
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+  - title: Feature C
+    details: Lorem ipsum dolor sit amet, consectetur adipiscing elit
+---
+

package/markdown-examples.md

@@ -0,0 +1,85 @@
+# Markdown Extension Examples
+
+This page demonstrates some of the built-in markdown extensions provided by VitePress.
+
+## Syntax Highlighting
+
+VitePress provides Syntax Highlighting powered by [Shiki](https://github.com/shikijs/shiki), with additional features like line-highlighting:
+
+**Input**
+
+````md
+```js{4}
+export default {
+  data () {
+    return {
+      msg: 'Highlighted!'
+    }
+  }
+}
+```
+````
+
+**Output**
+
+```js{4}
+export default {
+  data () {
+    return {
+      msg: 'Highlighted!'
+    }
+  }
+}
+```
+
+## Custom Containers
+
+**Input**
+
+```md
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+```
+
+**Output**
+
+::: info
+This is an info box.
+:::
+
+::: tip
+This is a tip.
+:::
+
+::: warning
+This is a warning.
+:::
+
+::: danger
+This is a dangerous warning.
+:::
+
+::: details
+This is a details block.
+:::
+
+## More
+
+Check out the documentation for the [full list of markdown extensions](https://vitepress.dev/guide/markdown).

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

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+import { Spec } from "./types/spec.ts";
+import { toCamelCase } from "./utils/naming.ts";
+
+async function fixQuickBaseSpec(): Promise<void> {
+  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."
+    );
+  }
+
+  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");
+  console.log("File read successfully");
+  const spec: Spec = JSON.parse(specContent);
+  console.log("JSON parsed successfully");
+
+  if (!spec.definitions || typeof spec.definitions !== "object") {
+    spec.definitions = {};
+  }
+  console.log("Spec definitions after initialization:", spec.definitions);
+
+  console.log(
+    "Original /apps/{appId}/events 200 schema:",
+    JSON.stringify(
+      spec.paths["/apps/{appId}/events"]?.get?.responses?.["200"]?.schema,
+      null,
+      2
+    )
+  );
+
+  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;
+          });
+      }
+    }
+  }
+
+  console.log("Spec definitions before enhanceTags:", spec.definitions);
+  console.log("Enhancing raw spec with tags...");
+  const { enhanceTags } = await import("./schema/tags/index.ts");
+  enhanceTags(spec);
+  console.log(
+    "After enhanceTags:",
+    JSON.stringify(
+      spec.paths["/apps/{appId}/events"]?.get?.responses?.["200"]?.schema,
+      null,
+      2
+    )
+  );
+
+  console.log("Enhancing raw spec with general enhancements...");
+  const { enhanceGeneral } = await import("./schema/enhance-general.ts");
+  enhanceGeneral(spec);
+  console.log(
+    "After enhanceGeneral:",
+    JSON.stringify(
+      spec.paths["/apps/{appId}/events"]?.get?.responses?.["200"]?.schema,
+      null,
+      2
+    )
+  );
+
+  console.log("Fixing array schemas...");
+  const { fixArrays } = await import("./schema/fix-arrays.ts");
+  fixArrays(spec);
+  console.log(
+    "After fixArrays:",
+    JSON.stringify(
+      spec.paths["/apps/{appId}/events"]?.get?.responses?.["200"]?.schema,
+      null,
+      2
+    )
+  );
+
+  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);
+}
+
+async function main() {
+  try {
+    console.log("Starting...");
+    await fixQuickBaseSpec();
+  } catch (error) {
+    console.error("Error:", error);
+    process.exit(1);
+  }
+}
+
+main();

package/open-api/generate-unified-interface.ts

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+console.log("Script started");
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+console.log("FS modules imported");
+
+import { join, dirname } from "path";
+console.log("Path modules imported");
+
+import { fileURLToPath } from "url";
+console.log("URL module imported");
+
+import { generateJsDoc } from "./utils/generateJsDoc.ts";
+import {
+  PropertyDetail,
+  ParamDetail,
+  JsDocOptions,
+  mapOpenApiTypeToTs,
+  mapRefToType,
+  parseInterfaceProperties,
+  parseOpenApiOperations,
+} from "./utils/sharedUtils.ts";
+import { writeFileSafe, runTask } from "./utils/common.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+console.log("__dirname set:", __dirname);
+
+const SPEC_FILE = join(__dirname, "output", "quickbase-fixed.json");
+const OUTPUT_DIR = join(__dirname, "..", "src", "generated-unified");
+const OUTPUT_FILE = join(OUTPUT_DIR, "QuickbaseClient.ts");
+const MODELS_DIR = join(__dirname, "..", "src", "generated", "models");
+
+function generateInterface(includeResponseProperties: boolean = false): void {
+  console.log(
+    "Generating interface with includeResponseProperties:",
+    includeResponseProperties
+  );
+
+  console.log("Checking spec file:", SPEC_FILE);
+  if (!existsSync(SPEC_FILE)) {
+    console.error(
+      `Spec file ${SPEC_FILE} not found. Run 'npm run fix-spec' first.`
+    );
+    process.exit(1);
+  }
+
+  console.log("Checking models directory:", MODELS_DIR);
+  if (!existsSync(MODELS_DIR)) {
+    console.error(
+      `Models directory ${MODELS_DIR} not found. Run 'npm run gen:openapi' first.`
+    );
+    process.exit(1);
+  }
+
+  const { operations, modelImports, missingTypes } = parseOpenApiOperations(
+    SPEC_FILE,
+    MODELS_DIR
+  );
+  console.log("Operations parsed:", operations.length);
+
+  const methods: string[] = operations.map((op) => {
+    const params = op.parameters
+      .map((p) => `${p.name}${p.required ? "" : "?"}: ${p.type}`)
+      .join("; ");
+    const jsDocOptions: JsDocOptions = {
+      summary: op.summary,
+      opId: op.name,
+      paramDetails: op.parameters,
+      returnType: op.returns,
+      returnTypeDetails: includeResponseProperties
+        ? op.returnTypeDetails || []
+        : [],
+      docLink: op.docLink,
+    };
+    const jsDoc = generateJsDoc(jsDocOptions);
+    return `${jsDoc}\n  ${op.name}: (params: { ${params} }) => Promise<${op.returns}>;`;
+  });
+
+  console.log("Writing missing types report...");
+  writeFileSafe(
+    join(OUTPUT_DIR, "missing-types-report.json"),
+    JSON.stringify({ missingTypes: Array.from(missingTypes) }, null, 2)
+  );
+
+  const importStatement =
+    modelImports.size > 0
+      ? `import { ${Array.from(modelImports)
+          .sort()
+          .join(", ")} } from "../generated/models";`
+      : "";
+  const interfaceContent = `// Generated on ${new Date().toISOString()}\n${importStatement}\n\nexport interface QuickbaseClient {\n${methods.join(
+    "\n"
+  )}\n}\n`;
+
+  console.log("Ensuring output directory exists and writing interface...");
+  writeFileSafe(OUTPUT_FILE, interfaceContent);
+  console.log("Generated:", OUTPUT_FILE);
+}
+
+console.log("Entering runTask block");
+runTask("generateInterface", () => generateInterface(true));
+
+console.log("Script completed");

package/open-api/generateDocsJson.ts

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+import { writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parseOpenApiOperations } from "./utils/sharedUtils.ts";
+import { writeFileSafe, runTask } from "./utils/common.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SPEC_FILE = join(__dirname, "output", "quickbase-fixed.json");
+const MODELS_DIR = join(__dirname, "..", "src", "generated", "models");
+const DOCS_DATA_DIR = join(__dirname, "..", "docs-data");
+const DOCS_JSON_FILE = join(DOCS_DATA_DIR, "api-docs.json");
+
+function generateDocsJson(): void {
+  console.log("Generating docs JSON...");
+  const { operations } = parseOpenApiOperations(SPEC_FILE, MODELS_DIR);
+  writeFileSafe(DOCS_JSON_FILE, JSON.stringify(operations, null, 2), "utf8");
+  console.log("Generated docs JSON:", DOCS_JSON_FILE);
+}
+
+runTask("generateDocsJson", generateDocsJson);
+
+console.log("Script completed");