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

package/package.json

@@ -1,18 +1,26 @@
 {
   "name": "quickbase-js",
-  "main": "dist/quickbase.js",
-  "types": "dist/quickbase.d.ts",
-  "version": "1.1.0-beta.3",
+  "version": "1.1.0-beta.5",
+  "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"
   },
-  "description": "QuickBase JavaScript client for frameworks and vanilla JS",
-  "module": "dist/quickbase.js",
-  "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/quickbase.js",
-      "types": "./dist/quickbase.d.ts"
+      "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": {
@@ -21,13 +29,15 @@
     "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 src/code-generation/fix-spec-main.ts",
-    "regenerate": "rimraf src/generated && node --loader ts-node/esm src/code-generation/regenerate-client.ts",
-    "regenerate-unified": "node --loader ts-node/esm src/code-generation/generate-unified-interface.ts",
-    "regenerate-all": "npm run fix-spec && npm run regenerate && npm run regenerate-unified",
-    "log-gen": "node --loader ts-node/esm src/log-gen.ts",
-    "build": "rimraf dist && rollup -c",
-    "build:prod": "rm -rf dist/* && NODE_ENV=production rollup -c",
+    "release:stable": "standard-version && git push --follow-tags origin main && npm publish",
+    "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",
+    "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",
@@ -35,17 +45,14 @@
     "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:pw:qb:auth": "playwright test tests/playwright/qb/auth",
-    "test::pw:qb:auth:temptoken": "playwright test tests/playwright/qb/auth/getTempToken.test.ts",
-    "test:pw:qb:auth:renewal": "playwright test tests/playwright/qb/auth/tokenRenewal.test.ts",
-    "test:pw:qb:auth:cache": "playwright test tests/playwright/qb/auth/cacheSwitching.test.ts",
-    "test:pw:qb:auth:temp401": "playwright test tests/playwright/qb/auth/fetchTempToken401.test.ts",
-    "test:pw:qb:auth:prefetch": "playwright test tests/playwright/qb/auth/tokenPrefetch.test.ts",
-    "test:pw:qb:auth:debug": "playwright test tests/playwright/qb/auth --headed --debug",
-    "test:pw:qb:auth:temp:debug": "playwright test tests/playwright/qb/auth/getTempToken.test.ts --headed --debug",
-    "test:pw:qb:auth:renewal:debug": "playwright test tests/playwright/qb/auth/tokenRenewal.test.ts --headed --debug --config=playwright.config.ts",
-    "test:pw:qb:auth:cache:debug": "playwright test tests/playwright/qb/auth/cacheSwitching.test.ts --headed --debug"
+    "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"
@@ -57,6 +64,7 @@
     "@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",
@@ -71,6 +79,7 @@
     "ts-morph": "^25.0.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
+    "undici-types": "^7.5.0",
     "vitest": "^3.0.8"
   }
 }

package/playwright-results.txt/.last-run.json

@@ -0,0 +1,4 @@
+{
+  "status": "passed",
+  "failedTests": []
+}

package/playwright.config.ts

@@ -29,7 +29,7 @@ const config = defineConfig({
 });
 
 console.log(
-  `Loading Playwright config with timeout: ${config.timeout}ms, workers: ${
+  `Loading Playwright: Testing temp token authorization in browser. Be patient, this should take at least 5min. Workers: ${
     config.workers || "default (half CPU cores)"
   }`
 );

package/rollup.config.mjs

@@ -0,0 +1,114 @@
+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 typescript from "@rollup/plugin-typescript";
+
+const isProd = process.env.NODE_ENV === "production";
+
+// External dependencies for both ESM and UMD builds
+const external = [
+  "node:http",
+  "node:https",
+  "node:zlib",
+  "node:stream",
+  "node:buffer",
+  "node:util",
+  "node:url",
+  "node:net",
+  "node:fs",
+  "node:path",
+  "node-fetch",
+];
+
+// Global mappings for UMD (browser) build
+const globals = {
+  "node-fetch": "fetch", // Map node-fetch to window.fetch in browsers
+};
+
+export default [
+  // ESM Build
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      dir: "dist/esm",
+      format: "esm",
+      sourcemap: true,
+      entryFileNames: "quickbase.js",
+    },
+    external,
+    plugins: [
+      nodeResolve({ preferBuiltins: true }), // Node.js resolution
+      commonjs(), // Convert CommonJS to ESM
+      typescript({
+        tsconfig: "./tsconfig.json",
+        noEmitOnError: true, // Fail on TypeScript errors
+        // Use Rollup to emit JavaScript, overriding noEmit for this build
+      }),
+      isProd && terser(), // Minification for production
+    ],
+  },
+  // UMD Build
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      file: "dist/umd/quickbase.umd.js",
+      format: "umd",
+      name: "QuickbaseJS", // Global name for browser
+      sourcemap: true,
+      globals,
+    },
+    external,
+    plugins: [
+      nodeResolve({ preferBuiltins: true, browser: true }), // Browser-first resolution
+      commonjs(), // Convert CommonJS to UMD
+      typescript({
+        tsconfig: "./tsconfig.json",
+        noEmitOnError: true, // Fail on TypeScript errors
+        // Use Rollup to emit JavaScript, overriding noEmit for this build
+      }),
+      isProd && terser(), // Minification for production
+    ],
+  },
+  // ESM Declarations
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      file: "dist/esm/quickbase.d.ts",
+      format: "esm",
+    },
+    plugins: [
+      dts({
+        tsconfig: "./tsconfig.json",
+        respectExternal: true, // Include external dependencies in declarations
+      }),
+    ],
+  },
+  // UMD Declarations
+  {
+    input: "src/quickbaseClient.ts",
+    output: {
+      file: "dist/umd/quickbase.umd.d.ts",
+      format: "umd",
+    },
+    plugins: [
+      dts({
+        tsconfig: "./tsconfig.json",
+        respectExternal: true, // Include external dependencies in declarations
+      }),
+    ],
+  },
+].map((config) => ({
+  ...config,
+  onwarn(warning, warn) {
+    // Suppress TypeScript plugin warnings
+    if (
+      warning.code === "PLUGIN_WARNING" &&
+      warning.plugin === "typescript" &&
+      warning.message.includes("TS5096")
+    ) {
+      return;
+    }
+    warn(warning);
+  },
+}));

package/src/generated-unified/QuickbaseClient.ts

@@ -1,5 +1,5 @@
-// Generated on 2025-03-11T21:50:08.483Z
-import { App, CopyApp200Response, CopyAppRequest, CreateApp200Response, CreateAppRequest, DeleteApp200Response, DeleteAppRequest, 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>;
@@ -20,10 +20,11 @@ export interface QuickbaseClient {
   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>;

package/test-artifacts/.last-run.json

@@ -1,4 +1,6 @@
 {
-  "status": "passed",
-  "failedTests": []
+  "status": "failed",
+  "failedTests": [
+    "07fa1d68e36f7ff08da6-e567a262e6a662a8edf4"
+  ]
 }

package/test-esm.js

@@ -0,0 +1 @@
+import { quickbase } from './dist/esm/quickbase.js'; const qb = quickbase({ realm: 'example', userToken: 'your-token' }); console.log(qb);

package/test-umd.js

@@ -0,0 +1 @@
+const quickbase = require('./dist/umd/quickbase.umd.js'); const qb = quickbase({ realm: 'example', userToken: 'your-token' }); console.log(qb);

package/test.ts

@@ -0,0 +1 @@
+console.log('Hello from TypeScript');

package/tests/playwright/qb/auth/umd.test.ts

@@ -0,0 +1,10 @@
+// tests/playwright/qb/auth/umd.test.ts
+import { test, expect } from "@playwright/test";
+test("UMD build works in browser", async ({ page }) => {
+  await page.goto("http://localhost:3000/test-umd.html");
+  const result = await page.evaluate(() => {
+    const qb = new QuickbaseJS({ realm: "example", useTempTokens: true });
+    return qb.getTempTokenDBID({ dbid: "test-dbid" });
+  });
+  expect(result).toBeTruthy();
+});

package/tests/vitest/qb/fields/createField.test.ts

@@ -0,0 +1,78 @@
+// tests/vitest/qb/fields/createField.test.ts (updated)
+import { describe, it, expect, afterAll } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - createField", () => {
+  const client = createClient();
+
+  const createdFieldIds: number[] = [];
+
+  afterAll(async () => {
+    if (createdFieldIds.length > 0) {
+      try {
+        const response = await client.deleteFields({
+          tableId: QB_TABLE_ID_1,
+          body: { fieldIds: createdFieldIds },
+        });
+        console.log(
+          `Cleaned up fields: ${JSON.stringify(response.deletedFieldIds)}`,
+          response.errors && response.errors.length > 0
+            ? `Errors: ${response.errors}`
+            : ""
+        );
+      } catch (error) {
+        console.error("Cleanup failed:", error);
+        console.log(`Fields left in table: ${createdFieldIds}`);
+      }
+    } else {
+      console.log("No fields to clean up.");
+    }
+  });
+
+  it("creates a field with user token", async () => {
+    const uniqueLabel = `TestField_${Date.now()}`;
+    const response = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: uniqueLabel,
+        fieldType: "text",
+        fieldHelp: "Created via integration test",
+        addToForms: true,
+      },
+    });
+
+    expect(response.id).toBeDefined();
+    expect(response.label).toBe(uniqueLabel);
+    expect(response.fieldType).toBe("text");
+    expect(response.fieldHelp).toBe("Created via integration test");
+
+    createdFieldIds.push(response.id);
+    console.log(`Created field ${uniqueLabel} with ID ${response.id}`);
+  });
+
+  it("fails with invalid field type", async () => {
+    const uniqueLabel = `InvalidField_${Date.now()}`;
+    await expect(
+      client.createField({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          label: uniqueLabel,
+          fieldType: "invalid_type" as "text", // Type assertion to bypass compile-time check
+          fieldHelp: "Should fail",
+        },
+      })
+    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
+  });
+
+  it("fails with missing label", async () => {
+    await expect(
+      client.createField({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          label: "",
+          fieldType: "text",
+        },
+      })
+    ).rejects.toThrow("API Error: Invalid input (Status: 400)");
+  });
+});

package/tests/vitest/qb/fields/deleteFields.test.ts

@@ -0,0 +1,89 @@
+// tests/vitest/qb/fields/deleteFields.test.ts
+import { describe, it, expect, beforeAll } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - deleteFields", () => {
+  const client = createClient();
+
+  let fieldIdsToDelete: number[] = [];
+
+  beforeAll(async () => {
+    try {
+      // Create test fields to delete
+      const fieldLabels = ["DeleteTest1", "DeleteTest2"];
+      for (const label of fieldLabels) {
+        const response = await client.createField({
+          tableId: QB_TABLE_ID_1,
+          body: {
+            label,
+            fieldType: "text",
+            fieldHelp: "Test field for deletion",
+          },
+        });
+        fieldIdsToDelete.push(response.id);
+        console.log(`Created field ${label} with ID ${response.id}`);
+      }
+      if (fieldIdsToDelete.length !== 2) {
+        throw new Error("Failed to create all test fields");
+      }
+    } catch (error) {
+      console.error("beforeAll failed:", error);
+      throw error; // Fail the suite if setup fails
+    }
+  });
+
+  it("deletes fields successfully with user token", async () => {
+    try {
+      const response = await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: {
+          fieldIds: fieldIdsToDelete,
+        },
+      });
+
+      console.log("deleteFields response:", JSON.stringify(response, null, 2));
+
+      expect(response).toBeDefined();
+      expect(response.deletedFieldIds).toEqual(
+        expect.arrayContaining(fieldIdsToDelete)
+      );
+      expect(response.errors ?? []).toHaveLength(0); // Handle undefined errors
+    } catch (error) {
+      console.error("deleteFields failed:", error);
+      throw error; // Re-throw to fail the test with details
+    }
+  });
+
+  it("handles partial success with errors", async () => {
+    const newField = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: "DeleteTest3",
+        fieldType: "text",
+      },
+    });
+    console.log(`Created field DeleteTest3 with ID ${newField.id}`);
+
+    const invalidFieldId = 999999; // Assume this ID doesn’t exist
+    const fieldIds = [newField.id, invalidFieldId];
+
+    const response = await client.deleteFields({
+      tableId: QB_TABLE_ID_1,
+      body: { fieldIds },
+    });
+
+    expect(response.deletedFieldIds).toContain(newField.id);
+    expect(response.deletedFieldIds).not.toContain(invalidFieldId);
+    expect(response.errors).toHaveLength(1);
+    expect(response.errors[0]).toMatch(/Field: 999999 was not found/i);
+  });
+
+  it("fails with invalid request (empty fieldIds)", async () => {
+    await expect(
+      client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [] },
+      })
+    ).rejects.toThrow("API Error: Bad Request (Status: 400)");
+  });
+});

package/tests/vitest/qb/fields/getField.test.ts

@@ -0,0 +1,85 @@
+// tests/vitest/qb/fields/getField.test.ts
+import { describe, it, expect } from "vitest";
+import { createClient, QB_TABLE_ID_1 } from "../../../setup.ts";
+
+describe("QuickbaseClient Integration - getField", () => {
+  const client = createClient();
+
+  it("retrieves an existing field with user token", async () => {
+    // Create a field to ensure we have a known field ID to retrieve
+    const uniqueLabel = `TestField_${Date.now()}`;
+    const createResponse = await client.createField({
+      tableId: QB_TABLE_ID_1,
+      body: {
+        label: uniqueLabel,
+        fieldType: "text",
+        fieldHelp: "Created for getField integration test",
+        addToForms: true,
+      },
+    });
+
+    expect(createResponse.id).toBeDefined();
+    const fieldId = createResponse.id;
+    console.log(`Created field ${uniqueLabel} with ID ${fieldId} for testing`);
+
+    // Test getField with the created field
+    const response = await client.getField({
+      fieldId: fieldId,
+      tableId: QB_TABLE_ID_1,
+      includeFieldPerms: true,
+    });
+
+    expect(response.id).toBe(fieldId);
+    expect(response.label).toBe(uniqueLabel);
+    expect(response.fieldType).toBe("text");
+    expect(response.fieldHelp).toBe("Created for getField integration test");
+    expect(response.permissions).toBeDefined();
+    expect(Array.isArray(response.permissions)).toBe(true);
+    console.log(`Retrieved field ${response.label} with ID ${response.id}`);
+
+    // Clean up the created field
+    try {
+      const deleteResponse = await client.deleteFields({
+        tableId: QB_TABLE_ID_1,
+        body: { fieldIds: [fieldId] },
+      });
+      console.log(
+        `Cleaned up field ${fieldId}: ${JSON.stringify(deleteResponse)}`
+      );
+    } catch (error) {
+      console.error(`Failed to clean up field ${fieldId}:`, error);
+    }
+  }, 10000); // Increase timeout to 10 seconds
+
+  it("fails with non-existent field ID", async () => {
+    const nonExistentFieldId = 999999; // Assuming this ID doesn’t exist
+    await expect(
+      client.getField({
+        fieldId: nonExistentFieldId,
+        tableId: QB_TABLE_ID_1,
+      })
+    ).rejects.toMatchObject({
+      message: expect.stringContaining(
+        "API Error: No such field (Status: 404)"
+      ),
+    });
+    console.log(
+      `Confirmed 404 for non-existent field ID ${nonExistentFieldId}`
+    );
+  });
+
+  it("fails with invalid table ID", async () => {
+    const invalidTableId = "invalid_dbid";
+    await expect(
+      client.getField({
+        fieldId: 1, // Arbitrary field ID
+        tableId: invalidTableId,
+      })
+    ).rejects.toMatchObject({
+      message: expect.stringContaining(
+        "API Error: Invalid request (Status: 400)"
+      ),
+    });
+    console.log(`Confirmed 400 for invalid table ID ${invalidTableId}`);
+  });
+});