microsoft-onedrive-mock 1.0.0

package/.ENV_EXAMPLE

@@ -0,0 +1,16 @@
+# 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=...
+
+# Optional: Simulate latency in ms (only works with TEST_TARGET=mock)
+# LATENCY=50
+
+# Client ID for the Microsoft Login Example
+ONEDRIVE_CLIENT_ID=e5...
+ONEDRIVE_TENANT_ID=common

package/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-24.04
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '24'
+        cache: 'npm'
+        
+    - name: Install dependencies
+      run: npm install
+
+    - name: Lint
+      run: npm run lint
+
+    - name: Build
+      run: npm run build
+
+    - name: Test (Node)
+      run: npm test
+
+    - name: Install Playwright Browsers
+      run: npx playwright@1.58.0 install chromium
+
+    - name: Test (Browser)
+      run: npm run test:browser
+
+    - name: Test Slow
+      run: npm run test:slow

package/.github/workflows/release.yml

@@ -0,0 +1,50 @@
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'New Version (e.g. 1.0.0, or leave empty for patch)'
+        required: false
+        type: string
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    # @link https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
+    permissions:
+      contents: write
+      # @link https://docs.npmjs.com/generating-provenance-statements#about-npm-provenance
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'npm'
+
+      - run: npm install
+      - name: Bump Version
+        id: bump
+        run: |
+            if [ -z "${{ inputs.version }}" ]; then
+              VERSION=$(npm version patch --no-git-tag-version)
+            else
+              VERSION=$(npm version ${{ inputs.version }} --no-git-tag-version)
+            fi
+            echo "version=${VERSION}" >> $GITHUB_OUTPUT
+      - run: npm run build
+      - run: npm run lint
+      - run: npm test
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Push changes
+        run: |
+          git config --global user.name 'github-actions[bot]'
+          git config --global user.email 'github-actions[bot]@users.noreply.github.com'
+          git add package.json package-lock.json
+          git commit -m "release: ${{ steps.bump.outputs.version }}"
+          git push

package/README.md

@@ -0,0 +1 @@
+# microsoft-onedrive-mock

package/dist/batch.d.ts

@@ -0,0 +1,2 @@
+import { Request, Response } from 'express';
+export declare const handleBatchRequest: (req: Request, res: Response) => Promise<void>;

package/dist/batch.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBatchRequest = void 0;
+const index_1 = require("./index");
+const handleBatchRequest = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const body = req.body;
+        if (!body || !Array.isArray(body.requests)) {
+            res.status(400).json({ error: { message: "Invalid batch payload" } });
+            return;
+        }
+        // We use an internal app instance without auth/latency middleware to process routes cleanly
+        const internalApp = (0, index_1.createApp)({ serverLagBefore: 0, serverLagAfter: 0 });
+        const batchResponses = yield Promise.all(body.requests.map((part) => __awaiter(void 0, void 0, void 0, function* () {
+            const { id, method, url, body: partBody, headers: partHeaders } = part;
+            // Reconstruct path. Graph batches often send relative urls like /me/drive/root
+            // We append /v1.0/ to map to our internal routes if missing
+            const requestPath = url.startsWith('/v1.0') ? url : `/v1.0${url.startsWith('/') ? '' : '/'}${url}`;
+            return new Promise((resolve) => {
+                const simulatedReq = {
+                    method: method || 'GET',
+                    url: requestPath,
+                    headers: partHeaders || {},
+                    body: partBody,
+                    query: {}
+                };
+                // Inject auth header from primary request to pass auth middleware
+                if (req.headers.authorization && !simulatedReq.headers.authorization) {
+                    simulatedReq.headers.authorization = req.headers.authorization;
+                }
+                const simulatedRes = {
+                    statusCode: 200,
+                    headers: {},
+                    charset: 'utf-8',
+                    status: function (code) {
+                        this.statusCode = code;
+                        return this;
+                    },
+                    set: function (headerKey, headerValue) {
+                        this.headers[headerKey] = headerValue;
+                        return this;
+                    },
+                    setHeader: function (headerKey, headerValue) {
+                        this.headers[headerKey] = headerValue;
+                        return this;
+                    },
+                    json: function (data) {
+                        this.data = data;
+                        this.end();
+                    },
+                    send: function (data) {
+                        // Normally this would be string/buffer, but let's just hold it
+                        this.data = data;
+                        this.end();
+                    },
+                    end: function () {
+                        resolve({
+                            id,
+                            status: this.statusCode,
+                            headers: this.headers,
+                            body: this.data
+                        });
+                    }
+                };
+                // Bypass async handlers and directly feed to internal instance
+                internalApp(simulatedReq, simulatedRes, () => {
+                    // Fallback next
+                    resolve({
+                        id,
+                        status: 404,
+                        body: { error: { message: "Not found within batch router" } }
+                    });
+                });
+            });
+        })));
+        res.json({
+            responses: batchResponses
+        });
+    }
+    catch (error) {
+        res.status(500).json({ error: { message: "Internal server error during batch", details: error.message } });
+    }
+});
+exports.handleBatchRequest = handleBatchRequest;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { driveStore } from './store';
+import { AppConfig } from './types';
+export * from './types';
+declare const createApp: (config?: AppConfig) => import("express-serve-static-core").Express;
+declare const startServer: (port: number, host?: string, config?: AppConfig) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+export { createApp, startServer, driveStore };

package/dist/index.js

@@ -0,0 +1,115 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.driveStore = exports.startServer = exports.createApp = void 0;
+const express_1 = __importDefault(require("express"));
+const cors_1 = __importDefault(require("cors"));
+const store_1 = require("./store");
+Object.defineProperty(exports, "driveStore", { enumerable: true, get: function () { return store_1.driveStore; } });
+const v1_1 = require("./routes/v1");
+const batch_1 = require("./batch");
+__exportStar(require("./types"), exports);
+const createApp = (config = {}) => {
+    if (!config.apiEndpoint) {
+        config.apiEndpoint = "";
+    }
+    const app = (0, express_1.default)();
+    app.use((0, cors_1.default)({
+        // For downloads Microsoft uses specific headers sometimes, expose ETag
+        exposedHeaders: ['ETag', 'Date', 'Content-Length', 'Location']
+    }));
+    app.set('etag', false);
+    // Latency simulator
+    app.use((req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const delay = Math.floor(Math.random() * 21);
+        if (delay > 0) {
+            yield new Promise(resolve => setTimeout(resolve, delay));
+        }
+        next();
+    }));
+    app.use(express_1.default.json({
+        verify: (req, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+    app.use(express_1.default.text({
+        type: ['multipart/mixed', 'multipart/related', 'text/*', 'application/xml', 'application/octet-stream'],
+        verify: (req, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+    // Explicit raw body for binary uploads
+    app.use(express_1.default.raw({
+        type: '*/*',
+        limit: '50mb',
+        verify: (req, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+    // Batch Route
+    app.post('/v1.0/$batch', batch_1.handleBatchRequest);
+    // Debug
+    app.post('/debug/clear', (req, res) => {
+        store_1.driveStore.clear();
+        res.status(200).send('Cleared');
+    });
+    // Health Check
+    app.get('/', (req, res) => {
+        res.status(200).send('OK');
+    });
+    // Auth Middleware
+    const validTokens = ['valid-token', 'another-valid-token'];
+    app.use((req, res, next) => {
+        const authHeaderVal = req.headers.authorization;
+        const authHeader = Array.isArray(authHeaderVal) ? authHeaderVal[0] : authHeaderVal;
+        if (!authHeader) {
+            res.status(401).json({ error: { code: "unauthenticated", message: "Unauthorized: No token provided" } });
+            return;
+        }
+        const token = authHeader.split(' ')[1];
+        if (!validTokens.includes(token)) {
+            res.status(401).json({ error: { code: "unauthenticated", message: "Unauthorized: Invalid token" } });
+            return;
+        }
+        next();
+    });
+    app.use((0, v1_1.createV1Router)());
+    return app;
+};
+exports.createApp = createApp;
+const startServer = (port, host = 'localhost', config = {}) => {
+    const app = createApp(config);
+    return app.listen(port, host, () => {
+        console.log(`Server is running on http://${host}:${port}`);
+    });
+};
+exports.startServer = startServer;
+if (require.main === module) {
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3006;
+    startServer(port);
+}

package/dist/routes/v1.d.ts

@@ -0,0 +1 @@
+export declare const createV1Router: () => import("express-serve-static-core").Router;

package/dist/routes/v1.js

@@ -0,0 +1,201 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createV1Router = void 0;
+const express_1 = __importDefault(require("express"));
+const store_1 = require("../store");
+const createV1Router = () => {
+    const app = express_1.default.Router();
+    // Helper to apply ?$select=id,name
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const applySelect = (item, selectQuery) => {
+        if (!selectQuery || typeof selectQuery !== 'string')
+            return item;
+        const fields = selectQuery.split(',').map(f => f.trim());
+        if (fields.length === 0)
+            return item;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const result = {};
+        for (const field of fields) {
+            if (item[field] !== undefined) {
+                result[field] = item[field];
+            }
+        }
+        return result;
+    };
+    // GET /me/drive/root
+    app.get('/v1.0/me/drive/root', (req, res) => {
+        const root = store_1.driveStore.getItem('root');
+        if (!root)
+            return res.status(404).json({ error: { message: "Root not found" } });
+        res.json(applySelect(root, req.query.$select));
+    });
+    // GET /me/drive/items/{id}
+    app.get('/v1.0/me/drive/items/:itemId', (req, res) => {
+        let itemId = req.params.itemId;
+        if (itemId === 'root')
+            itemId = 'root'; // Already handled if just mapping
+        const item = store_1.driveStore.getItem(itemId);
+        if (!item) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "Item not found" } });
+            return;
+        }
+        res.json(applySelect(item, req.query.$select));
+    });
+    // GET /me/drive/items/{id}/children
+    app.get('/v1.0/me/drive/items/:itemId/children', (req, res) => {
+        const itemId = req.params.itemId;
+        const children = store_1.driveStore.listItems(itemId);
+        const mappedChildren = children.map(c => applySelect(c, req.query.$select));
+        res.json({ value: mappedChildren });
+    });
+    // GET /me/drive/root/search(q='query')
+    app.get('/v1.0/me/drive/root/search\\(q=\':query\'\\)', (req, res) => {
+        let query = req.params.query || "";
+        // Decode URI component incase it's URL encoded like %20 or %27
+        query = decodeURIComponent(query);
+        // Strip out the trailing quote matching if it caught the literal '
+        if (query.endsWith("'"))
+            query = query.slice(0, -1);
+        query = query.toLowerCase();
+        // recursively find items
+        const allItems = store_1.driveStore.getAllItems();
+        const results = allItems.filter(item => item.name.toLowerCase().includes(query) && item.id !== 'root');
+        const mappedResults = results.map(c => applySelect(c, req.query.$select));
+        res.json({ value: mappedResults });
+    });
+    // POST /me/drive/items/{parent-id}/children (Create Metadata / Folder)
+    app.post('/v1.0/me/drive/items/:itemId/children', (req, res) => {
+        const parentId = req.params.itemId;
+        const body = req.body || {};
+        let parentItem = store_1.driveStore.getItem(parentId);
+        if (!parentItem && parentId === 'root') {
+            parentItem = store_1.driveStore.createItem({ id: 'root', name: 'root' }, true);
+        }
+        else if (!parentItem) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "Parent not found" } });
+            return;
+        }
+        const isFolder = !!body.folder;
+        const newItem = store_1.driveStore.createItem(Object.assign({ name: body.name || "Untitled", parentReference: { id: parentId } }, body), isFolder);
+        res.status(201).json(applySelect(newItem, req.query.$select));
+    });
+    // DELETE /me/drive/items/{id}
+    app.delete('/v1.0/me/drive/items/:itemId', (req, res) => {
+        const fileId = req.params.itemId;
+        if (fileId === 'root') {
+            res.status(400).json({ error: { message: "Cannot delete root" } });
+            return;
+        }
+        const item = store_1.driveStore.getItem(fileId);
+        if (!item) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "Item not found" } });
+            return;
+        }
+        const ifMatch = req.header('If-Match');
+        if (ifMatch && ifMatch !== item.eTag) {
+            res.status(412).json({ error: { code: "PreconditionFailed", message: "ETag mismatch" } });
+            return;
+        }
+        store_1.driveStore.deleteItem(fileId);
+        res.status(204).send();
+    });
+    // GET /me/drive/items/{id}/content
+    app.get('/v1.0/me/drive/items/:itemId/content', (req, res) => {
+        var _a;
+        const fileId = req.params.itemId;
+        const file = store_1.driveStore.getItem(fileId);
+        if (!file || file.folder) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "File not found" } });
+            return;
+        }
+        if ((_a = file.file) === null || _a === void 0 ? void 0 : _a.mimeType) {
+            res.setHeader('Content-Type', file.file.mimeType);
+        }
+        if (file.content === undefined) {
+            res.send("");
+            return;
+        }
+        if (Buffer.isBuffer(file.content)) {
+            res.send(file.content);
+        }
+        else if (typeof file.content === 'object') {
+            res.json(file.content);
+        }
+        else {
+            res.send(file.content);
+        }
+    });
+    // PUT /me/drive/items/{parent-id}:/{filename}:/content
+    app.put('/v1.0/me/drive/items/:parentId\\:/:filename\\:/content', (req, res) => {
+        const parentId = req.params.parentId;
+        const filename = req.params.filename;
+        // Find existing or create
+        const children = store_1.driveStore.listItems(parentId);
+        let item = children.find(c => c.name === filename);
+        const content = req.rawBody !== undefined ? req.rawBody : req.body;
+        const headerMime = req.headers['content-type'];
+        const mimeType = (Array.isArray(headerMime) ? headerMime[0] : headerMime) || 'application/octet-stream';
+        const isNew = !item;
+        if (item) {
+            const ifMatch = req.header('If-Match');
+            if (ifMatch && ifMatch !== item.eTag) {
+                res.status(412).json({ error: { code: "PreconditionFailed", message: "ETag mismatch" } });
+                return;
+            }
+            // Update
+            item = store_1.driveStore.updateItem(item.id, { content, file: { mimeType } });
+        }
+        else {
+            // Create
+            item = store_1.driveStore.createItem({
+                name: filename,
+                parentReference: { id: parentId },
+                content,
+                file: { mimeType }
+            });
+        }
+        res.status(isNew ? 201 : 200).json(applySelect(item, req.query.$select));
+    });
+    // PUT /me/drive/items/{id}/content
+    app.put('/v1.0/me/drive/items/:itemId/content', (req, res) => {
+        var _a;
+        const itemId = req.params.itemId;
+        let item = store_1.driveStore.getItem(itemId);
+        if (!item || item.folder) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "Item not found" } });
+            return;
+        }
+        const ifMatch = req.header('If-Match');
+        if (ifMatch && ifMatch !== item.eTag) {
+            res.status(412).json({ error: { code: "PreconditionFailed", message: "ETag mismatch" } });
+            return;
+        }
+        const content = req.rawBody !== undefined ? req.rawBody : req.body;
+        const headerMime = req.headers['content-type'];
+        const mimeType = (Array.isArray(headerMime) ? headerMime[0] : headerMime) || ((_a = item.file) === null || _a === void 0 ? void 0 : _a.mimeType) || 'application/octet-stream';
+        item = store_1.driveStore.updateItem(item.id, { content, file: { mimeType } });
+        res.status(200).json(applySelect(item, req.query.$select));
+    });
+    // Delta Query
+    // GET /me/drive/root/delta
+    app.get('/v1.0/me/drive/root/delta', (req, res) => {
+        const tokenStr = req.query.token;
+        let token = undefined;
+        if (tokenStr)
+            token = tokenStr;
+        const result = store_1.driveStore.getDelta(token);
+        const host = req.headers.host || 'localhost';
+        const protocol = req.protocol || 'http';
+        const baseUrl = `${protocol}://${host}`;
+        res.json({
+            '@odata.context': `${baseUrl}/v1.0/$metadata#Collection(driveItem)`,
+            '@odata.deltaLink': `${baseUrl}/v1.0/me/drive/root/delta?token=${result.deltaLink}`,
+            value: result.items
+        });
+    });
+    return app;
+};
+exports.createV1Router = createV1Router;

package/dist/store.d.ts

@@ -0,0 +1,24 @@
+import { DriveItem } from './types';
+export declare class DriveStore {
+    private items;
+    private deltaHistory;
+    constructor();
+    private calculateStats;
+    createItem(item: Partial<DriveItem> & {
+        name: string;
+    }, isFolder?: boolean): DriveItem;
+    updateItem(id: string, updates: Partial<DriveItem>): DriveItem | null;
+    getItem(id: string): DriveItem | null;
+    deleteItem(id: string): boolean;
+    listItems(parentId?: string): DriveItem[];
+    getAllItems(): DriveItem[];
+    clear(): void;
+    private addDeltaHistory;
+    getDeltaToken(): string;
+    getDelta(token?: string): {
+        items: DriveItem[];
+        deltaLink: string;
+    };
+    private incrementParentChildCount;
+}
+export declare const driveStore: DriveStore;