microsoft-graph 1.0.0

package/dist/services/workbookTable.js

@@ -0,0 +1,13 @@
+export function workbookTableRef(worksheetRef, tableId) {
+    if (!tableId) {
+        throw new Error("TableId is missing");
+    }
+    return {
+        siteId: worksheetRef.siteId,
+        driveId: worksheetRef.driveId,
+        itemId: worksheetRef.itemId,
+        worksheetId: worksheetRef.worksheetId,
+        sessionId: worksheetRef.sessionId,
+        tableId: tableId
+    };
+}

package/dist/services/workbookWorksheet.js

@@ -0,0 +1,13 @@
+export const defaultWorkbookWorksheetId = "{00000000-0001-0000-0000-000000000000}"; // Program Manager in Microsoft Office Extensibility team says this ID is used for the first sheet of all workbooks by design, but not documented. https://github.com/OfficeDev/office-js/issues/552#issuecomment-800841930
+export function workbookWorksheetRef(workbookRef, worksheetId) {
+    if (!worksheetId) {
+        throw new Error("WorksheetID is missing");
+    }
+    return {
+        siteId: workbookRef.siteId,
+        driveId: workbookRef.driveId,
+        itemId: workbookRef.itemId,
+        sessionId: workbookRef.sessionId,
+        worksheetId
+    };
+}

package/dist/tasks/createWorkbookAndStartSession.js

@@ -0,0 +1,10 @@
+import createWorkbook from "../operations/workbook/createWorkbook.js";
+import createWorkbookSession from "../operations/workbookSession/createWorkbookSession.js";
+export default async function createWorkbookAndStartSession(driveRef, itemPath) {
+    const workbook = await createWorkbook(driveRef, itemPath);
+    const workbookRef = await createWorkbookSession(workbook);
+    return {
+        ...workbook,
+        ...workbookRef
+    };
+}

package/dist/tasks/deleteDriveItemWithRetry.js

@@ -0,0 +1,16 @@
+import deleteDriveItem from "../operations/driveItem/deleteDriveItem.js";
+import { sleep } from "../services/sleep.js";
+export default async function deleteDriveItemWithRetry(driveItemRef) {
+    const retryDelays = [1000, 2000, 4000];
+    for (const delay of retryDelays) {
+        try {
+            await deleteDriveItem(driveItemRef);
+            return;
+        }
+        catch (_) {
+            await sleep(delay);
+        }
+    }
+    // Final attempt without delay
+    await deleteDriveItem(driveItemRef);
+}

package/dist/tasks/downloadDriveItemContent.js

@@ -0,0 +1,7 @@
+import { writeFile } from "node:fs/promises";
+import getDriveItemContent from "../operations/driveItem/getDriveItemContent.js";
+export default async function downloadDriveItemContent(itemRef, localFilePath) {
+    const arrayBuffer = await getDriveItemContent(itemRef);
+    const buffer = Buffer.from(arrayBuffer);
+    await writeFile(localFilePath, buffer);
+}

package/dist/tasks/endSessionAndDeleteWorkbook.js

@@ -0,0 +1,6 @@
+import closeWorkbookSession from "../operations/workbookSession/closeWorkbookSession.js";
+import deleteDriveItemWithRetry from "./deleteDriveItemWithRetry.js";
+export default async function endSessionAndDeleteWorkbook(workbookRef) {
+    await closeWorkbookSession(workbookRef);
+    await deleteDriveItemWithRetry(workbookRef); // Close session takes a moment to release the file lock
+}

package/dist/tasks/getRangeLastUsedCell.js

@@ -0,0 +1,38 @@
+import ProtocolError from "../errors/ProtocolError.js";
+import getWorkbookWorksheetRange from "../operations/workbookWorksheet/getWorkbookWorksheetRange.js";
+import { indexesToAddress as cellIndexesToAddress } from "../services/address.js";
+export default async function getRangeLastUsedCell(rangeRef) {
+    // TODO: Consider adding chunking if the range is too large
+    // TODO: Reduce cells returned by using "used range"?
+    const range = await getWorkbookWorksheetRange(rangeRef);
+    const { rowCount, columnCount } = range;
+    if (rowCount === undefined || columnCount === undefined) {
+        throw new ProtocolError("Counts missing");
+    }
+    const values = range.values;
+    if (values === undefined) {
+        throw new ProtocolError("Range values missing");
+    }
+    for (let rowIndex = rowCount - 1; rowIndex >= 0; rowIndex--) {
+        const row = values[rowIndex];
+        if (row === undefined) {
+            throw new ProtocolError("Row missing");
+        }
+        for (let columnIndex = columnCount - 1; columnIndex >= 0; columnIndex--) {
+            const cell = row[columnIndex];
+            if (cell === undefined) {
+                throw new ProtocolError("Cell missing");
+            }
+            if (cell !== null && cell !== "") {
+                const address = cellIndexesToAddress(rowIndex, columnIndex);
+                return {
+                    value: cell,
+                    address,
+                    rowIndex: rowIndex,
+                    columnIndex: columnIndex
+                };
+            }
+        }
+    }
+    return null;
+}

package/dist/tasks/getRangeLastUsedCell.test.js

@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../graphApi.js";
+import calculateWorkbook from "../operations/workbook/calculateWorkbook.js";
+import createWorkbook from "../operations/workbook/createWorkbook.js";
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+import { getDefaultDriveRef } from "../services/drive.js";
+import { driveItemPath } from "../services/driveItem.js";
+import { generateTempFileName } from "../services/temporaryFiles.js";
+import { workbookRangeRef } from "../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "./deleteDriveItemWithRetry.js";
+import getRangeLastUsedCell from "./getRangeLastUsedCell.js";
+describe("getRangeLastUsedCell", () => {
+    it("should return the last used cell value", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, "A1:B2");
+        try {
+            await sequential(updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2],
+                    [3, 4]
+                ]
+            }), calculateWorkbook(workbook));
+            const result = await getRangeLastUsedCell(rangeRef);
+            if (result === null) {
+                throw new Error("Expected a result");
+            }
+            expect(result.value).toBe(4);
+            expect(result.address).toBe("B2");
+            expect(result.rowIndex).toBe(1);
+            expect(result.columnIndex).toBe(1);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("should return the last non-empty cell value when the last cell is empty", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, "A1:B2");
+        try {
+            await sequential(updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2],
+                    [3, null]
+                ]
+            }), calculateWorkbook(workbook));
+            const result = await getRangeLastUsedCell(rangeRef);
+            if (result === null) {
+                throw new Error("Expected a result");
+            }
+            expect(result.value).toBe(3);
+            expect(result.address).toBe("A2");
+            expect(result.rowIndex).toBe(1);
+            expect(result.columnIndex).toBe(0);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("should return null when no cells are used", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        const rangeRef = workbookRangeRef(worksheetRef, "A1:B2");
+        try {
+            await sequential(updateWorkbookRange(rangeRef, {
+                values: [
+                    [null, null],
+                    [null, null]
+                ]
+            }), calculateWorkbook(workbook));
+            const result = await getRangeLastUsedCell(rangeRef);
+            expect(result).toBeNull();
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/tasks/getWorkbookTableVisibleBody.js

@@ -0,0 +1,24 @@
+import getWorkbookVisibleRange from "../operations/workbookRange/getWorkbookVisibleRange.js";
+import getWorkbookTableBodyRange from "../operations/workbookTable/getWorkbookTableBodyRange.js";
+export async function getWorkbookTableVisibleBody(tableRef) {
+    const range = await getWorkbookTableBodyRange(tableRef);
+    const visibleRange = await getWorkbookVisibleRange(range);
+    return visibleRange;
+    // TODO: Alternate approach. More performant, but doesn't handle hidden columns yet. Pondering!
+    // const rows = await listWorkbookTableRows(tableRef);
+    // const visibleRows: WorkbookTableRow[] = [];
+    // for (const row of rows) {
+    //     const index = row.index;
+    //     if (index === undefined) {
+    //         throw new ProtocolError("Row index is undefined");
+    //     }
+    //     const rowRange = await getWorkbookWorksheetRange({
+    //         ...tableRef,
+    //         address: workbookRangeAddress(`${index + 1}:${index + 1}`)
+    //     });
+    //     if (!rowRange.rowHidden) {
+    //         visibleRows.push(row);
+    //     }
+    // }
+    // return visibleRows;
+}

package/dist/tasks/getWorkbookTableVisibleBody.test.js

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import calculateWorkbook from "../operations/workbook/calculateWorkbook.js";
+import createWorkbook from "../operations/workbook/createWorkbook.js";
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+import createWorkbookTable from "../operations/workbookTable/createWorkbookTable.js";
+import createWorkbookWorksheet from "../operations/workbookWorksheet/createWorkbookWorksheet.js";
+import { getDefaultDriveRef } from "../services/drive.js";
+import { driveItemPath } from "../services/driveItem.js";
+import { generateTempFileName } from "../services/temporaryFiles.js";
+import { workbookRangeRef } from "../services/workbookRange.js";
+import deleteDriveItemWithRetry from "./deleteDriveItemWithRetry.js";
+import { getWorkbookTableVisibleBody } from "./getWorkbookTableVisibleBody.js";
+describe("getWorkbookTableVisibleBody", () => {
+    it("can retrieve the visible body range of a table", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook);
+            const rangeRef = workbookRangeRef(worksheet, "A1:D4");
+            const table = await createWorkbookTable(rangeRef, true);
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    ["Header1", "Header2", "Header3", "Header4"],
+                    ["Value1", "Value2", "Value3", "Value4"],
+                    ["Value5", "Value6", "Value7", "Value8"],
+                    ["Value9", "Value10", "Value11", "Value12"]
+                ]
+            });
+            await calculateWorkbook(workbook);
+            const visibleBodyRange = await getWorkbookTableVisibleBody(table);
+            expect(visibleBodyRange.values).toEqual([
+                ["Value1", "Value2", "Value3", "Value4"],
+                ["Value5", "Value6", "Value7", "Value8"],
+                ["Value9", "Value10", "Value11", "Value12"]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("omits hidden rows from the visible body range of a table", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook);
+            const rangeRef = workbookRangeRef(worksheet, "A1:D4");
+            const table = await createWorkbookTable(rangeRef, true);
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    ["Header1", "Header2", "Header3", "Header4"],
+                    ["Value1", "Value2", "Value3", "Value4"],
+                    ["Value5", "Value6", "Value7", "Value8"],
+                    ["Value9", "Value10", "Value11", "Value12"]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheet, "2:2");
+            await updateWorkbookRange(hiddenRange, { rowHidden: true });
+            await calculateWorkbook(workbook);
+            const visibleBodyRange = await getWorkbookTableVisibleBody(table);
+            expect(visibleBodyRange.values).toEqual([
+                ["Value5", "Value6", "Value7", "Value8"],
+                ["Value9", "Value10", "Value11", "Value12"]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("omits hidden columns from the visible body range of a table", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook);
+            const rangeRef = workbookRangeRef(worksheet, "A1:D4");
+            const table = await createWorkbookTable(rangeRef, true);
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    ["Header1", "Header2", "Header3", "Header4"],
+                    ["Value1", "Value2", "Value3", "Value4"],
+                    ["Value5", "Value6", "Value7", "Value8"],
+                    ["Value9", "Value10", "Value11", "Value12"]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheet, "B:B");
+            await updateWorkbookRange(hiddenRange, { columnHidden: true });
+            await calculateWorkbook(workbook);
+            const visibleBodyRange = await getWorkbookTableVisibleBody(table);
+            expect(visibleBodyRange.values).toEqual([
+                ["Value1", "Value3", "Value4"],
+                ["Value5", "Value7", "Value8"],
+                ["Value9", "Value11", "Value12"]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/tasks/getWorkbookWorksheetRefByName.js

@@ -0,0 +1,10 @@
+import listWorkbookWorksheets from "../operations/workbookWorksheet/listWorkbookWorksheets.js";
+export default async function getWorkbookWorksheetByName(workbookRef, name) {
+    // TODO: Probably can get this from a direct API call without fetching all worksheets
+    const worksheets = await listWorkbookWorksheets(workbookRef);
+    const worksheet = worksheets.find(worksheetRef => worksheetRef.name === name);
+    if (!worksheet) {
+        throw new Error(`Worksheet '${name}' not found.`); // TODO: Make NotFoundError
+    }
+    return worksheet;
+}

package/dist/tasks/setColumnHidden.js

@@ -0,0 +1,7 @@
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+export default async function setColumnHidden(rangeRef, hidden) {
+    await updateWorkbookRange(rangeRef, {
+        columnHidden: hidden
+    });
+}
+;

package/dist/tasks/setColumnHidden.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import calculateWorkbook from "../operations/workbook/calculateWorkbook.js";
+import createWorkbook from "../operations/workbook/createWorkbook.js";
+import getWorkbookVisibleRange from "../operations/workbookRange/getWorkbookVisibleRange.js";
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+import { getDefaultDriveRef } from "../services/drive.js";
+import { driveItemPath, } from "../services/driveItem.js";
+import { generateTempFileName } from "../services/temporaryFiles.js";
+import { workbookRangeRef } from "../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "./deleteDriveItemWithRetry.js";
+import setColumnHidden from "./setColumnHidden.js";
+describe("setColumnHidden", () => {
+    it("hides a column in an existing workbook", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        try {
+            const rangeRef = workbookRangeRef(worksheetRef, "A1:C3");
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheetRef, "B:B");
+            await setColumnHidden(hiddenRange, true);
+            await calculateWorkbook(workbook);
+            const visibleView = await getWorkbookVisibleRange(rangeRef);
+            expect(visibleView.values).toEqual([
+                [1, 3],
+                [4, 6],
+                [7, 9]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/tasks/setRowHidden.js

@@ -0,0 +1,7 @@
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+export default async function setRowHidden(rangeRef, hidden) {
+    await updateWorkbookRange(rangeRef, {
+        rowHidden: hidden
+    });
+}
+;

package/dist/tasks/setRowHidden.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import calculateWorkbook from "../operations/workbook/calculateWorkbook.js";
+import createWorkbook from "../operations/workbook/createWorkbook.js";
+import getWorkbookVisibleRange from "../operations/workbookRange/getWorkbookVisibleRange.js";
+import updateWorkbookRange from "../operations/workbookRange/updateWorkbookRange.js";
+import { getDefaultDriveRef } from "../services/drive.js";
+import { driveItemPath, } from "../services/driveItem.js";
+import { generateTempFileName } from "../services/temporaryFiles.js";
+import { workbookRangeRef } from "../services/workbookRange.js";
+import { defaultWorkbookWorksheetId, workbookWorksheetRef } from "../services/workbookWorksheet.js";
+import deleteDriveItemWithRetry from "./deleteDriveItemWithRetry.js";
+import setRowHidden from "./setRowHidden.js";
+describe("setRowHidden", () => {
+    it("hides a row in an existing workbook", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+        try {
+            const rangeRef = workbookRangeRef(worksheetRef, "A1:C3");
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    [1, 2, 3],
+                    [4, 5, 6],
+                    [7, 8, 9]
+                ]
+            });
+            const hiddenRange = workbookRangeRef(worksheetRef, "2:2");
+            await setRowHidden(hiddenRange, true);
+            await calculateWorkbook(workbook);
+            const visibleView = await getWorkbookVisibleRange(rangeRef);
+            expect(visibleView.values).toEqual([
+                [1, 2, 3],
+                [7, 8, 9]
+            ]);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/docs/approach.md

@@ -0,0 +1,7 @@
+# Justification/Approach
+Why not just use the default SDK for this? Well - there isn't really one. Sure, there is [`@microsoft/microsoft-graph-client`](https://www.npmjs.com/package/@microsoft/microsoft-graph-client), however it's thin and doesn't define 
+individual methods we can call. And there's also [`msgraph-typescript-typings`](https://github.com/microsoftgraph/msgraph-typescript-typings) which defines 
+the models, however nothing appears to exist to pull these basic concepts together into a SDK.
+
+This project implements `msgraph-typescript-typings` DTOs without using `@microsoft/microsoft-graph-client` as it added negligible value.
+

package/docs/calculateWorkbook.md

@@ -0,0 +1,20 @@
+# `calculateWorkbook()`
+Here's a gotcha. If you write to a workbook and immediately afterwards read from it, the change you just wrote might not have taken effect yet. This is due to the eventual consistency model Sharepoint uses. To ensure consistency you must call `calculateWorkbook()` before your reads. You can use this as part of a `sequential` batch as follows for the best performance:
+
+```typescript
+await updateWorkbookRange(rangeRef, { values: values });
+await calculateWorkbook(workbookRef); // IMPORTANT!!
+const usedRange = await getWorkbookUsedRange(worksheetRef);
+```
+
+The same applies to the batch version:
+
+```typescript
+ const [_, __, usedRange] = await sequential(
+    updateWorkbookRange(rangeRef, {
+        values: values
+    }),
+    calculateWorkbook(workbookRef), // IMPORTANT!!
+    getWorkbookUsedRange(worksheetRef)
+);
+```

package/docs/concepts.md

@@ -0,0 +1,4 @@
+# Key concepts
+GraphAPI exposes a set of operations. This SDK has a series of `operations` defined that maps to this API. If we want to do some rich manipulation of those operations we use a `task`.
+
+When using the SDK you can use low-level operations directly (ie `createWorkbookSession`) or you can use higher-level opinionated tasks (ie `createWorkbookAndOpenSession`). The opinionated tasks are useful for quick development, however they include assumptions that may not match your circumstance, and also do not lend themselves to optimizations like parallel requesting. You choose what works for you, and you can mix-and-match both.

package/docs/envs.md

@@ -0,0 +1,11 @@
+# Environment variables
+Environment variables are read just-in-time. A missing env will result in an exception.
+
+| Env                           | Mandatory | Purpose                                                            |
+| ----------------------------- | --------- | ------------------------------------------------------------------ |
+| `AZURE_TENANT_ID`             | Y         | Entra Tenant ID, used for authentication                           |
+| `AZURE_CLIENT_ID`             | Y         | Entra Client ID, used for authentication                           |
+| `AZURE_CLIENT_SECRET`         | Y         | Entra Client secret, used for authentication                       |
+| `SHAREPOINT_DEFAULT_SITE_ID`  | N         | ID of the Sharepoint site to use when none is specified otherwise. |
+| `SHAREPOINT_DEFAULT_DRIVE_ID` | N         | ID of the Drive  to use when none is specified otherwise           |
+| `HTTP_PROXY`                  | N         | HTTP proxy to route requests via. ie 'http://proxy:3128'           |

package/docs/performance.md

@@ -0,0 +1,24 @@
+# Performance
+If your particular use-case requires enhanced performance there are a couple of tools available to help.
+
+## Sessions
+If you have performing multiple operations on a workbook, first open a session using `createWorkbookSession` and close the session at the end with `closeWorkbookSession` (or it times out after 5mins or so). Without this GraphAPI effectively opens and closes the spreadsheet on every operation. With a session in place it keeps the document open.
+
+## Parallel batch
+If you have a number of operations that can be performed at the same time, use `await parallel(operation1(), operation2(), ...)`. This allows you to send up to 20 operations to GraphAPI in a single request and have them be performed in parallel. 
+
+## Parallel batch
+Sometimes the order of operations are important. To facilitate this variant of a batch operation you can use `await sequential(operation1(), operation2(), ...)`.
+
+```typescript
+ const [_, __, ___, clearedRange] = await sequential(
+    updateWorkbookRange(rangeRef, {
+        values: values
+    }),
+    clearWorkbookRange(rangeRef),
+    calculateWorkbook(workbookRef),
+    getWorkbookRange(rangeRef)
+);
+```
+
+While this allows for up to 20 operations to be submitted to GraphAPI in one request, it waits for the former operation to complete before starting the next.