quickbase-js 1.1.0-beta.3 → 1.1.0-beta.5

package/log-gen.yaml

@@ -1,5 +1,5 @@
 project: quickbase-js
-date: 3/11/2025
+date: 3/12/2025
 root: /home/drew/Projects/quickbase-js
 goals:
   - A library for interacting with the QuickBase RESTful API.
@@ -40,8 +40,8 @@ pipelineOverview:
   - getTempTokenDBID() method is wrapped to enhance temporary token generation reuse interacting with a token cache.
   - '#'
   - 'npm run fix-spec: Generates quickbase-fixed.json from the latest QuickBase_RESTful*.json file.'
-  - 'npm run regenerate: Generates raw TypeScript-fetch files in src/generated/.'
-  - 'npm run generate-unified: Generates a unified QuickbaseClient.ts interface in src/generated-unified/.'
+  - npm run regenerate:openapi Generates raw TypeScript-fetch files in src/generated/.
+  - 'npm run generate:unified: Generates a unified QuickbaseClient.ts interface in src/generated-unified/.'
 tree:
   name: .
   type: directory
@@ -58,15 +58,148 @@ tree:
       type: file
     - name: build.js
       type: file
+      contents: |-
+        import { execSync } from 'child_process';
+        import { rollup } from 'rollup';
+        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';
+        import { rimrafSync } from 'rimraf';
+        import { copyFileSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+        import { join } from 'path';
+
+        // Clean the dist folder
+        rimrafSync('dist');
+        rimrafSync('dist/temp-src');
+
+        // Step 1: Copy runtime-relevant files from src/ to dist/temp-src and remove .ts extensions
+        const srcDir = join(process.cwd(), 'src');
+        const tempSrcDir = join(process.cwd(), 'dist/temp-src');
+        const runtimeDirs = ['generated', 'generated-unified'];
+        const runtimeFiles = ['index.ts', 'quickbaseClient.ts', 'tokenCache.ts'];
+
+        function copyAndRewriteTsExtensions(src, dest) {
+          console.log(`Copying from ${src} to ${dest}`);
+          mkdirSync(dest, { recursive: true });
+          const files = readdirSync(src, { withFileTypes: true });
+          for (const file of files) {
+            const srcPath = join(src, file.name);
+            const destPath = join(dest, file.name);
+            if (file.isDirectory()) {
+              if (runtimeDirs.includes(file.name) || runtimeDirs.some(dir => src.includes(dir))) {
+                copyAndRewriteTsExtensions(srcPath, destPath);
+              } else {
+                console.log(`Skipping non-runtime directory ${srcPath}`);
+              }
+            } else if (file.name.endsWith('.ts')) {
+              if (runtimeFiles.includes(file.name) || src.includes('generated') || src.includes('generated-unified')) {
+                console.log(`Processing ${srcPath} -> ${destPath}`);
+                let content = readFileSync(srcPath, 'utf8');
+                content = content.replace(/(from\s+["']\.[\w\/-]+)\.ts(["'])/g, '$1$2');
+                content = content.replace(/(export\s+\*\s+from\s+["']\.[\w\/-]+)\.ts(["'])/g, '$1$2');
+                writeFileSync(destPath, content, 'utf8');
+              } else {
+                console.log(`Skipping non-runtime file ${srcPath}`);
+              }
+            } else {
+              console.log(`Skipping non-.ts file ${srcPath}`);
+            }
+          }
+        }
+        copyAndRewriteTsExtensions(srcDir, tempSrcDir);
+
+        // Step 2: Compile TypeScript to JavaScript with tsc
+        console.log('Running tsc...');
+        const tsFiles = readdirSync(tempSrcDir, { recursive: true })
+          .filter(file => file.endsWith('.ts'))
+          .map(file => join(tempSrcDir, file));
+        const tscCommand = `npx tsc ${tsFiles.join(' ')} --outDir ${join(process.cwd(), 'dist/temp')} --module ESNext --target ESNext --sourceMap --moduleResolution bundler --baseUrl ${process.cwd()}`;
+        console.log(`Command: ${tscCommand}`);
+        execSync(tscCommand, { stdio: 'inherit' });
+
+        // Step 3: Rollup configuration
+        const isProd = process.env.NODE_ENV === 'production';
+        const external = [
+          'node:http', 'node:https', 'node:zlib', 'node:stream', 'node:buffer',
+          'node:util', 'node:url', 'node:net', 'node:fs', 'node:path', 'node-fetch',
+        ];
+        const globals = { 'node-fetch': 'fetch' };
+
+        // ESM Build
+        console.log(`Building ESM bundle (${isProd ? 'minified' : 'unminified'})...`);
+        const esmBundle = await rollup({
+          input: 'dist/temp/quickbaseClient.js',
+          external,
+          plugins: [
+            nodeResolve({ preferBuiltins: true }),
+            commonjs(),
+            isProd && terser(), // Only minify in prod
+          ],
+        });
+        await esmBundle.write({
+          dir: 'dist/esm',
+          format: 'esm',
+          sourcemap: true,
+          entryFileNames: isProd ? 'quickbase.min.js' : 'quickbase.js',
+        });
+        await esmBundle.close();
+
+        // UMD Build
+        console.log(`Building UMD bundle (${isProd ? 'minified' : 'unminified'})...`);
+        const umdBundle = await rollup({
+          input: 'dist/temp/quickbaseClient.js',
+          external,
+          plugins: [
+            nodeResolve({ preferBuiltins: true, browser: true }),
+            commonjs(),
+            isProd && terser(), // Only minify in prod
+          ],
+        });
+        await umdBundle.write({
+          file: join(process.cwd(), 'dist/umd', isProd ? 'quickbase.umd.min.js' : 'quickbase.umd.js'),
+          format: 'umd',
+          name: 'QuickbaseJS',
+          sourcemap: true,
+          globals,
+        });
+        await umdBundle.close();
+
+        // Declarations
+        console.log('Generating declarations...');
+        const dtsBundle = await rollup({
+          input: 'src/quickbaseClient.ts',
+          plugins: [dts({ tsconfig: './tsconfig.json', respectExternal: true })],
+        });
+        await dtsBundle.write({ file: 'dist/esm/quickbase.d.ts', format: 'esm' });
+        await dtsBundle.write({ file: 'dist/umd/quickbase.umd.d.ts', format: 'umd' });
+        await dtsBundle.close();
+
+        // Clean up
+        rimrafSync('dist/temp');
+        rimrafSync('dist/temp-src');
+        console.log('Build completed successfully');
     - name: dist
       type: directory
       children:
-        - name: quickbase.d.ts
-          type: file
-        - name: quickbase.js
-          type: file
-        - name: quickbase.js.map
-          type: file
+        - name: esm
+          type: directory
+          children:
+            - name: quickbase.d.ts
+              type: file
+            - name: quickbase.min.js
+              type: file
+            - name: quickbase.min.js.map
+              type: file
+        - name: umd
+          type: directory
+          children:
+            - name: quickbase.umd.d.ts
+              type: file
+            - name: quickbase.umd.min.js
+              type: file
+            - name: quickbase.umd.min.js.map
+              type: file
     - name: examples
       type: directory
       children:
@@ -76,37 +209,167 @@ tree:
           type: file
     - name: log-gen.yaml
       type: file
+    - name: open-api
+      type: directory
+      children:
+        - name: definitions
+          type: directory
+          children:
+            - name: apps.ts
+              type: file
+            - name: auth.ts
+              type: file
+            - name: fields.ts
+              type: file
+            - name: index.ts
+              type: file
+            - name: records.ts
+              type: file
+            - name: relationships.ts
+              type: file
+            - name: reports.ts
+              type: file
+            - name: tables.ts
+              type: file
+        - name: fix-spec-main.ts
+          type: file
+        - name: generate-unified-interface.ts
+          type: file
+        - name: output
+          type: directory
+          children:
+            - name: quickbase-fixed.json
+              type: file
+        - name: paths
+          type: directory
+          children:
+            - name: apps.ts
+              type: file
+            - name: auth.ts
+              type: file
+            - name: fields.ts
+              type: file
+            - name: index.ts
+              type: file
+            - name: records.ts
+              type: file
+            - name: relationships.ts
+              type: file
+            - name: reports.ts
+              type: file
+            - name: tables.ts
+              type: file
+        - name: regenerate-client.ts
+          type: file
     - name: openapitools.json
       type: file
     - name: package-lock.json
       type: file
     - name: package.json
       type: file
+      contents: |
+        {
+          "name": "quickbase-js",
+          "version": "1.1.0-beta.4",
+          "description": "QuickBase JavaScript client for frameworks and vanilla JS",
+          "type": "module",
+          "main": "dist/esm/quickbase.js",
+          "module": "dist/esm/quickbase.js",
+          "types": "dist/esm/quickbase.d.ts",
+          "publishConfig": {
+            "access": "public"
+          },
+          "exports": {
+            ".": {
+              "import": {
+                "minified": "./dist/esm/quickbase.min.js",
+                "default": "./dist/esm/quickbase.js"
+              },
+              "require": {
+                "minified": "./dist/umd/quickbase.umd.min.js",
+                "default": "./dist/umd/quickbase.umd.js"
+              },
+              "types": "./dist/esm/quickbase.d.ts",
+              "umd:types": "./dist/umd/quickbase.umd.d.ts"
+            }
+          },
+          "scripts": {
+            "release": "standard-version",
+            "release:beta": "standard-version --prerelease beta",
+            "release:alpha": "standard-version --prerelease alpha",
+            "release:push": "npm run release:beta && git push --follow-tags origin main",
+            "release:publish": "npm run release:push && npm publish --tag beta",
+          
+
+            "fix-spec": "node --loader ts-node/esm open-api/fix-spec-main.ts",
+            "regenerate:openapi": "rimraf src/generated && node --loader ts-node/esm open-api/regenerate-client.ts",
+            "regenerate:unified": "node --loader ts-node/esm open-api/generate-unified-interface.ts",
+            "regenerate:all": "npm run fix-spec && npm run regenerate:openapi && npm run regenerate:unified",
+            "log-gen": "node --loader ts-node/esm tools/log-gen.ts",
+            "build": "rimraf dist && node --loader ts-node/esm build.js",
+            "build:prod": "rimraf dist && NODE_ENV=production node --loader ts-node/esm build.js",
+
+
+            "build-old": "rimraf dist && rollup -c",
+            "build:prod-old": "rimraf dist && NODE_ENV=production rollup -c",
+            "test:all": "vitest run tests/vitest/**/**/*.test.ts --reporter=basic && playwright test tests/playwright/qb --config playwright.config.ts --reporter=dot --quiet",
+            "test:pw:qb:all": "playwright test tests/playwright/qb --config playwright.config.ts",
+            "test:vitest:all": "vitest run tests/vitest/**/**/*.test.ts",
+            "test:vitest:qb": "vitest run tests/vitest/qb/**/*.test.ts",
+            "test:vitest:unit": "vitest run tests/vitest/unit/**/*.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:records": "vitest run tests/vitest/qb/records/**/*.test.ts",
+            "test:vitest:qb:tables": "vitest run tests/vitest/qb/tables/**/*.test.ts",
+            "test:vitest:unit:apps": "vitest run tests/vitest/unit/apps/**/*.test.ts",
+            "test:vitest:unit:auth": "vitest run tests/vitest/unit/auth/**/*.test.ts",
+            "test:vitest:unit:fields": "vitest run tests/vitest/unit/fields/**/*.test.ts",
+            "test:vitest:unit:records": "vitest run tests/vitest/unit/records/**/*.test.ts",
+            "test:vitest:unit:tables": "vitest run tests/vitest/unit/tables/**/*.test.ts",
+            "test:pw:qb:auth": "playwright test tests/playwright/qb/auth"
+          },
+          "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/js-yaml": "^4.0.9",
+            "@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",
+            "undici-types": "^7.5.0",
+            "vitest": "^3.0.8"
+          }
+        }
+    - name: playwright-results.txt
+      type: directory
+      children:
+        - name: .last-run.json
+          type: file
     - name: playwright.config.ts
       type: file
-    - name: rollup.config.js
+    - name: rollup.config.mjs
       type: file
     - name: src
       type: directory
       children:
-        - name: code-generation
-          type: directory
-          children:
-            - name: fix-spec-definitions.ts
-              type: file
-            - name: fix-spec-main.ts
-              type: file
-            - name: fix-spec-paths.ts
-              type: file
-            - name: generate-unified-interface.ts
-              type: file
-            - name: output
-              type: directory
-              children:
-                - name: quickbase-fixed.json
-                  type: file
-            - name: regenerate-client.ts
-              type: file
         - name: generated
           type: directory
           children:
@@ -191,6 +454,10 @@ tree:
                   type: file
                 - name: CreateAppRequestVariablesInner.ts
                   type: file
+                - name: CreateField200Response.ts
+                  type: file
+                - name: CreateFieldRequest.ts
+                  type: file
                 - name: CreateRelationship200Response.ts
                   type: file
                 - name: CreateRelationshipRequest.ts
@@ -199,6 +466,14 @@ tree:
                   type: file
                 - name: DeactivateUserToken200Response.ts
                   type: file
+                - name: DeleteApp200Response.ts
+                  type: file
+                - name: DeleteAppRequest.ts
+                  type: file
+                - name: DeleteFields200Response.ts
+                  type: file
+                - name: DeleteFieldsRequest.ts
+                  type: file
                 - name: DeleteFile200Response.ts
                   type: file
                 - name: DeleteRecords200Response.ts
@@ -221,9 +496,13 @@ tree:
                   type: file
                 - name: FieldProperties.ts
                   type: file
-                - name: GenerateDocument200Response.ts
+                - name: FieldUsage.ts
                   type: file
-                - name: GetField200Response.ts
+                - name: FieldUsageField.ts
+                  type: file
+                - name: FieldUsageUsage.ts
+                  type: file
+                - name: GenerateDocument200Response.ts
                   type: file
                 - name: GetRelationships200Response.ts
                   type: file
@@ -297,8 +576,6 @@ tree:
                   type: file
                 - name: UndenyUsers200Response.ts
                   type: file
-                - name: UpdateFieldRequest.ts
-                  type: file
                 - name: UpdateRelationshipRequest.ts
                   type: file
                 - name: UpdateTableRequest.ts
@@ -315,6 +592,8 @@ tree:
                   type: file
                 - name: UpsertRequest.ts
                   type: file
+                - name: UsageCount.ts
+                  type: file
                 - name: index.ts
                   type: file
             - name: runtime.ts
@@ -325,12 +604,13 @@ tree:
             - name: QuickbaseClient.ts
               type: file
               contents: |
-                // Generated on 2025-03-11T21:24:23.349Z
-                import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, DeleteRecords200Response, DeleteRecordsRequest, DeleteTableResponse, Field, GetRelationships200Response, GetTempTokenDBID200Response, ReportRunResponse, RunQueryRequest, RunQueryResponse, Table, UpdateTableRequest, Upsert200Response, Upsert207Response, UpsertRequest } from "../generated/models";
+                // Generated on 2025-03-12T19:20:50.952Z
+                import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, CreateField200Response, CreateFieldRequest, DeleteApp200Response, DeleteAppRequest, DeleteFields200Response, DeleteFieldsRequest, DeleteRecords200Response, DeleteRecordsRequest, DeleteTableResponse, Field, FieldUsage, GetRelationships200Response, GetTempTokenDBID200Response, ReportRunResponse, RunQueryRequest, RunQueryResponse, Table, UpdateTableRequest, Upsert200Response, Upsert207Response, UpsertRequest } from "../generated/models";
 
                 export interface QuickbaseClient {
                   createApp: (params: { body: CreateAppRequest }) => Promise<CreateApp200Response>;
                   getApp: (params: { appId: string }) => Promise<App>;
+                  deleteApp: (params: { appId: string; body: DeleteAppRequest }) => Promise<DeleteApp200Response>;
                   getAppEvents: (params: { appId: string }) => Promise<any[]>;
                   copyApp: (params: { appId: string; body: CopyAppRequest }) => Promise<CopyApp200Response>;
                   getAppTables: (params: { appId: string }) => Promise<Table[]>;
@@ -346,10 +626,11 @@ tree:
                   getReport: (params: { tableId: string; reportId: string }) => Promise<{ [key: string]: any }>;
                   runReport: (params: { reportId: string; generated: any }) => Promise<ReportRunResponse[]>;
                   getFields: (params: { tableId: string; includeFieldPerms?: boolean }) => Promise<Field[]>;
-                  getField: (params: { tableId: string; includeFieldPerms?: boolean; fieldId: number }) => Promise<{ [key: string]: any }>;
-                  updateField: (params: { tableId: string; fieldId: number; generated?: any }) => Promise<{ [key: string]: any }>;
-                  getFieldsUsage: (params: { tableId: string; skip?: number; top?: number }) => Promise<any[]>;
-                  getFieldUsage: (params: { tableId: string; fieldId: number }) => Promise<any[]>;
+                  createField: (params: { tableId: string; body: CreateFieldRequest }) => Promise<CreateField200Response>;
+                  deleteFields: (params: { tableId: string; body: DeleteFieldsRequest }) => Promise<DeleteFields200Response>;
+                  getField: (params: { fieldId: number; tableId: string; includeFieldPerms?: boolean }) => Promise<Field>;
+                  getFieldsUsage: (params: { tableId: string; skip?: number; top?: number }) => Promise<FieldUsage[]>;
+                  getFieldUsage: (params: { fieldId: number; tableId: string }) => Promise<FieldUsage[]>;
                   runFormula: (params: { generated?: any }) => Promise<{ [key: string]: any }>;
                   upsert: (params: { body: UpsertRequest }) => Promise<Upsert200Response | Upsert207Response>;
                   deleteRecords: (params: { body: DeleteRecordsRequest }) => Promise<DeleteRecords200Response>;
@@ -387,13 +668,6 @@ tree:
                 }
         - name: index.ts
           type: file
-        - name: log-gen.ts
-          type: file
-        - name: openapi-jars
-          type: directory
-          children:
-            - name: openapi-generator-cli-7.12.0.jar
-              type: file
         - name: quickbaseClient.ts
           type: file
           contents: |
@@ -478,15 +752,15 @@ tree:
 
               const tokenCache = new TokenCache();
 
-              const headers: HTTPHeaders = {
+              const baseHeaders: HTTPHeaders = {
                 "QB-Realm-Hostname": `${realm}.quickbase.com`,
                 "Content-Type": "application/json",
               };
 
               if (initialTempToken) {
-                headers["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
+                baseHeaders["Authorization"] = `QB-TEMP-TOKEN ${initialTempToken}`;
               } else if (userToken && !useTempTokens) {
-                headers["Authorization"] = `QB-USER-TOKEN ${userToken}`;
+                baseHeaders["Authorization"] = `QB-USER-TOKEN ${userToken}`;
               }
 
               const defaultFetch: typeof fetch | undefined =
@@ -495,7 +769,7 @@ tree:
                   : undefined;
               const configuration = new Configuration({
                 basePath: baseUrl,
-                headers: { ...headers },
+                headers: { ...baseHeaders },
                 fetchApi: fetchApi || defaultFetch,
                 credentials: useTempTokens ? "include" : "omit",
               });
@@ -561,7 +835,7 @@ tree:
                   `https://api.quickbase.com/v1/auth/temporary/${dbid}`,
                   {
                     method: "GET",
-                    headers: { ...headers },
+                    headers: { ...baseHeaders },
                     credentials: "include",
                   }
                 );
@@ -593,23 +867,24 @@ tree:
                 return token;
               };
 
-              const invokeMethod = async <K extends keyof QuickbaseClient>(
+              async function invokeMethod<K extends keyof QuickbaseClient>(
                 methodName: K,
                 params: Parameters<QuickbaseClient[K]>[0] & Partial<TempTokenParams>,
                 retryCount: number = 0
-              ): Promise<ReturnType<QuickbaseClient[K]>> => {
+              ): Promise<ReturnType<QuickbaseClient[K]>> {
                 const methodInfo = methodMap[methodName];
                 if (!methodInfo) {
                   throw new Error(`Method ${methodName} not found`);
                 }
 
-                const args: [any, RequestInit | undefined] =
+                const requestParameters =
                   methodInfo.paramMap.length === 1 &&
                   methodInfo.paramMap[0] === "requestParameters"
-                    ? [{ requestParameters: params }, undefined]
-                    : [params, undefined];
+                    ? { requestParameters: params }
+                    : params;
+                let requestOptions: RequestInit = {};
 
-                let token =
+                const selectedToken =
                   initialTempToken || (userToken && !useTempTokens ? userToken : undefined);
 
                 if (methodName === "getTempTokenDBID" && useTempTokens) {
@@ -622,43 +897,38 @@ tree:
                   }
                 }
 
-                if (useTempTokens && !token) {
+                let authorizationToken = selectedToken;
+                if (useTempTokens && !authorizationToken) {
                   const dbid = extractDbid(
                     params,
                     `No dbid found in params for ${methodName} to fetch temp token`
                   );
                   const cachedToken = tokenCache.get(dbid);
-                  if (cachedToken) {
-                    token = cachedToken;
-                  } else {
-                    if (typeof globalThis.window === "undefined" && !fetchApi) {
-                      throw new Error(
-                        "Temporary tokens require a browser environment or a custom fetchApi with browser-like session support"
-                      );
-                    }
-                    token = await fetchTempToken(dbid);
-                    if (methodName === "getTempTokenDBID") {
-                      return { temporaryAuthorization: token } as ReturnType<
-                        QuickbaseClient[K]
-                      >;
-                    }
+                  authorizationToken = cachedToken || (await fetchTempToken(dbid));
+                  if (methodName === "getTempTokenDBID") {
+                    return { temporaryAuthorization: authorizationToken } as ReturnType<
+                      QuickbaseClient[K]
+                    >;
                   }
-                  args[1] = {
-                    headers: {
-                      ...headers,
-                      Authorization: `QB-TEMP-TOKEN ${token}`,
-                    },
+                  requestOptions.headers = {
+                    ...baseHeaders,
+                    Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
+                  };
+                } else if (authorizationToken) {
+                  requestOptions.headers = {
+                    ...baseHeaders,
+                    Authorization: `QB-USER-TOKEN ${authorizationToken}`,
                   };
                 }
 
                 try {
-                  const response = await methodInfo.method(...args);
-                  return response;
+                  return await methodInfo.method(requestParameters, requestOptions);
                 } catch (error) {
                   if (
                     error instanceof ResponseError &&
                     error.response.status === 401 &&
-                    retryCount < 1
+                    retryCount < 1 &&
+                    useTempTokens
                   ) {
                     if (debug) {
                       console.log(
@@ -670,12 +940,10 @@ tree:
                       params,
                       `No dbid to refresh token after authorization error`
                     );
-                    token = await fetchTempToken(dbid);
-                    args[1] = {
-                      headers: {
-                        ...headers,
-                        Authorization: `QB-TEMP-TOKEN ${token}`,
-                      },
+                    authorizationToken = await fetchTempToken(dbid);
+                    requestOptions.headers = {
+                      ...baseHeaders,
+                      Authorization: `QB-TEMP-TOKEN ${authorizationToken}`,
                     };
                     if (debug) {
                       console.log(`Retrying ${methodName} with new token`);
@@ -699,7 +967,7 @@ tree:
                   }
                   throw error;
                 }
-              };
+              }
 
               const proxy = new Proxy<QuickbaseClient>({} as QuickbaseClient, {
                 get: (_, prop: string): ((params: any) => Promise<any>) | undefined => {
@@ -716,15 +984,71 @@ tree:
             }
         - name: tokenCache.ts
           type: file
+          contents: |
+            interface CachedToken {
+              token: string;
+              expiresAt: number; // Timestamp in milliseconds
+            }
+
+            export class TokenCache {
+              private cache: Map<string, CachedToken>;
+              private readonly lifespan: number; // Token lifespan in milliseconds
+
+              constructor(lifespan: number = 4 * 60 * 1000 + 50 * 1000) {
+                // Default 4:50
+                this.cache = new Map<string, CachedToken>();
+                this.lifespan = lifespan;
+              }
+
+              get(dbid: string): string | undefined {
+                const entry = this.cache.get(dbid);
+                const now = Date.now();
+                if (entry && entry.expiresAt > now) {
+                  return entry.token;
+                }
+                return undefined; // Expired or not found
+              }
+
+              // New method to get full entry
+              getEntry(dbid: string): CachedToken | undefined {
+                const entry = this.cache.get(dbid);
+                const now = Date.now();
+                if (entry && entry.expiresAt > now) {
+                  return entry;
+                }
+                return undefined; // Expired or not found
+              }
+
+              set(dbid: string, token: string): void {
+                const now = Date.now();
+                this.cache.set(dbid, {
+                  token,
+                  expiresAt: now + this.lifespan,
+                });
+              }
+
+              dump(): [string, CachedToken][] {
+                return Array.from(this.cache.entries());
+              }
+
+              // New method to clear the cache
+              clear(): void {
+                this.cache.clear();
+              }
+            }
     - name: test-artifacts
       type: directory
       children:
         - name: .last-run.json
           type: file
-        - name: test-results.json
-          type: file
+    - name: test-esm.js
+      type: file
     - name: test-results.json
       type: file
+    - name: test-umd.js
+      type: file
+    - name: test.ts
+      type: file
     - name: tests
       type: directory
       children:
@@ -749,6 +1073,8 @@ tree:
                       type: file
                     - name: tokenRenewal.test.ts
                       type: file
+                    - name: umd.test.ts
+                      type: file
         - name: setup.ts
           type: file
         - name: vitest
@@ -760,13 +1086,29 @@ tree:
                 - name: apps
                   type: directory
                   children:
+                    - name: copyApp.test.ts
+                      type: file
+                    - name: createApp.test.ts
+                      type: file
+                    - name: deleteApp.test.ts
+                      type: file
                     - name: getApp.test.ts
                       type: file
                 - name: fields
                   type: directory
                   children:
+                    - name: createField.test.ts
+                      type: file
+                    - name: deleteFields.test.ts
+                      type: file
+                    - name: getField.test.ts
+                      type: file
+                    - name: getFieldUsage.test.ts
+                      type: file
                     - name: getFields.test.ts
                       type: file
+                    - name: getFieldsUsage.test.ts
+                      type: file
                 - name: index.ts
                   type: file
                 - name: records
@@ -799,1882 +1141,161 @@ tree:
                 - name: apps
                   type: directory
                   children:
+                    - name: copyApp.test.ts
+                      type: file
+                    - name: createApp.test.ts
+                      type: file
+                    - name: deleteApp.test.ts
+                      type: file
                     - name: getApp.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/apps/getApp.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - getApp", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
-                          });
-
-                          it("initializes without errors", () => {
-                            expect(client).toBeDefined();
-                          });
-
-                          it("has getApp method", () => {
-                            expect(typeof client.getApp).toBe("function");
-                          });
-
-                          it("calls getApp successfully", async () => {
-                            mockFetch.mockImplementation((url: string, options: any) => {
-                              console.log("Mock fetch:", url, options);
-                              return Promise.resolve({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve({
-                                    id: QB_APP_ID,
-                                    name: "qb-copy",
-                                    created: "2025-02-13T18:22:33Z",
-                                    updated: "2025-03-04T04:25:51Z",
-                                    description: "",
-                                    timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-                                    dateFormat: "MM-DD-YYYY",
-                                    hasEveryoneOnTheInternet: false,
-                                    memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-                                    securityProperties: {
-                                      allowClone: false,
-                                      allowExport: true,
-                                      enableAppTokens: true,
-                                      hideFromPublic: false,
-                                      mustBeRealmApproved: false,
-                                      useIPFilter: false,
-                                    },
-                                  }),
-                              } as Response);
-                            });
-
-                            const result = await client.getApp({ appId: QB_APP_ID });
-                            expect(result).toEqual({
-                              id: QB_APP_ID,
-                              name: "qb-copy",
-                              created: new Date("2025-02-13T18:22:33Z"),
-                              updated: new Date("2025-03-04T04:25:51Z"),
-                              description: "",
-                              timeZone: "(UTC-08:00) Pacific Time (US & Canada)",
-                              dateFormat: "MM-DD-YYYY",
-                              hasEveryoneOnTheInternet: false,
-                              memoryInfo: { estMemory: 0, estMemoryInclDependentApps: 0 },
-                              securityProperties: {
-                                allowClone: false,
-                                allowExport: true,
-                                enableAppTokens: true,
-                                hideFromPublic: false,
-                                mustBeRealmApproved: false,
-                                useIPFilter: false,
-                              },
-                            });
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/apps/${QB_APP_ID}`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-                        });
                 - name: auth
                   type: directory
                   children:
                     - name: fetchTempToken401.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/auth/fetchTempToken401.test.ts
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - 401 with fetchTempToken 401", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { useTempTokens: true, debug: true });
-                          });
-
-                          it("fails without infinite loop when fetchTempToken returns 401 after initial 401", async () => {
-                            let callCount = 0;
-
-                            mockFetch.mockImplementation((url) => {
-                              callCount++;
-                              console.log(`Mock fetch call ${callCount}: ${url}`);
-                              if (url.includes("auth/temporary") && callCount === 1) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () =>
-                                    Promise.resolve({ temporaryAuthorization: "initial_token" }),
-                                });
-                              }
-                              if (url.includes("fields") && callCount === 2) {
-                                return Promise.resolve({
-                                  ok: false,
-                                  status: 401,
-                                  json: () => Promise.resolve({ message: "Unauthorized" }),
-                                });
-                              }
-                              if (url.includes("auth/temporary") && callCount === 3) {
-                                return Promise.resolve({
-                                  ok: false,
-                                  status: 401,
-                                  json: () =>
-                                    Promise.resolve({ message: "Unauthorized in fetchTempToken" }),
-                                });
-                              }
-                              return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
-                            });
-
-                            const consoleSpy = vi.spyOn(console, "log");
-                            await expect(client.getFields({ tableId: QB_TABLE_ID_1 })).rejects.toThrow(
-                              "API Error: Unauthorized in fetchTempToken (Status: 401)"
-                            );
-
-                            expect(mockFetch).toHaveBeenCalledTimes(3);
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              1,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              2,
-                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                }),
-                              })
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              3,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Authorization error for getFields, refreshing token:",
-                              expect.any(String)
-                            );
-                            expect(consoleSpy).not.toHaveBeenCalledWith(
-                              "Retrying getFields with new token"
-                            );
-                            consoleSpy.mockRestore();
-                          });
-                        });
                     - name: getTempToken.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/auth/getTempTokenDBID.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - getTempTokenDBID", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { useTempTokens: true, debug: false });
-                          });
-
-                          it("initializes without errors", () => {
-                            expect(client).toBeDefined();
-                          });
-
-                          it("has getTempTokenDBID method", () => {
-                            expect(typeof client.getTempTokenDBID).toBe("function");
-                          });
-
-                          it("fetches and caches temp token on first call", async () => {
-                            const mockToken = "b123xyz_temp_token";
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-                            });
-
-                            const result = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
-                            expect(result).toEqual({ temporaryAuthorization: mockToken });
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  "Content-Type": "application/json",
-                                }),
-                                credentials: "include",
-                              })
-                            );
-                          });
-
-                          it("reuses cached temp token on second call", async () => {
-                            const mockToken = "b123xyz_temp_token";
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-                            });
-
-                            const firstResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
-                            expect(firstResult).toEqual({ temporaryAuthorization: mockToken });
-                            expect(mockFetch).toHaveBeenCalledTimes(1);
-
-                            mockFetch.mockClear();
-                            const secondResult = await client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 });
-                            expect(secondResult).toEqual({ temporaryAuthorization: mockToken });
-                            expect(mockFetch).not.toHaveBeenCalled();
-                          });
-
-                          it("handles API error", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 401,
-                              json: () => Promise.resolve({ message: "Unauthorized" }),
-                            });
-
-                            await expect(
-                              client.getTempTokenDBID({ dbid: QB_TABLE_ID_1 })
-                            ).rejects.toSatisfy((error: Error) => {
-                              expect(error).toBeInstanceOf(Error);
-                              expect(error.message).toBe("API Error: Unauthorized (Status: 401)");
-                              return true;
-                            });
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  "Content-Type": "application/json",
-                                }),
-                                credentials: "include",
-                              })
-                            );
-                          });
-                        });
                     - name: retryOn401.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/auth/retryOn401.test.ts
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - 401 Retry Creates New Token", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { useTempTokens: true, debug: true });
-                          });
-
-                          it("creates a new token on 401 and retries successfully", async () => {
-                            const mockToken = "new_token_456";
-                            const mockFields = [{ id: 1, label: "Field1" }];
-                            let callCount = 0;
-
-                            mockFetch.mockImplementation((url) => {
-                              callCount++;
-                              console.log(`Mock fetch call ${callCount}: ${url}`);
-                              if (url.includes("auth/temporary") && callCount === 1) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-                                });
-                              }
-                              if (url.includes("fields") && callCount === 2) {
-                                return Promise.resolve({
-                                  ok: false,
-                                  status: 401,
-                                  text: () => Promise.resolve("Unauthorized"),
-                                });
-                              }
-                              if (url.includes("auth/temporary") && callCount === 3) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () =>
-                                    Promise.resolve({ temporaryAuthorization: mockToken + "_retry" }),
-                                });
-                              }
-                              if (url.includes("fields") && callCount === 4) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () => Promise.resolve(mockFields),
-                                });
-                              }
-                              return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
-                            });
-
-                            const consoleSpy = vi.spyOn(console, "log");
-                            const result = await client.getFields({ tableId: QB_TABLE_ID_1 });
-
-                            expect(result).toEqual(mockFields);
-                            expect(mockFetch).toHaveBeenCalledTimes(4);
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              1,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              2,
-                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                }),
-                              })
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              3,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              4,
-                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}`, // Removed &includeFieldPerms=false
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                }),
-                              })
-                            );
-
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Authorization error for getFields, refreshing token:",
-                              expect.any(String)
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              `Fetched and cached new token for dbid: ${QB_TABLE_ID_1}`,
-                              mockToken + "_retry",
-                              expect.any(String)
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Retrying getFields with new token"
-                            );
-                            consoleSpy.mockRestore();
-                          });
-                        });
                     - name: two401s.test.ts
                       type: file
-                      contents: |
-                        import { describe, it, expect, beforeEach, vi } from "vitest";
-                        import { createClient, mockFetch } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient - Two 401s in a Row", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { useTempTokens: true, debug: true });
-                          });
-
-                          it("logs an error after two 401s in a row", async () => {
-                            const mockDbid = "mockDbid123";
-                            const mockToken = "new_token_456";
-                            let callCount = 0;
-
-                            mockFetch.mockImplementation((url) => {
-                              callCount++;
-                              console.log(`Mock fetch call ${callCount}: ${url}`);
-                              if (url.includes("auth/temporary") && callCount === 1) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () => Promise.resolve({ temporaryAuthorization: mockToken }),
-                                });
-                              }
-                              if (url.includes("fields") && callCount === 2) {
-                                return Promise.resolve({
-                                  ok: false,
-                                  status: 401,
-                                  text: () => Promise.resolve("Unauthorized"),
-                                });
-                              }
-                              if (url.includes("auth/temporary") && callCount === 3) {
-                                return Promise.resolve({
-                                  ok: true,
-                                  status: 200,
-                                  json: () =>
-                                    Promise.resolve({ temporaryAuthorization: mockToken + "_retry" }),
-                                });
-                              }
-                              if (url.includes("fields") && callCount === 4) {
-                                return Promise.resolve({
-                                  ok: false,
-                                  status: 401,
-                                  json: () => Promise.resolve({ message: "Unauthorized again" }), // Changed to json()
-                                  text: () => Promise.resolve("Unauthorized again"), // Keep text() for fallback
-                                });
-                              }
-                              return Promise.reject(new Error(`Unexpected fetch call: ${url}`));
-                            });
-
-                            const consoleSpy = vi.spyOn(console, "log");
-                            await expect(client.getFields({ tableId: mockDbid })).rejects.toThrow(
-                              "API Error: Unauthorized again (Status: 401)"
-                            );
-
-                            expect(mockFetch).toHaveBeenCalledTimes(4);
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Authorization error for getFields, refreshing token:",
-                              expect.any(String)
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Fetched and cached new token for dbid: mockDbid123",
-                              mockToken + "_retry",
-                              expect.any(String)
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Retrying getFields with new token"
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Error response body for getFields:",
-                              { message: "Unauthorized again" }
-                            );
-                            consoleSpy.mockRestore();
-                          });
-                        });
                 - name: fields
                   type: directory
                   children:
+                    - name: createField.test.ts
+                      type: file
+                    - name: deleteFields.test.ts
+                      type: file
+                    - name: getField.test.ts
+                      type: file
+                    - name: getFieldUsage.test.ts
+                      type: file
                     - name: getFields.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/fields/getFields.test.ts
-                        import { describe, it, expect } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - getFields", () => {
-                          it("calls getFields successfully", async () => {
-                            mockFetch.mockImplementation((url: string, options: any) => {
-                              console.log("Mock fetch for getFields:", url, options);
-                              return Promise.resolve({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve([
-                                    {
-                                      id: 1,
-                                      label: "Field1",
-                                      fieldType: "text",
-                                      noWrap: false,
-                                      bold: false,
-                                      required: false,
-                                      appearsByDefault: false,
-                                      findEnabled: false,
-                                      unique: false,
-                                      doesDataCopy: false,
-                                      fieldHelp: "field help",
-                                      audited: false,
-                                      properties: {
-                                        primaryKey: false,
-                                        foreignKey: false,
-                                        numLines: 1,
-                                        maxLength: 0,
-                                        appendOnly: false,
-                                        allowHTML: false,
-                                        allowMentions: false,
-                                        sortAsGiven: false,
-                                        carryChoices: true,
-                                        allowNewChoices: false,
-                                        formula: "",
-                                        defaultValue: "",
-                                      },
-                                      permissions: [
-                                        { permissionType: "View", role: "Viewer", roleId: 10 },
-                                        { permissionType: "None", role: "Participant", roleId: 11 },
-                                        { permissionType: "Modify", role: "Administrator", roleId: 12 },
-                                      ],
-                                    },
-                                  ]),
-                              } as Response);
-                            });
-
-                            const client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
-                            const result = await client.getFields({
-                              tableId: QB_TABLE_ID_1,
-                              includeFieldPerms: true,
-                            });
-                            console.log("getFields response:", result);
-                            expect(result).toEqual(
-                              expect.arrayContaining([
-                                expect.objectContaining({
-                                  id: 1,
-                                  label: "Field1",
-                                  fieldType: "text",
-                                  noWrap: false,
-                                  bold: false,
-                                  required: false,
-                                  appearsByDefault: false,
-                                  findEnabled: false,
-                                  unique: false,
-                                  doesDataCopy: false,
-                                  fieldHelp: "field help",
-                                  audited: false,
-                                  properties: expect.objectContaining({
-                                    primaryKey: false,
-                                    foreignKey: false,
-                                    numLines: 1,
-                                    maxLength: 0,
-                                    appendOnly: false,
-                                    allowHTML: false,
-                                    allowMentions: false,
-                                    sortAsGiven: false,
-                                    carryChoices: true,
-                                    allowNewChoices: false,
-                                    formula: "",
-                                    defaultValue: "",
-                                  }),
-                                  permissions: expect.arrayContaining([
-                                    expect.objectContaining({
-                                      permissionType: "View",
-                                      role: "Viewer",
-                                      roleId: 10,
-                                    }),
-                                    expect.objectContaining({
-                                      permissionType: "None",
-                                      role: "Participant",
-                                      roleId: 11,
-                                    }),
-                                    expect.objectContaining({
-                                      permissionType: "Modify",
-                                      role: "Administrator",
-                                      roleId: 12,
-                                    }),
-                                  ]),
-                                }),
-                              ])
-                            );
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/fields?tableId=${QB_TABLE_ID_1}&includeFieldPerms=true`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-                        });
+                    - name: getFieldsUsage.test.ts
+                      type: file
                 - name: index.ts
                   type: file
-                  contents: |
-                    // tests/unit/index.ts
-                    export * from "./apps/getApp.test.ts";
-                    export * from "./fields/getFields.test.ts";
-                    export * from "./tables/getAppTables.test.ts";
                 - name: records
                   type: directory
                   children:
                     - name: deleteRecords.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/deleteRecords.test.ts
-                        import { describe, expect, test, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - deleteRecords", () => {
-                          let qb: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            qb = createClient(mockFetch, { debug: true }); // Use debug: true for consistency with other tests
-                          });
-
-                          test("sends correct DELETE request and handles success", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve({ numberDeleted: 1 }),
-                            });
-
-                            const result = await qb.deleteRecords({
-                              body: {
-                                from: QB_TABLE_ID_1,
-                                where: "{3.EX.'5'}", // Simulate deleting Record ID 5
-                              },
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "DELETE",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({ from: QB_TABLE_ID_1, where: "{3.EX.'5'}" }),
-                              })
-                            );
-                            expect(result).toEqual({ numberDeleted: 1 });
-                          });
-
-                          test("handles no records deleted", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve({ numberDeleted: 0 }),
-                            });
-
-                            const result = await qb.deleteRecords({
-                              body: {
-                                from: QB_TABLE_ID_1,
-                                where: "{3.EX.'999999'}", // Non-existent Record ID
-                              },
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "DELETE",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  from: QB_TABLE_ID_1,
-                                  where: "{3.EX.'999999'}",
-                                }),
-                              })
-                            );
-                            expect(result).toEqual({ numberDeleted: 0 });
-                          });
-
-                          test("throws error on API failure", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 400,
-                              json: () => Promise.resolve({ message: "Invalid query" }),
-                            });
-
-                            await expect(() =>
-                              qb.deleteRecords({
-                                body: {
-                                  from: QB_TABLE_ID_1,
-                                  where: "{3.EX.'invalid'}",
-                                },
-                              })
-                            ).rejects.toThrow("API Error: Invalid query (Status: 400)");
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "DELETE",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  from: QB_TABLE_ID_1,
-                                  where: "{3.EX.'invalid'}",
-                                }),
-                              })
-                            );
-                          });
-                        });
                     - name: runQuery.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/runQuery.test.ts
-                        import { describe, test, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-                        import { RunQueryRequest, RunQueryResponse } from "@/generated";
-
-                        describe("QuickbaseClient Unit - runQuery", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true });
-                          });
-
-                          test("sends correct POST request and handles successful query response", async () => {
-                            const queryRequest: RunQueryRequest = {
-                              from: QB_TABLE_ID_1,
-                              select: [3, 6, 7],
-                              where: "{6.EX.'Task 1'}",
-                              sortBy: [{ fieldId: 6, order: "ASC" }],
-                              groupBy: [{ fieldId: 7, grouping: "equal-values" }],
-                              options: { skip: 0, top: 100, compareWithAppLocalTime: false },
-                            };
-
-                            const mockResponse: RunQueryResponse = {
-                              data: [
-                                { "3": { value: 1 }, "6": { value: "Task 1" }, "7": { value: "High" } },
-                              ],
-                              fields: [
-                                { id: 3, label: "Record ID#", type: "recordid" },
-                                { id: 6, label: "Task Name", type: "text" },
-                                { id: 7, label: "Priority", type: "text" },
-                              ],
-                              metadata: {
-                                numFields: 3,
-                                numRecords: 1,
-                                skip: 0,
-                                top: 100,
-                                totalRecords: 1,
-                              },
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const result = await client.runQuery({ body: queryRequest });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records/query",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify(queryRequest),
-                              })
-                            );
-
-                            expect(result).toEqual(mockResponse);
-                          });
-
-                          test("handles API error with invalid query", async () => {
-                            const invalidQueryRequest = {
-                              from: QB_TABLE_ID_1,
-                              select: [3],
-                              where: "{999.EX.'Invalid'}", // Invalid field ID
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 400,
-                              json: () => Promise.resolve({ message: "Invalid query" }),
-                            });
-
-                            await expect(
-                              client.runQuery({ body: invalidQueryRequest })
-                            ).rejects.toThrow("API Error: Invalid query (Status: 400)");
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records/query",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify(invalidQueryRequest),
-                              })
-                            );
-                          });
-                        });
                     - name: upsert.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/upsert.test.ts
-                        import { describe, expect, test, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-                        import { vi } from "vitest";
-
-                        // Note: Type augmentation moved to src/types.d.ts
-                        describe("QuickbaseClient Unit - upsert", () => {
-                          beforeEach(() => {
-                            vi.resetModules(); // Reset module cache
-                            mockFetch.mockClear();
-                          });
-
-                          test("sends correct POST request and handles successful upsert", async () => {
-                            const qb = createClient(mockFetch, { debug: true });
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () =>
-                                Promise.resolve({
-                                  data: [{ id: 1, "6": { value: "value1" } }],
-                                  metadata: {
-                                    createdRecordIds: [1],
-                                    updatedRecordIds: [],
-                                    unchangedRecordIds: [],
-                                    totalNumberOfRecordsProcessed: 1,
-                                  },
-                                }),
-                            });
-
-                            console.log("[Test] Calling qb.upsert with:", {
-                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
-                            });
-                            const result = await qb.upsert({
-                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
-                            });
-
-                            console.log("[Test] mockFetch calls:", mockFetch.mock.calls);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  to: QB_TABLE_ID_1,
-                                  data: [{ "6": { value: "value1" } }],
-                                }),
-                              })
-                            );
-
-                            expect(result).toEqual({
-                              data: [{ id: 1, "6": { value: "value1" } }],
-                              metadata: {
-                                createdRecordIds: [1],
-                                updatedRecordIds: [],
-                                unchangedRecordIds: [],
-                                totalNumberOfRecordsProcessed: 1,
-                              },
-                            });
-                          });
-
-                          test("handles API error with invalid data", async () => {
-                            const qb = createClient(mockFetch, { debug: true });
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 400,
-                              json: () => Promise.resolve({ message: "Invalid data format" }),
-                            });
-
-                            await expect(
-                              qb.upsert({
-                                body: { to: QB_TABLE_ID_1, data: [{ "999": { value: "invalid" } }] },
-                              })
-                            ).rejects.toThrow("API Error: Invalid data format (Status: 400)");
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  to: QB_TABLE_ID_1,
-                                  data: [{ "999": { value: "invalid" } }],
-                                }),
-                              })
-                            );
-                          });
-
-                          test("handles upsert with temp token", async () => {
-                            const qb = createClient(mockFetch, { useTempTokens: true, debug: true });
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve({ temporaryAuthorization: "temp-token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve({
-                                    data: [{ id: 2, "7": { value: "value2" } }],
-                                    metadata: {
-                                      createdRecordIds: [2],
-                                      updatedRecordIds: [],
-                                      unchangedRecordIds: [],
-                                      totalNumberOfRecordsProcessed: 1,
-                                    },
-                                  }),
-                              });
-
-                            const result = await qb.upsert({
-                              body: { to: QB_TABLE_ID_1, data: [{ "7": { value: "value2" } }] },
-                              dbid: QB_TABLE_ID_1, // Use QB_TABLE_ID_1 as dbid for temp token
-                            } as any); // Temporary type assertion until types.d.ts is applied
-
-                            expect(mockFetch).toHaveBeenCalledTimes(2);
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              1,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  "Content-Type": "application/json",
-                                }),
-                                credentials: "include",
-                              })
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              2,
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: "QB-TEMP-TOKEN temp-token",
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  to: QB_TABLE_ID_1,
-                                  data: [{ "7": { value: "value2" } }],
-                                }),
-                              })
-                            );
-
-                            expect(result).toEqual({
-                              data: [{ id: 2, "7": { value: "value2" } }],
-                              metadata: {
-                                createdRecordIds: [2],
-                                updatedRecordIds: [],
-                                unchangedRecordIds: [],
-                                totalNumberOfRecordsProcessed: 1,
-                              },
-                            });
-                          });
-
-                          test("sends correct POST request with data fields", async () => {
-                            const qb = createClient(mockFetch, { debug: true });
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () =>
-                                Promise.resolve({
-                                  data: [{ id: 1, "6": { value: "value1" } }],
-                                  metadata: {
-                                    createdRecordIds: [1],
-                                    updatedRecordIds: [],
-                                    unchangedRecordIds: [],
-                                    totalNumberOfRecordsProcessed: 1,
-                                  },
-                                }),
-                            });
-
-                            const result = await qb.upsert({
-                              body: { to: QB_TABLE_ID_1, data: [{ "6": { value: "value1" } }] },
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              "https://api.quickbase.com/v1/records",
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify({
-                                  to: QB_TABLE_ID_1,
-                                  data: [{ "6": { value: "value1" } }],
-                                }),
-                              })
-                            );
-
-                            if (result.data && result.data.length > 0) {
-                              expect((result.data[0]["6"] as { value: any }).value).toBe("value1");
-                            } else {
-                              throw new Error("Expected data array to have at least one element");
-                            }
-                          });
-                        });
                 - name: tables
                   type: directory
                   children:
                     - name: createTable.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/createTable.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - createTable", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true });
-                          });
-
-                          it("calls createTable successfully with user token", async () => {
-                            const mockBody = {
-                              name: "TestTable",
-                              description: "Unit test table",
-                              singleRecordName: "Test",
-                              pluralRecordName: "Tests",
-                            };
-                            const mockResponse = {
-                              id: "newly-created-table-id-1234567890", // Changed from "buya8h9iz"
-                              name: "TestTable",
-                              alias: "_DBID_TESTTABLE",
-                              description: "Unit test table",
-                              created: new Date("2025-03-10T21:00:00.000Z"),
-                              updated: new Date("2025-03-10T21:00:00.000Z"),
-                              nextRecordId: 1,
-                              nextFieldId: 6,
-                              defaultSortFieldId: 2,
-                              defaultSortOrder: "DESC",
-                              keyFieldId: 3,
-                              singleRecordName: "Test",
-                              pluralRecordName: "Tests",
-                              sizeLimit: "500 MB",
-                              spaceUsed: "0 KB",
-                              spaceRemaining: "500 MB",
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const response = await client.createTable({
-                              appId: QB_APP_ID,
-                              body: mockBody,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(1);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "Content-Type": "application/json",
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                                body: JSON.stringify(mockBody),
-                              })
-                            );
-                          });
-                        });
                     - name: deleteTable.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/deleteTable.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_TABLE_ID_1,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - deleteTable", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true });
-                          });
-
-                          it("calls deleteTable successfully with user token", async () => {
-                            const mockResponse = {
-                              deletedTableId: QB_TABLE_ID_1,
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const response = await client.deleteTable({
-                              tableId: QB_TABLE_ID_1,
-                              appId: QB_APP_ID,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(1);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "DELETE",
-                                headers: expect.objectContaining({
-                                  "Content-Type": "application/json",
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-
-                          it("handles 404 error for non-existent table", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 404,
-                              json: () =>
-                                Promise.resolve({
-                                  message: "Invalid DBID",
-                                  description: "Table not found in app.",
-                                }),
-                            });
-
-                            await expect(
-                              client.deleteTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
-                            ).rejects.toThrow("API Error: Invalid DBID (Status: 404)");
-                            expect(mockFetch).toHaveBeenCalledTimes(1);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "DELETE",
-                                headers: expect.objectContaining({
-                                  "Content-Type": "application/json",
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-                        });
                     - name: getAppTables.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/tables/getAppTables.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - getAppTables", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true }); // Add debug: true for consistency
-                          });
-
-                          it("calls getAppTables successfully", async () => {
-                            mockFetch.mockImplementation((url: string, options: any) => {
-                              console.log("Mock fetch for getAppTables:", url, options);
-                              return Promise.resolve({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve([
-                                    {
-                                      id: "buwai2zr4",
-                                      name: "Root",
-                                      alias: "_DBID_ROOT",
-                                      description: "",
-                                      created: new Date("2025-02-13T18:22:33.000Z"),
-                                      updated: new Date("2025-02-13T18:22:34.000Z"),
-                                      nextRecordId: 1,
-                                      nextFieldId: 6,
-                                      defaultSortFieldId: 2,
-                                      defaultSortOrder: "DESC",
-                                      keyFieldId: 3,
-                                      singleRecordName: "Root",
-                                      pluralRecordName: "Roots",
-                                      sizeLimit: "500 MB",
-                                      spaceUsed: "0 KB",
-                                      spaceRemaining: "500 MB",
-                                    },
-                                  ]),
-                              } as Response);
-                            });
-
-                            const result = await client.getAppTables({ appId: QB_APP_ID });
-                            console.log("getAppTables response:", result);
-                            expect(result).toEqual(
-                              expect.arrayContaining([
-                                expect.objectContaining({
-                                  id: "buwai2zr4",
-                                  name: "Root",
-                                  alias: "_DBID_ROOT",
-                                  description: "",
-                                  created: new Date("2025-02-13T18:22:33.000Z"),
-                                  updated: new Date("2025-02-13T18:22:34.000Z"),
-                                  nextRecordId: 1,
-                                  nextFieldId: 6,
-                                  defaultSortFieldId: 2,
-                                  defaultSortOrder: "DESC",
-                                  keyFieldId: 3,
-                                  singleRecordName: "Root",
-                                  pluralRecordName: "Roots",
-                                  sizeLimit: "500 MB",
-                                  spaceUsed: "0 KB",
-                                  spaceRemaining: "500 MB",
-                                }),
-                              ])
-                            );
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                              })
-                            );
-                          });
-                        });
                     - name: getRelationships.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/relationships/getRelationships.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                          QB_TABLE_ID_1,
-                          QB_TABLE_ID_2,
-                        } from "@tests/setup.ts";
-                        import { GetRelationships200Response } from "/home/drew/Projects/quickbase-js/src/generated/models";
-
-                        describe("QuickbaseClient Unit - getRelationships", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true }); // Consistent with output
-                          });
-
-                          it("initializes without errors", () => {
-                            expect(client).toBeDefined();
-                          });
-
-                          it("has getRelationships method", () => {
-                            expect(typeof client.getRelationships).toBe("function");
-                          });
-
-                          it("sends correct GET request and handles successful response", async () => {
-                            const mockResponse: GetRelationships200Response = {
-                              metadata: {
-                                numRelationships: 1,
-                                skip: 0,
-                                totalRelationships: 1,
-                              },
-                              relationships: [
-                                {
-                                  id: 6,
-                                  parentTableId: QB_TABLE_ID_1, // Parent table
-                                  childTableId: QB_TABLE_ID_2, // Child table
-                                  foreignKeyField: {
-                                    id: 6,
-                                    label: "Related record",
-                                    type: "numeric",
-                                  },
-                                  isCrossApp: false,
-                                  lookupFields: [
-                                    {
-                                      id: 3,
-                                      label: "Name",
-                                      type: "text",
-                                    },
-                                  ],
-                                  summaryFields: [
-                                    {
-                                      id: 8,
-                                      label: "my summary field",
-                                      type: "numeric",
-                                    },
-                                  ],
-                                },
-                              ],
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const result = await client.getRelationships({
-                              tableId: QB_TABLE_ID_2,
-                              skip: 0,
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                              })
-                            );
-
-                            expect(result).toEqual(mockResponse);
-                            expect(result.metadata.numRelationships).toBe(1);
-                            expect(result.relationships).toHaveLength(1);
-                            expect(result.relationships[0].id).toBe(6);
-                            expect(result.relationships[0].foreignKeyField.label).toBe(
-                              "Related record"
-                            );
-                          });
-
-                          it("handles request without skip parameter", async () => {
-                            const mockResponse: GetRelationships200Response = {
-                              metadata: {
-                                numRelationships: 1,
-                                skip: 0,
-                                totalRelationships: 1,
-                              },
-                              relationships: [
-                                {
-                                  id: 6,
-                                  parentTableId: QB_TABLE_ID_1,
-                                  childTableId: QB_TABLE_ID_2,
-                                  foreignKeyField: {
-                                    id: 6,
-                                    label: "Related record",
-                                    type: "numeric",
-                                  },
-                                  isCrossApp: false,
-                                  lookupFields: [],
-                                  summaryFields: [],
-                                },
-                              ],
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const result = await client.getRelationships({
-                              tableId: QB_TABLE_ID_2, // Corrected from QB_TABLE_ID_1
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                              })
-                            );
-
-                            expect(result).toEqual(mockResponse);
-                          });
-
-                          it("handles API error response", async () => {
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 404,
-                              json: () => Promise.resolve({ message: "Table not found" }),
-                            });
-
-                            await expect(
-                              client.getRelationships({
-                                tableId: QB_TABLE_ID_2, // Corrected from QB_TABLE_ID_1
-                                skip: 0,
-                              })
-                            ).rejects.toThrow("API Error: Table not found (Status: 404)");
-
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                  "Content-Type": "application/json",
-                                }),
-                              })
-                            );
-                          });
-
-                          it("retries with temp token after 401", async () => {
-                            const mockResponse: GetRelationships200Response = {
-                              metadata: {
-                                numRelationships: 1,
-                                skip: 0,
-                                totalRelationships: 1,
-                              },
-                              relationships: [
-                                {
-                                  id: 6,
-                                  parentTableId: QB_TABLE_ID_1,
-                                  childTableId: QB_TABLE_ID_2,
-                                  foreignKeyField: {
-                                    id: 6,
-                                    label: "Related record",
-                                    type: "numeric",
-                                  },
-                                  isCrossApp: false,
-                                },
-                              ],
-                            };
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve({ temporaryAuthorization: "initial_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: false,
-                                status: 401,
-                                json: () => Promise.resolve({ message: "Unauthorized" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve({ temporaryAuthorization: "new_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve(mockResponse),
-                              });
-
-                            const tempClient = createClient(mockFetch, {
-                              useTempTokens: true,
-                              debug: true,
-                            });
-                            const result = await tempClient.getRelationships({
-                              tableId: QB_TABLE_ID_2,
-                              skip: 0,
-                            });
-
-                            expect(mockFetch).toHaveBeenCalledTimes(4);
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              1,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_2}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              2,
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  Authorization: "QB-TEMP-TOKEN initial_token",
-                                }),
-                              })
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              3,
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_2}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenNthCalledWith(
-                              4,
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_2}/relationships?skip=0`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  Authorization: "QB-TEMP-TOKEN new_token",
-                                }),
-                              })
-                            );
-
-                            expect(result).toEqual(mockResponse);
-                          });
-                        });
                     - name: getTable.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/tables/getTable.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_TABLE_ID_1,
-                          QB_REALM,
-                          QB_USER_TOKEN,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - getTable", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                          });
-
-                          it("calls getTable successfully with user token", async () => {
-                            client = createClient(mockFetch, { debug: true });
-
-                            const mockResponse = {
-                              id: QB_TABLE_ID_1,
-                              name: "Root",
-                              alias: "_DBID_ROOT",
-                              description: "",
-                              created: new Date("2025-02-13T18:22:33.000Z"),
-                              updated: new Date("2025-02-13T18:22:34.000Z"),
-                              nextRecordId: 1,
-                              nextFieldId: 6,
-                              defaultSortFieldId: 2,
-                              defaultSortOrder: "DESC",
-                              keyFieldId: 3,
-                              singleRecordName: "Root",
-                              pluralRecordName: "Roots",
-                              sizeLimit: "500 MB",
-                              spaceUsed: "0 KB",
-                              spaceRemaining: "500 MB",
-                            };
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: true,
-                              status: 200,
-                              json: () => Promise.resolve(mockResponse),
-                            });
-
-                            const response = await client.getTable({
-                              tableId: QB_TABLE_ID_1,
-                              appId: QB_APP_ID,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-
-                          it("calls getTable successfully with temp token", async () => {
-                            client = createClient(mockFetch, { debug: true, useTempTokens: true });
-
-                            const mockResponse = {
-                              id: QB_TABLE_ID_1,
-                              name: "Root",
-                              alias: "_DBID_ROOT",
-                              description: "",
-                              created: new Date("2025-02-13T18:22:33.000Z"),
-                              updated: new Date("2025-02-13T18:22:34.000Z"),
-                              nextRecordId: 1,
-                              nextFieldId: 6,
-                              defaultSortFieldId: 2,
-                              defaultSortOrder: "DESC",
-                              keyFieldId: 3,
-                              singleRecordName: "Root",
-                              pluralRecordName: "Roots",
-                              sizeLimit: "500 MB",
-                              spaceUsed: "0 KB",
-                              spaceRemaining: "500 MB",
-                            };
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve(mockResponse),
-                              });
-
-                            const response = await client.getTable({
-                              tableId: QB_TABLE_ID_1,
-                              appId: QB_APP_ID,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(2);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: "QB-TEMP-TOKEN temp_token",
-                                }),
-                              })
-                            );
-                          });
-
-                          it("retries successfully after 401 with temp token", async () => {
-                            client = createClient(mockFetch, { debug: true, useTempTokens: true });
-
-                            const mockResponse = {
-                              id: QB_TABLE_ID_1,
-                              name: "Root",
-                              alias: "_DBID_ROOT",
-                              description: "",
-                              created: new Date("2025-02-13T18:22:33.000Z"),
-                              updated: new Date("2025-02-13T18:22:34.000Z"),
-                              nextRecordId: 1,
-                              nextFieldId: 6,
-                              defaultSortFieldId: 2,
-                              defaultSortOrder: "DESC",
-                              keyFieldId: 3,
-                              singleRecordName: "Root",
-                              pluralRecordName: "Roots",
-                              sizeLimit: "500 MB",
-                              spaceUsed: "0 KB",
-                              spaceRemaining: "500 MB",
-                            };
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve({ temporaryAuthorization: "initial_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: false,
-                                status: 401,
-                                json: () => Promise.resolve({ message: "Unauthorized" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve({ temporaryAuthorization: "new_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve(mockResponse),
-                              });
-
-                            const response = await client.getTable({
-                              tableId: QB_TABLE_ID_1,
-                              appId: QB_APP_ID,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(4);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                headers: expect.objectContaining({
-                                  Authorization: "QB-TEMP-TOKEN new_token",
-                                }),
-                              })
-                            );
-                          });
-
-                          it("handles 401 with failed temp token retry", async () => {
-                            client = createClient(mockFetch, { debug: true, useTempTokens: true });
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () =>
-                                  Promise.resolve({ temporaryAuthorization: "initial_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: false,
-                                status: 401,
-                                json: () => Promise.resolve({ message: "Unauthorized" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: false,
-                                status: 401,
-                                json: () =>
-                                  Promise.resolve({ message: "Unauthorized in fetchTempToken" }),
-                              });
-
-                            await expect(
-                              client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
-                            ).rejects.toThrow(
-                              "API Error: Unauthorized in fetchTempToken (Status: 401)"
-                            );
-                            expect(mockFetch).toHaveBeenCalledTimes(3);
-                          });
-
-                          it("handles 404 Not Found", async () => {
-                            client = createClient(mockFetch, { debug: true });
-
-                            mockFetch.mockResolvedValueOnce({
-                              ok: false,
-                              status: 404,
-                              json: () => Promise.resolve({ message: "Table not found" }),
-                            });
-
-                            await expect(
-                              client.getTable({ tableId: QB_TABLE_ID_1, appId: QB_APP_ID })
-                            ).rejects.toThrow("API Error: Table not found (Status: 404)");
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "GET",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${QB_REALM}.quickbase.com`,
-                                  Authorization: `QB-USER-TOKEN ${QB_USER_TOKEN}`,
-                                }),
-                              })
-                            );
-                          });
-                        });
                     - name: updateTable.test.ts
                       type: file
-                      contents: |
-                        // tests/vitest/unit/records/updateTable.test.ts
-                        import { describe, it, expect, beforeEach } from "vitest";
-                        import {
-                          createClient,
-                          mockFetch,
-                          QB_APP_ID,
-                          QB_TABLE_ID_1,
-                        } from "@tests/setup.ts";
-
-                        describe("QuickbaseClient Unit - updateTable", () => {
-                          let client: ReturnType<typeof createClient>;
-
-                          beforeEach(() => {
-                            mockFetch.mockClear();
-                            client = createClient(mockFetch, { debug: true });
-                          });
-
-                          it("calls updateTable successfully with temp token", async () => {
-                            client = createClient(mockFetch, { debug: true, useTempTokens: true });
-
-                            const mockBody = {
-                              name: "Updated Root",
-                              description: "Updated description",
-                            };
-                            const mockResponse = {
-                              id: QB_TABLE_ID_1,
-                              name: "Updated Root",
-                              alias: "_DBID_ROOT",
-                              description: "Updated description",
-                              created: new Date("2025-02-13T18:22:33.000Z"),
-                              updated: new Date("2025-03-10T12:00:00.000Z"),
-                              nextRecordId: 1,
-                              nextFieldId: 6,
-                              defaultSortFieldId: 2,
-                              defaultSortOrder: "DESC",
-                              keyFieldId: 3,
-                              singleRecordName: "Root",
-                              pluralRecordName: "Roots",
-                              sizeLimit: "500 MB",
-                              spaceUsed: "0 KB",
-                              spaceRemaining: "500 MB",
-                            };
-
-                            mockFetch
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve({ temporaryAuthorization: "temp_token" }),
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: () => Promise.resolve(mockResponse),
-                              });
-
-                            const response = await client.updateTable({
-                              tableId: QB_TABLE_ID_1,
-                              appId: QB_APP_ID,
-                              body: mockBody,
-                            });
-                            expect(response).toEqual(mockResponse);
-                            expect(mockFetch).toHaveBeenCalledTimes(2);
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/auth/temporary/${QB_TABLE_ID_1}`,
-                              expect.any(Object)
-                            );
-                            expect(mockFetch).toHaveBeenCalledWith(
-                              `https://api.quickbase.com/v1/tables/${QB_TABLE_ID_1}?appId=${QB_APP_ID}`,
-                              expect.objectContaining({
-                                method: "POST",
-                                headers: expect.objectContaining({
-                                  "QB-Realm-Hostname": `${process.env.QB_REALM}.quickbase.com`,
-                                  Authorization: "QB-TEMP-TOKEN temp_token",
-                                  "Content-Type": "application/json",
-                                }),
-                                body: JSON.stringify(mockBody),
-                              })
-                            );
-                          });
-                        });
+                - name: umd.test.ts
+                  type: file
     - name: text.txt
       type: file
+    - name: tools
+      type: directory
+      children:
+        - name: log-gen.ts
+          type: file
+        - name: openapi-jars
+          type: directory
+          children:
+            - name: openapi-generator-cli-7.12.0.jar
+              type: file
+    - name: tsconfig.build.json
+      type: file
+      contents: |-
+        {
+          "extends": "./tsconfig.json",
+          "compilerOptions": {
+            "outDir": "dist/temp",
+            "noEmit": false,
+            "allowImportingTsExtensions": false,
+            "declaration": false,
+            "sourceMap": true
+          },
+          "include": ["dist/temp-src/**/*"],
+          "exclude": [
+            "node_modules",
+            "dist",
+            "tests/**/*",
+            "src/**/*" // Exclude original src/ to avoid confusion
+          ]
+        }
     - name: tsconfig.json
       type: file
+      contents: |-
+        {
+          "compilerOptions": {
+            "target": "ESNext",
+            "module": "ESNext",
+            "moduleResolution": "bundler",
+            "strict": true,
+            "lib": ["ES2015", "ESNext", "DOM"],
+            "types": ["node", "playwright/test", "undici-types"],
+            "esModuleInterop": true,
+            "resolveJsonModule": true,
+            "allowImportingTsExtensions": true,
+            "noEmit": true,
+            "outDir": "dist",
+            "rootDir": ".",
+            "declaration": true,
+            "sourceMap": true,
+            "baseUrl": ".",
+            "paths": {
+              "@/*": ["src/*"],
+              "@tests/*": ["tests/*"]
+            }
+          },
+          "include": ["src/**/*", "tests/**/*", "open-api/**/*", "tools/**/*"],
+          "exclude": ["node_modules", "dist", "specs"],
+          "ts-node": {
+            "esm": true,
+            "transpileOnly": true
+          }
+        }
     - name: versionrc.json
       type: file
     - name: vitest.config.ts
       type: file
+      contents: |
+        // vitest.config.ts
+        import { defineConfig } from "vitest/config";
+        import path from "path";
+        import dotenv from "dotenv"; // Add this import
+
+        // Load .env variables before tests run
+        dotenv.config({ path: path.resolve(__dirname, ".env") });
+
+        export default defineConfig({
+          test: {
+            environment: "jsdom",
+            include: ["tests/vitest/**/**/*.test.ts"],
+            setupFiles: ["tests/setup.ts"], // Relative path from root
+            pool: "forks",
+            poolOptions: {
+              forks: {
+                singleFork: true, // Run tests sequentially
+              },
+            },
+          },
+          resolve: {
+            alias: {
+              "@": path.resolve(__dirname, "./src"), // For src/ imports
+              "@tests": path.resolve(__dirname, "./tests"), // For tests/ imports
+            },
+          },
+        });