google-drive-mock 1.1.0 → 1.1.2

package/.agent/rules/project-guidelines.md

@@ -18,6 +18,11 @@ When working on this project, always adhere to the following workflow to ensure
    - Run this **AFTER** verifying the tests against the Real API.
    - This ensures that the Mock server implementation correctly handles the now-verified tests.
 
+4. **Ensure build works**
+  - Run "npm run lint"
+  - Run "npm run build"
+
+
 
 No Goes:
 

package/.github/workflows/release.yml

@@ -4,7 +4,7 @@ on:
   workflow_dispatch:
     inputs:
       version:
-        description: 'New Version (e.g. 1.0.0, or leave empty for minor)'
+        description: 'New Version (e.g. 1.0.0, or leave empty for patch)'
         required: false
         type: string
 
@@ -29,7 +29,7 @@ jobs:
         id: bump
         run: |
             if [ -z "${{ inputs.version }}" ]; then
-              VERSION=$(npm version minor --no-git-tag-version)
+              VERSION=$(npm version patch --no-git-tag-version)
             else
               VERSION=$(npm version ${{ inputs.version }} --no-git-tag-version)
             fi

package/dist/index.js

@@ -29,6 +29,14 @@ const createApp = (config = {}) => {
         exposedHeaders: ['ETag', 'Date', 'Content-Length']
     }));
     app.set('etag', false); // Disable default ETag generation to match Real API behavior
+    // Random delay to simulate real-world network latency (0-20ms)
+    app.use((req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+        const delay = Math.floor(Math.random() * 21); // 0 to 20ms
+        if (delay > 0) {
+            yield new Promise(resolve => setTimeout(resolve, delay));
+        }
+        next();
+    }));
     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));

package/dist/mappers.d.ts

@@ -7,3 +7,11 @@ export declare function toV2File(file: DriveFile): Record<string, unknown>;
  * Maps a V2 API File Update/Insert body to a partial Internal DriveFile (V3 format).
  */
 export declare function fromV2Update(body: Record<string, unknown>): Partial<DriveFile>;
+/**
+ * Filters an object based on the Google Drive API `fields` parameter.
+ * Supports nested fields like "files(id,name,parents)".
+ *
+ * @param data The object to filter
+ * @param fields The fields selection string
+ */
+export declare function applyFields(data: unknown, fields: string): unknown;

package/dist/mappers.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toV2File = toV2File;
 exports.fromV2Update = fromV2Update;
+exports.applyFields = applyFields;
 /**
  * Maps an internal DriveFile (V3 format) to a V2 API File resource.
  */
@@ -61,3 +62,81 @@ function fromV2Update(body) {
     }
     return update;
 }
+/**
+ * Filters an object based on the Google Drive API `fields` parameter.
+ * Supports nested fields like "files(id,name,parents)".
+ *
+ * @param data The object to filter
+ * @param fields The fields selection string
+ */
+function applyFields(data, fields) {
+    if (!fields || fields === '*')
+        return data;
+    // Parse top-level fields
+    const parsedFields = [];
+    let depth = 0;
+    let currentStart = 0;
+    for (let i = 0; i < fields.length; i++) {
+        const char = fields[i];
+        if (char === '(')
+            depth++;
+        else if (char === ')')
+            depth--;
+        else if (char === ',' && depth === 0) {
+            // Split
+            parseFieldPart(fields.substring(currentStart, i), parsedFields);
+            currentStart = i + 1;
+        }
+    }
+    // Last part
+    parseFieldPart(fields.substring(currentStart), parsedFields);
+    if (Array.isArray(data)) {
+        // If data is array, apply to each item?
+        // Usually fields selection on array applies to the object WRAPPING the array, 
+        // e.g. "files(id)" on { files: [...] }.
+        // But if we are called RESURSIVELY on an array value, we should map it.
+        return data.map(item => applyFields(item, fields));
+    }
+    if (typeof data !== 'object' || data === null) {
+        return data;
+    }
+    const dataObj = data;
+    const result = {};
+    for (const field of parsedFields) {
+        if (field.key === '*') {
+            // Wildcard at this level - copy everything? 
+            // Logic can be complex. For now, strict parity with requested use case.
+            return data;
+        }
+        if (Object.prototype.hasOwnProperty.call(dataObj, field.key)) {
+            const value = dataObj[field.key];
+            if (field.subFields) {
+                // Recursive apply
+                if (Array.isArray(value)) {
+                    result[field.key] = value.map((item) => applyFields(item, field.subFields));
+                }
+                else {
+                    result[field.key] = applyFields(value, field.subFields);
+                }
+            }
+            else {
+                result[field.key] = value;
+            }
+        }
+    }
+    return result;
+}
+function parseFieldPart(part, result) {
+    const trimmed = part.trim();
+    if (!trimmed)
+        return;
+    const parenStart = trimmed.indexOf('(');
+    if (parenStart !== -1 && trimmed.endsWith(')')) {
+        const key = trimmed.substring(0, parenStart);
+        const subFields = trimmed.substring(parenStart + 1, trimmed.length - 1);
+        result.push({ key, subFields });
+    }
+    else {
+        result.push({ key: trimmed });
+    }
+}

package/dist/routes/v3.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createV3Router = void 0;
 const express_1 = __importDefault(require("express"));
 const store_1 = require("../store");
+const mappers_1 = require("../mappers");
 const createV3Router = () => {
     const app = express_1.default.Router();
     // About
@@ -22,7 +23,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, _l;
+                var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
                 const str = queryStr.trim();
                 if (!str)
                     return true;
@@ -140,6 +141,10 @@ const createV3Router = () => {
                     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());
                 }
+                if (part.startsWith("modifiedTime >= '")) {
+                    const timeStr = (_m = part.match(/modifiedTime >= '(.*)'/)) === null || _m === void 0 ? void 0 : _m[1];
+                    return !!(timeStr && new Date(file.modifiedTime) >= new Date(timeStr));
+                }
                 // Fallback / Unknown
                 return true;
             };
@@ -198,12 +203,19 @@ const createV3Router = () => {
             const nextSkip = skip + pageSize;
             nextPageToken = Buffer.from(JSON.stringify({ skip: nextSkip })).toString('base64');
         }
-        res.json({
+        const response = {
             kind: "drive#fileList",
             incompleteSearch: false,
             files: resultFiles,
             nextPageToken
-        });
+        };
+        const fields = req.query.fields;
+        if (fields) {
+            res.json((0, mappers_1.applyFields)(response, fields));
+        }
+        else {
+            res.json(response);
+        }
     });
     // Changes: Get Start Page Token
     app.get('/drive/v3/changes/startPageToken', (req, res) => {

package/package.json

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

package/src/index.ts

@@ -18,6 +18,15 @@ const createApp = (config: AppConfig = {}) => {
     }));
     app.set('etag', false); // Disable default ETag generation to match Real API behavior
 
+    // Random delay to simulate real-world network latency (0-20ms)
+    app.use(async (req, res, next) => {
+        const delay = Math.floor(Math.random() * 21); // 0 to 20ms
+        if (delay > 0) {
+            await new Promise(resolve => setTimeout(resolve, delay));
+        }
+        next();
+    });
+
     app.use(async (req, res, next) => {
         if (config.serverLagBefore && config.serverLagBefore > 0) {
             await new Promise(resolve => setTimeout(resolve, config.serverLagBefore));

package/src/mappers.ts

@@ -59,3 +59,87 @@ export function fromV2Update(body: Record<string, unknown>): Partial<DriveFile>
 
     return update;
 }
+
+
+/**
+ * Filters an object based on the Google Drive API `fields` parameter.
+ * Supports nested fields like "files(id,name,parents)".
+ * 
+ * @param data The object to filter
+ * @param fields The fields selection string
+ */
+export function applyFields(data: unknown, fields: string): unknown {
+    if (!fields || fields === '*') return data;
+
+    // Parse top-level fields
+    const parsedFields: { key: string, subFields?: string }[] = [];
+
+    let depth = 0;
+    let currentStart = 0;
+
+    for (let i = 0; i < fields.length; i++) {
+        const char = fields[i];
+        if (char === '(') depth++;
+        else if (char === ')') depth--;
+        else if (char === ',' && depth === 0) {
+            // Split
+            parseFieldPart(fields.substring(currentStart, i), parsedFields);
+            currentStart = i + 1;
+        }
+    }
+    // Last part
+    parseFieldPart(fields.substring(currentStart), parsedFields);
+
+    if (Array.isArray(data)) {
+        // If data is array, apply to each item?
+        // Usually fields selection on array applies to the object WRAPPING the array, 
+        // e.g. "files(id)" on { files: [...] }.
+        // But if we are called RESURSIVELY on an array value, we should map it.
+        return data.map(item => applyFields(item, fields));
+    }
+
+    if (typeof data !== 'object' || data === null) {
+        return data;
+    }
+
+    const dataObj = data as Record<string, unknown>;
+    const result: Record<string, unknown> = {};
+
+    for (const field of parsedFields) {
+        if (field.key === '*') {
+            // Wildcard at this level - copy everything? 
+            // Logic can be complex. For now, strict parity with requested use case.
+            return data;
+        }
+
+        if (Object.prototype.hasOwnProperty.call(dataObj, field.key)) {
+            const value = dataObj[field.key];
+            if (field.subFields) {
+                // Recursive apply
+                if (Array.isArray(value)) {
+                    result[field.key] = value.map((item: unknown) => applyFields(item, field.subFields!));
+                } else {
+                    result[field.key] = applyFields(value, field.subFields!);
+                }
+            } else {
+                result[field.key] = value;
+            }
+        }
+    }
+
+    return result;
+}
+
+function parseFieldPart(part: string, result: { key: string, subFields?: string }[]) {
+    const trimmed = part.trim();
+    if (!trimmed) return;
+
+    const parenStart = trimmed.indexOf('(');
+    if (parenStart !== -1 && trimmed.endsWith(')')) {
+        const key = trimmed.substring(0, parenStart);
+        const subFields = trimmed.substring(parenStart + 1, trimmed.length - 1);
+        result.push({ key, subFields });
+    } else {
+        result.push({ key: trimmed });
+    }
+}

package/src/routes/v3.ts

@@ -1,5 +1,6 @@
 import express, { Request, Response } from 'express';
 import { driveStore } from '../store';
+import { applyFields } from '../mappers';
 
 export const createV3Router = () => {
     const app = express.Router();
@@ -140,6 +141,10 @@ export const createV3Router = () => {
                     const timeStr = part.match(/modifiedTime = '(.*)'/)?.[1];
                     return !!(timeStr && new Date(file.modifiedTime).toISOString() === new Date(timeStr).toISOString());
                 }
+                if (part.startsWith("modifiedTime >= '")) {
+                    const timeStr = part.match(/modifiedTime >= '(.*)'/)?.[1];
+                    return !!(timeStr && new Date(file.modifiedTime) >= new Date(timeStr));
+                }
 
                 // Fallback / Unknown
                 return true;
@@ -205,12 +210,19 @@ export const createV3Router = () => {
             nextPageToken = Buffer.from(JSON.stringify({ skip: nextSkip })).toString('base64');
         }
 
-        res.json({
+        const response: Record<string, unknown> = {
             kind: "drive#fileList",
             incompleteSearch: false,
             files: resultFiles,
             nextPageToken
-        });
+        };
+
+        const fields = req.query.fields as string;
+        if (fields) {
+            res.json(applyFields(response, fields));
+        } else {
+            res.json(response);
+        }
     });
 
     // Changes: Get Start Page Token

package/test/folder_query.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+const randomString = () => Math.random().toString(36).substring(7);
+
+describe('Folder Query Investigation', () => {
+    let config: TestConfig;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+        headers = {
+            Authorization: `Bearer ${config.token}`
+        };
+    });
+
+    it('should return files in a folder with specific query parameters', 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: 'QueryTestParams_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
+        // 2. Create a few files in the folder
+        const file1 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'file1',
+                parents: [parentId]
+            })
+        }).then(res => res.json());
+
+        const file2 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'file2',
+                parents: [parentId]
+            })
+        }).then(res => res.json());
+
+        // Wait for consistency
+        await new Promise(r => setTimeout(r, 2000));
+
+        // 3. Run the user's specific query
+        const queryParts = [
+            `'${parentId}' in parents`,
+            `and trashed = false`
+        ];
+
+        // Optional: Add modifiedTime check if needed, but let's start with basic structure
+        // const checkpoint = { modifiedTime: '...' };
+        // if (checkpoint) {
+        //     queryParts.push(`and modifiedTime >= '${checkpoint.modifiedTime}'`);
+        // }
+
+        const batchSize = 10;
+        const params = new URLSearchParams({
+            q: queryParts.join(' '),
+            pageSize: (batchSize + 10) + '',
+            orderBy: "modifiedTime asc,name asc",
+            fields: "files(id,name,mimeType,parents,modifiedTime,size)",
+            supportsAllDrives: "true",
+            includeItemsFromAllDrives: "true",
+        });
+
+        const url =
+            config.baseUrl +
+            "/drive/v3/files?" +
+            params.toString();
+
+        console.log('Requesting URL:', url);
+
+        const res = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${config.token}`,
+            },
+        });
+
+        if (res.status !== 200) {
+            console.error('Error response:', await res.text());
+        }
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        console.log('Found files:', data.files.length);
+        const ids = data.files.map((f: { id: string }) => f.id);
+        expect(ids).toContain(file1.id);
+        expect(ids).toContain(file2.id);
+
+        // Check if fields are returned
+        const f1 = data.files.find((f: { id: string }) => f.id === file1.id) as Record<string, unknown>;
+        expect(f1.name).toBeDefined();
+        expect(f1.modifiedTime).toBeDefined();
+        expect(f1.parents).toBeDefined();
+        expect(f1.parents).toContain(parentId);
+
+        // Strict key check
+        const expectedKeys = ['id', 'name', 'mimeType', 'parents', 'modifiedTime', 'size'].sort();
+        const actualKeys = Object.keys(f1).sort();
+
+        // Log for debugging if they don't match (Vitest will show diff)
+        if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys)) {
+            console.log('Keys mismatch! Actual:', actualKeys);
+        }
+        expect(actualKeys).toEqual(expectedKeys);
+
+    }, 60000);
+
+    it('should return files with modifiedTime filter', async () => {
+        const parentRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'QueryTestTime_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        const parentId = (await parentRes.json()).id;
+
+        // Create file 1 (Old)
+        const file1 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'file1_old', parents: [parentId] })
+        }).then(res => res.json());
+
+        // Wait to ensure distinct modifiedTime
+        await new Promise(r => setTimeout(r, 1500));
+
+        // Checkpoint time
+        const checkpointTime = new Date().toISOString();
+
+        await new Promise(r => setTimeout(r, 1500));
+
+        // Create file 2 (New)
+        const file2 = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'file2_new', parents: [parentId] })
+        }).then(res => res.json());
+
+        // Query: parent + trashed + modifiedTime >= checkpoint
+        const queryParts = [
+            `'${parentId}' in parents`,
+            `and trashed = false`,
+            `and modifiedTime >= '${checkpointTime}'`
+        ];
+
+        const params = new URLSearchParams({
+            q: queryParts.join(' '),
+            pageSize: '10',
+            orderBy: "modifiedTime asc,name asc",
+            fields: "files(id,name,mimeType,parents,modifiedTime,size)",
+            supportsAllDrives: "true",
+            includeItemsFromAllDrives: "true",
+        });
+
+        const url = `${config.baseUrl}/drive/v3/files?${params.toString()}`;
+        const res = await fetch(url, { headers: { Authorization: `Bearer ${config.token}` } });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        const ids = data.files.map((f: { id: string }) => f.id);
+
+        // Should contain file2 (New), but NOT file1 (Old)
+        expect(ids).toContain(file2.id);
+        expect(ids).not.toContain(file1.id);
+    }, 60000);
+});

package/test/folder_search.test.ts

@@ -0,0 +1,81 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { getTestConfig, TestConfig } from './config';
+
+const randomString = () => Math.random().toString(36).substring(7);
+
+describe('Folder Search Parity', () => {
+    let config: TestConfig;
+    let headers: Record<string, string>;
+
+    beforeAll(async () => {
+        config = await getTestConfig();
+        headers = {
+            Authorization: `Bearer ${config.token}`
+        };
+    });
+
+    it('should return only id for folder search with fields=files(id)', async () => {
+        const folderName = 'SearchTest_' + randomString();
+        const FOLDER_MIME_TYPE = 'application/vnd.google-apps.folder';
+
+        // 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: 'Parent_' + randomString(),
+                mimeType: FOLDER_MIME_TYPE
+            })
+        });
+        expect(parentRes.status).toBe(200);
+        const parentId = (await parentRes.json()).id;
+
+        // 2. Create the target folder inside parent
+        const targetRes = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: folderName,
+                mimeType: FOLDER_MIME_TYPE,
+                parents: [parentId]
+            })
+        });
+        expect(targetRes.status).toBe(200);
+        const targetId = (await targetRes.json()).id;
+
+        // Wait for consistency
+        await new Promise(r => setTimeout(r, 2000));
+
+        // 3. User's Query
+        const query = `name = '${folderName}' and '${parentId}' in parents and trashed = false and mimeType = '${FOLDER_MIME_TYPE}'`;
+
+        const params = new URLSearchParams({
+            q: query,
+            fields: 'files(id,mimeType)',
+            orderBy: 'createdTime asc'
+        });
+
+        const url = `${config.baseUrl}/drive/v3/files?${params.toString()}`;
+        console.log('Requesting URL:', url);
+
+        const res = await fetch(url, { headers });
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        expect(data.files).toBeDefined();
+        expect(data.files.length).toBeGreaterThan(0);
+
+        const foundFolder = data.files[0];
+        expect(foundFolder.id).toBe(targetId);
+        expect(foundFolder.mimeType).toBe(FOLDER_MIME_TYPE);
+
+        // Strict Key Check
+        const actualKeys = Object.keys(foundFolder).sort();
+        const expectedKeys = ['id', 'mimeType'].sort(); // User requested only id
+
+        if (JSON.stringify(actualKeys) !== JSON.stringify(expectedKeys)) {
+            console.log('Keys mismatch! Actual:', actualKeys);
+        }
+        expect(actualKeys).toEqual(expectedKeys);
+    }, 60000);
+});

package/test/iterate_changes.test.ts

@@ -212,6 +212,229 @@ describe('Iterate Changes Queries', () => {
 
     }, 60000);
 
+    it('should find files where write time >= X, sorted by modifiedTime and name', async () => {
+        // 1. Create file OLD (should be excluded)
+        const fileOld = await createFileWithContent('file_A_Old', randomString(), config);
+
+        // Wait to ensure distinct time
+        await new Promise(r => setTimeout(r, 1500));
+
+        // 2. Create ISO-time target files (Equal Time)
+        // We create one, get its time, then create another and patch it to match.
+        const fileMiddle1 = await createFileWithContent('file_B_Middle1', randomString(), config);
+        // Get target time
+        const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle1.id}?fields=modifiedTime`, { headers });
+        const timeX = (await timeXRes.json()).modifiedTime;
+
+        // Create second middle file
+        const fileMiddle2 = await createFileWithContent('file_B_Middle2', randomString(), config);
+
+        // Patch fileMiddle2 to match fileMiddle1 time
+        await new Promise(r => setTimeout(r, 1100)); // Wait before patching to ensure it would be different otherwise
+        const patchBody = JSON.stringify({ modifiedTime: timeX });
+        await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+
+        // Wait again for New file
+        await new Promise(r => setTimeout(r, 1500));
+
+        // 3. Create file New (should be included, greater match logic)
+        const fileNew = await createFileWithContent('file_C_New', randomString(), config);
+
+        // 4. Query: modifiedTime >= timeX
+        // Sort by modifiedTime asc, name asc
+        const q = `modifiedTime >= '${timeX}' 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,modifiedTime)`;
+        const res = await fetch(url, { headers });
+        if (res.status !== 200) {
+            console.error('Error response:', await res.text());
+        }
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        // 5. Verify results
+        const resultIds = data.files.map((f: DriveFile) => f.id);
+
+        // Should NOT contain Old
+        expect(resultIds).not.toContain(fileOld.id);
+
+        // Should contain Middle1, Middle2, New
+        const relevantFiles = data.files.filter((f: DriveFile) => [fileMiddle1.id, fileMiddle2.id, fileNew.id].includes(f.id));
+        expect(relevantFiles.length).toBe(3);
+
+        // Verify Order
+        // Expect: [Middle1/Middle2 (sorted by NAME), New]
+
+        // First two should be the middle ones
+        const firstTwoIds = [relevantFiles[0].id, relevantFiles[1].id];
+        expect(firstTwoIds).toContain(fileMiddle1.id);
+        expect(firstTwoIds).toContain(fileMiddle2.id);
+
+        // Verify secondary sort of first two by NAME
+        const expectedFirst = fileMiddle1.name < fileMiddle2.name ? fileMiddle1.id : fileMiddle2.id;
+        const expectedSecond = fileMiddle1.name < fileMiddle2.name ? fileMiddle2.id : fileMiddle1.id;
+        expect(relevantFiles[0].id).toBe(expectedFirst);
+        expect(relevantFiles[1].id).toBe(expectedSecond);
+
+        // Third should be New
+        expect(relevantFiles[2].id).toBe(fileNew.id);
+
+        // Verify timestamps
+        expect(new Date(relevantFiles[0].modifiedTime).toISOString()).toBe(new Date(timeX).toISOString());
+        expect(new Date(relevantFiles[1].modifiedTime).toISOString()).toBe(new Date(timeX).toISOString());
+        expect(new Date(relevantFiles[2].modifiedTime) > new Date(timeX)).toBe(true);
+
+    }, 60000);
+
+    // Test for Name >= Query support
+    // VERIFIED: UNSUPPORTED. Returns 500 Internal Error from Google Drive API.
+    /*
+    it('should find files where name >= X', async () => {
+        const fileA = await createFileWithContent('file_A_NameCheck', randomString(), config);
+        const fileB = await createFileWithContent('file_B_NameCheck', randomString(), config);
+        const fileC = await createFileWithContent('file_C_NameCheck', randomString(), config);
+
+        // Query: name >= 'file_B_NameCheck'
+        // Expect to find B and C, but not A.
+        const q = `name >= 'file_B_NameCheck' and trashed = false`;
+        const orderBy = 'name asc';
+
+        console.log('Query:', q);
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}`;
+        const res = await fetch(url, { headers });
+
+        if (res.status !== 200) {
+            console.error('Error response:', await res.text());
+        }
+        // We expect 200 if supported, or 400/500 if not.
+        // We will assert 200 to see if it passes.
+        expect(res.status).toBe(200);
+
+        const data = await res.json();
+        const names = data.files.map((f: DriveFile) => f.name);
+
+        expect(names).toContain('file_B_NameCheck');
+        expect(names).toContain('file_C_NameCheck');
+        expect(names).not.toContain('file_A_NameCheck');
+    }, 60000);
+    /*
+    it('should find files where name >= X', async () => {
+        // ... (existing commented code)
+    }, 60000);
+    */
+
+    // Test for ID >= Query support
+    // VERIFIED: UNSUPPORTED. Returns 400 Bad Request from Google Drive API.
+    /*
+    it('should find files where id >= X', async () => {
+        const fileA = await createFileWithContent('file_A_IdCheck', randomString(), config);
+        const fileB = await createFileWithContent('file_B_IdCheck', randomString(), config);
+        const fileC = await createFileWithContent('file_C_IdCheck', randomString(), config);
+
+        // Sort IDs to know order
+        const ids = [fileA.id, fileB.id, fileC.id].sort();
+        const pivotId = ids[1]; // Middle ID
+
+        // Query: id >= pivotId
+        // Expect to find pivotId and larger ID.
+        const q = `id >= '${pivotId}' and trashed = false`;
+        const orderBy = 'createdTime asc'; // Sort logic for ID is unsupported, use createdTime or name
+
+        console.log('Query:', q);
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}`;
+        const res = await fetch(url, { headers });
+
+        if (res.status !== 200) {
+            console.error('Error response:', await res.text());
+        }
+        // We expect 200 if supported, or 400/500 if not. 
+        expect(res.status).toBe(200);
+
+        const data = await res.json();
+        const resultIds = data.files.map((f: DriveFile) => f.id);
+
+        expect(resultIds).toContain(ids[1]);
+        expect(resultIds).toContain(ids[2]);
+        expect(resultIds).not.toContain(ids[0]);
+    }, 60000);
+    */
+
+    // MongoDB-style keyset pagination query using 'name'
+    // VERIFIED: This query is NOT supported by Google Drive API.
+    // 'name > ...' returns 500 Internal Error on Real API.
+    // 'id > ...' returns 400 Bad Request on Real API.
+    // it('should find files using keyset pagination: (modifiedTime > T) OR (modifiedTime = T AND name > N)', async () => {
+    //     // 1. Create file OLD (should be excluded)
+    //     const fileOld = await createFileWithContent('file_A_Old', randomString(), config);
+
+    //     // Wait
+    //     await new Promise(r => setTimeout(r, 1500));
+
+    //     // 2. Create ISO-time target files (Equal Time)
+    //     // We need explicit names to test > logic.
+    //     const name1 = 'file_B_Middle1';
+    //     const name2 = 'file_B_Middle2';
+
+    //     const fileMiddle1 = await createFileWithContent(name1, randomString(), config);
+    //     // Get target time
+    //     const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle1.id}?fields=modifiedTime`, { headers });
+    //     const timeX = (await timeXRes.json()).modifiedTime;
+
+    //     // Create second middle file
+    //     const fileMiddle2 = await createFileWithContent(name2, randomString(), config);
+
+    //     // Patch fileMiddle2 to match fileMiddle1 time
+    //     await new Promise(r => setTimeout(r, 1100));
+    //     const patchBody = JSON.stringify({ modifiedTime: timeX });
+    //     await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+
+    //     // Wait again for New file
+    //     await new Promise(r => setTimeout(r, 1500));
+
+    //     // 3. Create file New (should be included, greater match logic)
+    //     const fileNew = await createFileWithContent('file_C_New', randomString(), config);
+
+    //     // Scenario: We want to page after 'file_B_Middle1'.
+    //     // So we want (modifiedTime > timeX) OR (modifiedTime = timeX AND name > 'file_B_Middle1').
+    //     // Since names are sorted Middle1 < Middle2 < C_New (alphabetical),
+    //     // we expect to find Middle2 and C_New.
+
+    //     const cursorName = name1;
+    //     const cursorTime = timeX;
+
+
+    //     // Simplified query to test 'name >' operator support first
+    //     const q = `name > '${cursorName}' and trashed = false`;
+    //     const orderBy = 'name asc';
+
+    //     console.log('Query:', q);
+
+    //     console.log('Query:', q);
+
+    //     const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&fields=files(id,name,modifiedTime)`;
+    //     const res = await fetch(url, { headers });
+
+    //     if (res.status !== 200) {
+    //         console.error('Error response:', await res.text());
+    //     }
+    //     expect(res.status).toBe(200);
+    //     const data = await res.json();
+
+    //     const resultIds = data.files.map((f: DriveFile) => f.id);
+
+    //     // Must contain Middle2 and fileNew
+    //     expect(resultIds).toContain(fileMiddle2.id);
+    //     expect(resultIds).toContain(fileNew.id);
+
+    //     // Must NOT contain Middle1 (it equals cursor, we want >)
+    //     expect(resultIds).not.toContain(fileMiddle1.id);
+    //     expect(resultIds).not.toContain(fileOld.id);
+
+    // }, 60000);
+
     it('should iterate via changes tokens with specific fields', async () => {
         // User request verification:
         // const params = new URLSearchParams({
@@ -405,4 +628,293 @@ describe('Iterate Changes Queries', () => {
         expect(ids.size).toBe(totalFiles);
 
     }, 120000); // 25 files creation might take a bit
+
+    // Test for ID > Query support (v3)
+    // VERIFIED: UNSUPPORTED. Returns 400 Bad Request on v3.
+    /*
+    it('should find files where id > X on v3 API', async () => {
+        const fileA = await createFileWithContent('file_A_IdCheck_v3', randomString(), config);
+        const fileB = await createFileWithContent('file_B_IdCheck_v3', randomString(), config);
+        const fileC = await createFileWithContent('file_C_IdCheck_v3', randomString(), config);
+
+        // Sort IDs to know order
+        const ids = [fileA.id, fileB.id, fileC.id].sort();
+        const pivotId = ids[1]; // Middle ID
+
+        // Query: id > pivotId
+        const q = `id > '${pivotId}' and trashed = false`;
+        const orderBy = 'createdTime asc'; 
+
+        console.log('Query v3:', q);
+
+        const url = `${config.baseUrl}/drive/v3/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}`;
+        const res = await fetch(url, { headers });
+
+        if (res.status !== 200) {
+            console.error('Error response v3:', await res.text());
+        }
+        expect(res.status).toBe(200);
+        
+        const data = await res.json();
+        const resultIds = data.files.map((f: DriveFile) => f.id);
+
+        expect(resultIds).toContain(ids[2]);
+        expect(resultIds).not.toContain(ids[1]); // strict >
+        expect(resultIds).not.toContain(ids[0]);
+    }, 60000);
+    */
+
+    // Test for ID > Query support on v2 API
+    // VERIFIED: UNSUPPORTED. Returns 400 Bad Request on v2.
+    /*
+    it('should find files where id > X on v2 API', async () => {
+        // ... (existing code)
+    }, 60000);
+    */
+
+    // MongoDB-style keyset pagination query using 'title' on v2 API
+    // VERIFIED: UNSUPPORTED. Returns 500 Internal Error on v2 for this complex query.
+    /*
+    it('should find files using keyset pagination on v2: (modifiedDate > T) OR (modifiedDate = T AND title > N)', async () => {
+        // 1. Create file OLD (should be excluded)
+        const fileOld = await createFileWithContent('file_A_Old_v2', randomString(), config);
+
+        // Wait
+        await new Promise(r => setTimeout(r, 1500));
+
+        // 2. Create ISO-time target files (Equal Time)
+        // We need explicit names to test > logic.
+        const name1 = 'file_B_Middle1_v2';
+        const name2 = 'file_B_Middle2_v2';
+
+        const fileMiddle1 = await createFileWithContent(name1, randomString(), config);
+        // Get target time (using v3 to get precise time, assuming v2 sees same time)
+        const timeXRes = await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle1.id}?fields=modifiedTime`, { headers });
+        const timeX = (await timeXRes.json()).modifiedTime;
+
+        // Create second middle file
+        const fileMiddle2 = await createFileWithContent(name2, randomString(), config);
+
+        // Patch fileMiddle2 to match fileMiddle1 time
+        await new Promise(r => setTimeout(r, 1100));
+        const patchBody = JSON.stringify({ modifiedTime: timeX });
+        await fetch(`${config.baseUrl}/drive/v3/files/${fileMiddle2.id}`, { method: 'PATCH', headers: { ...headers, 'Content-Type': 'application/json' }, body: patchBody });
+
+        // Wait again for New file
+        await new Promise(r => setTimeout(r, 1500));
+
+        // 3. Create file New (should be included, greater match logic)
+        const fileNew = await createFileWithContent('file_C_New_v2', randomString(), config);
+
+        // Scenario: We want to page after 'file_B_Middle1'.
+        // So we want (modifiedDate > timeX) OR (modifiedDate = timeX AND title > 'file_B_Middle1_v2').
+
+        const cursorTitle = name1;
+        const cursorTime = timeX;
+
+        // Query using v2 fields: modifiedDate and title
+        const q = `(modifiedDate > '${cursorTime}') or (modifiedDate = '${cursorTime}' and title > '${cursorTitle}') and trashed = false`;
+        // v2 uses 'title' for name
+
+        console.log('Query v2 Keyset:', q);
+
+        const url = `${config.baseUrl}/drive/v2/files?q=${encodeURIComponent(q)}`;
+        const res = await fetch(url, { headers });
+
+        if (res.status !== 200) {
+            console.error('Error response v2 Keyset:', await res.text());
+        }
+        expect(res.status).toBe(200);
+        const data = await res.json();
+
+        const resultIds = data.items.map((f: any) => f.id);
+
+        // Must contain Middle2 and fileNew
+        expect(resultIds).toContain(fileMiddle2.id);
+        expect(resultIds).toContain(fileNew.id);
+
+        // Must NOT contain Middle1 (it equals cursor, we want >)
+        expect(resultIds).not.toContain(fileMiddle1.id);
+        expect(resultIds).not.toContain(fileOld.id);
+    }, 60000);
+    */
+
+    // Test for Paginated Changes in Parent Folder (v3)
+    it('should paginate through "changes" (files > time) in a specific parent folder (v3)', async () => {
+        // 1. Create Parent Folder
+        const resP = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'ParentFolder_Pagination_v3_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(resP.status).toBe(200);
+        const parentId = (await resP.json()).id;
+
+        // 2. Create files
+        const totalFiles = 6;
+        const baseName = 'InFolder_v3_' + randomString();
+
+        // Create files
+        for (let i = 0; i < totalFiles; i++) {
+            // Use body for parents to be safe
+            const res = await fetch(`${config.baseUrl}/drive/v3/files?fields=id,parents`, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    name: `${baseName}_${i}`,
+                    mimeType: 'text/plain',
+                    parents: [parentId]
+                })
+            });
+            if (res.status !== 200) {
+                console.error('Create file failed:', await res.text());
+            }
+            expect(res.status).toBe(200);
+            const created = await res.json();
+            if (!created.parents || !created.parents.includes(parentId)) {
+                console.error('File created but parent missing:', created);
+            }
+        }
+
+        // Wait for potential eventual consistency/indexing
+        console.log('Waiting 5s for indexing...');
+        await new Promise(r => setTimeout(r, 5000));
+
+        // Get one file to check time
+        const listOne = await fetch(`${config.baseUrl}/drive/v3/files?q='${parentId}' in parents&pageSize=1&fields=files(modifiedTime)`, { headers });
+        const oneData = await listOne.json();
+        if (!oneData.files || oneData.files.length === 0) {
+            throw new Error('No files found in parent check!');
+        }
+        const refTime = oneData.files[0].modifiedTime;
+        console.log('Reference File Time:', refTime);
+
+        // Filter: modifiedTime > refTime - 1 hour (to safely include all)
+        const startTime = new Date(new Date(refTime).getTime() - 3600000).toISOString();
+        console.log('Filter Start Time:', startTime);
+
+        // 3. Query with Pagination
+        const q = `'${parentId}' in parents and modifiedTime > '${startTime}' and trashed = false`;
+        const orderBy = 'modifiedTime asc';
+        const pageSize = 2; // Force pagination
+
+        const collectedFiles: DriveFile[] = [];
+        let pageToken: string | undefined;
+
+        console.log('Query v3 Parent Pagination:', q);
+
+        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 v3:', await res.text());
+            }
+            expect(res.status).toBe(200);
+            const data = await res.json();
+
+            if (data.files) {
+                console.log(`Page returned ${data.files.length} files. NextToken: ${!!data.nextPageToken}`);
+                collectedFiles.push(...data.files);
+            }
+            pageToken = data.nextPageToken;
+
+            if (collectedFiles.length > totalFiles + 5) break;
+        } while (pageToken);
+
+        expect(collectedFiles.length).toBe(totalFiles);
+        const names = collectedFiles.map(f => f.name);
+        expect(names).toHaveLength(totalFiles);
+    }, 120000);
+
+    // Test for Paginated Changes in Parent Folder (v2)
+    it('should paginate through "changes" (files > time) in a specific parent folder (v2)', async () => {
+        // 1. Create Parent Folder (v3 create is fine, reusable for v2 test)
+        const resP = await fetch(`${config.baseUrl}/drive/v3/files`, {
+            method: 'POST',
+            headers: { ...headers, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                name: 'ParentFolder_Pagination_v2_' + randomString(),
+                mimeType: 'application/vnd.google-apps.folder'
+            })
+        });
+        expect(resP.status).toBe(200);
+        const parentId = (await resP.json()).id;
+
+        // 2. Create files (v3 create is fine)
+        const totalFiles = 6;
+        const baseName = 'InFolder_v2_' + randomString();
+
+        for (let i = 0; i < totalFiles; i++) {
+            const res = await fetch(`${config.baseUrl}/drive/v3/files?fields=id,parents`, {
+                method: 'POST',
+                headers: { ...headers, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    name: `${baseName}_${i}`,
+                    mimeType: 'text/plain',
+                    parents: [parentId]
+                })
+            });
+            expect(res.status).toBe(200);
+        }
+
+        console.log('Waiting 5s for indexing (v2)...');
+        await new Promise(r => setTimeout(r, 5000));
+
+        // Get one file to check time (v2 uses modifiedDate)
+        // v2 list: items
+        const listOne = await fetch(`${config.baseUrl}/drive/v2/files?q='${parentId}' in parents&maxResults=1`, { headers });
+        if (listOne.status !== 200) {
+            console.error('v2 check failed:', await listOne.text());
+        }
+        const oneData = await listOne.json();
+
+        if (!oneData.items || oneData.items.length === 0) {
+            throw new Error('No files found in parent check v2!');
+        }
+        const refTime = oneData.items[0].modifiedDate;
+        console.log('Reference File Time v2:', refTime);
+
+        // Filter: modifiedDate > refTime - 1 hour
+        const startTime = new Date(new Date(refTime).getTime() - 3600000).toISOString();
+        console.log('Filter Start Time v2:', startTime);
+
+        // 3. Query with Pagination (v2 syntax)
+        const q = `'${parentId}' in parents and modifiedDate > '${startTime}' and trashed = false`;
+        const orderBy = 'modifiedDate asc';
+        const pageSize = 2; // maxResults
+
+        // v2 uses 'items' and 'title', not 'name'
+        interface DriveV2File { id: string; title: string; modifiedDate: string; }
+        const collectedFiles: DriveV2File[] = [];
+        let pageToken: string | undefined;
+
+        console.log('Query v2 Parent Pagination:', q);
+
+        do {
+            const url: string = `${config.baseUrl}/drive/v2/files?q=${encodeURIComponent(q)}&orderBy=${encodeURIComponent(orderBy)}&maxResults=${pageSize}` + (pageToken ? `&pageToken=${pageToken}` : '');
+            const res = await fetch(url, { headers });
+
+            if (res.status !== 200) {
+                console.error('Pagination Error v2:', await res.text());
+            }
+            expect(res.status).toBe(200);
+            const data = await res.json();
+
+            if (data.items) {
+                console.log(`Page returned ${data.items.length} items. NextToken: ${!!data.nextPageToken}`);
+                collectedFiles.push(...data.items);
+            }
+            pageToken = data.nextPageToken;
+
+            if (collectedFiles.length > totalFiles + 5) break;
+        } while (pageToken);
+
+        expect(collectedFiles.length).toBe(totalFiles);
+        const names = collectedFiles.map((f) => f.title); // v2 uses title
+        expect(names).toHaveLength(totalFiles);
+    }, 120000);
 });