microsoft-graph 1.0.0

package/dist/operations/workbookWorksheet/createWorkbookWorksheet.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import createWorkbookWorksheet from "./createWorkbookWorksheet.js";
+describe("createWorkbookWorksheet", () => {
+    it("can create a new worksheet 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 worksheetName = "Sheet2";
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook, worksheetName);
+            expect(worksheet.name).toBe(worksheetName);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can create a new worksheet without a name", { 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);
+            expect(worksheet.name).toBeDefined();
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookWorksheet/deleteWorkbookWorksheet.js

@@ -0,0 +1,14 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Permanently delete a worksheet. @see https://learn.microsoft.com/en-us/graph/api/worksheet-delete */
+export default function deleteWorkbookWorksheet(worksheetRef) {
+    return operation({
+        method: "DELETE",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}", worksheetRef),
+        headers: {
+            "workbook-session-id": worksheetRef.sessionId,
+        },
+        body: null,
+        responseTransform: () => undefined
+    });
+}

package/dist/operations/workbookWorksheet/deleteWorkbookWorksheet.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import createWorkbookWorksheet from "./createWorkbookWorksheet.js";
+import deleteWorkbookWorksheet from "./deleteWorkbookWorksheet.js";
+import listWorkbookWorksheets from "./listWorkbookWorksheets.js";
+describe("deleteWorkbookWorksheet", () => {
+    it("can delete a worksheet from an existing workbook", { 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);
+            await deleteWorkbookWorksheet(worksheet);
+            await calculateWorkbook(workbook);
+            const worksheets = await listWorkbookWorksheets(workbook);
+            expect(worksheets.some(ws => ws.id === worksheet.worksheetId)).toBe(false);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookWorksheet/getWorkbookWorksheetRange.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Fetch a range, including values and formatting. @see https://learn.microsoft.com/en-us/graph/api/range-get */
+export default function getWorkbookWorksheetRange(rangeRef) {
+    return operation({
+        method: "GET",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}/range(address='${rangeRef.address}')`, rangeRef),
+        headers: {
+            "workbook-session-id": rangeRef.sessionId,
+        },
+        body: null,
+        responseTransform: response => {
+            const range = response;
+            return {
+                ...range,
+                ...rangeRef
+            };
+        }
+    });
+}

package/dist/operations/workbookWorksheet/getWorkbookWorksheetRange.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+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 "../../tasks/deleteDriveItemWithRetry.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import updateWorkbookRange from "../workbookRange/updateWorkbookRange.js";
+describe("getWorkbookWorksheetRange", () => {
+    it("can retrieve a range from an existing worksheet", { timeout: 10000 }, async () => {
+        const address = "A1:B2";
+        const values = [[1, 2], [3, 4]];
+        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, address);
+        try {
+            const range = await updateWorkbookRange(rangeRef, {
+                values: values
+            });
+            expect(range.values).toEqual(values);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookWorksheet/listWorkbookWorksheets.js

@@ -0,0 +1,28 @@
+import ProtocolError from "../../errors/ProtocolError.js";
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+import { workbookWorksheetRef } from "../../services/workbookWorksheet.js";
+/** Retrieve a list of worksheets. @see https://learn.microsoft.com/en-us/graph/api/worksheet-list */
+export default function listWorkbookWorksheets(workbookRef) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets", workbookRef),
+        headers: {
+            "workbook-session-id": workbookRef.sessionId,
+        },
+        body: null,
+        responseTransform: response => {
+            const worksheets = response;
+            return worksheets.value.map(worksheet => {
+                const worksheetRef = workbookWorksheetRef(workbookRef, worksheet.id);
+                if (!worksheet.name) {
+                    throw new ProtocolError("Item.name is undefined");
+                }
+                return {
+                    ...worksheet,
+                    ...worksheetRef,
+                };
+            });
+        }
+    });
+}

package/dist/operations/workbookWorksheet/listWorkbookWorksheets.test.js

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "vitest";
+import { sequential } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import createWorkbookWorksheet from "./createWorkbookWorksheet.js";
+import listWorkbookWorksheets from "./listWorkbookWorksheets.js";
+describe("listWorkbookWorksheets", () => {
+    it("can list worksheets in an existing workbook", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            const worksheet1 = await createWorkbookWorksheet(workbook);
+            const worksheet2 = await createWorkbookWorksheet(workbook);
+            await calculateWorkbook(workbook);
+            const worksheets = await listWorkbookWorksheets(workbook);
+            const worksheetIds = worksheets.map(ws => ws.worksheetId);
+            expect(worksheetIds).toContain(worksheet1.worksheetId);
+            expect(worksheetIds).toContain(worksheet2.worksheetId);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can list worksheets in an existing workbook parallel", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const driveRef = getDefaultDriveRef();
+        const workbook = await createWorkbook(driveRef, workbookPath);
+        try {
+            const [worksheet1, worksheet2, _, worksheets] = await sequential(createWorkbookWorksheet(workbook), createWorkbookWorksheet(workbook), calculateWorkbook(workbook), listWorkbookWorksheets(workbook));
+            const worksheetIds = worksheets.map(worksheet => worksheet.worksheetId);
+            expect(worksheetIds).toContain(worksheet1.worksheetId);
+            expect(worksheetIds).toContain(worksheet2.worksheetId);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/operations/workbookWorksheet/updateWorkbookWorksheet.js

@@ -0,0 +1,21 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Update the name, position and/or visibility of a worksheet. @see https://learn.microsoft.com/en-us/graph/api/worksheet-update */
+export default function updateWorkbookWorksheet(worksheetRef, updates) {
+    return operation({
+        method: "PATCH",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/workbook/worksheets/{worksheet-id}", worksheetRef),
+        headers: {
+            "workbook-session-id": worksheetRef.sessionId,
+            "content-type": "application/json",
+        },
+        body: updates,
+        responseTransform: response => {
+            const worksheet = response;
+            return {
+                ...worksheet,
+                ...worksheetRef
+            };
+        }
+    });
+}

package/dist/operations/workbookWorksheet/updateWorkbookWorksheet.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, } from "../../services/driveItem.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import createWorkbookWorksheet from "./createWorkbookWorksheet.js";
+import updateWorkbookWorksheet from "./updateWorkbookWorksheet.js";
+describe("updateWorkbookWorksheet", () => {
+    it("can update the name of an existing worksheet", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook);
+            const newName = "UpdatedSheet";
+            const updatedWorksheet = await updateWorkbookWorksheet(worksheet, { name: newName });
+            expect(updatedWorksheet.name).toBe(newName);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("can update the visibility of an existing worksheet", { timeout: 10000 }, async () => {
+        const workbookName = generateTempFileName("xlsx");
+        const workbookPath = driveItemPath(workbookName);
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        try {
+            const worksheet = await createWorkbookWorksheet(workbook);
+            const updatedWorksheet = await updateWorkbookWorksheet(worksheet, { visibility: "Hidden" });
+            expect(updatedWorksheet.visibility).toBe("Hidden");
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+});

package/dist/services/accessToken.js

@@ -0,0 +1,15 @@
+import { ClientSecretCredential } from "@azure/identity";
+import { azureClientIdEnv, azureClientSecretEnv, azureTenantIdEnv } from "./configuration.js";
+const innerTokenCache = {};
+/** Get an access token for a given scope. If an unexpired one is cached it will be returned, otherwise requests a new one. */
+export async function getCurrentAccessToken(scope) {
+    let innerToken = innerTokenCache[scope];
+    if (!innerToken || innerToken.expiresOnTimestamp < Date.now()) {
+        const azureTenantId = azureTenantIdEnv();
+        const azureClientId = azureClientIdEnv();
+        const azureClientSecret = azureClientSecretEnv();
+        const credential = new ClientSecretCredential(azureTenantId, azureClientId, azureClientSecret);
+        innerTokenCache[scope] = innerToken = await credential.getToken(scope);
+    }
+    return innerToken.token;
+}

package/dist/services/address.js

@@ -0,0 +1,3 @@
+export function indexesToAddress(row, col) {
+    return `${String.fromCharCode(65 + col)}${row + 1}`;
+}

package/dist/services/configuration.js

@@ -0,0 +1,20 @@
+import EnvironmentVariableMissingError from "../errors/EnvironmentVariableMissingError.js";
+function get(env, fallbackValue = null) {
+    const value = process.env[env]?.trim() ?? "";
+    if (value === "") {
+        if (fallbackValue === null) {
+            throw new EnvironmentVariableMissingError(env);
+        }
+        return fallbackValue ?? "";
+    }
+    return value;
+}
+function bind(env, fallbackValue = null) {
+    return () => get(env, fallbackValue);
+}
+export const azureTenantIdEnv = bind("AZURE_TENANT_ID");
+export const azureClientIdEnv = bind("AZURE_CLIENT_ID");
+export const azureClientSecretEnv = bind("AZURE_CLIENT_SECRET");
+export const defaultSiteIdEnv = bind("SHAREPOINT_DEFAULT_SITE_ID");
+export const defaultDriveIdEnv = bind("SHAREPOINT_DEFAULT_DRIVE_ID");
+export const httpProxyEnv = bind("HTTP_PROXY", "");

package/dist/services/drive.js

@@ -0,0 +1,17 @@
+import ProtocolError from "../errors/ProtocolError.js";
+import { defaultDriveIdEnv, defaultSiteIdEnv } from "./configuration.js";
+export function driveRef(siteRef, driveId) {
+    if (!driveId) {
+        throw new ProtocolError("DriveID is missing");
+    }
+    return {
+        siteId: siteRef.siteId,
+        driveId,
+    };
+}
+export function getDefaultDriveRef() {
+    return {
+        siteId: defaultSiteIdEnv(),
+        driveId: defaultDriveIdEnv()
+    };
+}

package/dist/services/driveItem.js

@@ -0,0 +1,48 @@
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+import ProtocolError from "../errors/ProtocolError.js";
+const segmentPattern = /^[^"*:<>?\\|#]{1,256}$/;
+const reservedNames = [
+    "CON", "PRN", "AUX", "NUL",
+    "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+    "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"
+];
+export const workbookFileExtension = "xlsx";
+export const rootDriveItemPath = driveItemPath("/");
+/** Create a drive item path from a given set of segments. Ie ["a","b"] => "/a/b" */
+export function driveItemPath(...segments) {
+    for (const segment of segments) {
+        if (segment === "") {
+            throw new InvalidArgumentError("Segment cannot be an empty string.");
+        }
+        if (!segmentPattern.test(segment)) {
+            throw new InvalidArgumentError(`Segment '${segment}' does not match required pattern '${segmentPattern}'.`);
+        }
+        if (reservedNames.includes(segment.toUpperCase())) {
+            throw new InvalidArgumentError(`Segment '${segment}' is a reserved name.`);
+        }
+        if (segment.endsWith(".")) {
+            throw new InvalidArgumentError(`Segment '${segment}' cannot end with a period.`);
+        }
+    }
+    let path = `${segments.join("/")}`;
+    if (!path.startsWith("/")) {
+        path = `/${path}`;
+    }
+    if (path.includes("//")) {
+        throw new InvalidArgumentError("Path cannot contain consecutive slashes.");
+    }
+    if (path.length > 400) {
+        throw new InvalidArgumentError("Path length exceeds 400 characters.");
+    }
+    return path;
+}
+export function driveItemRef(driveRef, itemId) {
+    if (!itemId) {
+        throw new ProtocolError("ItemID is missing");
+    }
+    return {
+        siteId: driveRef.siteId,
+        driveId: driveRef.driveId,
+        itemId
+    };
+}

package/dist/services/driveItem.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+import { driveItemPath } from "./driveItem.js";
+describe("driveItemPath", () => {
+    it("throws an error for empty segment", () => {
+        expect(() => driveItemPath("")).toThrow(InvalidArgumentError);
+    });
+    it.each([
+        [["a"], "/a"],
+        [["a", "b"], "/a/b"],
+        [["a", "b", "c.txt"], "/a/b/c.txt"],
+        [["/a"], "/a"],
+        [[], "/"],
+    ])("parses %s", (segments, expected) => {
+        expect(driveItemPath(...segments)).toEqual(expected);
+    });
+});

package/dist/services/httpAgent.js

@@ -0,0 +1,9 @@
+import { HttpProxyAgent } from "http-proxy-agent";
+import { httpProxyEnv } from "./configuration.js";
+export function getHttpAgent() {
+    const httpProxy = httpProxyEnv();
+    if (!httpProxy) {
+        return undefined;
+    }
+    return new HttpProxyAgent(httpProxy);
+}

package/dist/services/httpStatus.js

@@ -0,0 +1,3 @@
+export function isHttpOk(status) {
+    return status >= 200 && status < 300;
+}

package/dist/services/operationId.js

@@ -0,0 +1,6 @@
+export function operationIndexToId(index) {
+    return index.toString();
+}
+export function operationIdToIndex(id) {
+    return Number.parseInt(id, 10);
+}

package/dist/services/sharepointUrl.js

@@ -0,0 +1,24 @@
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+/** Get the site name and item path from a given SharePoint document URL. (ie https://msftfuturesecureai.sharepoint.com/sites/FSAI-MQG/_layouts/15/doc.aspx?sourcedoc={500ff055-1e0f-4c2e-8b32-d167fba4778b} */
+export function parseSharepointUrl(url) {
+    if (!url.hostname.endsWith(".sharepoint.com")) {
+        throw new InvalidArgumentError("Invalid SharePoint URL. Hostname must end with '.sharepoint.com'.");
+    }
+    const hostName = url.hostname;
+    const pathSegments = url.pathname.split("/");
+    const siteNameIndex = pathSegments.indexOf("sites") + 1;
+    if (siteNameIndex <= 0 || !pathSegments[siteNameIndex]) {
+        throw new InvalidArgumentError("Invalid SharePoint URL. Site name not found.");
+    }
+    const siteName = pathSegments[siteNameIndex];
+    const sourcedoc = url.searchParams.get("sourcedoc");
+    if (!sourcedoc) {
+        throw new InvalidArgumentError("Invalid SharePoint URL. Path not found in parameters.");
+    }
+    const itemId = sourcedoc.replace(/[{}]/g, "").toLocaleUpperCase();
+    return {
+        hostName,
+        siteName,
+        itemId,
+    };
+}

package/dist/services/sharepointUrl.test.js

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { parseSharepointUrl } from "./sharepointUrl.js";
+describe("parseSharepointUrl", () => {
+    it.each([
+        [
+            "https://msftfuturesecureai.sharepoint.com/sites/FSAI-MQG/_layouts/15/doc.aspx?sourcedoc={500ff055-1e0f-4c2e-8b32-d167fba4778b}&action=edit",
+            {
+                hostName: "msftfuturesecureai.sharepoint.com",
+                siteName: "FSAI-MQG",
+                itemId: "500FF055-1E0F-4C2E-8B32-D167FBA4778B"
+            }
+        ],
+        [
+            "https://msftfuturesecureai.sharepoint.com/:x:/r/sites/FSAI-MQG/_layouts/15/Doc.aspx?sourcedoc=%7B500FF055-1E0F-4C2E-8B32-D167FBA4778B%7D&file=Book.xlsx&action=default&mobileredirect=true",
+            {
+                hostName: "msftfuturesecureai.sharepoint.com",
+                siteName: "FSAI-MQG",
+                itemId: "500FF055-1E0F-4C2E-8B32-D167FBA4778B"
+            }
+        ],
+        [
+            "https://msftfuturesecureai.sharepoint.com/:x:/r/sites/FSAI-MQG/_layouts/15/Doc.aspx?sourcedoc=%7B418801C2-AF81-44F9-AD17-324A973AA6AF%7D&file=a.xlsx&action=default&mobileredirect=true",
+            {
+                hostName: "msftfuturesecureai.sharepoint.com",
+                siteName: "FSAI-MQG",
+                itemId: "418801C2-AF81-44F9-AD17-324A973AA6AF"
+            }
+        ],
+    ])("parses %s", (url, expected) => {
+        expect(parseSharepointUrl(new URL(url))).toEqual(expected);
+    });
+});

package/dist/services/site.js

@@ -0,0 +1,15 @@
+import ProtocolError from "../errors/ProtocolError.js";
+import { defaultSiteIdEnv } from "./configuration.js";
+export function siteRef(siteId) {
+    if (!siteId) {
+        throw new ProtocolError("SiteID is missing");
+    }
+    return {
+        siteId
+    };
+}
+export function getDefaultSiteRef() {
+    return {
+        siteId: defaultSiteIdEnv(),
+    };
+}

package/dist/services/sleep.js

@@ -0,0 +1,3 @@
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}

package/dist/services/stringCaseConversion.js

@@ -0,0 +1,5 @@
+export function kebabToCamelCase(str) {
+    return str
+        .replace(/^-+|-+$/g, "") // Remove leading and trailing dashes
+        .replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}

package/dist/services/stringCaseConversion.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { kebabToCamelCase } from "./stringCaseConversion.js";
+describe("kebabToCamelCase", () => {
+    it("should handle single word strings", () => {
+        expect(kebabToCamelCase("single")).toBe("single");
+    });
+    it("should handle empty strings", () => {
+        expect(kebabToCamelCase("")).toBe("");
+    });
+    it("should handle strings with multiple dashes", () => {
+        expect(kebabToCamelCase("multiple-dashes-in-string")).toBe("multipleDashesInString");
+    });
+    it("should handle strings with leading and trailing dashes", () => {
+        expect(kebabToCamelCase("-leading-and-trailing-")).toBe("leadingAndTrailing");
+    });
+});

package/dist/services/templatedPaths.js

@@ -0,0 +1,20 @@
+import BadTemplateError from "../errors/BadTemplateError.js";
+import { kebabToCamelCase } from "./stringCaseConversion.js";
+const argmentPattern = /\{([a-z-]+)\}/g;
+/** Create a GraphAPI path based on a given template and arguments. Escaping is automatically handeld */
+export function generatePath(template, args) {
+    if (!template.startsWith("/")) {
+        throw new BadTemplateError(`Path template '${template}' must start with a slash.`);
+    }
+    if (template.includes("\n")) {
+        throw new BadTemplateError("Path template must not contain newlines.");
+    }
+    return template.replace(argmentPattern, (_, match) => {
+        const camelCaseKey = kebabToCamelCase(match);
+        const value = args[camelCaseKey];
+        if (value === undefined) {
+            throw new BadTemplateError(`Path template references argument '${camelCaseKey}' however no such argument provided.`);
+        }
+        return encodeURIComponent(value);
+    });
+}

package/dist/services/templatedPaths.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import BadTemplateError from "../errors/BadTemplateError.js";
+import { generatePath } from "./templatedPaths.js";
+describe("generatePath", () => {
+    it("should generate a valid path with correct arguments", () => {
+        const template = "/me/drive/items/{item-id}/children";
+        const args = { itemId: "123" };
+        const result = generatePath(template, args);
+        expect(result).toBe("/me/drive/items/123/children");
+    });
+    it("should throw BadTemplateError if template does not start with a slash", () => {
+        const template = "me/drive/items/{item-id}/children";
+        const args = { itemId: "123" };
+        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+    });
+    it("should throw BadTemplateError if template contains newlines", () => {
+        const template = "/me/drive/items/{item-id}/children\n";
+        const args = { itemId: "123" };
+        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+    });
+    it("should throw BadTemplateError if argument is missing", () => {
+        const template = "/me/drive/items/{item-id}/children";
+        const args = {};
+        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+    });
+    it("should encode URI components", () => {
+        const template = "/me/drive/items/{item-id}/children";
+        const args = { itemId: "item name with spaces" };
+        const result = generatePath(template, args);
+        expect(result).toBe("/me/drive/items/item%20name%20with%20spaces/children");
+    });
+    it("should generate a valid path when the same argument is used twice", () => {
+        const template = "/me/drive/items/{item-id}/children/{item-id}";
+        const args = { itemId: "123" };
+        const result = generatePath(template, args);
+        expect(result).toBe("/me/drive/items/123/children/123");
+    });
+    it("should throw BadTemplateError if template has an argument that is not matched", () => {
+        const template = "/me/drive/items/{item-id}/children/{child-id}";
+        const args = { itemId: "123" };
+        expect(() => generatePath(template, args)).toThrow(BadTemplateError);
+    });
+    it("should generate a valid path with multiple arguments", () => {
+        const template = "/users/{user-id}/messages/{message-id}/attachments/{attachment-id}";
+        const args = { userId: "user123", messageId: "msg456", attachmentId: "att789" };
+        const result = generatePath(template, args);
+        expect(result).toBe("/users/user123/messages/msg456/attachments/att789");
+    });
+});

package/dist/services/temporaryFiles.js

@@ -0,0 +1,11 @@
+export function generateTempFileName(extension = "tmp") {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    const length = 16;
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        const randomIndex = Math.floor(Math.random() * charactersLength);
+        result += characters[randomIndex];
+    }
+    return `~${result}.${extension}`;
+}

package/dist/services/workbookRange.js

@@ -0,0 +1,10 @@
+export function workbookRangeRef(worksheetRef, address) {
+    return {
+        siteId: worksheetRef.siteId,
+        driveId: worksheetRef.driveId,
+        itemId: worksheetRef.itemId,
+        sessionId: worksheetRef.sessionId,
+        worksheetId: worksheetRef.worksheetId,
+        address: address
+    };
+}

package/dist/services/workbookRangeAddress.js

@@ -0,0 +1,8 @@
+import InvalidArgumentError from "../errors/InvalidArgumentError.js";
+const addressPattern = /^[A-Z]+\d+(:[A-Z]+\d+)?$/;
+export function workbookRangeAddress(address) {
+    if (!addressPattern.test(address)) {
+        throw new InvalidArgumentError(`Invalid address format. It must match the pattern ${addressPattern}.`);
+    }
+    return address;
+}