microsoft-onedrive-mock 1.0.0

package/src/batch.ts

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Request, Response } from 'express';
+import { createApp } from './index';
+
+export const handleBatchRequest = async (req: Request, res: Response) => {
+    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 = createApp({ serverLagBefore: 0, serverLagAfter: 0 });
+
+        const batchResponses = await Promise.all(body.requests.map(async (part: any) => {
+            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: any = {
+                    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: any = {
+                    statusCode: 200,
+                    headers: {},
+                    charset: 'utf-8',
+                    status: function (code: number) {
+                        this.statusCode = code;
+                        return this;
+                    },
+                    set: function (headerKey: string, headerValue: string) {
+                        this.headers[headerKey] = headerValue;
+                        return this;
+                    },
+                    setHeader: function (headerKey: string, headerValue: string) {
+                        this.headers[headerKey] = headerValue;
+                        return this;
+                    },
+                    json: function (data: any) {
+                        this.data = data;
+                        this.end();
+                    },
+                    send: function (data: any) {
+                        // 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 as Request, simulatedRes as Response, () => {
+                    // Fallback next
+                    resolve({
+                        id,
+                        status: 404,
+                        body: { error: { message: "Not found within batch router" } }
+                    });
+                });
+            });
+        }));
+
+        res.json({
+            responses: batchResponses
+        });
+
+    } catch (error: any) {
+        res.status(500).json({ error: { message: "Internal server error during batch", details: error.message } });
+    }
+};

package/src/index.ts

@@ -0,0 +1,102 @@
+import express, { Request } from 'express';
+import cors from 'cors';
+import { driveStore } from './store';
+import { createV1Router } from './routes/v1';
+import { handleBatchRequest } from './batch';
+import { AppConfig } from './types';
+
+export * from './types';
+
+const createApp = (config: AppConfig = {}) => {
+    if (!config.apiEndpoint) {
+        config.apiEndpoint = "";
+    }
+
+    const app = express();
+    app.use(cors({
+        // For downloads Microsoft uses specific headers sometimes, expose ETag
+        exposedHeaders: ['ETag', 'Date', 'Content-Length', 'Location']
+    }));
+    app.set('etag', false);
+
+    // Latency simulator
+    app.use(async (req, res, next) => {
+        const delay = Math.floor(Math.random() * 21);
+        if (delay > 0) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        next();
+    });
+
+    app.use(express.json({
+        verify: (req: Request, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+    app.use(express.text({
+        type: ['multipart/mixed', 'multipart/related', 'text/*', 'application/xml', 'application/octet-stream'],
+        verify: (req: Request, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+
+    // Explicit raw body for binary uploads
+    app.use(express.raw({
+        type: '*/*',
+        limit: '50mb',
+        verify: (req: Request, res, buf) => {
+            req.rawBody = buf;
+        }
+    }));
+
+    // Batch Route
+    app.post('/v1.0/$batch', handleBatchRequest);
+
+    // Debug
+    app.post('/debug/clear', (req, res) => {
+        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(createV1Router());
+
+    return app;
+};
+
+const startServer = (port: number, host: string = 'localhost', config: AppConfig = {}) => {
+    const app = createApp(config);
+    return app.listen(port, host, () => {
+        console.log(`Server is running on http://${host}:${port}`);
+    });
+};
+
+if (require.main === module) {
+    const port = process.env.PORT ? parseInt(process.env.PORT, 10) : 3006;
+    startServer(port);
+}
+
+export { createApp, startServer, driveStore };

package/src/routes/v1.ts

@@ -0,0 +1,227 @@
+import express, { Request, Response } from 'express';
+import { driveStore } from '../store';
+
+export const createV1Router = () => {
+    const app = express.Router();
+
+    // Helper to apply ?$select=id,name
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const applySelect = (item: any, selectQuery?: string | string[] | qs.ParsedQs | qs.ParsedQs[]) => {
+        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: any = {};
+        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: Request, res: Response) => {
+        const root = driveStore.getItem('root');
+        if (!root) return res.status(404).json({ error: { message: "Root not found" } });
+        res.json(applySelect(root, req.query.$select as string));
+    });
+
+    // GET /me/drive/items/{id}
+    app.get('/v1.0/me/drive/items/:itemId', (req: Request, res: Response) => {
+        let itemId = req.params.itemId as string;
+        if (itemId === 'root') itemId = 'root'; // Already handled if just mapping
+
+        const item = driveStore.getItem(itemId);
+        if (!item) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "Item not found" } });
+            return;
+        }
+        res.json(applySelect(item, req.query.$select as string));
+    });
+
+    // GET /me/drive/items/{id}/children
+    app.get('/v1.0/me/drive/items/:itemId/children', (req: Request, res: Response) => {
+        const itemId = req.params.itemId as string;
+        const children = driveStore.listItems(itemId);
+        const mappedChildren = children.map(c => applySelect(c, req.query.$select as string));
+        res.json({ value: mappedChildren });
+    });
+
+    // GET /me/drive/root/search(q='query')
+    app.get('/v1.0/me/drive/root/search\\(q=\':query\'\\)', (req: Request, res: Response) => {
+        let query = (req.params.query as string) || "";
+        // 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 = 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 as string));
+        res.json({ value: mappedResults });
+    });
+
+    // POST /me/drive/items/{parent-id}/children (Create Metadata / Folder)
+    app.post('/v1.0/me/drive/items/:itemId/children', (req: Request, res: Response) => {
+        const parentId = req.params.itemId as string;
+        const body = req.body || {};
+
+        let parentItem = driveStore.getItem(parentId);
+        if (!parentItem && parentId === 'root') {
+            parentItem = 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 = driveStore.createItem({
+            name: body.name || "Untitled",
+            parentReference: { id: parentId },
+            ...body
+        }, isFolder);
+
+        res.status(201).json(applySelect(newItem, req.query.$select as string));
+    });
+
+    // DELETE /me/drive/items/{id}
+    app.delete('/v1.0/me/drive/items/:itemId', (req: Request, res: Response) => {
+        const fileId = req.params.itemId as string;
+        if (fileId === 'root') {
+            res.status(400).json({ error: { message: "Cannot delete root" } });
+            return;
+        }
+
+        const item = 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;
+        }
+
+        driveStore.deleteItem(fileId);
+        res.status(204).send();
+    });
+
+    // GET /me/drive/items/{id}/content
+    app.get('/v1.0/me/drive/items/:itemId/content', (req: Request, res: Response) => {
+        const fileId = req.params.itemId as string;
+        const file = driveStore.getItem(fileId);
+
+        if (!file || file.folder) {
+            res.status(404).json({ error: { code: "itemNotFound", message: "File not found" } });
+            return;
+        }
+
+        if (file.file?.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: Request, res: Response) => {
+        const parentId = req.params.parentId as string;
+        const filename = req.params.filename as string;
+
+        // Find existing or create
+        const children = 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 = driveStore.updateItem(item.id, { content, file: { mimeType } })!;
+        } else {
+            // Create
+            item = driveStore.createItem({
+                name: filename,
+                parentReference: { id: parentId },
+                content,
+                file: { mimeType }
+            });
+        }
+
+        res.status(isNew ? 201 : 200).json(applySelect(item, req.query.$select as string));
+    });
+
+    // PUT /me/drive/items/{id}/content
+    app.put('/v1.0/me/drive/items/:itemId/content', (req: Request, res: Response) => {
+        const itemId = req.params.itemId as string;
+        let item = 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) || item.file?.mimeType || 'application/octet-stream';
+
+        item = driveStore.updateItem(item.id, { content, file: { mimeType } })!;
+        res.status(200).json(applySelect(item, req.query.$select as string));
+    });
+
+    // Delta Query
+    // GET /me/drive/root/delta
+    app.get('/v1.0/me/drive/root/delta', (req: Request, res: Response) => {
+        const tokenStr = req.query.token as string;
+
+        let token: string | undefined = undefined;
+        if (tokenStr) token = tokenStr;
+
+        const result = 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;
+};

package/src/store.ts

@@ -0,0 +1,191 @@
+import * as crypto from 'crypto';
+import { DriveItem } from './types';
+
+export class DriveStore {
+    private items: Map<string, DriveItem>;
+    // To support delta we need a linear history of items created/updated/deleted
+    private deltaHistory: DriveItem[];
+
+    constructor() {
+        this.items = new Map();
+        this.deltaHistory = [];
+    }
+
+    private calculateStats(content: unknown): { size: number, sha1Hash: string } {
+        let buffer: 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: Partial<DriveItem> & { name: string }, isFolder = false): DriveItem {
+        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: DriveItem = {
+            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: item.file?.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: string, updates: Partial<DriveItem>): DriveItem | null {
+        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: Record<string, unknown> = {};
+        if (updates.content !== undefined && item.file) {
+            const stats = this.calculateStats(updates.content);
+            statsUpdates.size = stats.size;
+            statsUpdates.file = {
+                ...item.file,
+                hashes: { sha1Hash: stats.sha1Hash }
+            };
+        }
+
+        const updatedItem: DriveItem = {
+            ...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: string): DriveItem | null {
+        return this.items.get(id) || null;
+    }
+
+    deleteItem(id: string): boolean {
+        const item = this.items.get(id);
+        if (!item) return false;
+
+        const deleted = this.items.delete(id);
+        if (deleted) {
+            const deletedItem = {
+                ...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?: string): DriveItem[] {
+        const allItems = Array.from(this.items.values());
+        if (!parentId) return allItems;
+
+        return allItems.filter(i => i.parentReference?.id === parentId);
+    }
+
+    getAllItems(): DriveItem[] {
+        return Array.from(this.items.values());
+    }
+
+    clear(): void {
+        this.items.clear();
+        this.deltaHistory = [];
+
+        // Always recreate a standard root folder
+        this.createItem({ id: 'root', name: 'root' }, true);
+    }
+
+    // Delta History (simulated changes API)
+    private addDeltaHistory(item: DriveItem) {
+        this.deltaHistory.push(JSON.parse(JSON.stringify(item)));
+    }
+
+    getDeltaToken(): string {
+        return String(this.deltaHistory.length);
+    }
+
+    getDelta(token?: string): { items: DriveItem[], deltaLink: string } {
+        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<string, DriveItem>();
+        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
+        };
+    }
+
+    private incrementParentChildCount(parentId: string, amount: number) {
+        const parent = this.items.get(parentId);
+        if (parent && parent.folder) {
+            parent.folder.childCount = Math.max(0, parent.folder.childCount + amount);
+        }
+    }
+}
+
+export const driveStore = new DriveStore();
+// Initialize root on boot
+driveStore.clear();

package/src/types.ts

@@ -0,0 +1,59 @@
+export interface AppConfig {
+    apiEndpoint?: string;
+    serverLagBefore?: number;
+    serverLagAfter?: number;
+}
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-namespace
+    namespace Express {
+        interface Request {
+            rawBody?: Buffer | string;
+        }
+    }
+}
+
+// Basic representation of a Microsoft Graph DriveItem
+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;
+
+    // Internal usage for mock state
+    content?: unknown;
+    [key: string]: unknown;
+}
+
+export interface DeltaResponse {
+    '@odata.context': string;
+    '@odata.nextLink'?: string;
+    '@odata.deltaLink'?: string;
+    value: DriveItem[];
+}