google-drive-mock 0.0.1

package/.ENV_EXAMPLE

@@ -0,0 +1,15 @@
+# To run tests against the real Google Drive API
+# Copy this file to .ENV and fill in the values
+
+# 'mock' (default) or 'real'
+TEST_TARGET=real
+
+# OAuth2 Access Token for your Google Account
+# Get one via 'npm run example:login'
+GDRIVE_TOKEN=ya29.a0...
+
+# Optional: Simulate latency in ms (only works with TEST_TARGET=mock)
+# LATENCY=50
+
+# Client ID for the Google Login Example
+# GDRIVE_CLIENT_ID=...

package/.aiexclude

@@ -0,0 +1,6 @@
+node_modules/**
+dist/**
+.env
+.git/**
+coverage/**
+test/__screenshots__/

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,24 @@
+name: Release
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    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
+      - run: npm run build
+      - run: npm run lint
+      - run: npm test
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/AGENTS.md

@@ -0,0 +1,9 @@
+# AI Instructions
+
+Always run the following commands after making changes to the codebase to ensure integrity:
+
+1. `npm run build`
+2. `npm run lint`
+3. `npm test`
+4. `npm test:browser`
+5. `npm test:real`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniel Meyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# google-drive-mock
+![google-drive-mock](google-drive-mock.png)
+
+<br />
+
+<p style="text-align: center;">
+Mock-Server that simulates being google-drive.<br />
+Used for testing the <a href="https://rxdb.info/" target="_blank">RxDB Google-Drive-Sync</a>.<br />
+Mostly Vibe-Coded.<br />
+</p>
+
+
+## Installation
+
+```bash
+npm install google-drive-mock
+```
+
+## Usage
+
+```typescript
+import { startServer } from 'google-drive-mock';
+
+// start the server
+const port = 3000;
+const server = startServer(port);
+
+// Store a file
+const createResponse = await fetch('http://localhost:3000/drive/v3/files', {
+    method: 'POST',
+    headers: {
+        'Authorization': 'Bearer valid-token',
+        'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+        name: 'test-file.txt',
+        mimeType: 'text/plain'
+    })
+});
+const file = await createResponse.json();
+console.log('Created File:', file);
+
+// Read the file
+const readResponse = await fetch(`http://localhost:3000/drive/v3/files/${file.id}`, {
+    method: 'GET',
+    headers: {
+        'Authorization': 'Bearer valid-token'
+    }
+});
+const fileContent = await readResponse.json();
+console.log('Read File:', fileContent);
+
+// Stop the server
+server.close();
+
+```
+
+## Tech
+
+- TypeScript
+- Express
+- Vitest
+
+## Browser Testing
+
+To run tests inside a headless browser (Chromium):
+
+```bash
+npm run test:browser
+```
+
+## Real Google Drive API Testing
+
+To run tests against the real Google Drive API instead of the mock:
+
+1. Create a `.ENV` file (see `.ENV_EXAMPLE`):
+   ```
+   TEST_TARGET=real
+   GDRIVE_TOKEN=your-access-token
+   ```
+2. Run tests:
+   ```bash
+   npm test:real
+   ```
+
+## Contributing
+
+GitHub issues for this project are closed. If you find a bug, please create a Pull Request with a test case reproducing the issue.
+

package/dist/batch.d.ts

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

package/dist/batch.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBatchRequest = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const store_1 = require("./store");
+const handleBatchRequest = (req, res) => {
+    const contentType = req.headers['content-type'];
+    if (!contentType || !contentType.includes('multipart/mixed')) {
+        return res.status(400).send('Content-Type must be multipart/mixed');
+    }
+    const boundaryMatch = contentType.match(/boundary=(.+)/);
+    if (!boundaryMatch) {
+        return res.status(400).send('Multipart boundary missing');
+    }
+    let boundary = boundaryMatch[1];
+    // Boundaries in header can be quoted
+    if (boundary.startsWith('"') && boundary.endsWith('"')) {
+        boundary = boundary.substring(1, boundary.length - 1);
+    }
+    const rawBody = req.body;
+    if (typeof rawBody !== 'string') {
+        return res.status(400).send('Body parsing failed');
+    }
+    const parts = parseMultipart(rawBody, boundary);
+    const responses = [];
+    for (const part of parts) {
+        const response = processPart(part);
+        responses.push(response);
+    }
+    const responseBoundary = `batch_${Math.random().toString(36).substring(2)}`;
+    const responseBody = buildMultipartResponse(responses, responseBoundary);
+    res.set('Content-Type', `multipart/mixed; boundary=${responseBoundary}`);
+    res.end(responseBody);
+};
+exports.handleBatchRequest = handleBatchRequest;
+function parseMultipart(body, boundary) {
+    const parts = [];
+    // Split by --boundary
+    // Note: The last part ends with --boundary--
+    const rawParts = body.split(`--${boundary}`);
+    for (const rawPart of rawParts) {
+        // Skip empty or end parts
+        if (rawPart.trim() === '' || rawPart.trim() === '--')
+            continue;
+        // Parse outer headers
+        const sections = rawPart.trim().split(/\r?\n\r?\n/);
+        const headersSection = sections[0];
+        const rest = sections.slice(1);
+        let contentId = '';
+        const headerLines = headersSection.split(/\r?\n/);
+        for (const line of headerLines) {
+            if (line.toLowerCase().startsWith('content-id:')) {
+                contentId = line.split(':')[1].trim();
+            }
+        }
+        const httpContent = rest.join('\r\n\r\n'); // Reconstruct body if multiple parts? 
+        if (!httpContent && sections.length < 2)
+            continue; // No body?
+        // Ideally, httpContent is the rest. 
+        // But if we split by double newline, we might have split the inner body too.
+        // Better: Find first double newline index manually.
+        // ... (Rewriting loop to be safer)
+        const firstDoubleNewline = rawPart.indexOf('\r\n\r\n');
+        const firstDoubleNewlineLF = rawPart.indexOf('\n\n');
+        let splitIndex = -1;
+        let splitLen = 0;
+        if (firstDoubleNewline !== -1) {
+            splitIndex = firstDoubleNewline;
+            splitLen = 4;
+        }
+        else if (firstDoubleNewlineLF !== -1) {
+            splitIndex = firstDoubleNewlineLF;
+            splitLen = 2;
+        }
+        if (splitIndex === -1)
+            continue;
+        const headersStr = rawPart.substring(0, splitIndex).trim();
+        const bodyStr = rawPart.substring(splitIndex + splitLen); // No trim on body?
+        // Parse outer headers
+        const hLines = headersStr.split(/\r?\n/);
+        for (const line of hLines) {
+            if (line.toLowerCase().startsWith('content-id:')) {
+                contentId = line.split(':')[1].trim();
+            }
+        }
+        if (!bodyStr)
+            continue;
+        // Inner HTTP part
+        // Same logic for inner split
+        const innerSplitIndexCRLF = bodyStr.indexOf('\r\n\r\n');
+        const innerSplitIndexLF = bodyStr.indexOf('\n\n');
+        let innerSplitIndex = -1;
+        let innerSplitLen = 0;
+        if (innerSplitIndexCRLF !== -1) {
+            innerSplitIndex = innerSplitIndexCRLF;
+            innerSplitLen = 4;
+        }
+        else if (innerSplitIndexLF !== -1 && (innerSplitIndexCRLF === -1 || innerSplitIndexLF < innerSplitIndexCRLF)) {
+            innerSplitIndex = innerSplitIndexLF;
+            innerSplitLen = 2;
+        }
+        // If NO header terminator found in inner body, maybe no headers? (But request line exists)
+        // Request line is mandatory.
+        let requestLine = '';
+        let innerHeadersStr = '';
+        let httpBody = '';
+        if (innerSplitIndex !== -1) {
+            const head = bodyStr.substring(0, innerSplitIndex);
+            httpBody = bodyStr.substring(innerSplitIndex + innerSplitLen);
+            const lines = head.split(/\r?\n/);
+            requestLine = lines[0];
+            innerHeadersStr = lines.slice(1).join('\n');
+        }
+        else {
+            // Maybe no body? Just headers?
+            const lines = bodyStr.trim().split(/\r?\n/);
+            requestLine = lines[0];
+            innerHeadersStr = lines.slice(1).join('\n');
+            httpBody = '';
+        }
+        const [method, url] = requestLine.split(' ');
+        // Parse inner headers
+        const headers = {};
+        const innerHLines = innerHeadersStr.split(/\r?\n/);
+        for (const line of innerHLines) {
+            const [key, ...value] = line.split(':');
+            if (key)
+                headers[key.toLowerCase()] = value.join(':').trim();
+        }
+        let parsedBody;
+        if (httpBody && httpBody.trim()) {
+            try {
+                parsedBody = JSON.parse(httpBody);
+            }
+            catch (_a) {
+                parsedBody = httpBody;
+            }
+        }
+        // Clean URL (remove prefix if present, though clients usually send relative path)
+        // Ensure /drive/v3/files...
+        parts.push({
+            contentId,
+            method,
+            url,
+            headers,
+            body: parsedBody
+        });
+    }
+    return parts;
+}
+function processPart(part) {
+    // Simple logic dispatch
+    // We only support /drive/v3/files operations basically
+    // Helper to match URL (Simplified for mock)
+    const fileIdMatch = part.url.match(/\/drive\/v3\/files\/([^/?]+)/);
+    const filesListMatch = part.url.match(/\/drive\/v3\/files/); // Matches /drive/v3/files?q=... or just .../files
+    const aboutMatch = part.url.match(/\/drive\/v3\/about/);
+    try {
+        // GET File
+        if (part.method === 'GET' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const file = store_1.driveStore.getFile(fileId);
+            if (!file)
+                return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 200, body: file };
+        }
+        // GET Files List
+        if (part.method === 'GET' && filesListMatch && !fileIdMatch) {
+            const files = store_1.driveStore.listFiles();
+            return {
+                contentId: part.contentId,
+                statusCode: 200,
+                body: {
+                    kind: "drive#fileList",
+                    incompleteSearch: false,
+                    files: files
+                }
+            };
+        }
+        // GET About
+        if (part.method === 'GET' && aboutMatch) {
+            const about = store_1.driveStore.getAbout();
+            return {
+                contentId: part.contentId,
+                statusCode: 200,
+                body: Object.assign({ kind: "drive#about" }, about)
+            };
+        }
+        // POST Create File
+        if (part.method === 'POST' && filesListMatch) {
+            if (!part.body || !part.body.name) {
+                return { contentId: part.contentId, statusCode: 400, body: { error: { code: 400, message: 'Name required' } } };
+            }
+            const newFile = store_1.driveStore.createFile({
+                name: part.body.name,
+                mimeType: part.body.mimeType,
+                parents: part.body.parents
+            });
+            return { contentId: part.contentId, statusCode: 200, body: newFile };
+        }
+        if (part.method === 'PATCH' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const updated = store_1.driveStore.updateFile(fileId, part.body);
+            if (!updated)
+                return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 200, body: updated };
+        }
+        if (part.method === 'DELETE' && fileIdMatch) {
+            const fileId = fileIdMatch[1];
+            const deleted = store_1.driveStore.deleteFile(fileId);
+            if (!deleted)
+                return { contentId: part.contentId, statusCode: 404, body: { error: { code: 404, message: 'File not found' } } };
+            return { contentId: part.contentId, statusCode: 204 }; // No body
+        }
+        return { contentId: part.contentId, statusCode: 404, body: { error: { message: "Not handler found for batch request url " + part.url } } };
+    }
+    catch (e) {
+        return { contentId: part.contentId, statusCode: 500, body: { error: { message: e.message } } };
+    }
+}
+function buildMultipartResponse(responses, boundary) {
+    let output = '';
+    for (const response of responses) {
+        output += `--${boundary}\r\n`;
+        output += `Content-Type: application/http\r\n`;
+        output += `Content-ID: ${response.contentId}\r\n\r\n`;
+        output += `HTTP/1.1 ${response.statusCode} OK\r\n`; // Simplified status text
+        output += `Content-Type: application/json; charset=UTF-8\r\n\r\n`;
+        if (response.body) {
+            output += JSON.stringify(response.body) + '\r\n';
+        }
+        output += '\r\n';
+    }
+    output += `--${boundary}--`;
+    return output;
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+interface AppConfig {
+    serverLagBefore?: number;
+    serverLagAfter?: number;
+}
+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 };

package/dist/index.js

@@ -0,0 +1,186 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = exports.createApp = void 0;
+const express_1 = __importDefault(require("express"));
+const store_1 = require("./store");
+const batch_1 = require("./batch");
+const createApp = (config = {}) => {
+    const app = (0, express_1.default)();
+    app.use((req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        if (config.serverLagBefore && config.serverLagBefore > 0) {
+            yield new Promise(resolve => setTimeout(resolve, config.serverLagBefore));
+        }
+        if (config.serverLagAfter && config.serverLagAfter > 0) {
+            const originalSend = res.send;
+            res.send = function (...args) {
+                setTimeout(() => {
+                    originalSend.apply(res, args);
+                }, config.serverLagAfter);
+                return res;
+            };
+        }
+        next();
+    }));
+    app.use(express_1.default.json());
+    app.use(express_1.default.text({ type: 'multipart/mixed' }));
+    // Batch Route
+    app.post('/batch', batch_1.handleBatchRequest);
+    // Debug Route (for testing)
+    app.post('/debug/clear', (req, res) => {
+        store_1.driveStore.clear();
+        res.status(200).send('Cleared');
+    });
+    // Auth Middleware
+    const validTokens = ['valid-token', 'another-valid-token'];
+    app.use((req, res, next) => {
+        const authHeader = req.headers.authorization;
+        if (!authHeader) {
+            res.status(401).json({ error: { code: 401, message: "Unauthorized: No token provided" } });
+            return;
+        }
+        const token = authHeader.split(' ')[1];
+        if (!validTokens.includes(token)) {
+            res.status(401).json({ error: { code: 401, message: "Unauthorized: Invalid token" } });
+            return;
+        }
+        next();
+    });
+    // Middleware to simulate some Google API behaviors (optional, can be expanded)
+    // About
+    app.get('/drive/v3/about', (req, res) => {
+        const about = store_1.driveStore.getAbout();
+        res.json(Object.assign({ kind: "drive#about" }, about));
+    });
+    // Files: List
+    app.get('/drive/v3/files', (req, res) => {
+        const files = store_1.driveStore.listFiles();
+        res.json({
+            kind: "drive#fileList",
+            incompleteSearch: false,
+            files: files
+        });
+    });
+    // Files: Create
+    app.post('/drive/v3/files', (req, res) => {
+        const body = req.body;
+        if (!body || !body.name) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: Name is required" } });
+            return;
+        }
+        // Enforce Unique Name Constraint (Mock Behavior customization)
+        const existing = store_1.driveStore.listFiles().find(f => f.name === body.name);
+        if (existing) {
+            res.status(409).json({ error: { code: 409, message: "Conflict: File with same name already exists" } });
+            return;
+        }
+        const newFile = store_1.driveStore.createFile({
+            name: body.name,
+            mimeType: body.mimeType || "application/octet-stream",
+            parents: body.parents || []
+        });
+        res.status(200).json(newFile);
+    });
+    // Files: Get
+    app.get('/drive/v3/files/:fileId', (req, res) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        const file = store_1.driveStore.getFile(fileId);
+        if (!file) {
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+        const etag = `"${file.version}"`;
+        res.setHeader('ETag', etag);
+        if (req.headers['if-none-match'] === etag) {
+            res.status(304).end();
+            return;
+        }
+        res.json(file);
+    });
+    // Files: Update
+    app.patch('/drive/v3/files/:fileId', (req, res) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        const updates = req.body;
+        if (!updates) {
+            res.status(400).json({ error: { code: 400, message: "Bad Request: No updates provided" } });
+            return;
+        }
+        // Check for Precondition (If-Match)
+        // Note: Real Google Drive API V3 was observed to allow overwrites (status 200) 
+        // on PATCH even with mismatching If-Match headers (likely due to ETag generation nuances).
+        // Relaxing Mock to match Real API behavior (Last Write Wins).
+        /*
+        const existingFile = driveStore.getFile(fileId);
+        if (existingFile) {
+            const ifMatch = req.headers['if-match'];
+            if (ifMatch && ifMatch !== '*' && ifMatch !== `"${existingFile.version}"`) {
+                res.status(412).json({ error: { code: 412, message: "Precondition Failed" } });
+                return;
+            }
+        }
+        */
+        const updatedFile = store_1.driveStore.updateFile(fileId, updates);
+        if (!updatedFile) {
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+        res.json(updatedFile);
+    });
+    // Files: Delete
+    app.delete('/drive/v3/files/:fileId', (req, res) => {
+        const fileId = req.params.fileId;
+        if (typeof fileId !== 'string') {
+            res.status(400).send("Invalid file ID");
+            return;
+        }
+        // Check for Precondition (If-Match)
+        const existingFile = store_1.driveStore.getFile(fileId);
+        if (existingFile) {
+            const ifMatch = req.headers['if-match'];
+            if (ifMatch && ifMatch !== '*' && ifMatch !== `"${existingFile.version}"`) {
+                res.status(412).json({ error: { code: 412, message: "Precondition Failed" } });
+                return;
+            }
+        }
+        const deleted = store_1.driveStore.deleteFile(fileId);
+        if (!deleted) {
+            // According to Google API, delete might return 404 if not found, or 204 if successful (or 200). 
+            // Docs says "If successful, this method returns an empty response body." usually 204.
+            // But if not found:
+            res.status(404).json({ error: { code: 404, message: "File not found" } });
+            return;
+        }
+        res.status(204).send();
+    });
+    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) {
+    startServer(3000);
+}

package/dist/store.d.ts

@@ -0,0 +1,23 @@
+export interface DriveFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    kind: string;
+    parents?: string[];
+    version: number;
+    [key: string]: unknown;
+}
+export declare class DriveStore {
+    private files;
+    constructor();
+    createFile(file: Partial<DriveFile> & {
+        name: string;
+    }): DriveFile;
+    updateFile(id: string, updates: Partial<DriveFile>): DriveFile | null;
+    getFile(id: string): DriveFile | null;
+    deleteFile(id: string): boolean;
+    listFiles(): DriveFile[];
+    clear(): void;
+    getAbout(): object;
+}
+export declare const driveStore: DriveStore;