microsoft-graph 1.0.0

package/dist/graphApi.js

@@ -0,0 +1,116 @@
+import fetch from 'node-fetch';
+import InvalidArgumentError from "./errors/InvalidArgumentError.js";
+import RequestFailedError from "./errors/RequestFailedError.js";
+import { getCurrentAccessToken } from "./services/accessToken.js";
+import { getHttpAgent } from "./services/httpAgent.js";
+import { operationIdToIndex, operationIndexToId } from "./services/operationId.js";
+export const authenticationScope = "https://graph.microsoft.com/.default";
+export const endpoint = "https://graph.microsoft.com/v1.0";
+export const batchEndpoint = `${endpoint}/$batch`;
+const maxBatchOperations = 20; // https://learn.microsoft.com/en-us/graph/json-batching?tabs=http#batch-size-limitations
+export function operation(definition) {
+    // The returned operation can be called directly by simply `await`ing it, or it can be passed to the `parallel` or `sequential` functions to be executed in a batch.
+    const op = single(definition);
+    op.definition = definition;
+    return op;
+}
+async function single(definition) {
+    const accessToken = await getCurrentAccessToken(authenticationScope);
+    const agent = getHttpAgent();
+    const requestHeaders = {
+        "authorization": `Bearer ${accessToken}`,
+        ...Object.fromEntries(Object.entries(definition.headers ?? {}).filter(([_, v]) => v !== undefined)), // TODO: Tidy
+    };
+    const reply = await fetch(`${endpoint}${definition.path}`, {
+        method: definition.method,
+        headers: requestHeaders,
+        body: definition.body === null ? null : JSON.stringify(definition.body),
+        agent
+    });
+    const replyContentType = reply.headers.get('content-type')?.toLowerCase();
+    const body = replyContentType?.startsWith("application/json") ? await reply.json() : null;
+    RequestFailedError.throwIfNotOkOperation(reply.status, 0, definition, body);
+    return definition.responseTransform(body);
+}
+/** Execute a batch of GraphAPI operations in parallel. Provides the best performance for batch operations, however only useful if operations can logically be performed at the same time. */
+export async function parallel(...ops) {
+    const definitions = ops.map(op => op.definition);
+    return await execute(...definitions);
+}
+/** Execute a batch of GraphAPI operations sequentially. */
+export async function sequential(...ops) {
+    const definitions = ops.map(op => op.definition);
+    const sequentialOps = definitions.map((definition, index) => ({
+        ...definition,
+        dependsOn: index > 0 ? [index - 1] : undefined // Each op is dependant on the previous op
+    }));
+    return await execute(...sequentialOps);
+}
+async function execute(...ops) {
+    InvalidArgumentError.throwIfGreater(ops.length, maxBatchOperations, `At most ${maxBatchOperations} operations allowed, but ${ops.length} were provided.`);
+    if (ops.length === 0) {
+        return [];
+    }
+    const requestPayload = await composeRequestPayload(ops);
+    const reply = await fetch(batchEndpoint, requestPayload);
+    const replyPayload = await reply.json();
+    RequestFailedError.throwIfNotOkBatch(reply.status, ops, replyPayload);
+    const responses = parseResponses(replyPayload, ops);
+    return responses;
+}
+async function composeRequestPayload(ops) {
+    const accessToken = await getCurrentAccessToken(authenticationScope);
+    const agent = await getHttpAgent();
+    const requestBody = {
+        requests: ops.map((op, index) => ({
+            id: operationIndexToId(index),
+            method: op.method,
+            url: op.path,
+            headers: op.headers,
+            body: op.body === null ? undefined : op.body,
+            dependsOn: op.dependsOn?.map((id) => id.toString())
+        }))
+    };
+    const requestPayload = {
+        method: "POST",
+        headers: {
+            "authorization": `Bearer ${accessToken}`,
+            "accept": "application/json",
+            "content-type": "application/json"
+        },
+        body: JSON.stringify(requestBody),
+        agent
+    };
+    return requestPayload;
+}
+function normalizeBody(contentType, body) {
+    if (contentType?.startsWith("application/json") && typeof body === "string") {
+        return JSON.parse(atob(body));
+    }
+    return body;
+}
+function normalizeHeaders(input) {
+    const headers = {};
+    for (const key in input) {
+        if (input[key]) {
+            headers[key.toLocaleLowerCase()] = input[key];
+        }
+    }
+    return headers;
+}
+function parseResponses(replyPayload, ops) {
+    const results = [];
+    for (const response of replyPayload.responses) {
+        const index = operationIdToIndex(response.id);
+        const headers = normalizeHeaders(response.headers);
+        const contentType = headers["content-type"];
+        const body = normalizeBody(contentType, response.body);
+        const op = ops[index];
+        if (!op) {
+            throw new Error("Op not found. Should be impossible");
+        }
+        RequestFailedError.throwIfNotOkOperation(response.status, index, op, body);
+        results[index] = op.responseTransform(body);
+    }
+    return results; // TODO: Is there a neater way to massage the types correctly? This is functionally correct, but I do want to avoid using `unknown` here if possible.
+}

package/dist/index.js

@@ -0,0 +1,2 @@
+export {};
+// This file exists to satisfy npm "main"

package/dist/models/AccessToken.js

@@ -0,0 +1 @@
+export {};

package/dist/models/DriveId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/DriveItemId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/DriveItemPath.js

@@ -0,0 +1 @@
+export {};

package/dist/models/DriveItemRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/DriveRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/GraphOperation.js

@@ -0,0 +1 @@
+export {};

package/dist/models/GraphOperationDefinition.js

@@ -0,0 +1 @@
+export {};

package/dist/models/HostName.js

@@ -0,0 +1 @@
+export {};

package/dist/models/Scope.js

@@ -0,0 +1 @@
+export {};

package/dist/models/SiteId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/SiteName.js

@@ -0,0 +1 @@
+export {};

package/dist/models/SiteRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookNamedRangeRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookRangeAddress.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookRangeName.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookRangeRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookSessionId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookTableId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookTableRef.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookWorksheetId.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookWorksheetName.js

@@ -0,0 +1 @@
+export {};

package/dist/models/WorkbookWorksheetRef.js

@@ -0,0 +1 @@
+export {};

package/dist/operations/drive/createFolder.js

@@ -0,0 +1,27 @@
+import { operation } from "../../graphApi.js";
+import { driveItemRef } from "../../services/driveItem.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Create folder if it doesn't exist, and return the folder. Use a `DriveRef` to create in root or `DriveItemRef` to create in a subfolder. @see https://learn.microsoft.com/en-us/graph/api/driveitem-post-children */
+export default function createFolder(parentRef, folderName) {
+    const pathSegment = parentRef.itemId ? "items/{item-id}" : "root";
+    return operation({
+        method: "POST",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/${pathSegment}/children`, parentRef),
+        headers: {
+            "content-type": "application/json",
+        },
+        body: {
+            name: folderName,
+            folder: {},
+            "@microsoft.graph.conflictBehavior": "rename", // Do nothing if already exists
+        },
+        responseTransform: response => {
+            const item = response;
+            const itemRef = driveItemRef(parentRef, item.id);
+            return {
+                ...item,
+                ...itemRef
+            };
+        }
+    });
+}

package/dist/operations/drive/createFolder.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItem from "../driveItem/deleteDriveItem.js";
+import createFolder from "./createFolder.js";
+describe("createFolder", () => {
+    it("can create root folder", { timeout: 10000 }, async () => {
+        const driveRef = getDefaultDriveRef();
+        const folderName = generateTempFileName();
+        const folder = await createFolder(driveRef, folderName);
+        expect(folder.webUrl?.endsWith(`/${folderName}`)).toBeTruthy();
+        await deleteDriveItem(folder);
+    });
+    it("can create sub-folder", { timeout: 10000 }, async () => {
+        const driveRef = getDefaultDriveRef();
+        const parentFolderName = generateTempFileName("parent");
+        console.debug(`Creating parent folder ${parentFolderName}...`);
+        const parentFolder = await createFolder(driveRef, parentFolderName);
+        console.debug(`Created parent folder ${parentFolder.webUrl}...`);
+        try {
+            const childFolderName = generateTempFileName("child");
+            console.debug(`Creating child folder ${childFolderName}...`);
+            const childFolder = await createFolder(parentFolder, childFolderName);
+            console.debug(`Created child folder ${childFolder.webUrl}...`);
+            expect(childFolder.webUrl).contains(`/${parentFolderName}/${childFolderName}`);
+        }
+        finally {
+            await deleteDriveItem(parentFolder);
+        }
+    });
+});

package/dist/operations/drive/listDrives.js

@@ -0,0 +1,23 @@
+import { operation } from "../../graphApi.js";
+import { driveRef } from "../../services/drive.js";
+import { generatePath } from "../../services/templatedPaths.js";
+import { getDefaultSiteRef } from "../../services/site.js";
+/** Retrieve the list of Drive resources available for a Site. @see https://learn.microsoft.com/en-us/graph/api/drive-list */
+export default function listDrives(siteRef = getDefaultSiteRef()) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives", siteRef),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const list = response;
+            return list.value.map(drive => {
+                const ref = driveRef(siteRef, drive.id);
+                return {
+                    ...drive,
+                    ...ref
+                };
+            });
+        }
+    });
+}

package/dist/operations/drive/listDrives.test.js

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest";
+import listDrives from "./listDrives.js";
+describe("listDrives", () => {
+    it("can listDrives", async () => {
+        const drives = await listDrives();
+        console.debug("Drives:", drives.map((drive) => [drive.id, drive.name]));
+        expect(drives.length).toBeGreaterThan(0);
+    });
+});

package/dist/operations/driveItem/copyDriveItem.js

@@ -0,0 +1,21 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Initiate an asynchronous copy of an item. NOTE: The copied file may not be immediately available and polling is required. @see https://learn.microsoft.com/en-us/graph/api/driveitem-copy */
+export default function copyDriveItem(srcFileRef, dstFolderRef, dstFileName) {
+    return operation({
+        method: "POST",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/copy", srcFileRef),
+        headers: {
+            "content-type": "application/json",
+        },
+        body: {
+            name: dstFileName,
+            parentReference: {
+                siteId: dstFolderRef.siteId,
+                driveId: dstFolderRef.driveId,
+                id: dstFolderRef.itemId,
+            },
+        },
+        responseTransform: () => undefined
+    });
+}

package/dist/operations/driveItem/copyDriveItem.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 createFolder from "../drive/createFolder.js";
+import copyDriveItem from "./copyDriveItem.js";
+import getDriveItemByPath from "./getDriveItemByPath.js";
+describe("copyDriveItem", () => {
+    it("can copy an item to a new folder", { timeout: 10000 }, async () => {
+        const driveRef = getDefaultDriveRef();
+        const srcFolderName = generateTempFileName();
+        const srcFolder = await createFolder(driveRef, srcFolderName);
+        const dstFolderName = generateTempFileName();
+        const dstFolder = await createFolder(driveRef, dstFolderName);
+        try {
+            const copiedItemName = `${srcFolderName}-copy`;
+            await copyDriveItem(srcFolder, dstFolder, copiedItemName);
+            const copyPath = driveItemPath(dstFolderName, copiedItemName);
+            const copyFolder = await getDriveItemByPath(driveRef, copyPath);
+            expect(copyFolder.webUrl?.endsWith(copyPath)).toBeTruthy();
+        }
+        finally {
+            await deleteDriveItemWithRetry(srcFolder);
+            await deleteDriveItemWithRetry(dstFolder);
+        }
+    });
+});

package/dist/operations/driveItem/deleteDriveItem.js

@@ -0,0 +1,12 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Delete an item. @see https://learn.microsoft.com/en-us/graph/api/driveitem-delete */
+export default function deleteDriveItem(itemRef) {
+    return operation({
+        method: "DELETE",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}", itemRef),
+        headers: {},
+        body: null,
+        responseTransform: () => undefined
+    });
+}

package/dist/operations/driveItem/deleteDriveItem.test.js

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import createFolder from "../drive/createFolder.js";
+import deleteDriveItem from "./deleteDriveItem.js";
+import getDriveItem from "./getDriveItem.js";
+describe("deleteDriveItem", () => {
+    it("can delete an existing folder", { timeout: 10000 }, async () => {
+        const folderName = generateTempFileName();
+        const folder = await createFolder(getDefaultDriveRef(), folderName);
+        await deleteDriveItem(folder);
+        await expect(getDriveItem(folder)).rejects.toThrow();
+    });
+    it("throws an error when trying to delete a non-existent item", async () => {
+        const driveRef = getDefaultDriveRef();
+        const nonExistentItemRef = {
+            ...driveRef,
+            itemId: "non-existent-item-id"
+        };
+        await expect(deleteDriveItem(nonExistentItemRef)).rejects.toThrow();
+    });
+});

package/dist/operations/driveItem/getDriveItem.js

@@ -0,0 +1,18 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve the metadata for an item in a drive. @see https://learn.microsoft.com/en-us/graph/api/driveitem-get */
+export default function getDriveItem(itemRef) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}", itemRef),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const item = response;
+            return {
+                ...item,
+                ...itemRef
+            };
+        }
+    });
+}

package/dist/operations/driveItem/getDriveItem.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import createFolder from "../drive/createFolder.js";
+import getDriveItem from "./getDriveItem.js";
+describe("getDriveItem", () => {
+    const defaultDriveRef = getDefaultDriveRef();
+    it("can retrieve an existing folder", { timeout: 10000 }, async () => {
+        const folderName = generateTempFileName();
+        const folder = await createFolder(defaultDriveRef, folderName);
+        const retrievedFolder = await getDriveItem(folder);
+        expect(retrievedFolder.id).toBe(folder.id);
+        expect(retrievedFolder.name).toBe(folderName);
+        await deleteDriveItemWithRetry(folder);
+    });
+    it("throws an error when trying to retrieve a non-existent item", async () => {
+        const nonExistentItemRef = {
+            ...defaultDriveRef,
+            itemId: "non-existent-item-id"
+        };
+        await expect(getDriveItem(nonExistentItemRef)).rejects.toThrow();
+    });
+});

package/dist/operations/driveItem/getDriveItemByPath.js

@@ -0,0 +1,20 @@
+import { operation } from "../../graphApi.js";
+import { driveItemRef } from "../../services/driveItem.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve the metadata for an item in a drive by file path. If the target file is moved this will cease working. @see https://learn.microsoft.com/en-us/graph/api/driveitem-get */
+export default function getDriveItemByPath(driveRef, itemPath) {
+    return operation({
+        method: "GET",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/root:${itemPath}`, driveRef),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const item = response;
+            const itemRef = driveItemRef(driveRef, item.id);
+            return {
+                ...item,
+                ...itemRef
+            };
+        }
+    });
+}

package/dist/operations/driveItem/getDriveItemByPath.test.js

@@ -0,0 +1,22 @@
+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 createFolder from "../drive/createFolder.js";
+import getDriveItemByPath from "./getDriveItemByPath.js";
+describe("getDriveItemByPath", () => {
+    it("can retrieve an existing folder by path", { timeout: 10000 }, async () => {
+        const folderName = generateTempFileName();
+        const folder = await createFolder(getDefaultDriveRef(), folderName);
+        const folderPath = driveItemPath(folderName);
+        const retrievedFolder = await getDriveItemByPath(getDefaultDriveRef(), folderPath);
+        expect(retrievedFolder.id).toBe(folder.id);
+        expect(retrievedFolder.name).toBe(folderName);
+        await deleteDriveItemWithRetry(folder);
+    });
+    it("throws an error when trying to retrieve a non-existent item by path", async () => {
+        const nonExistentItemPath = driveItemPath("non-existent-item-path");
+        await expect(getDriveItemByPath(getDefaultDriveRef(), nonExistentItemPath)).rejects.toThrow();
+    });
+});

package/dist/operations/driveItem/getDriveItemContent.js

@@ -0,0 +1,22 @@
+import fetch from 'node-fetch';
+import { authenticationScope, endpoint } from "../../graphApi.js";
+import { getCurrentAccessToken } from "../../services/accessToken.js";
+import { getHttpAgent } from "../../services/httpAgent.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Download drive item. @see https://learn.microsoft.com/en-us/graph/api/driveitem-get-content */
+export default async function getDriveItemContent(itemRef) {
+    // Note this method doesn't match the standard pattern since the batching library doesn't support non-JSON return types, and there appears to be no value in adding support.
+    const url = `${endpoint}${generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}/content", itemRef)}`;
+    const accessToken = await getCurrentAccessToken(authenticationScope);
+    const agent = getHttpAgent();
+    const response = await fetch(url, {
+        headers: {
+            "authorization": `Bearer ${accessToken}`
+        },
+        agent
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to download file: ${response.status} ${response.statusText}`);
+    }
+    return await response.arrayBuffer();
+}

package/dist/operations/driveItem/getDriveItemContent.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemPath, driveItemRef } 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 calculateWorkbook from "../workbook/calculateWorkbook.js";
+import createWorkbook from "../workbook/createWorkbook.js";
+import updateWorkbookRange from "../workbookRange/updateWorkbookRange.js";
+import getDriveItemContent from "./getDriveItemContent.js";
+describe("getDriveItemContent", () => {
+    it("can download the content of an existing workbook", { timeout: 20000 }, async () => {
+        const workbookPath = driveItemPath(generateTempFileName("xlsx"));
+        const workbook = await createWorkbook(getDefaultDriveRef(), workbookPath);
+        try {
+            const worksheetRef = workbookWorksheetRef(workbook, defaultWorkbookWorksheetId);
+            const rangeRef = workbookRangeRef(worksheetRef, "A1:B1");
+            await updateWorkbookRange(rangeRef, {
+                values: [
+                    ["Hello", "World"]
+                ]
+            });
+            await calculateWorkbook(workbook);
+            const content = await getDriveItemContent(workbook);
+            expect(content).toBeInstanceOf(ArrayBuffer);
+            expect(content.byteLength).toBeGreaterThan(0);
+        }
+        finally {
+            await deleteDriveItemWithRetry(workbook);
+        }
+    });
+    it("throws an error when trying to download a non-existent item", async () => {
+        const nonExistentItemRef = driveItemRef(getDefaultDriveRef(), "non-existent-item-id");
+        await expect(getDriveItemContent(nonExistentItemRef)).rejects.toThrow();
+    });
+});

package/dist/operations/driveItem/listDriveItems.js

@@ -0,0 +1,25 @@
+import { operation } from "../../graphApi.js";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { driveItemRef } from "../../services/driveItem.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve the metadata for items in a drive by file path. Use a `DriveRef` to reference a drive root or `DriveItemRef` for a subfolder. @see https://learn.microsoft.com/en-us/graph/api/driveitem-list-children */
+export default function listDriveItems(parentRef = getDefaultDriveRef()) {
+    const pathSegment = parentRef.itemId ? "items/{item-id}" : "root";
+    return operation({
+        method: "GET",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/${pathSegment}/children`, parentRef),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const list = response;
+            const items = list.value.map(item => {
+                const itemRef = driveItemRef(parentRef, item.id);
+                return {
+                    ...item,
+                    ...itemRef,
+                };
+            });
+            return items;
+        }
+    });
+}

package/dist/operations/driveItem/listDriveItems.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultDriveRef } from "../../services/drive.js";
+import { generateTempFileName } from "../../services/temporaryFiles.js";
+import deleteDriveItemWithRetry from "../../tasks/deleteDriveItemWithRetry.js";
+import createFolder from "../drive/createFolder.js";
+import listDriveItems from "./listDriveItems.js";
+describe("listDriveItems", () => {
+    it("can list items in the root folder", { timeout: 10000 }, async () => {
+        const driveRef = getDefaultDriveRef();
+        const items = await listDriveItems(driveRef);
+        expect(items).toBeInstanceOf(Array);
+    });
+    it("can list items in a folder", async () => {
+        const driveRef = getDefaultDriveRef();
+        const folder = await createFolder(driveRef, generateTempFileName());
+        try {
+            const items = await listDriveItems(folder);
+            expect(items).toBeInstanceOf(Array);
+        }
+        finally {
+            await deleteDriveItemWithRetry(folder);
+        }
+    });
+});

package/dist/operations/site/getSite.js

@@ -0,0 +1,18 @@
+import { operation } from "../../graphApi.js";
+import { generatePath } from "../../services/templatedPaths.js";
+/** Retrieve properties for a site resource. @see https://learn.microsoft.com/en-us/graph/api/site-get */
+export default function getSite(siteRef) {
+    return operation({
+        method: "GET",
+        path: generatePath("/sites/{site-id}", siteRef),
+        headers: {},
+        body: null,
+        responseTransform: response => {
+            const site = response;
+            return {
+                ...site,
+                ...siteRef
+            };
+        }
+    });
+}

package/dist/operations/site/getSite.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { getDefaultSiteRef, siteRef } from "../../services/site.js";
+import getSite from "./getSite.js";
+describe("getSite", () => {
+    it("can retrieve an existing site", async () => {
+        const defaultSiteRef = getDefaultSiteRef();
+        const site = await getSite(defaultSiteRef);
+        expect(site.id).toBeDefined();
+        expect(site.name).toBeDefined();
+    });
+    it("throws an error when trying to retrieve a non-existent site", async () => {
+        const nonExistentSiteRef = siteRef("non-existent-site-id");
+        await expect(getSite(nonExistentSiteRef)).rejects.toThrow();
+    });
+});