quickbase-js 1.0.1-beta.0

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "quickbase-js",
+  "main": "dist/quickbaseClient.js",
+  "types": "dist/quickbaseClient.d.ts",
+  "version": "1.0.1-beta.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "QuickBase JavaScript client for frameworks and vanilla JS",
+  "module": "dist/quickbaseClient.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/quickbaseClient.js",
+      "types": "./dist/quickbaseClient.d.ts"
+    }
+  },
+  "scripts": {
+    "release": "standard-version",
+    "release:beta": "standard-version --prerelease beta",
+    "release:alpha": "standard-version --prerelease alpha",
+    "fix-spec": "node --loader ts-node/esm src/code-generation/fix-spec-main.ts",
+    "regenerate": "node --loader ts-node/esm src/code-generation/regenerate-client.ts",
+    "generate-unified": "node --loader ts-node/esm src/code-generation/generate-unified-interface.ts",
+    "log-gen": "node --loader ts-node/esm src/log-gen.ts",
+    "build": "rimraf dist && rollup -c",
+    "build:prod": "rm -rf dist/* && NODE_ENV=production rollup -c",
+    "test": "vitest run tests/vitest/**/**/*.test.ts",
+    "test:pw:qb:all": "playwright test tests/playwright/qb --config playwright.config.ts",
+    "test:vitest:qb": "vitest run tests/vitest/qb/**/*.test.ts",
+    "test:vitest:qb:apps": "vitest run tests/vitest/qb/apps/**/*.test.ts",
+    "test:vitest:qb:auth": "vitest run tests/vitest/qb/auth/**/*.test.ts",
+    "test:vitest:qb:fields": "vitest run tests/vitest/qb/fields/**/*.test.ts",
+    "test:vitest:qb:tables": "vitest run tests/vitest/qb/tables/**/*.test.ts",
+    "test:pw:qb:auth": "playwright test tests/playwright/qb/auth",
+    "test::pw:qb:auth:temptoken": "playwright test tests/playwright/qb/auth/getTempToken.test.ts",
+    "test:pw:qb:auth:renewal": "playwright test tests/playwright/qb/auth/tokenRenewal.test.ts",
+    "test:pw:qb:auth:cache": "playwright test tests/playwright/qb/auth/cacheSwitching.test.ts",
+    "test:pw:qb:auth:temp401": "playwright test tests/playwright/qb/auth/fetchTempToken401.test.ts",
+    "test:pw:qb:auth:prefetch": "playwright test tests/playwright/qb/auth/tokenPrefetch.test.ts",
+    "test:pw:qb:auth:debug": "playwright test tests/playwright/qb/auth --headed --debug",
+    "test:pw:qb:auth:temp:debug": "playwright test tests/playwright/qb/auth/getTempToken.test.ts --headed --debug",
+    "test:pw:qb:auth:renewal:debug": "playwright test tests/playwright/qb/auth/tokenRenewal.test.ts --headed --debug --config=playwright.config.ts",
+    "test:pw:qb:auth:cache:debug": "playwright test tests/playwright/qb/auth/cacheSwitching.test.ts --headed --debug"
+  },
+  "dependencies": {
+    "typescript": "^5.8.2"
+  },
+  "devDependencies": {
+    "@openapitools/openapi-generator-cli": "^2.17.0",
+    "@playwright/test": "^1.51.0",
+    "@rollup/plugin-commonjs": "^28.0.3",
+    "@rollup/plugin-node-resolve": "^16.0.0",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.1.2",
+    "@types/node": "^22.13.10",
+    "dotenv": "^16.4.7",
+    "glob": "^11.0.1",
+    "js-yaml": "^4.1.0",
+    "jsdom": "^26.0.0",
+    "node-fetch": "^3.3.2",
+    "openapi-types": "^12.1.3",
+    "rimraf": "^5.0.10",
+    "rollup": "^4.35.0",
+    "rollup-plugin-dts": "^6.1.1",
+    "standard-version": "^9.5.0",
+    "ts-morph": "^25.0.1",
+    "ts-node": "^10.9.2",
+    "tslib": "^2.8.1",
+    "vitest": "^3.0.8"
+  }
+}

package/playwright.config.ts

@@ -0,0 +1,37 @@
+// playwright.config.ts
+import { defineConfig, devices } from "@playwright/test";
+
+const config = defineConfig({
+  fullyParallel: true,
+  workers: undefined, // Default: half of CPU cores (e.g., 2 on a 4-core machine)
+  // workers: 2, // Or explicitly set to 2 for controlled testing
+  testDir: "./tests/playwright",
+  timeout: 600000, // 10 minutes
+  retries: 2,
+  reporter: [
+    ["list"],
+    ["json", { outputFile: "test-artifacts/test-results.json" }],
+  ],
+  use: {
+    baseURL: "https://api.quickbase.com",
+    headless: true,
+    viewport: { width: 1280, height: 720 },
+    actionTimeout: 10000,
+    screenshot: "off",
+  },
+  outputDir: "test-artifacts",
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+});
+
+console.log(
+  `Loading Playwright config with timeout: ${config.timeout}ms, workers: ${
+    config.workers || "default (half CPU cores)"
+  }`
+);
+
+export default config;

package/rollup.config.js

@@ -0,0 +1,70 @@
+import typescript from "@rollup/plugin-typescript";
+import terser from "@rollup/plugin-terser";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import commonjs from "@rollup/plugin-commonjs";
+import dts from "rollup-plugin-dts";
+
+const isProd = process.env.NODE_ENV === "production";
+
+export default [
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      dir: "dist",
+      format: "esm",
+      sourcemap: true,
+      compact: isProd,
+      entryFileNames: "quickbaseClient.js",
+    },
+    external: [
+      "node:http",
+      "node:https",
+      "node:zlib",
+      "node:stream",
+      "node:buffer",
+      "node:util",
+      "node:url",
+      "node:net",
+      "node:fs",
+      "node:path",
+      "node-fetch",
+    ],
+    plugins: [
+      nodeResolve({ preferBuiltins: true }),
+      commonjs(),
+      typescript({
+        tsconfig: "./tsconfig.json",
+        declaration: false, // No .d.ts here, handled by dts plugin
+      }),
+      isProd && terser(),
+    ],
+  },
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      file: "dist/quickbaseClient.d.ts",
+      format: "esm",
+      // Optional: sourcemap for .d.ts if needed for debugging
+      // sourcemap: true,
+    },
+    plugins: [
+      dts({
+        tsconfig: "./tsconfig.json",
+        // Ensure all referenced files are included
+        respectExternal: true,
+      }),
+    ],
+  },
+].map((config) => ({
+  ...config,
+  onwarn(warning, warn) {
+    if (
+      warning.code === "PLUGIN_WARNING" &&
+      warning.plugin === "typescript" &&
+      warning.message.includes("TS5096")
+    ) {
+      return;
+    }
+    warn(warning);
+  },
+}));

package/src/code-generation/fix-spec-definitions.ts

@@ -0,0 +1,136 @@
+export const definitions = {
+  App: {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      name: { type: "string" },
+      created: { type: "string", format: "date-time" },
+      updated: { type: "string", format: "date-time" },
+      description: { type: "string" },
+      timeZone: { type: "string" },
+      dateFormat: { type: "string" },
+      hasEveryoneOnTheInternet: { type: "boolean" },
+      memoryInfo: {
+        type: "object",
+        properties: {
+          estMemory: { type: "number" },
+          estMemoryInclDependentApps: { type: "number" },
+        },
+      },
+      securityProperties: {
+        type: "object",
+        properties: {
+          allowClone: { type: "boolean" },
+          allowExport: { type: "boolean" },
+          enableAppTokens: { type: "boolean" },
+          hideFromPublic: { type: "boolean" },
+          mustBeRealmApproved: { type: "boolean" },
+          useIPFilter: { type: "boolean" },
+        },
+      },
+    },
+    required: ["id", "name"],
+  },
+  Field: {
+    type: "object",
+    properties: {
+      id: { type: "number" },
+      label: { type: "string" },
+      fieldType: { type: "string" },
+      noWrap: { type: "boolean" },
+      bold: { type: "boolean" },
+      required: { type: "boolean" },
+      appearsByDefault: { type: "boolean" },
+      findEnabled: { type: "boolean" },
+      unique: { type: "boolean" },
+      doesDataCopy: { type: "boolean" },
+      fieldHelp: { type: "string" },
+      audited: { type: "boolean" },
+      properties: {
+        type: "object",
+        properties: {
+          primaryKey: { type: "boolean" },
+          foreignKey: { type: "boolean" },
+          numLines: { type: "number" },
+          maxLength: { type: "number" },
+          appendOnly: { type: "boolean" },
+          allowHTML: { type: "boolean" },
+          allowMentions: { type: "boolean" },
+          sortAsGiven: { type: "boolean" },
+          carryChoices: { type: "boolean" },
+          allowNewChoices: { type: "boolean" },
+          formula: { type: "string" },
+          defaultValue: { type: "string" },
+        },
+      },
+      permissions: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            permissionType: { type: "string" },
+            role: { type: "string" },
+            roleId: { type: "number" },
+          },
+        },
+      },
+    },
+    required: ["id", "label", "fieldType"],
+  },
+  Table: {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      name: { type: "string" },
+      alias: { type: "string" },
+      created: { type: "string", format: "date-time" },
+      defaultSortFieldId: { type: "number" },
+      defaultSortOrder: { type: "string" },
+      description: { type: "string" },
+      keyFieldId: { type: "number" },
+      nextFieldId: { type: "number" },
+      nextRecordId: { type: "number" },
+      pluralRecordName: { type: "string" },
+      singleRecordName: { type: "string" },
+      sizeLimit: { type: "string" },
+      spaceRemaining: { type: "string" },
+      spaceUsed: { type: "string" },
+      updated: { type: "string", format: "date-time" },
+    },
+    required: ["id", "name"],
+  },
+  Record: {
+    type: "object",
+    properties: {
+      id: { type: "number" },
+      fields: {
+        type: "object",
+        additionalProperties: { type: "string" },
+      },
+    },
+    required: ["id"],
+  },
+  Upsert200Response: {
+    type: "object",
+    properties: {
+      id: { type: "number" },
+      status: { type: "string" },
+    },
+    required: ["id"],
+  },
+  ReportRunResponse: {
+    type: "object",
+    properties: {
+      id: { type: "string" },
+      data: { type: "object" }, // Placeholder
+    },
+    required: ["id"],
+  },
+  GetTempTokenDBID200Response: {
+    type: "object",
+    properties: {
+      temporaryAuthorization: { type: "string" },
+    },
+    required: ["temporaryAuthorization"],
+  },
+};

package/src/code-generation/fix-spec-main.ts

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import { promises as fs } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import * as glob from "glob";
+import { paths } from "./fix-spec-paths.ts";
+import { definitions } from "./fix-spec-definitions.ts";
+
+interface Parameter {
+  name: string;
+  in: string;
+  required?: boolean;
+  type?: string;
+  schema?: { type?: string; items?: any; $ref?: string; properties?: any };
+  example?: any;
+}
+
+interface Operation {
+  parameters?: Parameter[];
+  responses?: Record<string, { description: string; schema?: any }>;
+  operationId?: string;
+  summary?: string;
+  tags?: string[];
+}
+
+interface Spec {
+  paths: Record<string, Record<string, Operation>>;
+  definitions?: Record<string, any>;
+  operations?: any;
+  groups?: any;
+  components?: any;
+}
+
+function toCamelCase(str: string): string {
+  return str
+    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+    .replace(/^./, (str) => str.toLowerCase());
+}
+
+function fixArraySchemas(spec: Spec) {
+  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) {
+            if (param.schema.type === "array" && !param.schema.items) {
+              console.log(
+                `Fixing missing items in ${pathKey}(${method}).${param.name}`
+              );
+              param.schema.items =
+                pathKey === "/records" && param.name === "generated"
+                  ? { $ref: "#/definitions/Record" }
+                  : { 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 in ${pathKey}(${method}).${param.name}.${propKey}`
+                  );
+                  prop.items =
+                    propKey === "data" && pathKey === "/records"
+                      ? { $ref: "#/definitions/Record" }
+                      : { type: "string" };
+                }
+              }
+            }
+          }
+        });
+      }
+      if (operation.responses) {
+        for (const status in operation.responses) {
+          const response = operation.responses[status];
+          if (response.schema) {
+            if (response.schema.type === "array" && !response.schema.items) {
+              console.log(
+                `Fixing missing items in ${pathKey}(${method}).responses.${status}`
+              );
+              response.schema.items =
+                pathKey === "/records"
+                  ? { $ref: "#/definitions/Upsert200Response" }
+                  : { 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 in ${pathKey}(${method}).responses.${status}.${propKey}`
+                  );
+                  prop.items =
+                    propKey === "data" && pathKey === "/records"
+                      ? { $ref: "#/definitions/Upsert200Response" }
+                      : { type: "string" };
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+async function fixQuickBaseSpec(): Promise<void> {
+  try {
+    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")
+    );
+    if (specFiles.length === 0) {
+      console.error(
+        "No QuickBase_RESTful_*.json files found in specs/ folder."
+      );
+      process.exit(1);
+    }
+    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");
+    const spec: Spec = JSON.parse(specContent);
+
+    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: Parameter) => {
+              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 = "string";
+              return param;
+            });
+        }
+      }
+    }
+
+    console.log("Applying endpoint fixes...");
+    spec.paths = { ...spec.paths, ...paths }; // Merge original and custom paths
+
+    console.log("Fixing array schemas...");
+    fixArraySchemas(spec);
+
+    console.log("Applying definitions...");
+    spec.definitions = { ...spec.definitions, ...definitions }; // Merge definitions
+
+    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!");
+  } catch (error) {
+    console.error("Failed to fix spec:", error);
+    process.exit(1);
+  }
+}
+
+fixQuickBaseSpec();

package/src/code-generation/fix-spec-paths.ts

@@ -0,0 +1,163 @@
+// src/code-generation/fix-spec-paths.ts
+export const paths = {
+  "/apps/{appId}": {
+    get: {
+      operationId: "getApp",
+      summary: "Get an app by ID",
+      tags: ["Apps"],
+      parameters: [
+        {
+          name: "appId",
+          in: "path",
+          required: true,
+          type: "string",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: { $ref: "#/definitions/App" },
+        },
+      },
+    },
+  },
+  "/fields": {
+    get: {
+      operationId: "getFields",
+      summary: "Get all fields for a table",
+      tags: ["Fields"],
+      parameters: [
+        {
+          name: "tableId",
+          in: "query",
+          required: true,
+          type: "string",
+        },
+        {
+          name: "includeFieldPerms",
+          in: "query",
+          required: false,
+          type: "boolean",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Field" },
+          },
+        },
+      },
+    },
+  },
+  "/tables": {
+    get: {
+      operationId: "getAppTables",
+      summary: "Get all tables for an app",
+      tags: ["Tables"],
+      parameters: [
+        {
+          name: "appId",
+          in: "query",
+          required: true,
+          type: "string",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Table" },
+          },
+        },
+      },
+    },
+  },
+  "/records/query": {
+    post: {
+      operationId: "upsertRecords",
+      summary: "Upsert records",
+      tags: ["Records"],
+      parameters: [
+        {
+          name: "generated",
+          in: "body",
+          required: true,
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Record" },
+          },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Upsert200Response" },
+          },
+        },
+        207: {
+          description: "Multi-Status (partial success)",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/Upsert207Response" }, // Corrected from Upsert200Response
+          },
+        },
+      },
+    },
+  },
+  "/reports/{reportId}/run": {
+    post: {
+      operationId: "runReport",
+      summary: "Run a report",
+      tags: ["Reports"],
+      parameters: [
+        {
+          name: "reportId",
+          in: "path",
+          required: true,
+          type: "string",
+        },
+        {
+          name: "generated",
+          in: "body",
+          required: true,
+          schema: { type: "object" },
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: {
+            type: "array",
+            items: { $ref: "#/definitions/ReportRunResponse" },
+          },
+        },
+      },
+    },
+  },
+  "/auth/temporary/{dbid}": {
+    get: {
+      operationId: "getTempTokenDBID",
+      summary: "Get a temporary authorization token for a specific dbid",
+      tags: ["Auth"],
+      parameters: [
+        {
+          name: "dbid",
+          in: "path",
+          required: true,
+          type: "string",
+        },
+      ],
+      responses: {
+        200: {
+          description: "Success",
+          schema: { $ref: "#/definitions/GetTempTokenDBID200Response" },
+        },
+      },
+    },
+  },
+};