microsoft-graph 2.0.0 → 2.2.0

package/dist/errors/RequestFailedError.js

@@ -1,21 +1,13 @@
-import { isHttpOk } from "../services/httpStatus.js";
 export default class RequestFailedError extends Error {
     constructor(message) {
         super(message);
         this.name = "RequestFailedError";
     }
-    static throwIfNotOkBatch(status, ops, error) {
-        if (!isHttpOk(status)) {
-            throw new RequestFailedError(`GraphAPI batch failed with HTTP ${status}\n` +
-                `Operation: ${JSON.stringify(ops, null, 2)}\n` +
-                `Error: ${JSON.stringify(error, null, 2)}}`);
-        }
-    }
-    static throwIfNotOkOperation(status, index, op, error) {
-        if (!isHttpOk(status)) {
-            throw new RequestFailedError(`GraphAPI operation ${index} failed with HTTP ${status}\n` +
-                `Operation: ${JSON.stringify(op, null, 2)}\n` +
-                `Error: ${JSON.stringify(error, null, 2)}}`);
+    static throw(message, request, response) {
+        const r = request;
+        if (r?.headers?.authorization) {
+            r.headers.authorization = "<REDACTED>";
         }
+        throw new RequestFailedError(`${message}\n\nREQUEST: ${JSON.stringify(r, null, 2)}\n\nRESPONSE: ${JSON.stringify(response, null, 2)}`);
     }
 }

package/dist/graphApi.d.ts

@@ -3,13 +3,14 @@ import type { Scope } from "./models/Scope.ts";
 export declare const authenticationScope: Scope;
 export declare const endpoint = "https://graph.microsoft.com/v1.0";
 export declare const batchEndpoint = "https://graph.microsoft.com/v1.0/$batch";
-type ExecutionResults<T> = {
-    [K in keyof T]: T[K] extends GraphOperation<infer R> ? R : never;
-};
+/** Define a operation, which can either be `await`d to execute independently, or passed with other operations ot `parallel` or `sequential` to execute as part of a batch. */
 export declare function operation<T>(definition: GraphOperationDefinition<T>): GraphOperation<T>;
 /** 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 declare function parallel<T extends GraphOperation<unknown>[]>(...ops: T): Promise<ExecutionResults<T>>;
+export declare function parallel<T extends GraphOperation<unknown>[]>(...operations: T): Promise<OperationResponse<T>>;
 /** Execute a batch of GraphAPI operations sequentially. */
-export declare function sequential<T extends GraphOperation<unknown>[]>(...ops: T): Promise<ExecutionResults<T>>;
+export declare function sequential<T extends GraphOperation<unknown>[]>(...operations: T): Promise<OperationResponse<T>>;
+type OperationResponse<T> = {
+    [K in keyof T]: T[K] extends GraphOperation<infer R> ? R : never;
+};
 export {};
 //# sourceMappingURL=graphApi.d.ts.map

package/dist/graphApi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphApi.d.ts","sourceRoot":"","sources":["../src/graphApi.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAC3F,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAM/C,eAAO,MAAM,mBAAmB,EAA6C,KAAK,CAAC;AACnF,eAAO,MAAM,QAAQ,qCAAqC,CAAC;AAC3D,eAAO,MAAM,aAAa,4CAAuB,CAAC;AAiBlD,KAAK,gBAAgB,CAAC,CAAC,IAAI;KACtB,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CACnE,CAAC;AAGF,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,wBAAwB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAMvF;AA2BD,6LAA6L;AAC7L,wBAAsB,QAAQ,CAAC,CAAC,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAG3G;AAED,2DAA2D;AAC3D,wBAAsB,UAAU,CAAC,CAAC,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAQ7G"}
+{"version":3,"file":"graphApi.d.ts","sourceRoot":"","sources":["../src/graphApi.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAgB,cAAc,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACzG,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAQ/C,eAAO,MAAM,mBAAmB,EAA6C,KAAK,CAAC;AACnF,eAAO,MAAM,QAAQ,qCAAqC,CAAC;AAC3D,eAAO,MAAM,aAAa,4CAAuB,CAAC;AAElD,8KAA8K;AAC9K,wBAAgB,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,wBAAwB,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAQvF;AAED,6LAA6L;AAC7L,wBAAsB,QAAQ,CAAC,CAAC,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAInH;AAED,2DAA2D;AAC3D,wBAAsB,UAAU,CAAC,CAAC,SAAS,cAAc,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,UAAU,EAAE,CAAC,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAOrH;AAoBD,KAAK,iBAAiB,CAAC,CAAC,IAAI;KAC1B,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,cAAc,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK;CAChE,CAAC"}

package/dist/graphApi.js

@@ -1,107 +1,160 @@
-import fetch from 'node-fetch';
+import fetch from "node-fetch";
 import InconsistentContextError from "./errors/InconsistentContextError.js";
 import InvalidArgumentError from "./errors/InvalidArgumentError.js";
+import NeverError from "./errors/NeverError.js";
+import ProtocolError from "./errors/ProtocolError.js";
 import RequestFailedError from "./errors/RequestFailedError.js";
 import { getCurrentAccessToken } from "./services/accessToken.js";
 import { getContext } from "./services/context.js";
 import { tryGetHttpAgent } from "./services/httpAgent.js";
+import { isHttpOk, isHttpTooManyRequests } from "./services/httpStatus.js";
 import { operationIdToIndex, operationIndexToId } from "./services/operationId.js";
+import { sleep } from "./services/sleep.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
+/** Define a operation, which can either be `await`d to execute independently, or passed with other operations ot `parallel` or `sequential` to execute as part of a batch. */
 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 single = async (definition) => {
+        return await executeSingle(definition);
+    };
     const op = single(definition);
     op.definition = definition;
     return op;
 }
-async function single(definition) {
+/** 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(...operations) {
+    const definitions = operations.map((op) => op.definition);
+    return (await executeBatch(...definitions));
+}
+/** Execute a batch of GraphAPI operations sequentially. */
+export async function sequential(...operations) {
+    const definitions = operations.map((definition, index) => ({
+        ...definition.definition,
+        dependsOn: index > 0 ? [index - 1] : undefined, // Each op is dependant on the previous op
+    }));
+    return (await executeBatch(...definitions));
+}
+const maxBatchOperations = 20; // https://learn.microsoft.com/en-us/graph/json-batching?tabs=http#batch-size-limitations
+const maxRetries = 3;
+const defaultRetryDelayMilliseconds = 1000;
+const consecutiveRetryDelayMultiplier = 2;
+async function executeSingle(definition) {
     const context = getContext(definition.contextId);
     const accessToken = await getCurrentAccessToken(context.tenantId, context.clientId, context.clientSecret, authenticationScope);
     const agent = tryGetHttpAgent(context.httpProxy);
-    const requestHeaders = {
-        "authorization": `Bearer ${accessToken}`,
-        ...Object.fromEntries(Object.entries(definition.headers ?? {}).filter(([_, v]) => v !== undefined)), // TODO: Tidy
-    };
-    const reply = await fetch(`${endpoint}${definition.path}`, {
+    const response = await innerFetch({
+        url: `${endpoint}${definition.path}`,
         method: definition.method,
-        headers: requestHeaders,
+        headers: {
+            authorization: createAuthorizationHeader(accessToken),
+            ...headersToObject(definition.headers),
+        },
         body: definition.body === null ? null : JSON.stringify(definition.body),
-        agent
+        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);
+    return definition.responseTransform(response);
 }
-/** 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) {
+async function executeBatch(...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 firstOp = ops[0];
     if (!firstOp) {
-        throw new Error("First op not found. Should be impossible");
+        throw new NeverError("First op not found. Should be impossible");
     }
     const contextId = firstOp.contextId;
-    if (ops.some(op => op.contextId !== contextId)) {
+    if (ops.some((op) => op.contextId !== contextId)) {
         throw new InconsistentContextError("All operations in a batch must share the same contextId.");
     }
     const context = getContext(contextId);
     const accessToken = await getCurrentAccessToken(context.tenantId, context.clientId, context.clientSecret, authenticationScope);
     const agent = tryGetHttpAgent(context.httpProxy);
-    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 = {
+    const body = await innerFetch({
+        url: batchEndpoint,
         method: "POST",
         headers: {
-            "authorization": `Bearer ${accessToken}`,
-            "accept": "application/json",
-            "content-type": "application/json"
+            authorization: createAuthorizationHeader(accessToken),
+            accept: "application/json",
+            "content-type": "application/json",
         },
-        body: JSON.stringify(requestBody),
-        agent
-    };
-    return requestPayload;
+        body: JSON.stringify({
+            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()),
+            })),
+        }),
+        agent,
+    });
+    const responses = [];
+    for (const r of body.responses) {
+        const index = operationIdToIndex(r.id);
+        const headers = normalizeBatchHeaders(r.headers);
+        const contentType = headers["content-type"];
+        const body = normalizeBatchBody(contentType, r.body);
+        const op = ops[index];
+        if (!op) {
+            throw new ProtocolError("Reference to operation that was not submitted in the batch");
+        }
+        if (!isHttpOk(r.status)) {
+            const bodyError = body;
+            const errorMessage = bodyError?.error ? `[${bodyError.error.code}] ${bodyError.error.message}` : `HTTP ${r.status}`;
+            RequestFailedError.throw(`GraphAPI operation ${index} failed: '${errorMessage}'`, op, r);
+        }
+        responses[index] = op.responseTransform(body);
+    }
+    return responses; // 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.
+}
+/** Execute request, supporting GraphAPI retry logic */
+async function innerFetch(args) {
+    const { url, ...options } = args;
+    let retryAfterMilliseconds = defaultRetryDelayMilliseconds;
+    let response = null;
+    let attempts = 0; // Track the number of attempts
+    while (attempts < maxRetries) {
+        // Retry at most 3 times
+        response = await fetch(url, options);
+        if (!isHttpTooManyRequests(response.status)) {
+            break;
+        }
+        const requestedRetryAfterSeconds = Number.parseInt(response.headers.get("Retry-After") ?? "0", 10);
+        if (requestedRetryAfterSeconds) {
+            retryAfterMilliseconds = requestedRetryAfterSeconds * 1000;
+        }
+        await sleep(retryAfterMilliseconds);
+        retryAfterMilliseconds *= consecutiveRetryDelayMultiplier;
+        attempts++; // Increment the attempt counter
+    }
+    if (attempts >= maxRetries) {
+        RequestFailedError.throw(`GraphAPI fetch exceed retry limit of ${maxRetries} attempts.`, args);
+    }
+    if (!response) {
+        throw new NeverError("Response is null. Should be impossible");
+    }
+    if (isHttpTooManyRequests(response.status)) {
+        RequestFailedError.throw("GraphAPI fetch failed after 3 retries due to too many requests.", args);
+    }
+    const replyContentType = response.headers.get("content-type")?.toLowerCase();
+    const body = replyContentType?.startsWith("application/json") ? await response.json() : null;
+    if (!isHttpOk(response.status)) {
+        const bodyError = body;
+        const errorMessage = bodyError?.error ? `[${bodyError.error.code}] ${bodyError.error.message}` : `HTTP ${response.status} ${response.statusText}`;
+        RequestFailedError.throw(`GraphAPI fetch failed: '${errorMessage}'`, args, body);
+    }
+    return body;
 }
-function normalizeBody(contentType, body) {
+function normalizeBatchBody(contentType, body) {
     if (contentType?.startsWith("application/json") && typeof body === "string") {
         return JSON.parse(atob(body));
     }
     return body;
 }
-function normalizeHeaders(input) {
+function normalizeBatchHeaders(input) {
     const headers = {};
     for (const key in input) {
         if (input[key]) {
@@ -110,19 +163,9 @@ function normalizeHeaders(input) {
     }
     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.
+function createAuthorizationHeader(accessToken) {
+    return `Bearer ${accessToken}`;
+}
+function headersToObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([_, v]) => v !== undefined));
 }

package/dist/microsoftGraph/errors/BadTemplateError.js

@@ -0,0 +1,6 @@
+export default class BadTemplateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BadTemplateError";
+    }
+}

package/dist/microsoftGraph/errors/InvalidArgumentError.js

@@ -0,0 +1,6 @@
+export default class InvalidArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "InvalidArgumentError";
+    }
+}

package/dist/microsoftGraph/errors/RequestFailedError.js

@@ -0,0 +1,6 @@
+export default class RequestFailedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RequestFailedError";
+    }
+}

package/dist/microsoftGraph/graphApi.js

@@ -0,0 +1,49 @@
+import InvalidArgumentError from "./errors/InvalidArgumentError.js";
+import RequestFailedError from "./errors/RequestFailedError.js";
+import { getCurrentAccessToken } from "./services/accessToken.js";
+const authenticationScope = "https://graph.microsoft.com/.default";
+const batchEndpoint = "https://graph.microsoft.com/v1.0/$batch";
+const minBatchCalls = 1;
+const maxBatchCalls = 20; // https://learn.microsoft.com/en-us/graph/json-batching?tabs=http#batch-size-limitations
+/** Execute GraphAPI batch with up to 20 requests to be executed as a batch. */
+export async function execute(...ops) {
+    const accessToken = await getCurrentAccessToken(authenticationScope);
+    if (ops.length < minBatchCalls || ops.length > maxBatchCalls) {
+        throw new InvalidArgumentError(`Requires at least ${minBatchCalls} and at most ${maxBatchCalls} calls`);
+    }
+    const response = await fetch(batchEndpoint, {
+        method: "POST",
+        headers: {
+            'authorization': `Bearer ${accessToken}`,
+            'accept': 'application/json',
+            'content-type': 'application/json'
+        },
+        body: JSON.stringify({
+            requests: ops.map((call, index) => ({
+                id: index.toString(),
+                method: call.method,
+                url: call.path,
+                headers: call.headers,
+                body: call.body,
+                dependsOn: call.dependsOn?.map((id) => id.toString())
+            }))
+        })
+    });
+    if (!response.ok) {
+        throw new RequestFailedError(`Batch request failed with status ${response.status}`);
+    }
+    const json = await response.json();
+    if (!json.responses) {
+        throw new RequestFailedError("Batch request did not return any responses");
+    }
+    const results = {};
+    for (const response of json.responses) {
+        if (response.status !== 200) {
+            const body = response.body;
+            throw new RequestFailedError(`[REQUEST INDEX: ${response.id} STATUS: ${response.status} CODE: ${body.code}]: ${body.message}`);
+        }
+        const index = Number.parseInt(response.id, 10);
+        results[index] = response.body;
+    }
+    return results;
+}

package/dist/microsoftGraph/helpers/openSite.js

@@ -0,0 +1,12 @@
+import { execute } from "../graphApi.js";
+import getSiteByName from "../operations/site/getSiteByName.js";
+/** Convenience helper to get a reference to a site by name. Avoid using this however and code to siteId instead for a less brittle and performant result. */
+export async function openSiteByName(hostName, siteName) {
+    const [site] = await execute(getSiteByName(hostName, siteName));
+    if (site.id === undefined) { // TODO: This may need to be refined on testing
+        throw new Error(`Site ${siteName} not found in host ${hostName}`);
+    }
+    return {
+        siteId: site.id,
+    };
+}

package/dist/microsoftGraph/helpers/openWorkbook.js

@@ -0,0 +1,23 @@
+import { execute } from "../graphApi.js";
+import createWorkbookSession from "../operations/workbookSession/createWorkbookSession.js";
+import { defaultDriveId, defaultSiteId } from "../services/configuration.js";
+/** Opinionated convenience helper to start a workbook session. Includes starting a session. */
+export async function openWorkbook(workbookRef) {
+    const [session] = await execute(createWorkbookSession(workbookRef));
+    return {
+        ...workbookRef,
+        sessionId: session.id,
+    };
+}
+export async function openWorkbookInDefaultDrive(itemId) {
+    const itemRef = {
+        siteId: defaultSiteId,
+        driveId: defaultDriveId,
+        itemId: itemId
+    };
+    const [session] = await execute(createWorkbookSession(itemRef));
+    return {
+        ...itemRef,
+        sessionId: session.id,
+    };
+}

package/dist/microsoftGraph/helpers/openWorksheet.js

@@ -0,0 +1,7 @@
+/** Convenience helper to start a worksheet session */
+export function openWorksheet(workbookRef, worksheetId) {
+    return {
+        ...workbookRef,
+        worksheetId: worksheetId
+    };
+}

package/dist/microsoftGraph/models/AccessToken.js

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

package/dist/microsoftGraph/models/DriveId.js

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

package/dist/microsoftGraph/models/DriveItemId.js

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

package/dist/microsoftGraph/models/DriveItemPath.js

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

package/dist/microsoftGraph/models/DriveItemRef.js

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

package/dist/microsoftGraph/models/DriveRef.js

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

package/dist/microsoftGraph/models/GraphOperation.js

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

package/dist/microsoftGraph/models/GraphOptions.js

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

package/dist/microsoftGraph/models/HostName.js

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

package/dist/microsoftGraph/models/Scope.js

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

package/dist/microsoftGraph/models/SiteId.js

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

package/dist/microsoftGraph/models/SiteName.js

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

package/dist/microsoftGraph/models/SiteRef.js

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

package/dist/microsoftGraph/models/WorkbookNamedRangeRef.js

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

package/dist/microsoftGraph/models/WorkbookRangeAddress.js

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

package/dist/microsoftGraph/models/WorkbookRangeName.js

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

package/dist/microsoftGraph/models/WorkbookRangeRef.js

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

package/dist/microsoftGraph/models/WorkbookRef.js

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

package/dist/microsoftGraph/models/WorkbookSessionId.js

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

package/dist/microsoftGraph/models/WorkbookWorksheetId.js

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

package/dist/microsoftGraph/models/WorkbookWorksheetRef.js

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

package/dist/microsoftGraph/models/regenerate-dtos.js

@@ -0,0 +1,68 @@
+// biome-ignore lint/correctness/noNodejsModules: Fit for purpose
+import fs from "node:fs/promises";
+// biome-ignore lint/correctness/noNodejsModules: Fit for purpose
+import https from "node:https";
+// biome-ignore lint/correctness/noNodejsModules: Fit for purpose
+import { dirname } from "node:path";
+// biome-ignore lint/correctness/noNodejsModules: Fit for purpose
+import { fileURLToPath } from "node:url";
+const inputUrl = "https://raw.githubusercontent.com/microsoftgraph/msgraph-typescript-typings/refs/heads/main/microsoft-graph.d.ts";
+const outputFilePath = `${dirname(fileURLToPath(import.meta.url))}/Dto.d.ts`;
+async function downloadFile(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode !== 200) {
+                reject(new Error(`Failed to download file: ${res.statusCode}`));
+                return;
+            }
+            let data = "";
+            res.on("data", (chunk) => {
+                data += chunk;
+            });
+            res.on("end", () => resolve(data));
+        }).on("error", reject);
+    });
+}
+async function writeFile(path, data) {
+    const payload = `/*\n * DO NOT MODIFY THIS FILE, it is programmatically generated.\n * Run \`npm run regenerate-dtos\` to regenerate.\n*/\n\n${data}`;
+    return await fs.writeFile(path, payload, "utf-8");
+}
+function fixWhiteSpace(data) {
+    return data.replace(/\u202F/g, " ");
+}
+function fixAnyDataType(data) {
+    return data
+        .replace(/: any\b/g, ": unknown")
+        .replace(/\<any\>/g, "<unknown>");
+}
+function fixLintDisables(data) {
+    return data
+        .replace(/\/\/ tslint:disable-next-line: [a-z- ]+\n/g, "");
+}
+function linkStronglyTypedIds(data) {
+    // biome-ignore lint/style/useTemplate: <explanation>
+    return `import type { DriveId } from './DriveId.ts'\n` +
+        `import type { DriveItemId } from './DriveItemId.ts'\n` +
+        `import type { SiteId } from './SiteId.ts';\n\n` +
+        data
+            .replace(/export interface Entity\s*{[^}]*id\?: string;/g, "export interface Entity<TId = string> {\n    // The unique identifier for an entity. Read-only.\n    id?: TId;")
+            .replace("export interface BaseItem extends Entity", "export interface BaseItem<TId = string> extends Entity<TId>")
+            .replace("export interface Site extends BaseItem", "export interface Site extends BaseItem<SiteId>")
+            .replace("export interface Drive extends BaseItem", "export interface Drive extends BaseItem<DriveId>")
+            .replace("export interface DriveItem extends BaseItem", "export interface DriveItem extends BaseItem<DriveItemId>")
+            .replace("export interface Workbook extends Entity", "export interface Workbook extends Entity<DriveItemId>");
+}
+function fixNamespaces(data) {
+    return data
+        .replace(/microsoftgraph\./g, "")
+        .replace(/Partners\.Billing\.Billing/g, "unknown"); // Workaround possible incorrect ordering. Not worth time to investigate
+}
+let data = await downloadFile(inputUrl);
+data = fixWhiteSpace(data);
+data = fixAnyDataType(data);
+data = fixLintDisables(data);
+data = fixNamespaces(data);
+data = linkStronglyTypedIds(data);
+await writeFile(outputFilePath, data);
+// biome-ignore lint/suspicious/noConsoleLog: <explanation>
+console.log(`File saved to ${outputFilePath}`);

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

@@ -0,0 +1,17 @@
+import { generatePath } from "../../services/templatedPaths.js";
+/** Create folder if it doesn't exist, and return the folder. @see https://learn.microsoft.com/en-us/graph/api/driveitem-post-children */
+export default function createFolder(driveRef, folderPath, opts) {
+    return {
+        method: "POST",
+        path: generatePath(`/sites/{site-id}/drives/{drive-id}/root:${folderPath}:/children`, driveRef),
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: {
+            name: folderPath,
+            folder: {},
+            "@microsoft.graph.conflictBehavior": "rename", // Do nothing if already exists
+        },
+        dependsOn: opts?.dependsOn,
+    };
+}

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

@@ -0,0 +1,11 @@
+import { generatePath } from "../../services/templatedPaths.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, opts) {
+    return {
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives", siteRef),
+        headers: {},
+        body: null,
+        dependsOn: opts?.dependsOn,
+    };
+}

package/dist/microsoftGraph/operations/driveItem/copyDriveItem.js

@@ -0,0 +1,20 @@
+import { generatePath } from "../../services/templatedPaths.js";
+/** Initiate an asyncronous 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, opts) {
+    return {
+        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,
+            },
+        },
+        dependsOn: opts?.dependsOn,
+    };
+}

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

@@ -0,0 +1,11 @@
+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, opts) {
+    return {
+        method: "DELETE",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}", itemRef),
+        headers: {},
+        body: null,
+        dependsOn: opts?.dependsOn,
+    };
+}

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

@@ -0,0 +1,11 @@
+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, opts) {
+    return {
+        method: "GET",
+        path: generatePath("/sites/{site-id}/drives/{drive-id}/items/{item-id}", itemRef),
+        headers: {},
+        body: null,
+        dependsOn: opts?.dependsOn,
+    };
+}