microsoft-onedrive-mock 1.0.0

package/dist/store.js

@@ -0,0 +1,175 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driveStore = exports.DriveStore = void 0;
+const crypto = __importStar(require("crypto"));
+class DriveStore {
+    constructor() {
+        this.items = new Map();
+        this.deltaHistory = [];
+    }
+    calculateStats(content) {
+        let buffer;
+        if (typeof content === 'string') {
+            buffer = Buffer.from(content);
+        }
+        else if (Buffer.isBuffer(content)) {
+            buffer = content;
+        }
+        else if (content === undefined || content === null) {
+            buffer = Buffer.from('');
+        }
+        else {
+            buffer = Buffer.from(JSON.stringify(content));
+        }
+        return {
+            size: buffer.length,
+            sha1Hash: crypto.createHash('sha1').update(buffer).digest('hex')
+        };
+    }
+    createItem(item, isFolder = false) {
+        var _a;
+        if (!item.name) {
+            throw new Error("Item name is required");
+        }
+        const id = item.id || Math.random().toString(36).substring(7);
+        const now = new Date().toISOString();
+        const newItem = Object.assign(Object.assign({ createdDateTime: now, lastModifiedDateTime: now }, item), { id, name: item.name, eTag: `W/"1"`, cTag: `"cTag-1"`, size: 0, parentReference: item.parentReference || { driveId: "b!", id: "root" } });
+        if (isFolder) {
+            newItem.folder = { childCount: 0 };
+        }
+        else {
+            const stats = this.calculateStats(item.content);
+            newItem.size = stats.size;
+            newItem.file = {
+                mimeType: ((_a = item.file) === null || _a === void 0 ? void 0 : _a.mimeType) || "application/octet-stream",
+                hashes: { sha1Hash: stats.sha1Hash }
+            };
+        }
+        this.items.set(id, newItem);
+        this.addDeltaHistory(newItem);
+        // Update parent childCount if making a folder
+        if (newItem.parentReference && newItem.parentReference.id) {
+            this.incrementParentChildCount(newItem.parentReference.id, 1);
+        }
+        return newItem;
+    }
+    updateItem(id, updates) {
+        const item = this.items.get(id);
+        if (!item)
+            return null;
+        // Extract internal version number from etag to increment
+        const currentVersion = parseInt(item.eTag.replace(/\D/g, '') || "1", 10);
+        const newVersion = currentVersion + 1;
+        const statsUpdates = {};
+        if (updates.content !== undefined && item.file) {
+            const stats = this.calculateStats(updates.content);
+            statsUpdates.size = stats.size;
+            statsUpdates.file = Object.assign(Object.assign({}, item.file), { hashes: { sha1Hash: stats.sha1Hash } });
+        }
+        const updatedItem = Object.assign(Object.assign(Object.assign(Object.assign({}, item), updates), statsUpdates), { eTag: `W/"${newVersion}"`, cTag: `"cTag-${newVersion}"`, lastModifiedDateTime: updates.lastModifiedDateTime || new Date().toISOString() });
+        this.items.set(id, updatedItem);
+        this.addDeltaHistory(updatedItem);
+        return updatedItem;
+    }
+    getItem(id) {
+        return this.items.get(id) || null;
+    }
+    deleteItem(id) {
+        const item = this.items.get(id);
+        if (!item)
+            return false;
+        const deleted = this.items.delete(id);
+        if (deleted) {
+            const deletedItem = Object.assign(Object.assign({}, item), { deleted: { state: "deleted" }, lastModifiedDateTime: new Date().toISOString() });
+            this.addDeltaHistory(deletedItem);
+            // Decrement parent count
+            if (item.parentReference && item.parentReference.id) {
+                this.incrementParentChildCount(item.parentReference.id, -1);
+            }
+        }
+        return deleted;
+    }
+    listItems(parentId) {
+        const allItems = Array.from(this.items.values());
+        if (!parentId)
+            return allItems;
+        return allItems.filter(i => { var _a; return ((_a = i.parentReference) === null || _a === void 0 ? void 0 : _a.id) === parentId; });
+    }
+    getAllItems() {
+        return Array.from(this.items.values());
+    }
+    clear() {
+        this.items.clear();
+        this.deltaHistory = [];
+        // Always recreate a standard root folder
+        this.createItem({ id: 'root', name: 'root' }, true);
+    }
+    // Delta History (simulated changes API)
+    addDeltaHistory(item) {
+        this.deltaHistory.push(JSON.parse(JSON.stringify(item)));
+    }
+    getDeltaToken() {
+        return String(this.deltaHistory.length);
+    }
+    getDelta(token) {
+        const tokenIndex = token ? parseInt(token, 10) : 0;
+        const start = isNaN(tokenIndex) ? 0 : Math.max(0, tokenIndex);
+        const items = this.deltaHistory.slice(start);
+        // In MS Graph, if a file transitions multiple states, delta should ideally just return the latest state
+        // but for a mock, returning the log or deduping by id to latest state is standard.
+        // Let's dedupe to match real API behavior mostly (returns latest state within the page)
+        const dedupedMap = new Map();
+        for (const item of items) {
+            dedupedMap.set(item.id, item);
+        }
+        const dedupedItems = Array.from(dedupedMap.values());
+        const newToken = String(this.deltaHistory.length);
+        return {
+            items: dedupedItems,
+            deltaLink: newToken
+        };
+    }
+    incrementParentChildCount(parentId, amount) {
+        const parent = this.items.get(parentId);
+        if (parent && parent.folder) {
+            parent.folder.childCount = Math.max(0, parent.folder.childCount + amount);
+        }
+    }
+}
+exports.DriveStore = DriveStore;
+exports.driveStore = new DriveStore();
+// Initialize root on boot
+exports.driveStore.clear();

package/dist/types.d.ts

@@ -0,0 +1,60 @@
+export interface AppConfig {
+    apiEndpoint?: string;
+    serverLagBefore?: number;
+    serverLagAfter?: number;
+}
+declare global {
+    namespace Express {
+        interface Request {
+            rawBody?: Buffer | string;
+        }
+    }
+}
+export interface DriveItem {
+    id: string;
+    name: string;
+    eTag: string;
+    cTag: string;
+    createdBy?: {
+        user: {
+            displayName: string;
+        };
+    };
+    lastModifiedBy?: {
+        user: {
+            displayName: string;
+        };
+    };
+    createdDateTime: string;
+    lastModifiedDateTime: string;
+    size: number;
+    parentReference?: {
+        driveId?: string;
+        driveType?: string;
+        id?: string;
+        path?: string;
+    };
+    file?: {
+        mimeType: string;
+        hashes?: {
+            quickXorHash?: string;
+            sha1Hash?: string;
+            sha256Hash?: string;
+        };
+    };
+    folder?: {
+        childCount: number;
+    };
+    deleted?: {
+        state: string;
+    };
+    '@microsoft.graph.downloadUrl'?: string;
+    content?: unknown;
+    [key: string]: unknown;
+}
+export interface DeltaResponse {
+    '@odata.context': string;
+    '@odata.nextLink'?: string;
+    '@odata.deltaLink'?: string;
+    value: DriveItem[];
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/eslint.config.mjs

@@ -0,0 +1,15 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+    { files: ["**/*.{js,mjs,cjs,ts}"] },
+    { languageOptions: { globals: globals.node } },
+    pluginJs.configs.recommended,
+    ...tseslint.configs.recommended,
+    {
+        ignores: ["dist/**", "coverage/**", "node_modules/**"]
+    }
+];

package/examples/device-login.ts

@@ -0,0 +1,84 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+const clientId = 'e5f346a8-8996-4d46-9f93-6e6817d9078e';
+const tenantId = 'common';
+
+async function runDeviceLogin() {
+    const authority = `https://login.microsoftonline.com/${tenantId}/oauth2/v2.0`;
+
+    // 1. Get device code
+    const deviceCodeParams = new URLSearchParams();
+    deviceCodeParams.append('client_id', clientId);
+    deviceCodeParams.append('scope', 'Files.ReadWrite.All User.Read offline_access');
+
+    let deviceCodeRes;
+    try {
+        deviceCodeRes = await fetch(`${authority}/devicecode`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            body: deviceCodeParams.toString()
+        });
+    } catch (e) {
+        console.error("Network error executing fetch request:", e);
+        return;
+    }
+
+    const deviceCodeData = await deviceCodeRes.json();
+    if (!deviceCodeRes.ok) {
+        console.error('❌ Failed to start device login:', deviceCodeData);
+        console.error('\nNOTE: Your Azure App must have "Allow public client flows" enabled in Authentication settings for Device Code flow to work.');
+        return;
+    }
+
+    console.log('\n====================================================');
+    console.log(deviceCodeData.message);
+    console.log('====================================================\n');
+
+    // 2. Poll for token
+    const tokenParams = new URLSearchParams();
+    tokenParams.append('grant_type', 'urn:ietf:params:oauth:grant-type:device_code');
+    tokenParams.append('client_id', clientId);
+    tokenParams.append('device_code', deviceCodeData.device_code);
+
+    let polling = true;
+    while (polling) {
+        await new Promise(resolve => setTimeout(resolve, deviceCodeData.interval * 1000));
+
+        const tokenRes = await fetch(`${authority}/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            },
+            body: tokenParams.toString()
+        });
+
+        const tokenData = await tokenRes.json();
+
+        if (tokenRes.ok) {
+            console.log('\n✅ Successfully authenticated!');
+
+            // Save to .ENV
+            const envPath = path.resolve(__dirname, '../.ENV');
+            let envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf8') : '';
+            if (envContent.includes('ONEDRIVE_TOKEN=')) {
+                envContent = envContent.replace(/ONEDRIVE_TOKEN=[^\n]*/, `ONEDRIVE_TOKEN=${tokenData.access_token}`);
+            } else {
+                envContent += `\nONEDRIVE_TOKEN=${tokenData.access_token}\n`;
+            }
+            fs.writeFileSync(envPath, envContent);
+            console.log('✅ Updated .ENV with your new ONEDRIVE_TOKEN');
+            console.log('You can now run: npm run test:real');
+            polling = false;
+        } else if (tokenData.error !== 'authorization_pending') {
+            console.error('\n❌ Login failed:', tokenData.error_description || tokenData.error);
+            polling = false;
+        } else {
+            process.stdout.write('.');
+        }
+    }
+}
+
+runDeviceLogin();

package/examples/microsoft-login.html

@@ -0,0 +1,227 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Microsoft OneDrive Token Generator</title>
+    <style>
+        body {
+            font-family: sans-serif;
+            padding: 20px;
+            max-width: 600px;
+            margin: 0 auto;
+        }
+
+        .form-group {
+            margin-bottom: 15px;
+        }
+
+        label {
+            display: block;
+            margin-bottom: 5px;
+            font-weight: bold;
+        }
+
+        input[type="text"] {
+            width: 100%;
+            padding: 8px;
+            box-sizing: border-box;
+        }
+
+        button {
+            padding: 10px 20px;
+            background-color: #0078d4;
+            color: white;
+            border: none;
+            cursor: pointer;
+            font-size: 16px;
+            border-radius: 4px;
+        }
+
+        button:hover {
+            background-color: #005a9e;
+        }
+
+        button#copy-btn {
+            background-color: #28a745;
+            margin-top: 10px;
+        }
+
+        button#copy-btn:hover {
+            background-color: #218838;
+        }
+
+        #token-display {
+            margin-top: 20px;
+            background: #f0f0f0;
+            padding: 15px;
+            border-radius: 4px;
+            display: none;
+        }
+
+        textarea {
+            width: 100%;
+            padding: 8px;
+            box-sizing: border-box;
+            border: 1px solid #ccc;
+            border-radius: 4px;
+            resize: vertical;
+            font-family: monospace;
+        }
+
+        .hidden {
+            display: none;
+        }
+    </style>
+    <!-- MSAL.js v3 -->
+    <script type="text/javascript" src="https://alcdn.msauth.net/browser/2.37.1/js/msal-browser.min.js"></script>
+</head>
+
+<body>
+
+    <h1>Microsoft OneDrive Login</h1>
+    <p>Enter your Client ID (Application ID) and Tenant ID to authenticate and get an access token. The login uses
+        MSAL.js for OAuth2 Implicit/SPA flow.</p>
+
+    <div class="form-group">
+        <label for="client-id">Client ID:</label>
+        <input type="text" id="client-id" placeholder="e.g. 11111111-1111-1111-1111-111111111111">
+    </div>
+
+    <div class="form-group">
+        <label for="tenant-id">Tenant ID:</label>
+        <input type="text" id="tenant-id" placeholder="e.g. common (or your specific tenant GUID)">
+    </div>
+
+    <button id="login-btn" onclick="handleAuth()">Login to Microsoft Graph</button>
+
+    <div id="token-display">
+        <h3>Access Token:</h3>
+        <textarea id="access-token" readonly rows="6"></textarea>
+        <button id="copy-btn" onclick="copyToken()">Copy Token</button>
+
+        <h3>Full .ENV Content:</h3>
+        <textarea id="env-content" readonly rows="12"></textarea>
+        <button id="copy-env-btn" onclick="copyEnv()">Copy .ENV</button>
+    </div>
+
+    <script>
+        let msalInstance = null;
+        let loginRequest = {
+            scopes: ["Files.ReadWrite.All", "User.Read"]
+        };
+
+        window.onload = async function () {
+            const storedClientId = localStorage.getItem('ms_client_id');
+            const storedTenantId = localStorage.getItem('ms_tenant_id') || 'common';
+            if (storedClientId) document.getElementById('client-id').value = storedClientId;
+            document.getElementById('tenant-id').value = storedTenantId;
+
+            // If we have clientId, we can initialize MSAL to check if we are returning from a redirect
+            if (storedClientId) {
+                initializeMsal(storedClientId, storedTenantId);
+                try {
+                    const response = await msalInstance.handleRedirectPromise();
+                    if (response && response.accessToken) {
+                        displayToken(response.accessToken, storedClientId, storedTenantId);
+                    }
+                } catch (err) {
+                    console.error("Redirect error:", err);
+                    alert("Failed to process login redirect: " + err.message);
+                }
+            }
+        }
+
+        function initializeMsal(clientId, tenantId) {
+            // Determine if the user is running on https or http
+            const currentOrigin = window.location.origin;
+            const redirectUri = currentOrigin + "/microsoft-login.html";
+
+            const msalConfig = {
+                auth: {
+                    clientId: clientId,
+                    authority: `https://login.microsoftonline.com/${tenantId}`,
+                    redirectUri: redirectUri,
+                }
+            };
+            msalInstance = new msal.PublicClientApplication(msalConfig);
+        }
+
+        async function handleAuth() {
+            const clientId = document.getElementById('client-id').value.trim();
+            const tenantId = document.getElementById('tenant-id').value.trim() || 'common';
+
+            if (!clientId) {
+                alert('Please enter a Client ID');
+                return;
+            }
+
+            localStorage.setItem('ms_client_id', clientId);
+            localStorage.setItem('ms_tenant_id', tenantId);
+
+            initializeMsal(clientId, tenantId);
+
+            try {
+                // Use redirect flow instead of popup. This avoids popup blockers and 
+                // cleanly returns the user to this page with the '#code=...' in the URL,
+                // which handleRedirectPromise() will then automatically exchange for the JWT Access Token!
+                await msalInstance.loginRedirect(loginRequest);
+            } catch (err) {
+                console.error(err);
+                alert('Login failed: ' + (err.message || err));
+            }
+        }
+
+        function displayToken(accessToken, clientId, tenantId) {
+            document.getElementById('token-display').style.display = 'block';
+            document.getElementById('access-token').value = accessToken;
+
+            const envContent = `# To run tests against the real Microsoft Graph API
+# Copy this file to .ENV and fill in the values
+
+# 'mock' (default) or 'real'
+TEST_TARGET=real
+
+# OAuth2 Access Token for your Microsoft Account
+# Get one via 'npm run example:login'
+ONEDRIVE_TOKEN=${accessToken}
+
+# Client ID for the Microsoft Login Example
+ONEDRIVE_CLIENT_ID=${clientId}
+ONEDRIVE_TENANT_ID=${tenantId}
+
+# Optional: Simulate latency in ms (only works with TEST_TARGET=mock)
+# LATENCY=50
+`;
+            document.getElementById('env-content').value = envContent;
+        }
+
+        function copyToken() {
+            copyToClipboard('access-token', 'copy-btn');
+        }
+
+        function copyEnv() {
+            copyToClipboard('env-content', 'copy-env-btn');
+        }
+
+        function copyToClipboard(elementId, buttonId) {
+            const textEl = document.getElementById(elementId);
+            textEl.select();
+            textEl.setSelectionRange(0, 99999);
+
+            navigator.clipboard.writeText(textEl.value).then(() => {
+                const btn = document.getElementById(buttonId);
+                const originalText = btn.innerText;
+                btn.innerText = 'Copied!';
+                setTimeout(() => {
+                    btn.innerText = originalText;
+                }, 2000);
+            }).catch(err => {
+                console.error('Failed to copy text: ', err);
+            });
+        }
+    </script>
+</body>
+
+</html>

package/examples/serve-login.ts

@@ -0,0 +1,11 @@
+import express from 'express';
+
+const app = express();
+const port = 8080;
+
+app.use(express.static(__dirname));
+
+app.listen(port, () => {
+    console.log(`Login example running at http://localhost:${port}/microsoft-login.html`);
+    console.log('NOTE: Ensure "http://localhost:8080/microsoft-login.html" is added as a Redirect URI in your Microsoft Entra ID app registration (SPA).');
+});

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "microsoft-onedrive-mock",
+  "version": "1.0.0",
+  "description": "Mock-Server that simulates being Microsoft OneDrive. Used for testing.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "TEST_TARGET=mock vitest run",
+    "test:slow": "LATENCY=20 vitest run",
+    "test:browser": "PORT=3006 start-server-and-test dev http://localhost:3006 'TEST_TARGET=mock BROWSER_ENABLED=true vitest run --browser --no-file-parallelism'",
+    "test:browser:real": "TEST_TARGET=real BROWSER_ENABLED=true vitest run --browser",
+    "test:real": "ts-node scripts/check-token.ts && TEST_TARGET=real vitest run",
+    "example:login": "ts-node examples/serve-login.ts",
+    "example:device-login": "ts-node examples/device-login.ts",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix"
+  },
+  "type": "commonjs",
+  "peerDependencies": {
+    "express": "5.2.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.2",
+    "@microsoft/microsoft-graph-types": "^2.43.1",
+    "@types/cors": "2.8.19",
+    "@types/express": "5.0.6",
+    "@types/node": "25.1.0",
+    "@types/supertest": "6.0.3",
+    "@vitest/browser": "4.0.18",
+    "@vitest/browser-playwright": "4.0.18",
+    "async-test-util": "2.5.0",
+    "cors": "2.8.6",
+    "dotenv": "17.2.3",
+    "eslint": "9.39.2",
+    "express": "5.2.1",
+    "globals": "17.2.0",
+    "playwright": "1.58.0",
+    "start-server-and-test": "2.1.3",
+    "supertest": "7.2.2",
+    "ts-node": "^10.9.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.54.0",
+    "vitest": "4.0.18"
+  }
+}