quickbase-js 0.1.0-beta.8 → 0.1.0-beta.9

package/tools/log-gen.yaml

@@ -1,7 +1,7 @@
 project: >-
   quickbase-js
 date: >-
-  3/17/2025
+  3/19/2025
 root: >-
   /home/drew/Projects/quickbase-js
 goals:
@@ -888,6 +888,10 @@ tree:
           type: >-
             directory
           children:
+            - name: >-
+                generateJsDoc.ts
+              type: >-
+                file
             - name: >-
                 infer-schema.ts
               type: >-
@@ -929,6 +933,10 @@ tree:
             ThrottleBucket.ts
           type: >-
             file
+        - name: >-
+            authorizationStrategy.ts
+          type: >-
+            file
         - name: >-
             generated
           type: >-
@@ -1642,6 +1650,10 @@ tree:
             quickbaseClient.ts
           type: >-
             file
+        - name: >-
+            rateLimiter.ts
+          type: >-
+            file
         - name: >-
             tokenCache.ts
           type: >-
@@ -1675,6 +1687,10 @@ tree:
         test-umd.js
       type: >-
         file
+    - name: >-
+        test.log
+      type: >-
+        file
     - name: >-
         test.ts
       type: >-
@@ -2276,13 +2292,6 @@ tree:
                         from
                         "../../../../src/quickbaseClient";
 
-                        import
-                        {
-                        ResponseError
-                        }
-                        from
-                        "../../../../src/generated/runtime";
-
 
                         describe("QuickbaseClient
                         Integration
@@ -2296,55 +2305,73 @@ tree:
                         =>
                         {
                           let client: QuickbaseClient;
-                          const mockFetch = vi.fn();
 
                           beforeEach(() => {
+                            const userToken = process.env.QB_USER_TOKEN;
+                            const realm = process.env.QB_REALM;
+                            const tableId = process.env.QB_TABLE_ID_1; // Consistent env var name
+
+                            if (!userToken) {
+                              throw new Error(
+                                "QB_USER_TOKEN environment variable is required for integration test"
+                              );
+                            }
+                            if (!tableId) {
+                              throw new Error(
+                                "QB_TABLE_ID_1 environment variable is required for integration test"
+                              );
+                            }
+
                             const config = {
-                              realm: process.env.QB_REALM || "builderprogram-dbradford6815",
-                              userToken: "mock-user-token",
+                              realm,
+                              userToken,
                               debug: true,
-                              fetchApi: mockFetch,
                             };
-                            console.log("[quickbaseTest] Config:", config);
+                            console.log("[quickbaseTest] Config:", {
+                              realm,
+                              userToken: userToken.substring(0, 10) + "...",
+                              tableId, // Log to confirm
+                              debug: true,
+                            });
                             client = quickbase(config);
                           });
 
-                          it("retries on transient 401 with user token and succeeds", async () => {
-                            const consoleSpy = vi.spyOn(console, "log");
+                          it(
+                            "successfully retrieves fields with user token, retrying on transient 401 if needed",
+                            async () => {
+                              const consoleSpy = vi.spyOn(console, "log");
 
-                            mockFetch
-                              .mockImplementationOnce(() => {
-                                const response = new Response(null, {
-                                  status: 401,
-                                  statusText: "Unauthorized",
-                                });
-                                console.log("[mockFetch] Throwing 401 ResponseError");
-                                return Promise.reject(new ResponseError(response));
-                              })
-                              .mockResolvedValueOnce({
-                                ok: true,
-                                status: 200,
-                                json: async () => [{ id: 1, label: "Mock Field", fieldType: "text" }],
-                              });
+                              const tableId = process.env.QB_TABLE_ID_1!; // Match beforeEach
+                              let fields;
+                              try {
+                                fields = await client.getFields({ tableId });
+                              } catch (error) {
+                                console.error("[integrationTest] Failed to retrieve fields:", error);
+                                throw error;
+                              }
 
-                            const fields = await client.getFields({ tableId: "mock-table-id" });
+                              expect(fields).toBeInstanceOf(Array);
+                              expect(fields.length).toBeGreaterThan(0);
+                              expect(fields[0]).toHaveProperty("id");
+                              expect(fields[0]).toHaveProperty("label");
 
-                            expect(fields).toBeInstanceOf(Array);
-                            expect(fields.length).toBeGreaterThan(0);
-                            expect(fields[0]).toHaveProperty("id");
-                            expect(fields[0]).toHaveProperty("label");
+                              console.log("[integrationTest] Fields retrieved:", fields.length);
 
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Authorization error for getFields (user token), retrying with same token:",
-                              "" // Matches empty ResponseError message from mock
-                            );
-                            expect(consoleSpy).toHaveBeenCalledWith(
-                              "Retrying getFields with user token"
-                            );
-                            expect(mockFetch).toHaveBeenCalledTimes(2);
+                              const retryLog = consoleSpy.mock.calls.some((call) =>
+                                call[0].includes("Retrying getFields with existing user token")
+                              );
+                              if (retryLog) {
+                                console.log("[integrationTest] Retry on 401 detected");
+                              } else {
+                                console.log(
+                                  "[integrationTest] No 401 retries observed (expected if no transient failure)"
+                                );
+                              }
 
-                            consoleSpy.mockRestore();
-                          });
+                              consoleSpy.mockRestore();
+                            },
+                            { timeout: 10000 }
+                          );
                         });
                 - name: >-
                     fields
@@ -3378,6 +3405,138 @@ tree:
                             }
                           });
                         });
+                - name: >-
+                    formulas
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        runFormula.test.ts
+                      type: >-
+                        file
+                      contents: >
+                        //
+                        tests/vitest/qb/formulas/runFormula.test.ts
+
+
+                        import
+                        {
+                        describe,
+                        it,
+                        expect,
+                        beforeAll,
+                        afterAll
+                        }
+                        from
+                        "vitest";
+
+                        import
+                        {
+                          createClient,
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                        }
+                        from
+                        "@tests/setup.ts";
+
+                        import
+                        {
+                          RunFormulaRequest,
+                          RunFormula200Response,
+                          Upsert200Response,
+                        }
+                        from
+                        "@/generated/models";
+
+
+                        describe("QuickbaseClient
+                        Integration
+                        -
+                        runFormula",
+                        ()
+                        =>
+                        {
+                          let client: ReturnType<typeof createClient>;
+                          let testRecordId: number;
+
+                          beforeAll(async () => {
+                            // Validate environment variables
+                            if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
+                            if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+                            if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+
+                            // Initialize client with user token only
+                            client = createClient(undefined, {
+                              realm: QB_REALM,
+                              userToken: QB_USER_TOKEN,
+                              debug: true,
+                            });
+
+                            // Upsert a test record to ensure we have a valid rid
+                            const upsertResponse: Upsert200Response = await client.upsert({
+                              body: {
+                                to: QB_TABLE_ID_1,
+                                data: [
+                                  {
+                                    "6": { value: `Test Record ${Date.now()}` }, // Assuming field 6 is a text field (e.g., "Task Name")
+                                  },
+                                ],
+                                fieldsToReturn: [3], // Return Record ID# (field ID 3)
+                              },
+                            });
+
+                            // Extract the created record ID
+                            testRecordId = upsertResponse.data[0]["3"].value as number;
+                            console.log(`Upserted test record with ID: ${testRecordId}`);
+                          });
+
+                          afterAll(async () => {
+                            // Clean up the test record
+                            if (testRecordId) {
+                              await client.deleteRecords({
+                                body: {
+                                  from: QB_TABLE_ID_1,
+                                  where: `{3.EX.${testRecordId}}`, // Delete by Record ID#
+                                },
+                              });
+                              console.log(`Cleaned up test record with ID: ${testRecordId}`);
+                            }
+                          });
+
+                          it("runs simple formula without rid and returns correct result", async () => {
+                            const request: RunFormulaRequest = {
+                              from: QB_TABLE_ID_1,
+                              formula: "1 + 1", // Simple arithmetic to verify functionality
+                            };
+
+                            const response: RunFormula200Response = await client.runFormula({
+                              body: request,
+                            });
+
+                            console.log("Real API response (no rid):", response);
+
+                            expect(response).toHaveProperty("result");
+                            expect(response.result).toBe("2"); // Expect "2" as a string
+                          }, 10000);
+
+                          it("runs formula with rid and field ID 3, returns correct numeric result", async () => {
+                            const request: RunFormulaRequest = {
+                              from: QB_TABLE_ID_1,
+                              formula: "Sum([Record ID#], 20)", // Field ID 3 is "Record ID#"
+                              rid: testRecordId, // Use the upserted record ID
+                            };
+
+                            const response: RunFormula200Response = await client.runFormula({
+                              body: request,
+                            });
+
+                            console.log("Real API response (with rid):", response);
+
+                            expect(response).toHaveProperty("result");
+                            expect(response.result).toBe(String(testRecordId + 20)); // Dynamic result based on the record ID
+                          }, 10000);
+                        });
                 - name: >-
                     index.ts
                   type: >-
@@ -4028,6 +4187,132 @@ tree:
                   type: >-
                     directory
                   children:
+                    - name: >-
+                        createRelationship.test.ts
+                      type: >-
+                        file
+                      contents: >
+                        //
+                        tests/vitest/qb/tables/createRelationship.test.ts
+
+
+                        import
+                        {
+                        test,
+                        expect
+                        }
+                        from
+                        "vitest";
+
+                        import
+                        {
+                        quickbase
+                        }
+                        from
+                        "/home/drew/Projects/quickbase-js/src/quickbaseClient";
+
+                        import
+                        {
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                          QB_TABLE_ID_2,
+                        }
+                        from
+                        "/home/drew/Projects/quickbase-js/tests/setup.ts";
+
+
+                        test(
+                          "QuickbaseClient Integration - createRelationship > creates a new relationship in QuickBase",
+                          { timeout: 60000 }, // 60 seconds for create and delete
+                          async () => {
+                            // Validate environment variables
+                            if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
+                            if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+                            if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+                            if (!QB_TABLE_ID_2) throw new Error("QB_TABLE_ID_2 is not defined in .env");
+
+                            // Initialize client
+                            const client = quickbase({
+                              realm: QB_REALM,
+                              userToken: QB_USER_TOKEN,
+                              debug: true,
+                            });
+
+                            // Define the relationship creation request
+                            const uniqueLabel = `TestRelationship_${Date.now()}`;
+                            const requestBody = {
+                              parentTableId: QB_TABLE_ID_1,
+                              foreignKeyField: { label: uniqueLabel },
+                              lookupFieldIds: [6], // Assuming field 6 exists in QB_TABLE_ID_1
+                              summaryFields: [
+                                {
+                                  summaryFid: 6, // Assuming field 6 in QB_TABLE_ID_2 is numeric
+                                  label: `Sum_${uniqueLabel}`,
+                                  accumulationType: "SUM",
+                                },
+                              ],
+                            };
+
+                            console.log("Config used:", {
+                              realm: QB_REALM,
+                              userToken: "[REDACTED]",
+                              parentTableId: QB_TABLE_ID_1,
+                              childTableId: QB_TABLE_ID_2,
+                            });
+                            console.log("Creating relationship with:", requestBody);
+
+                            // Create the relationship
+                            const response = await client.createRelationship({
+                              tableId: QB_TABLE_ID_2,
+                              body: requestBody,
+                            });
+
+                            console.log("Real API response:", JSON.stringify(response, null, 2));
+
+                            // Assertions for creation
+                            expect(response).toBeDefined();
+                            expect(response.id).toBeDefined();
+                            expect(response.parentTableId).toBe(QB_TABLE_ID_1);
+                            expect(response.childTableId).toBe(QB_TABLE_ID_2);
+                            expect(response.foreignKeyField).toBeDefined();
+                            expect(response.foreignKeyField?.label).toBe(uniqueLabel);
+                            expect(response.lookupFields).toHaveLength(1);
+                            expect(response.lookupFields[0].id).toBeGreaterThan(0);
+                            expect(response.summaryFields).toHaveLength(1);
+                            expect(response.summaryFields[0].label).toBe(`Sum_${uniqueLabel}`);
+
+                            // Cleanup: Delete the relationship
+                            const relationshipId = response.id;
+                            console.log("Deleting relationship with ID:", relationshipId);
+                            const deleteResponse = await client.deleteRelationship({
+                              tableId: QB_TABLE_ID_2,
+                              relationshipId,
+                            });
+
+                            console.log(
+                              "Delete relationship response:",
+                              JSON.stringify(deleteResponse, null, 2)
+                            );
+
+                            // Verify deletion
+                            expect(deleteResponse).toBeDefined();
+                            expect(deleteResponse.relationshipId).toBe(relationshipId);
+
+                            // Confirm relationship is gone
+                            const relationships = await client.getRelationships({
+                              tableId: QB_TABLE_ID_2,
+                            });
+                            console.log(
+                              "Relationships after deletion:",
+                              JSON.stringify(relationships, null, 2)
+                            );
+                            const deletedRelationship = relationships.relationships.find(
+                              (r) => r.id === relationshipId
+                            );
+                            expect(deletedRelationship).toBeUndefined(); // Should no longer exist
+                          }
+                        );
                     - name: >-
                         createTable.test.ts
                       type: >-
@@ -4101,6 +4386,173 @@ tree:
                             console.log("Cleanup - Deleted table:", deleteResponse);
                           }
                         );
+                    - name: >-
+                        deleteRelationship.test.ts
+                      type: >-
+                        file
+                      contents: >
+                        //
+                        tests/vitest/qb/tables/deleteRelationship.test.ts
+
+
+                        import
+                        {
+                        test,
+                        expect
+                        }
+                        from
+                        "vitest";
+
+                        import
+                        {
+                        quickbase
+                        }
+                        from
+                        "/home/drew/Projects/quickbase-js/src/quickbaseClient";
+
+                        import
+                        {
+                          QB_REALM,
+                          QB_USER_TOKEN,
+                          QB_TABLE_ID_1,
+                          QB_TABLE_ID_2,
+                        }
+                        from
+                        "/home/drew/Projects/quickbase-js/tests/setup.ts";
+
+
+                        test(
+                          "QuickbaseClient Integration - deleteRelationship > creates and deletes a relationship in QuickBase",
+                          { timeout: 60000 }, // 60 seconds for two API calls
+                          async () => {
+                            // Validate environment variables
+                            if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
+                            if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+                            if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+                            if (!QB_TABLE_ID_2) throw new Error("QB_TABLE_ID_2 is not defined in .env");
+
+                            // Initialize client
+                            const client = quickbase({
+                              realm: QB_REALM,
+                              userToken: QB_USER_TOKEN,
+                              debug: true,
+                            });
+
+                            // Step 1: Create a relationship
+                            const uniqueLabel = `TestRelationship_${Date.now()}`;
+                            const createRequestBody = {
+                              parentTableId: QB_TABLE_ID_1,
+                              foreignKeyField: { label: uniqueLabel },
+                              lookupFieldIds: [6], // Assuming field 6 exists in QB_TABLE_ID_1
+                              summaryFields: [
+                                {
+                                  summaryFid: 6, // Assuming field 6 in QB_TABLE_ID_2 is numeric
+                                  label: `Sum_${uniqueLabel}`,
+                                  accumulationType: "SUM",
+                                },
+                              ],
+                            };
+
+                            console.log("Config used:", {
+                              realm: QB_REALM,
+                              userToken: "[REDACTED]",
+                              parentTableId: QB_TABLE_ID_1,
+                              childTableId: QB_TABLE_ID_2,
+                            });
+                            console.log("Creating relationship with:", createRequestBody);
+
+                            const createResponse = await client.createRelationship({
+                              tableId: QB_TABLE_ID_2,
+                              body: createRequestBody,
+                            });
+
+                            console.log(
+                              "Created relationship response:",
+                              JSON.stringify(createResponse, null, 2)
+                            );
+
+                            // Verify creation
+                            expect(createResponse).toBeDefined();
+                            expect(createResponse.id).toBeDefined();
+                            expect(createResponse.parentTableId).toBe(QB_TABLE_ID_1);
+                            expect(createResponse.childTableId).toBe(QB_TABLE_ID_2);
+                            expect(createResponse.foreignKeyField).toBeDefined();
+                            expect(createResponse.foreignKeyField?.label).toBe(uniqueLabel);
+
+                            const relationshipId = createResponse.id;
+                            const foreignKeyFieldId = createResponse.foreignKeyField?.id;
+
+                            // Step 2: Delete the relationship
+                            console.log("Deleting relationship with ID:", relationshipId);
+                            const deleteResponse = await client.deleteRelationship({
+                              tableId: QB_TABLE_ID_2,
+                              relationshipId,
+                            });
+
+                            console.log(
+                              "Delete relationship response:",
+                              JSON.stringify(deleteResponse, null, 2)
+                            );
+
+                            // Verify deletion (adjusted to match actual response)
+                            expect(deleteResponse).toBeDefined();
+                            expect(deleteResponse.relationshipId).toBe(relationshipId); // Updated to use "relationshipId"
+
+                            // Step 3: Confirm relationship is gone (or non-functional)
+                            try {
+                              const relationships = await client.getRelationships({
+                                tableId: QB_TABLE_ID_2,
+                              });
+                              console.log(
+                                "Relationships after deletion:",
+                                JSON.stringify(relationships, null, 2)
+                              );
+                              // Check if the relationship is still listed (metadata might persist)
+                              const deletedRelationship = relationships.relationships.find(
+                                (r) => r.id === relationshipId
+                              );
+                              if (deletedRelationship) {
+                                console.log("Relationship metadata persists:", deletedRelationship);
+                                expect(deletedRelationship.foreignKeyField).toBeUndefined(); // Should lack fields
+                              }
+                            } catch (error) {
+                              console.error("Error fetching relationships post-deletion:", error);
+                              expect(error.message).toMatch(/404|not found/i); // Optional stricter check
+                            }
+
+                            // Cleanup remaining fields
+                            const lookupFieldId = createResponse.lookupFields[0]?.id;
+                            const summaryFieldId = createResponse.summaryFields[0]?.id;
+
+                            if (foreignKeyFieldId) {
+                              await client.deleteFields({
+                                tableId: QB_TABLE_ID_2,
+                                body: { fieldIds: [foreignKeyFieldId] },
+                              });
+                              console.log(
+                                `Deleted foreign key field ${foreignKeyFieldId} from ${QB_TABLE_ID_2}`
+                              );
+                            }
+                            if (lookupFieldId) {
+                              await client.deleteFields({
+                                tableId: QB_TABLE_ID_2,
+                                body: { fieldIds: [lookupFieldId] },
+                              });
+                              console.log(
+                                `Deleted lookup field ${lookupFieldId} from ${QB_TABLE_ID_2}`
+                              );
+                            }
+                            if (summaryFieldId) {
+                              await client.deleteFields({
+                                tableId: QB_TABLE_ID_1,
+                                body: { fieldIds: [summaryFieldId] },
+                              });
+                              console.log(
+                                `Deleted summary field ${summaryFieldId} from ${QB_TABLE_ID_1}`
+                              );
+                            }
+                          }
+                        );
                     - name: >-
                         deleteTable.test.ts
                       type: >-
@@ -4409,10 +4861,7 @@ tree:
                         {
                         describe,
                         it,
-                        expect,
-                        beforeAll,
-                        afterAll,
-                        beforeEach
+                        expect
                         }
                         from
                         "vitest";
@@ -4446,38 +4895,30 @@ tree:
                         {
                           let client: ReturnType<typeof createClient>;
                           let relationshipId: number;
-                          let newLookupFieldId: number;
-                          let newChildFieldId: number;
+                          let newLookupFieldId: number | undefined;
+                          let newChildFieldId: number | undefined;
+                          let generatedLookupFieldId: number | undefined;
+                          let generatedSummaryFieldId: number | undefined;
 
-                          beforeAll(async () => {
-                            client = createClient(fetch, {
-                              realm: QB_REALM,
-                              userToken: QB_USER_TOKEN,
-                              debug: true,
-                            });
+                          // No beforeAll/afterAll since we'll create and delete within the test
 
+                          it("creates, updates, deletes, and verifies a relationship", async () => {
+                            // Validate environment variables
                             if (!QB_REALM) throw new Error("QB_REALM is not defined in .env");
                             if (!QB_USER_TOKEN) throw new Error("QB_USER_TOKEN is not defined in .env");
+                            if (!QB_TABLE_ID_1) throw new Error("QB_TABLE_ID_1 is not defined in .env");
+                            if (!QB_TABLE_ID_2) throw new Error("QB_TABLE_ID_2 is not defined in .env");
 
-                            // Fetch relationship ID
-                            const relationshipsResponse = await client.getRelationships({
-                              tableId: QB_TABLE_ID_2,
-                              skip: 0,
+                            // Initialize client
+                            client = createClient(fetch, {
+                              realm: QB_REALM,
+                              userToken: QB_USER_TOKEN,
+                              debug: true,
                             });
 
-                            const relationship = relationshipsResponse.relationships.find(
-                              (r) => r.parentTableId === QB_TABLE_ID_1
-                            );
-                            if (!relationship) {
-                              throw new Error(
-                                `No relationship found between parent ${QB_TABLE_ID_1} and child ${QB_TABLE_ID_2}`
-                              );
-                            }
-                            relationshipId = relationship.id;
-
-                            // Create fields
+                            // Step 1: Create fields for the relationship update
                             const lookupFieldRequest: CreateFieldRequest = {
-                              label: "Test Lookup Field",
+                              label: `Test Lookup Field_${Date.now()}`,
                               fieldType: "text",
                             };
                             const lookupResponse = await client.createField({
@@ -4485,9 +4926,15 @@ tree:
                               body: lookupFieldRequest,
                             });
                             newLookupFieldId = lookupResponse.id;
+                            if (!newLookupFieldId) {
+                              throw new Error("Failed to retrieve ID for newly created lookup field");
+                            }
+                            console.log(
+                              `Created lookup field with ID ${newLookupFieldId} in parent table ${QB_TABLE_ID_1}`
+                            );
 
                             const childFieldRequest: CreateFieldRequest = {
-                              label: "Test Child Numeric",
+                              label: `Test Child Numeric_${Date.now()}`,
                               fieldType: "numeric",
                             };
                             const childResponse = await client.createField({
@@ -4495,224 +4942,190 @@ tree:
                               body: childFieldRequest,
                             });
                             newChildFieldId = childResponse.id;
-
-                            console.log(
-                              `Created lookup field ${newLookupFieldId} in parent ${QB_TABLE_ID_1}`
-                            );
-                            console.log(
-                              `Created child field ${newChildFieldId} in child ${QB_TABLE_ID_2}`
-                            );
+                            if (!newChildFieldId) {
+                              throw new Error("Failed to retrieve ID for newly created child field");
+                            }
                             console.log(
-                              `Using relationshipId: ${relationshipId} from child ${QB_TABLE_ID_2} to parent ${QB_TABLE_ID_1}`
+                              `Created child field with ID ${newChildFieldId} in child table ${QB_TABLE_ID_2}`
                             );
-                          }, 30000);
 
-                          afterAll(async () => {
-                            if (newLookupFieldId) {
-                              await client.deleteFields({
-                                tableId: QB_TABLE_ID_1,
-                                body: { fieldIds: [newLookupFieldId] },
-                              });
-                              console.log(`Deleted field ${newLookupFieldId} from ${QB_TABLE_ID_1}`);
-                            }
-                            if (newChildFieldId) {
-                              await client.deleteFields({
-                                tableId: QB_TABLE_ID_2,
-                                body: { fieldIds: [newChildFieldId] },
-                              });
-                              console.log(`Deleted field ${newChildFieldId} from ${QB_TABLE_ID_2}`);
-                            }
-                          }, 30000);
+                            // Step 2: Create a new relationship
+                            const uniqueLabel = `TestRelationship_${Date.now()}`;
+                            const createRequestBody = {
+                              parentTableId: QB_TABLE_ID_1,
+                              foreignKeyField: { label: uniqueLabel },
+                              lookupFieldIds: [6], // Assuming field 6 exists in QB_TABLE_ID_1
+                              summaryFields: [
+                                {
+                                  summaryFid: 6, // Assuming field 6 in QB_TABLE_ID_2 is numeric
+                                  label: `Sum_${uniqueLabel}`,
+                                  accumulationType: "SUM",
+                                },
+                              ],
+                            };
 
-                          beforeEach(async () => {
-                            // Reset relationship to a clean state before each test
-                            const relationshipsResponse = await client.getRelationships({
+                            console.log("Creating relationship with:", createRequestBody);
+                            const createResponse = await client.createRelationship({
                               tableId: QB_TABLE_ID_2,
+                              body: createRequestBody,
                             });
-                            const relationship = relationshipsResponse.relationships.find(
-                              (r) => r.id === relationshipId
+                            console.log(
+                              "Created relationship response:",
+                              JSON.stringify(createResponse, null, 2)
                             );
-                            const cleanupRequest: UpdateRelationshipRequest = {
-                              lookupFieldIds: (relationship?.lookupFields || [])
-                                .map((f) => f.id)
-                                .filter((id) => id !== newLookupFieldId),
-                              summaryFields: (relationship?.summaryFields || []).map((f) => ({
-                                summaryFid: f.id,
-                                label: f.label,
-                                accumulationType: "COUNT", // Assuming COUNT for existing fields; adjust if needed
-                              })),
-                            };
-                            await client.updateRelationship({
-                              tableId: QB_TABLE_ID_2,
-                              relationshipId,
-                              body: cleanupRequest,
-                            });
-                            console.log(`Reset relationship ${relationshipId} before test`);
-                          });
-
-                          it(
-                            "adds a lookup field to the relationship",
-                            async ({ expect }) => {
-                              const tableId = QB_TABLE_ID_2;
 
-                              // Get current state
-                              const initialResponse = await client.getRelationships({ tableId });
-                              const initialRelationship = initialResponse.relationships.find(
-                                (r) => r.id === relationshipId
-                              );
-                              const currentLookupFields = (initialRelationship?.lookupFields || []).map(
-                                (f) => f.id
-                              );
-
-                              const request: UpdateRelationshipRequest = {
-                                lookupFieldIds: [...currentLookupFields, newLookupFieldId],
-                              };
-
-                              const updateResponse = await client.updateRelationship({
-                                tableId,
-                                relationshipId,
-                                body: request,
-                              });
+                            expect(createResponse).toBeDefined();
+                            expect(createResponse.id).toBeDefined();
+                            expect(createResponse.parentTableId).toBe(QB_TABLE_ID_1);
+                            expect(createResponse.childTableId).toBe(QB_TABLE_ID_2);
+                            expect(createResponse.foreignKeyField?.label).toBe(uniqueLabel);
 
-                              expect(updateResponse.id).toBe(relationshipId);
-                              expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
-                              expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
-                              expect(
-                                updateResponse.lookupFields.some((f) => f.id === newLookupFieldId)
-                              ).toBe(true);
+                            relationshipId = createResponse.id;
 
-                              const relationshipsResponse = await client.getRelationships({ tableId });
-                              const updatedRelationship = relationshipsResponse.relationships.find(
-                                (r) => r.id === relationshipId
-                              );
-                              expect(
-                                updatedRelationship!.lookupFields.some((f) => f.id === newLookupFieldId)
-                              ).toBe(true);
-                            },
-                            { timeout: 30000 }
-                          );
+                            // Step 3: Update the relationship - Add a lookup field
+                            const tableId = QB_TABLE_ID_2;
+                            const initialResponse = await client.getRelationships({ tableId });
+                            const initialRelationship = initialResponse.relationships.find(
+                              (r) => r.id === relationshipId
+                            );
+                            const currentLookupFields = (initialRelationship?.lookupFields || []).map(
+                              (f) => f.id
+                            );
+                            console.log("Current lookupFields before update:", currentLookupFields);
 
-                          it(
-                            "adds a summary field to the parent table",
-                            async ({ expect }) => {
-                              const tableId = QB_TABLE_ID_2;
+                            const updateLookupRequest: UpdateRelationshipRequest = {
+                              lookupFieldIds: [newLookupFieldId!],
+                            };
+                            console.log(
+                              "Adding lookup field request:",
+                              JSON.stringify(updateLookupRequest, null, 2)
+                            );
 
-                              // Get current state
-                              const initialResponse = await client.getRelationships({ tableId });
-                              const initialRelationship = initialResponse.relationships.find(
-                                (r) => r.id === relationshipId
-                              );
-                              const currentSummaryFields = (
-                                initialRelationship?.summaryFields || []
-                              ).map((f) => ({
-                                summaryFid: f.id,
-                                label: f.label,
-                                accumulationType: "COUNT",
-                              }));
-
-                              const request: UpdateRelationshipRequest = {
-                                summaryFields: [
-                                  ...currentSummaryFields,
-                                  {
-                                    summaryFid: newChildFieldId,
-                                    label: "Test Summary Field",
-                                    accumulationType: "SUM",
-                                  },
-                                ],
-                              };
+                            const updateLookupResponse = await client.updateRelationship({
+                              tableId,
+                              relationshipId,
+                              body: updateLookupRequest,
+                            });
+                            console.log(
+                              "Update lookup response:",
+                              JSON.stringify(updateLookupResponse, null, 2)
+                            );
 
-                              const updateResponse = await client.updateRelationship({
-                                tableId,
-                                relationshipId,
-                                body: request,
-                              });
+                            const newLookup = updateLookupResponse.lookupFields.find(
+                              (f) =>
+                                f.label.includes("Test Lookup Field") &&
+                                !currentLookupFields.includes(f.id)
+                            );
+                            generatedLookupFieldId = newLookup?.id;
+                            console.log(
+                              `Captured generated lookup field ID: ${generatedLookupFieldId}`
+                            );
 
-                              expect(updateResponse.id).toBe(relationshipId);
-                              expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
-                              expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
-                              expect(
-                                updateResponse.summaryFields.some(
-                                  (f) => f.label === "Test Summary Field"
-                                )
-                              ).toBe(true);
+                            expect(updateLookupResponse.id).toBe(relationshipId);
+                            expect(updateLookupResponse.childTableId).toBe(QB_TABLE_ID_2);
+                            expect(updateLookupResponse.parentTableId).toBe(QB_TABLE_ID_1);
+                            expect(
+                              updateLookupResponse.lookupFields.some((f) =>
+                                f.label.includes("Test Lookup Field")
+                              )
+                            ).toBe(true);
+
+                            // Step 4: Update the relationship - Add a summary field
+                            const currentSummaryFields = (updateLookupResponse.summaryFields || []).map(
+                              (f) => f.id
+                            );
+                            console.log("Current summaryFields before update:", currentSummaryFields);
 
-                              const relationshipsResponse = await client.getRelationships({ tableId });
-                              const updatedRelationship = relationshipsResponse.relationships.find(
-                                (r) => r.id === relationshipId
-                              );
-                              expect(
-                                updatedRelationship!.summaryFields.some(
-                                  (f) => f.label === "Test Summary Field"
-                                )
-                              ).toBe(true);
-                            },
-                            { timeout: 30000 }
-                          );
+                            const updateSummaryRequest: UpdateRelationshipRequest = {
+                              summaryFields: [
+                                {
+                                  summaryFid: newChildFieldId!,
+                                  label: "Test Summary Field",
+                                  accumulationType: "SUM",
+                                },
+                              ],
+                            };
+                            console.log(
+                              "Adding summary field request:",
+                              JSON.stringify(updateSummaryRequest, null, 2)
+                            );
 
-                          it(
-                            "handles an invalid field ID gracefully",
-                            async ({ expect }) => {
-                              const tableId = QB_TABLE_ID_2;
+                            const updateSummaryResponse = await client.updateRelationship({
+                              tableId,
+                              relationshipId,
+                              body: updateSummaryRequest,
+                            });
+                            console.log(
+                              "Update summary response:",
+                              JSON.stringify(updateSummaryResponse, null, 2)
+                            );
 
-                              const request: UpdateRelationshipRequest = {
-                                lookupFieldIds: [999999], // Invalid ID
-                              };
+                            const newSummary = updateSummaryResponse.summaryFields.find(
+                              (f) =>
+                                f.label.includes("Test Summary Field") &&
+                                !currentSummaryFields.includes(f.id)
+                            );
+                            generatedSummaryFieldId = newSummary?.id;
+                            console.log(
+                              `Captured generated summary field ID: ${generatedSummaryFieldId}`
+                            );
 
-                              await expect(
-                                client.updateRelationship({
-                                  tableId,
-                                  relationshipId,
-                                  body: request,
-                                })
-                              ).rejects.toThrow(/API Error:.*400/);
-                            },
-                            { timeout: 30000 }
-                          );
+                            expect(updateSummaryResponse.id).toBe(relationshipId);
+                            expect(updateSummaryResponse.childTableId).toBe(QB_TABLE_ID_2);
+                            expect(updateSummaryResponse.parentTableId).toBe(QB_TABLE_ID_1);
+                            expect(
+                              updateSummaryResponse.summaryFields.some((f) =>
+                                f.label.includes("Test Summary Field")
+                              )
+                            ).toBe(true);
+
+                            // Step 5: Delete the relationship
+                            console.log("Deleting relationship with ID:", relationshipId);
+                            const deleteResponse = await client.deleteRelationship({
+                              tableId: QB_TABLE_ID_2,
+                              relationshipId,
+                            });
+                            console.log(
+                              "Delete relationship response:",
+                              JSON.stringify(deleteResponse, null, 2)
+                            );
 
-                          it(
-                            "succeeds with no changes (idempotent)",
-                            async ({ expect }) => {
-                              const tableId = QB_TABLE_ID_2;
+                            expect(deleteResponse).toBeDefined();
+                            expect(deleteResponse.relationshipId).toBe(relationshipId);
 
-                              // Get current state
-                              const initialResponse = await client.getRelationships({ tableId });
-                              const initialRelationship = initialResponse.relationships.find(
-                                (r) => r.id === relationshipId
-                              );
-                              const currentLookupFields = (initialRelationship?.lookupFields || []).map(
-                                (f) => f.id
-                              );
-                              const currentSummaryFields = (
-                                initialRelationship?.summaryFields || []
-                              ).map((f) => ({
-                                summaryFid: f.id,
-                                label: f.label,
-                                accumulationType: "COUNT",
-                              }));
-
-                              const request: UpdateRelationshipRequest = {
-                                lookupFieldIds: currentLookupFields,
-                                summaryFields: currentSummaryFields,
-                              };
+                            // Step 6: Verify deletion
+                            const relationships = await client.getRelationships({
+                              tableId: QB_TABLE_ID_2,
+                            });
+                            console.log(
+                              "Relationships after deletion:",
+                              JSON.stringify(relationships, null, 2)
+                            );
+                            const deletedRelationship = relationships.relationships.find(
+                              (r) => r.id === relationshipId
+                            );
+                            expect(deletedRelationship).toBeUndefined(); // Confirm relationship is gone
 
-                              const updateResponse = await client.updateRelationship({
-                                tableId,
-                                relationshipId,
-                                body: request,
+                            // Cleanup remaining fields from setup
+                            if (newLookupFieldId) {
+                              await client.deleteFields({
+                                tableId: QB_TABLE_ID_1,
+                                body: { fieldIds: [newLookupFieldId] },
                               });
-
-                              expect(updateResponse.id).toBe(relationshipId);
-                              expect(updateResponse.childTableId).toBe(QB_TABLE_ID_2);
-                              expect(updateResponse.parentTableId).toBe(QB_TABLE_ID_1);
-                              expect(updateResponse.lookupFields.map((f) => f.id)).toEqual(
-                                currentLookupFields
+                              console.log(
+                                `Deleted lookup field ${newLookupFieldId} from ${QB_TABLE_ID_1}`
                               );
-                              expect(updateResponse.summaryFields?.map((f) => f.id) || []).toEqual(
-                                currentSummaryFields.map((f) => f.summaryFid)
+                            }
+                            if (newChildFieldId) {
+                              await client.deleteFields({
+                                tableId: QB_TABLE_ID_2,
+                                body: { fieldIds: [newChildFieldId] },
+                              });
+                              console.log(
+                                `Deleted child field ${newChildFieldId} from ${QB_TABLE_ID_2}`
                               );
-                            },
-                            { timeout: 30000 }
-                          );
+                            }
+                          }, 60000);
                         });
                     - name: >-
                         updateTable.test.ts
@@ -4785,6 +5198,10 @@ tree:
               type: >-
                 directory
               children:
+                - name: >-
+                    ThrottleBucket.test.ts
+                  type: >-
+                    file
                 - name: >-
                     apps
                   type: >-
@@ -4832,13 +5249,17 @@ tree:
                       type: >-
                         file
                     - name: >-
-                        retryTempTokenTwo401.test.ts
+                        retryTempTokenMaxRetries.test.ts
                       type: >-
                         file
                     - name: >-
                         retryUserToken401.test.ts
                       type: >-
                         file
+                    - name: >-
+                        ssoTokenRefresh.test.ts
+                      type: >-
+                        file
                 - name: >-
                     fields
                   type: >-
@@ -4872,10 +5293,23 @@ tree:
                         updateField.test.ts
                       type: >-
                         file
+                - name: >-
+                    formulas
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        runFormula.test.ts
+                      type: >-
+                        file
                 - name: >-
                     index.ts
                   type: >-
                     file
+                - name: >-
+                    inferHttpMethod.test.ts
+                  type: >-
+                    file
                 - name: >-
                     rateLimit.test.ts
                   type: >-
@@ -4902,10 +5336,18 @@ tree:
                   type: >-
                     directory
                   children:
+                    - name: >-
+                        createRelationship.test.ts
+                      type: >-
+                        file
                     - name: >-
                         createTable.test.ts
                       type: >-
                         file
+                    - name: >-
+                        deleteRelationship.test.ts
+                      type: >-
+                        file
                     - name: >-
                         deleteTable.test.ts
                       type: >-