google-drive-mock 1.0.13 → 1.1.0

package/.github/workflows/release.yml

@@ -4,8 +4,8 @@ on:
   workflow_dispatch:
     inputs:
       version:
-        description: 'New Version (e.g. 1.0.0)'
-        required: true
+        description: 'New Version (e.g. 1.0.0, or leave empty for minor)'
+        required: false
         type: string
 
 jobs:
@@ -25,7 +25,15 @@ jobs:
           cache: 'npm'
 
       - run: npm install
-      - run: npm version ${{ inputs.version }} --no-git-tag-version
+      - name: Bump Version
+        id: bump
+        run: |
+            if [ -z "${{ inputs.version }}" ]; then
+              VERSION=$(npm version minor --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
@@ -38,5 +46,5 @@ jobs:
           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: ${{ inputs.version }}"
+          git commit -m "release: ${{ steps.bump.outputs.version }}"
           git push

package/dist/batch.js

@@ -100,7 +100,7 @@ function processPart(part, req) {
                 body: Object.assign({ kind: "drive#about" }, about)
             };
         }
-        // POST Create File
+        // POST Create File (Standard)
         if (part.method === 'POST' && filesListMatch) {
             if (!part.body || !part.body.name) {
                 return { contentId: part.contentId, statusCode: 400, body: { error: { code: 400, message: 'Name required' } } };

package/dist/index.js

@@ -26,7 +26,7 @@ const createApp = (config = {}) => {
     }
     const app = (0, express_1.default)();
     app.use((0, cors_1.default)({
-        exposedHeaders: ['ETag']
+        exposedHeaders: ['ETag', 'Date', 'Content-Length']
     }));
     app.set('etag', false); // Disable default ETag generation to match Real API behavior
     app.use((req, res, next) => __awaiter(void 0, void 0, void 0, function* () {

package/dist/routes/v3.js

@@ -22,7 +22,7 @@ const createV3Router = () => {
             // Enhanced query parser for Mock
             // Recursive function to handle nested OR/AND logic with parens
             const evaluateQuery = (queryStr, file) => {
-                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
                 const str = queryStr.trim();
                 if (!str)
                     return true;
@@ -136,6 +136,10 @@ const createV3Router = () => {
                     const timeStr = (_k = part.match(/modifiedTime < '(.*)'/)) === null || _k === void 0 ? void 0 : _k[1];
                     return !!(timeStr && new Date(file.modifiedTime) < new Date(timeStr));
                 }
+                if (part.startsWith("modifiedTime = '")) {
+                    const timeStr = (_l = part.match(/modifiedTime = '(.*)'/)) === null || _l === void 0 ? void 0 : _l[1];
+                    return !!(timeStr && new Date(file.modifiedTime).toISOString() === new Date(timeStr).toISOString());
+                }
                 // Fallback / Unknown
                 return true;
             };
@@ -172,10 +176,33 @@ const createV3Router = () => {
                 return 0;
             });
         }
+        // Pagination
+        const pageSize = req.query.pageSize ? parseInt(req.query.pageSize, 10) : 100; // Default 100
+        let skip = 0;
+        if (req.query.pageToken) {
+            try {
+                const tokenJson = Buffer.from(req.query.pageToken, 'base64').toString('utf-8');
+                const tokenData = JSON.parse(tokenJson);
+                if (typeof tokenData.skip === 'number') {
+                    skip = tokenData.skip;
+                }
+            }
+            catch (_a) {
+                // Ignore invalid token, start from 0
+            }
+        }
+        const totalFiles = files.length;
+        const resultFiles = files.slice(skip, skip + pageSize);
+        let nextPageToken;
+        if (skip + pageSize < totalFiles) {
+            const nextSkip = skip + pageSize;
+            nextPageToken = Buffer.from(JSON.stringify({ skip: nextSkip })).toString('base64');
+        }
         res.json({
             kind: "drive#fileList",
             incompleteSearch: false,
-            files: files
+            files: resultFiles,
+            nextPageToken
         });
     });
     // Changes: Get Start Page Token
@@ -419,8 +446,10 @@ const createV3Router = () => {
             res.status(400).send("Invalid file ID");
             return;
         }
-        const updates = req.body;
-        if (!updates) {
+        const updates = req.body || {};
+        const hasBody = Object.keys(updates).length > 0;
+        const hasQueryParams = req.query.addParents || req.query.removeParents;
+        if (!hasBody && !hasQueryParams) {
             res.status(400).json({ error: { code: 400, message: "Bad Request: No updates provided" } });
             return;
         }
@@ -429,6 +458,27 @@ const createV3Router = () => {
             res.status(404).json({ error: { code: 404, message: "File not found" } });
             return;
         }
+        const addParents = req.query.addParents;
+        if (addParents) {
+            const parentsToAdd = addParents.split(',');
+            const currentParents = updatedFile.parents || [];
+            const newParents = [...new Set([...currentParents, ...parentsToAdd])]; // Union
+            // Update the file with new parents
+            const result = store_1.driveStore.updateFile(fileId, { parents: newParents });
+            if (result) {
+                Object.assign(updatedFile, result);
+            }
+        }
+        const removeParents = req.query.removeParents;
+        if (removeParents) {
+            const parentsToRemove = removeParents.split(',');
+            const currentParents = updatedFile.parents || [];
+            const newParents = currentParents.filter(p => !parentsToRemove.includes(p));
+            const result = store_1.driveStore.updateFile(fileId, { parents: newParents });
+            if (result) {
+                Object.assign(updatedFile, result);
+            }
+        }
         res.json(updatedFile);
     });
     // Files: Delete

package/dist/store.js

@@ -81,7 +81,7 @@ class DriveStore {
         }
         // Merge updates and increment version
         const newVersion = file.version + 1;
-        const updatedFile = Object.assign(Object.assign(Object.assign(Object.assign({}, file), updates), statsUpdates), { version: newVersion, etag: String(newVersion), modifiedTime: new Date().toISOString() });
+        const updatedFile = Object.assign(Object.assign(Object.assign(Object.assign({}, file), updates), statsUpdates), { version: newVersion, etag: String(newVersion), modifiedTime: updates.modifiedTime || new Date().toISOString() });
         this.files.set(id, updatedFile);
         this.addChange(updatedFile);
         return updatedFile;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "google-drive-mock",
-  "version": "1.0.13",
+  "version": "1.1.0",
   "description": "Mock-Server that simulates being google-drive. Used for testing.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/batch.ts

@@ -133,7 +133,8 @@ function processPart(part: BatchPart, req: Request): BatchResponse {
             };
         }
 
-        // POST Create File
+
+        // POST Create File (Standard)
         if (part.method === 'POST' && filesListMatch) {
             if (!part.body || !part.body.name) {
                 return { contentId: part.contentId, statusCode: 400, body: { error: { code: 400, message: 'Name required' } } };

package/src/index.ts

@@ -14,7 +14,7 @@ const createApp = (config: AppConfig = {}) => {
 
     const app = express();
     app.use(cors({
-        exposedHeaders: ['ETag']
+        exposedHeaders: ['ETag', 'Date', 'Content-Length']
     }));
     app.set('etag', false); // Disable default ETag generation to match Real API behavior
 

package/src/routes/v3.ts

@@ -136,6 +136,10 @@ export const createV3Router = () => {
                     const timeStr = part.match(/modifiedTime < '(.*)'/)?.[1];
                     return !!(timeStr && new Date(file.modifiedTime) < new Date(timeStr));
                 }
+                if (part.startsWith("modifiedTime = '")) {
+                    const timeStr = part.match(/modifiedTime = '(.*)'/)?.[1];
+                    return !!(timeStr && new Date(file.modifiedTime).toISOString() === new Date(timeStr).toISOString());
+                }
 
                 // Fallback / Unknown
                 return true;
@@ -177,10 +181,35 @@ export const createV3Router = () => {
             });
         }
 
+        // Pagination
+        const pageSize = req.query.pageSize ? parseInt(req.query.pageSize as string, 10) : 100; // Default 100
+        let skip = 0;
+        if (req.query.pageToken) {
+            try {
+                const tokenJson = Buffer.from(req.query.pageToken as string, 'base64').toString('utf-8');
+                const tokenData = JSON.parse(tokenJson);
+                if (typeof tokenData.skip === 'number') {
+                    skip = tokenData.skip;
+                }
+            } catch {
+                // Ignore invalid token, start from 0
+            }
+        }
+
+        const totalFiles = files.length;
+        const resultFiles = files.slice(skip, skip + pageSize);
+
+        let nextPageToken: string | undefined;
+        if (skip + pageSize < totalFiles) {
+            const nextSkip = skip + pageSize;
+            nextPageToken = Buffer.from(JSON.stringify({ skip: nextSkip })).toString('base64');
+        }
+
         res.json({
             kind: "drive#fileList",
             incompleteSearch: false,
-            files: files
+            files: resultFiles,
+            nextPageToken
         });
     });
 
@@ -474,9 +503,11 @@ export const createV3Router = () => {
             res.status(400).send("Invalid file ID");
             return;
         }
-        const updates = req.body;
+        const updates = req.body || {};
+        const hasBody = Object.keys(updates).length > 0;
+        const hasQueryParams = req.query.addParents || req.query.removeParents;
 
-        if (!updates) {
+        if (!hasBody && !hasQueryParams) {
             res.status(400).json({ error: { code: 400, message: "Bad Request: No updates provided" } });
             return;
         }
@@ -488,6 +519,29 @@ export const createV3Router = () => {
             return;
         }
 
+        const addParents = req.query.addParents as string;
+        if (addParents) {
+            const parentsToAdd = addParents.split(',');
+            const currentParents = updatedFile.parents || [];
+            const newParents = [...new Set([...currentParents, ...parentsToAdd])]; // Union
+            // Update the file with new parents
+            const result = driveStore.updateFile(fileId, { parents: newParents });
+            if (result) {
+                Object.assign(updatedFile, result);
+            }
+        }
+
+        const removeParents = req.query.removeParents as string;
+        if (removeParents) {
+            const parentsToRemove = removeParents.split(',');
+            const currentParents = updatedFile.parents || [];
+            const newParents = currentParents.filter(p => !parentsToRemove.includes(p));
+            const result = driveStore.updateFile(fileId, { parents: newParents });
+            if (result) {
+                Object.assign(updatedFile, result);
+            }
+        }
+
         res.json(updatedFile);
     });
 

package/src/store.ts

@@ -114,7 +114,7 @@ export class DriveStore {
             ...statsUpdates,
             version: newVersion,
             etag: String(newVersion),
-            modifiedTime: new Date().toISOString()
+            modifiedTime: updates.modifiedTime || new Date().toISOString()
         };
         this.files.set(id, updatedFile);
         this.addChange(updatedFile);

package/test/batch_insert_download.test.ts

@@ -0,0 +1,150 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('Batch Insert and Download Test', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    // Helper from user request (adapted)
+    async function insertDocumentFiles<RxDocType>(
+        googleDriveOptions: { apiEndpoint: string, authToken: string },
+        init: { docsFolderId: string },
+        primaryPath: string,
+        docs: RxDocType[]
+    ) {
+        const boundary = "batch_" + Math.random().toString(16).slice(2);
+
+
+
+        const parts = docs.map((doc, i) => {
+            const id = (doc as Record<string, unknown>)[primaryPath] as string;
+            const body = JSON.stringify({
+                name: id + '.json',
+                mimeType: 'application/json',
+                parents: [init.docsFolderId],
+            });
+
+            return (
+                `--${boundary}\r\n` +
+                `Content-Type: application/http\r\n` +
+                `Content-ID: <item-${i}>\r\n\r\n` +
+                `POST /drive/v3/files HTTP/1.1\r\n` +
+                `Content-Type: application/json; charset=UTF-8\r\n\r\n` +
+                `${body}\r\n`
+            );
+        });
+        const batchBody = parts.join("") + `--${boundary}--`;
+        const res = await fetch(googleDriveOptions.apiEndpoint + "/batch/drive/v3", {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${googleDriveOptions.authToken}`,
+                "Content-Type": `multipart/mixed; boundary=${boundary}`,
+            },
+            body: batchBody,
+        });
+
+
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`GDR13: Batch insert failed. Status: ${res.status}. Error: ${text}`);
+        }
+        const text = await res.text();
+        console.log('Batch Response:', text.substring(0, 1000)); // Log snippet
+        return text;
+    }
+
+    it('should insert docs using batch POST and download them', async () => {
+        const docCount = 3;
+        const docs = [];
+        for (let i = 0; i < docCount; i++) {
+            docs.push({ id: `item_${Date.now()}_${i}`, data: `Data ${i}` });
+        }
+
+        console.log('Inserting docs via batch POST...');
+        const batchResponse = await insertDocumentFiles(
+            { apiEndpoint: config.baseUrl, authToken: config.token },
+            { docsFolderId: config.testFolderId },
+            'id',
+            docs
+        );
+
+        // Parse IDs from batch response?
+        // The user snippet returns raw text.
+        // We usually rely on create returning the created file metadata (including ID).
+        // Let's parse the response to get the IDs.
+
+        const boundaryMatch = (batchResponse.match(/boundary=(.+)/) || [])[1];
+        let boundary = boundaryMatch;
+        // Or inspect Content-Type header from response? Ideally yes but user helper returns body text.
+        // Let's try to detect boundary from body first line if not found?
+        // But headers are gone.
+
+        // Wait, the user helper receives the Response object and returns text().
+        // We lose headers :(.
+        // Let's assume boundary from body first line.
+        const firstLine = batchResponse.trim().split(/\r?\n/)[0];
+        if (firstLine.startsWith('--')) {
+            boundary = firstLine.substring(2).trim();
+        } else {
+            // Maybe no boundary in body if empty? unlikely for batch.
+        }
+
+        if (!boundary) throw new Error('Could not detect boundary in batch response');
+
+        const parts = batchResponse.split(`--${boundary}`);
+        const createdIds: string[] = [];
+
+        for (const part of parts) {
+            if (!part.trim() || part.trim() === '--') continue;
+            // Find JSON body
+            const jsonStart = part.indexOf('{');
+            const jsonEnd = part.lastIndexOf('}');
+            if (jsonStart !== -1 && jsonEnd !== -1) {
+                try {
+                    const jsonStr = part.substring(jsonStart, jsonEnd + 1);
+                    const file = JSON.parse(jsonStr);
+                    if (file.id) {
+                        createdIds.push(file.id);
+                    }
+
+                } catch {
+                    // ignore parse errors
+                }
+            }
+        }
+
+        expect(createdIds.length).toBe(docCount);
+        console.log(`Created ${createdIds.length} files. Downloading...`);
+
+        for (const fileId of createdIds) {
+            const downloadUrl = `${config.baseUrl}/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&supportsAllDrives=true`;
+            // console.log(`Downloading ${fileId} from ${downloadUrl}`);
+
+            const res = await fetch(downloadUrl, {
+                headers: { Authorization: `Bearer ${config.token}` }
+            });
+
+            if (!res.ok) {
+                throw new Error(`Download failed for ${fileId}: ${res.status} ${await res.text()}`);
+            }
+
+
+            const text = await res.text();
+            // console.log(`Content for ${fileId}:`, text);
+
+            // Expect empty content for metadata-only insert? 
+            // Or maybe Drive defaults to empty JSON object '{}'?
+            // Real API behavior for empty file created via metadata POST: 0 bytes.
+            expect(text).toBe('');
+        }
+
+    }, 30000);
+});

package/test/concurrent_fetch.test.ts

@@ -41,13 +41,12 @@ export async function batchFetchDocumentContentsRaw(
     }
 
     // This will be a multipart/mixed body that you must parse yourself.
-    return await res.text();
+    const text = await res.text();
+    console.log('############################# text:');
+    console.log(text);
+    return text;
 }
 
-/**
- * Parses a multipart/mixed response body from Google Drive Batch API.
- * Returns an array of objects containing { status, headers, body }.
- */
 /**
  * Parses a multipart/mixed response body from Google Drive Batch API.
  * Returns an array of objects containing { status, headers, body }.
@@ -135,7 +134,15 @@ describe('Batch Fetch Test', () => {
         if (config) config.stop();
     });
 
-    async function uploadJsonFile(name: string, content: unknown): Promise<string> {
+
+    interface TestContent {
+        index: number;
+        timestamp: number;
+        msg: string;
+        random: number;
+    }
+
+    async function uploadJsonFile(name: string, content: TestContent): Promise<string> {
         const metadata = {
             name: name,
             parents: [config.testFolderId],
@@ -175,13 +182,13 @@ describe('Batch Fetch Test', () => {
     it('should fetch content of many files in a single batch request', async () => {
         const fileCount = 5;
         const fileIds: string[] = [];
-        const expectedContents: Record<string, unknown> = {};
+        const expectedContents: Record<string, TestContent> = {};
 
         console.log(`Creating ${fileCount} files...`);
 
         for (let i = 0; i < fileCount; i++) {
             const fileName = `BatchFile_${i}_${Date.now()}.json`;
-            const content = { index: i, timestamp: Date.now(), msg: `Hello World ${i}`, random: Math.random() };
+            const content: TestContent = { index: i, timestamp: Date.now(), msg: `Hello World ${i}`, random: Math.random() };
 
             const id = await uploadJsonFile(fileName, content);
             fileIds.push(id);
@@ -215,7 +222,7 @@ describe('Batch Fetch Test', () => {
         expect(parsedResults.length).toBe(fileCount);
 
         for (const result of parsedResults) {
-            let content = result.body;
+            let content = result.body as TestContent;
 
 
             // All environments (Mock and Real) must return 302 Redirect for alt=media in batch
@@ -236,7 +243,7 @@ describe('Batch Fetch Test', () => {
             });
 
             if (!res.ok) throw new Error(`Failed to follow redirect: ${res.status} ${await res.text()}`);
-            content = await res.json();
+            content = await res.json() as TestContent;
 
 
             const expected = Object.values(expectedContents).find(c => c.index === content.index);

package/test/dates_and_sorting.test.ts

@@ -319,7 +319,6 @@ describe('Date Updates and Sorting', () => {
                 throw new Error(`Create failed: ${createRes.status} ${text}`);
             }
             const file = await createRes.json();
-            console.log('Explicit Time Check File:', JSON.stringify(file, null, 2));
             if (!file.modifiedTime) throw new Error('modifiedTime missing from response');
             const modifiedTimeCreate = new Date(file.modifiedTime).getTime();
 
@@ -468,7 +467,6 @@ describe('Date Updates and Sorting', () => {
                 body: 'Time Check Separate'
             });
             const file = await createRes.json();
-            console.log('Explicit Time Check File:', JSON.stringify(file, null, 2));
             if (!file.modifiedTime) throw new Error('modifiedTime missing from response');
             const modifiedTimeCreate = new Date(file.modifiedTime).getTime();
 

package/test/iterate_changes.test.ts

@@ -0,0 +1,408 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import {
+    getTestConfig,
+    TestConfig
+} from './config';
+import { DriveFile } from '../src/store';
+
+const randomString = () => Math.random().toString(36).substring(7);
+
+const createFileWithContent = async (name: string, content: string, config: TestConfig) => {
+    const res = await fetch(`${config.baseUrl}/upload/drive/v3/files?uploadType=media`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${config.token}`,
+            'Content-Type': 'text/plain'
+        },
+        body: content
+    });
+    const file = await res.json();
+    // V3 standard upload might not set name in body for media upload if not multipart. 
+    // But store.createFile handles it. 
+    // To be safe and ensure name is set as expected for query (though create with media upload sets name to Untitled usually),
+    // let's update it or use multipart. 
+    // actually, let's just use the patch to set name/metadata to ensure it's correct for the test.
+
+    // Better: use multipart or just update after create.
+    await fetch(`${config.baseUrl}/drive/v3/files/${file.id}`, {
+        method: 'PATCH',
+        headers: {
+            'Authorization': `Bearer ${config.token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ name })
+    });
+
+    // Fetch again to get full fields including modifiedTime
+    const getRes = await fetch(`${config.baseUrl}/drive/v3/files/${file.id}?fields=*`, {
+        headers: { 'Authorization': `Bearer ${config.token}` }
+    });
+    return await getRes.json();
+};
+
+describe('Iterate Changes Queries', () => {
+    let config: TestConfig;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+        headers = {
+            Authorization: `Bearer ${config.token}`
+        };
+    });
+
+    it('should find files where last write time was greater than X, sorted by modifiedTime and id, with limit', async () => {
+        // Create 3 files with slight delays to ensure different modifiedTimes
+        const file1 = await createFileWithContent('file1', randomString(), config);
+        await new Promise(r => setTimeout(r, 1100)); // Ensure > 1s diff for reliable sorting if seconds resolution
+        const file2 = await createFileWithContent('file2', randomString(), config);
+        await new Promise(r => setTimeout(r, 1100));
+        const file3 = await createFileWithContent('file3', randomString(), config);
+
+        // Use file1's modifiedTime as the baseline (X)
+        const timeX = file1.modifiedTime;
+
+        // Query: modifiedTime > X, orderBy modifiedTime asc, name asc (using name as proxy for ID stability in test if needed, but user asked for ID)
+        // User asked for: Sorted by write data and id. with limit
+        const q = `modifiedTime > '${timeX}' and trashed = false`;
+        const orderBy = 'modifiedTime asc, name asc';
+        const pageSize = 1;
+
+        // First page
+        const url1 = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}`;
+        const res1 = await fetch(url1, { headers });
+        if (res1.status !== 200) {
+            const txt = await res1.text();
+            console.error('Error 1:', txt);
+        }
+        expect(res1.status).toBe(200);
+        const data1 = await res1.json();
+
+        expect(data1.files.length).toBe(1);
+        expect(data1.files[0].id).toBe(file2.id);
+
+        // If we want to simulate iteration, we would use nextPageToken or just offset logic if we supported it, 
+        // but here we just test that the query works and LIMIT works.
+
+        // Verify we can get the next one if we increase limit
+        const url2 = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=2`;
+        const res2 = await fetch(url2, { headers });
+        const data2 = await res2.json();
+        expect(data2.files.length).toBe(2);
+        expect(data2.files[0].id).toBe(file2.id);
+        expect(data2.files[1].id).toBe(file3.id);
+    }, 60000);
+
+    it('should find all files where write time was equal to X, sorted by name, with limit', async () => {
+        // Create 3 files effectively at the "same" time.
+        // To do this reliably on Real API, we create one, get its time, and then PATCH the others to have that same time (if possible).
+        // However, Drive API might not allow arbitrary modifiedTime patching easily without setModifiedDate=true param or similar.
+        // Actually, V3 supports modifying modifiedTime.
+
+        const file1 = await createFileWithContent('file_B_middle', randomString(), config);
+        // Get the time from file1 to use as target
+        const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?fields=modifiedTime`, { headers });
+        const timeX = (await timeXRes.json()).modifiedTime;
+
+        // Create two more files
+        const file2 = await createFileWithContent('file_A_first', randomString(), config);
+        const file3 = await createFileWithContent('file_C_last', randomString(), config);
+
+        // Patch file2 and file3 to have the SAME modifiedTime as file1
+        // We need to wait a bit to ensure they would naturally have different times if we didn't patch, 
+        // to prove the patch worked and we are sorting by name not time.
+        await new Promise(r => setTimeout(r, 1100));
+
+        const patchBody = JSON.stringify({ modifiedTime: timeX });
+        await fetch(`${config.baseUrl}/drive/v3/files/${file2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+        await fetch(`${config.baseUrl}/drive/v3/files/${file3.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+
+        const q = `modifiedTime = '${timeX}' and trashed = false`;
+        const orderBy = 'name asc';
+        const pageSize = 10;
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}&fields=files(id,name,modifiedTime)`;
+        const res = await fetch(url, { headers });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        // Should find all 3 files
+        const relevantFiles = data.files.filter((f: DriveFile) => [file1.id, file2.id, file3.id].includes(f.id));
+        expect(relevantFiles.length).toBe(3);
+
+        // Verify they are sorted by name: A, B, C
+        expect(relevantFiles[0].name).toBe('file_A_first');
+        expect(relevantFiles[1].name).toBe('file_B_middle');
+        expect(relevantFiles[2].name).toBe('file_C_last');
+
+        // Verify times
+        relevantFiles.forEach((f: DriveFile) => {
+            if (!f.modifiedTime) {
+                console.error('Missing modifiedTime for file:', f.id, f.name);
+            }
+            expect(new Date(f.modifiedTime).toISOString()).toBe(new Date(timeX).toISOString());
+        });
+    }, 60000);
+
+    it('should find files where write time = X AND inside a specific parent folder, sorted by name', async () => {
+        // 1. Create a parent folder
+        const parentRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'ParentFolder_EqualTime_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
+        // 2. Create 3 files IN parent + 1 file OUTSIDE parent
+        // We want them all to have the SAME modifiedTime eventually.
+
+        // Create baseline file in parent
+        const file1 = await createFileWithContent('file_B_middle', randomString(), config);
+        // Move to parent
+        await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?addParents=${parentId}`, { method: 'PATCH', headers });
+
+        // Get target time
+        const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?fields=modifiedTime`, { headers });
+        const timeX = (await timeXRes.json()).modifiedTime;
+
+        // Create other files
+        const file2 = await createFileWithContent('file_A_first', randomString(), config);
+        await fetch(`${config.baseUrl}/drive/v3/files/${file2.id}?addParents=${parentId}`, { method: 'PATCH', headers });
+
+        const file3 = await createFileWithContent('file_C_last', randomString(), config);
+        await fetch(`${config.baseUrl}/drive/v3/files/${file3.id}?addParents=${parentId}`, { method: 'PATCH', headers });
+
+        const fileOutside = await createFileWithContent('file_Outside', randomString(), config);
+
+        // DELAY to ensure natural time diff, then PATCH all to timeX
+        await new Promise(r => setTimeout(r, 1100));
+
+        const patchBody = JSON.stringify({ modifiedTime: timeX });
+        await fetch(`${config.baseUrl}/drive/v3/files/${file2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+        await fetch(`${config.baseUrl}/drive/v3/files/${file3.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+        await fetch(`${config.baseUrl}/drive/v3/files/${fileOutside.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+
+        // 3. Query: modifiedTime = X AND parentId in parents
+        const q = `modifiedTime = '${timeX}' and '${parentId}' in parents and trashed = false`;
+        const orderBy = 'name asc';
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,modifiedTime,parents)`;
+        const res = await fetch(url, { headers });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        // 4. Verify results
+        // Should find file1, file2, file3
+        // Should NOT find fileOutside
+        const ids = data.files.map((f: DriveFile) => f.id);
+        expect(ids).toContain(file1.id);
+        expect(ids).toContain(file2.id);
+        expect(ids).toContain(file3.id);
+        expect(ids).not.toContain(fileOutside.id);
+        expect(data.files.length).toBe(3);
+
+        // Verify Sort Order
+        expect(data.files[0].name).toBe('file_A_first');
+        expect(data.files[1].name).toBe('file_B_middle');
+        expect(data.files[2].name).toBe('file_C_last');
+
+    }, 60000);
+
+    it('should iterate via changes tokens with specific fields', async () => {
+        // User request verification:
+        // const params = new URLSearchParams({
+        //   pageToken: checkpoint.pageToken, // we need to get a start page token first
+        //   pageSize: String(batchSize),
+        //   includeItemsFromAllDrives: "true",
+        //   supportsAllDrives: "true",
+        //   includeRemoved: "true",
+        //   fields: "changes(fileId,removed,file(id,name,parents,trashed)),nextPageToken,newStartPageToken",
+        // });
+
+        // 1. Get Start Page Token
+        const startTokenUrl = `${config.baseUrl}/drive/v3/changes/startPageToken?supportsAllDrives=true`;
+        const startTokenRes = await fetch(startTokenUrl, { headers });
+        expect(startTokenRes.status).toBe(200);
+        const startTokenData = await startTokenRes.json();
+        const startPageToken = startTokenData.startPageToken;
+        expect(startPageToken).toBeDefined();
+
+        // 2. Make some changes
+        const file1 = await createFileWithContent('change-file-1', randomString(), config);
+        await new Promise(r => setTimeout(r, 1000));
+
+        // Trash a file to test includeRemoved/removed field
+        const trashRes = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}`, {
+            method: 'PATCH',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ trashed: true })
+        });
+        expect(trashRes.status).toBe(200);
+
+        // 3. List Changes
+        const params = new URLSearchParams({
+            pageToken: startPageToken,
+            pageSize: "10",
+            includeItemsFromAllDrives: "true",
+            supportsAllDrives: "true",
+            includeRemoved: "true",
+            fields: "changes(fileId,removed,file(id,name,parents,trashed)),nextPageToken,newStartPageToken"
+        });
+
+        const listUrl = `${config.baseUrl}/drive/v3/changes?${params.toString()}`;
+        const listRes = await fetch(listUrl, { headers });
+
+        if (listRes.status !== 200) {
+            console.error('Changes List Error:', await listRes.text());
+        }
+        expect(listRes.status).toBe(200);
+        const data = await listRes.json();
+
+        expect(data.changes).toBeDefined();
+        // We expect at least the creation and trash of file1. 
+        // Note: Real API might batch them or show multiple entries.
+        // We just verify structure and presence of fields requested.
+
+        if (data.changes.length > 0) {
+            const change = data.changes[0];
+            expect(change.fileId).toBeDefined();
+            // removed can be boolean
+            expect(change.removed).toBeDefined();
+            if (!change.removed && change.file) {
+                const file = change.file as DriveFile;
+                expect(file.id).toBeDefined();
+                expect(file.name).toBeDefined();
+            }
+        }
+    }, 60000);
+
+    it('should find files where write time > X AND inside a specific parent folder', async () => {
+        // 1. Create a parent folder
+        const parentRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'ParentFolder_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parent = await parentRes.json();
+        const parentId = parent.id;
+
+        // 2. Create 3 files:
+        //    - One IN parent, modified OLD
+        //    - One IN parent, modified NEW
+        //    - One OUTSIDE parent, modified NEW
+
+        // Define "Old" and "New" times.
+        // We'll just create them sequentially with delays.
+
+        // File 1: In parent, first.
+        const file1 = await createFileWithContent('FileInParentOld', 'content1', config);
+        // Move to parent
+        const moveRes1 = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?addParents=${parentId}`, {
+            method: 'PATCH', headers
+        });
+        expect(moveRes1.status).toBe(200);
+
+        await new Promise(r => setTimeout(r, 1100));
+
+        // This time will be our X
+        // We want to find files modified > this time.
+        // So file1 should NOT be found (it is <= itself/X, or we rely on creating a checkpoint after it).
+        // Let's create a checkpoint file or just use file1's time.
+        const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${file1.id}?fields=modifiedTime`, { headers });
+        const timeXJson = await timeXRes.json();
+        const timeX = timeXJson.modifiedTime;
+
+        await new Promise(r => setTimeout(r, 1100));
+
+        // File 2: In parent, NEW (should be found)
+        const file2 = await createFileWithContent('FileInParentNew', 'content2', config);
+        const moveRes2 = await fetch(`${config.baseUrl}/drive/v3/files/${file2.id}?addParents=${parentId}`, {
+            method: 'PATCH', headers
+        });
+        expect(moveRes2.status).toBe(200);
+
+        // File 3: Outside parent, NEW (should NOT be found)
+        await createFileWithContent('FileOutsideNew', 'content3', config);
+        // (Default parent or root, explicitly not our parentId)
+
+        // 3. Query: modifiedTime > X AND 'parentId' in parents
+        const q = `modifiedTime > '${timeX}' and '${parentId}' in parents and trashed = false`;
+        const orderBy = 'modifiedTime asc, name asc';
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,parents,modifiedTime)`;
+        const res = await fetch(url, { headers });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        const matchingFiles = data.files.filter((f: DriveFile) => f.id === file2.id);
+        const nonMatchingFile1 = data.files.filter((f: DriveFile) => f.id === file1.id);
+
+        // Should find file2
+        expect(matchingFiles.length).toBe(1);
+        expect(matchingFiles[0].id).toBe(file2.id);
+
+        // Should NOT find file1 (too old)
+        expect(nonMatchingFile1.length).toBe(0);
+
+        // Should NOT find file3 (wrong parent) check manually in case it returned it
+        const file3Found = data.files.find((f: DriveFile) => f.name === 'FileOutsideNew');
+        expect(file3Found).toBeUndefined();
+
+    }, 60000);
+
+    it('should paginate through files using nextPageToken', async () => {
+        // Create files
+        const totalFiles = 6;
+        const baseName = 'PaginatedFile_' + randomString();
+        for (let i = 0; i < totalFiles; i++) {
+            await createFileWithContent(`${baseName}_${i}`, `content_${i}`, config);
+            // Small delay to ensure order if we sort by time, but we'll sort by name to be deterministic
+        }
+
+        const q = `name contains '${baseName}' and trashed = false`;
+        const orderBy = 'name asc';
+        const pageSize = 2;
+        const collectedFiles: DriveFile[] = [];
+        let pageToken: string | undefined;
+
+        // Iterate pages until no token
+        do {
+            const url: string = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&pageSize=${pageSize}` + (pageToken ? `&pageToken=${pageToken}` : '');
+            const res = await fetch(url, { headers });
+
+            if (res.status !== 200) {
+                console.error('Pagination Error:', await res.text());
+            }
+            expect(res.status).toBe(200);
+            const data = await res.json();
+
+            if (data.files) {
+                collectedFiles.push(...data.files);
+            }
+            pageToken = data.nextPageToken;
+
+            // Safety break to prevent infinite loops if API is broken
+            if (collectedFiles.length > totalFiles + 10) break;
+        } while (pageToken);
+
+        // Verify total
+        // Note: Drive API matching is eventually consistent. 
+        // We might need to retry or wait if count is not yet totalFiles, 
+        // but since we created them with delays, it usually works.
+        // If it flakes on count, we might need a retry loop wrapper around the whole test or query.
+        expect(collectedFiles.length).toBe(totalFiles);
+
+        // Verify unique IDs
+        const ids = new Set(collectedFiles.map(f => f.id));
+        expect(ids.size).toBe(totalFiles);
+
+    }, 120000); // 25 files creation might take a bit
+});

package/test/parallel_update.test.ts

@@ -0,0 +1,138 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('Parallel Content Update Test', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    // Helper from user request (adapted)
+    async function updateDocumentFiles<DocType>(
+        googleDriveOptions: { apiEndpoint: string, authToken: string },
+        primaryPath: string,
+        docs: DocType[],
+        fileIdByDocId: Record<string, string>,
+        concurrency = 5
+    ) {
+        const queue = [...docs];
+        const results: Record<string, { id: string }> = {};
+
+        async function worker() {
+            while (queue.length) {
+                const doc = queue.shift()!;
+
+                const docId = (doc as Record<string, unknown>)[primaryPath] as string;
+                const fileId = fileIdByDocId[docId];
+
+                if (!fileId) throw new Error(`File ID not found for doc ${docId}`);
+
+                const url =
+                    googleDriveOptions.apiEndpoint +
+                    `/upload/drive/v3/files/${encodeURIComponent(fileId)}` +
+                    `?uploadType=media&supportsAllDrives=true&fields=id`;
+
+                const res = await fetch(url, {
+                    method: "PATCH",
+                    headers: {
+                        Authorization: `Bearer ${googleDriveOptions.authToken}`,
+                        "Content-Type": "application/json; charset=UTF-8",
+                    },
+                    body: JSON.stringify(doc),
+                });
+
+                if (!res.ok) {
+                    const text = await res.text().catch(() => "");
+                    throw new Error(`GDR15: Update failed for ${docId}. Status: ${res.status}. Error: ${text}`);
+                }
+
+                results[docId] = await res.json(); // { id }
+            }
+        }
+
+        await Promise.all(Array.from({ length: concurrency }, () => worker()));
+        return results;
+    }
+
+
+    async function createFile(name: string, content: unknown): Promise<string> {
+        const metadata = {
+            name: name,
+            parents: [config.testFolderId],
+            mimeType: 'application/json'
+        };
+        const multipartBoundary = '-------TestBoundary' + Date.now();
+        const delimiter = '\r\n--' + multipartBoundary + '\r\n';
+        const closeDelim = '\r\n--' + multipartBoundary + '--';
+
+        const body = delimiter +
+            'Content-Type: application/json\r\n\r\n' +
+            JSON.stringify(metadata) +
+            delimiter +
+            'Content-Type: application/json\r\n\r\n' +
+            JSON.stringify(content) +
+            closeDelim;
+
+        const res = await fetch(`${config.baseUrl}/upload/drive/v3/files?uploadType=multipart&fields=id`, {
+            method: 'POST',
+            headers: {
+                Authorization: 'Bearer ' + config.token,
+                'Content-Type': 'multipart/related; boundary="' + multipartBoundary + '"'
+            },
+            body: body
+        });
+        if (!res.ok) throw new Error(`Create failed: ${res.status}`);
+        const data = await res.json();
+        return data.id;
+    }
+
+    it('should update file contents in parallel', async () => {
+        const docCount = 5;
+        const docs = [];
+        const fileIdByDocId: Record<string, string> = {};
+
+        // 1. Create initial files
+        console.log(`Creating ${docCount} initial files...`);
+        for (let i = 0; i < docCount; i++) {
+            const docId = `doc_${Date.now()}_${i}`;
+            const initialContent = { id: docId, data: 'initial' };
+            const fileName = `${docId}.json`;
+            const fileId = await createFile(fileName, initialContent);
+            fileIdByDocId[docId] = fileId;
+            docs.push({ id: docId, data: 'updated_' + i, random: Math.random() });
+        }
+
+        // 2. Run parallel update
+        console.log('Running parallel updates...');
+        await updateDocumentFiles(
+            { apiEndpoint: config.baseUrl, authToken: config.token },
+            'id',
+            docs,
+            fileIdByDocId,
+            3 // Concurrency
+        );
+
+        // 3. Verify updates
+        console.log('Verifying content...');
+        for (const doc of docs) {
+            const fileId = fileIdByDocId[doc.id];
+            const url = `${config.baseUrl}/drive/v3/files/${fileId}?alt=media`;
+            const res = await fetch(url, {
+                headers: { Authorization: `Bearer ${config.token}` }
+            });
+            if (!res.ok) throw new Error(`Download failed: ${res.status}`);
+            const downloadedContent = await res.json();
+
+            // Note: Drive might not return exact JSON identical if it adds properties?
+            // Usually strict JSON equality works.
+            expect(downloadedContent).toEqual(doc);
+        }
+
+    }, 30000);
+});

package/test/url_parameters.test.ts

@@ -0,0 +1,76 @@
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+describe('URL Parameters Test', () => {
+    let config: TestConfig;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+    });
+
+    afterAll(() => {
+        if (config) config.stop();
+    });
+
+    it('should download file content using alt=media and supportsAllDrives=true', async () => {
+        const fileName = `UrlParamTest_${Date.now()}.json`;
+        const content = { msg: 'Hello World', timestamp: Date.now() };
+
+        // 1. Upload File
+        const metadata = {
+            name: fileName,
+            parents: [config.testFolderId],
+            mimeType: 'application/json'
+        };
+
+        const multipartBoundary = '-------TestBoundary' + Date.now();
+        const delimiter = '\r\n--' + multipartBoundary + '\r\n';
+        const closeDelim = '\r\n--' + multipartBoundary + '--';
+
+        const body = delimiter +
+            'Content-Type: application/json\r\n\r\n' +
+            JSON.stringify(metadata) +
+            delimiter +
+            'Content-Type: application/json\r\n\r\n' +
+            JSON.stringify(content) +
+            closeDelim;
+
+        const uploadUrl = `${config.baseUrl}/upload/drive/v3/files?uploadType=multipart&fields=id`;
+        const uploadRes = await fetch(uploadUrl, {
+            method: 'POST',
+            headers: {
+                Authorization: 'Bearer ' + config.token,
+                'Content-Type': 'multipart/related; boundary="' + multipartBoundary + '"'
+            },
+            body: body
+        });
+
+        if (!uploadRes.ok) {
+            throw new Error(`Failed to upload file. Status: ${uploadRes.status} ${await uploadRes.text()}`);
+        }
+
+        const data = await uploadRes.json();
+        const fileId = data.id;
+        expect(fileId).toBeDefined();
+
+        // 2. Download with specific URL parameters
+        const downloadUrl = `${config.baseUrl}/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&supportsAllDrives=true`;
+        console.log('Downloading from:', downloadUrl);
+
+        const res = await fetch(downloadUrl, {
+            method: 'GET',
+            headers: {
+                Authorization: 'Bearer ' + config.token
+            }
+        });
+
+        if (!res.ok) {
+            throw new Error(`Failed to download file. Status: ${res.status} ${await res.text()}`);
+        }
+
+        const downloadedContent = await res.json();
+        expect(downloadedContent).toEqual(content);
+
+    }, 30000);
+});