nango 0.69.21 → 0.69.26

package/dist/testMocks/utils.js

@@ -1,180 +1,600 @@
 import * as crypto from 'crypto';
 import { promises as fs } from 'fs';
 import * as path from 'path';
+import parseLinksHeader from 'parse-link-header';
 import { vi } from 'vitest';
 import { getProvider } from '@nangohq/providers';
-import { ActionError, PaginationService } from '@nangohq/runner-sdk';
-class NangoActionMock {
+import paginateService from '@nangohq/runner-sdk/lib/paginate.service.js';
+class LegacyFixtureProvider {
     dirname;
     name;
-    Model;
-    paginationService;
-    nango = { secretKey: 'secret-key' };
-    activityLogId = 'test-activity-log-id';
-    syncId;
-    nangoConnectionId;
-    environmentId = 1;
-    environmentName;
-    syncJobId;
-    abortSignal;
-    syncConfig;
-    runnerFlags = {};
-    scriptType = 'action';
-    startTime = Date.now();
-    isCLI = false;
-    connectionId;
-    providerConfigKey;
-    provider;
-    ActionError = ActionError;
-    telemetryBag = {
-        customLogs: 0,
-        proxyCalls: 0,
-        durationMs: 0,
-        memoryGb: 1
-    };
-    logger = { level: 'debug' };
-    setLogger;
-    log;
-    getConnection;
-    getMetadata;
-    updateMetadata;
-    paginate;
-    get;
-    post;
-    patch;
-    put;
-    delete;
-    proxy;
-    getWebhookURL;
-    getToken;
-    getIntegration;
-    setMetadata;
-    setFieldMapping;
-    getFieldMapping;
-    getEnvironmentVariables;
-    getFlowAttributes;
-    triggerAction;
-    triggerSync;
-    zodValidateInput;
-    startSync;
-    uncontrolledFetch;
-    tryAcquireLock;
-    releaseLock;
-    releaseAllLocks;
-    constructor({ dirname, name, Model }) {
+    fileCache = new Map();
+    mockFileCache = new Map();
+    constructor(dirname, name) {
         this.dirname = dirname;
-        this.nango = {
-            secretKey: 'secret-key'
-        };
-        this.providerConfigKey = dirname;
-        this.connectionId = 'test-connection-id';
         this.name = name;
-        this.Model = Model;
-        this.paginationService = PaginationService;
-        this.setLogger = vi.fn();
-        this.log = vi.fn();
-        this.getConnection = vi.fn(this.getConnectionData.bind(this));
-        this.getMetadata = vi.fn(this.getMetadataData.bind(this));
-        this.paginate = vi.fn(this.getProxyPaginateData.bind(this));
-        this.get = vi.fn(this.proxyGetData.bind(this));
-        this.post = vi.fn(this.proxyPostData.bind(this));
-        this.patch = vi.fn(this.proxyPatchData.bind(this));
-        this.put = vi.fn(this.proxyPutData.bind(this));
-        this.delete = vi.fn(this.proxyDeleteData.bind(this));
-        this.proxy = vi.fn(this.proxyData.bind(this));
-        this.getWebhookURL = vi.fn(() => 'https://example.com/webhook');
-        this.updateMetadata = vi.fn();
-        this.getToken = vi.fn();
-        this.getIntegration = vi.fn();
-        this.setMetadata = vi.fn();
-        this.setFieldMapping = vi.fn();
-        this.getFieldMapping = vi.fn();
-        this.getEnvironmentVariables = vi.fn();
-        this.getFlowAttributes = vi.fn();
-        this.triggerAction = vi.fn();
-        this.triggerSync = vi.fn();
-        this.zodValidateInput = vi.fn();
-        this.startSync = vi.fn();
-        this.uncontrolledFetch = vi.fn();
-        this.tryAcquireLock = vi.fn();
-        this.releaseLock = vi.fn();
-        this.releaseAllLocks = vi.fn();
     }
     async getMockFile(fileName, throwOnMissing, identity) {
-        const filePath = path.resolve(this.dirname, `mocks/${fileName}.json`);
+        const filePath = path.resolve(this.dirname, `../mocks/${fileName}.json`);
         try {
             const fileContent = await fs.readFile(filePath, 'utf-8');
             const data = JSON.parse(fileContent);
             return data;
         }
         catch (err) {
-            if (identity && identity.requestIdentity && fileName.includes(identity.requestIdentityHash)) {
-                const normalizedHash = computeNormalizedHash(identity.requestIdentity);
-                if (normalizedHash !== identity.requestIdentityHash) {
-                    const fallbackFileName = fileName.replace(identity.requestIdentityHash, normalizedHash);
-                    const fallbackFilePath = path.resolve(this.dirname, `mocks/${fallbackFileName}.json`);
-                    try {
-                        const fileContent = await fs.readFile(fallbackFilePath, 'utf-8');
-                        const data = JSON.parse(fileContent);
-                        return data;
-                        // eslint-disable-next-line no-empty
-                    }
-                    catch { }
-                }
-            }
             if (throwOnMissing) {
                 throw new Error(`Failed to load mock data from ${filePath}: ${err.message} ${identity ? JSON.stringify(identity, null, 2) : ''}`);
             }
+            return undefined;
         }
     }
     async hashDirExists(hashDir) {
-        const filePath = path.resolve(this.dirname, `mocks/${hashDir}/`);
+        const filePath = path.resolve(this.dirname, `../mocks/${hashDir}/`);
         try {
             await fs.stat(filePath);
             return true;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
         }
-        catch (err) {
+        catch (_) {
             return false;
         }
     }
+    async getFilesInDir(dir) {
+        if (this.fileCache.has(dir)) {
+            return this.fileCache.get(dir);
+        }
+        const dirPath = path.resolve(this.dirname, `../mocks/${dir}`);
+        try {
+            const entries = await fs.readdir(dirPath);
+            const jsonFiles = entries.filter((f) => f.endsWith('.json'));
+            this.fileCache.set(dir, jsonFiles);
+            return jsonFiles;
+        }
+        catch (_) {
+            this.fileCache.set(dir, []);
+            return [];
+        }
+    }
+    async parseMockFile(dir, filename) {
+        const cacheKey = `${dir}/${filename}`;
+        if (this.mockFileCache.has(cacheKey)) {
+            return this.mockFileCache.get(cacheKey);
+        }
+        const filePath = path.resolve(this.dirname, `../mocks/${dir}/${filename}`);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            this.mockFileCache.set(cacheKey, parsed);
+            return parsed;
+        }
+        catch (_) {
+            return null;
+        }
+    }
+    paramsMatch(stored, incoming) {
+        if (stored.length !== incoming.length) {
+            return false;
+        }
+        const sortedStored = [...stored].sort((a, b) => a[0].localeCompare(b[0]));
+        const sortedIncoming = [...incoming].sort((a, b) => a[0].localeCompare(b[0]));
+        for (const [index, storedEntry] of sortedStored.entries()) {
+            const incomingEntry = sortedIncoming[index];
+            if (!incomingEntry) {
+                return false;
+            }
+            if (storedEntry[0] !== incomingEntry[0]) {
+                return false;
+            }
+            if (String(storedEntry[1]) !== String(incomingEntry[1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    async findMockByParams(dir, identity) {
+        const files = await this.getFilesInDir(dir);
+        for (const filename of files) {
+            const mockFile = await this.parseMockFile(dir, filename);
+            if (!mockFile || !mockFile.requestIdentity) {
+                continue;
+            }
+            if (this.paramsMatch(mockFile.requestIdentity.params, identity.requestIdentity.params)) {
+                if (mockFile.requestIdentity.headers.length > 0 || identity.requestIdentity.headers.length > 0) {
+                    if (!this.paramsMatch(mockFile.requestIdentity.headers, identity.requestIdentity.headers)) {
+                        continue;
+                    }
+                }
+                if (mockFile.requestIdentity.data !== undefined || identity.requestIdentity.data !== undefined) {
+                    const storedDataIdentity = mockFile.requestIdentity.data;
+                    const incomingDataIdentity = identity.requestIdentity.data;
+                    if (String(storedDataIdentity) !== String(incomingDataIdentity)) {
+                        continue;
+                    }
+                }
+                return mockFile;
+            }
+        }
+        return null;
+    }
     async getCachedResponse(identity) {
         const dir = `nango/${identity.method}/proxy/${identity.endpoint}/${this.name}/`;
         const hashBasedPath = `${dir}/${identity.requestIdentityHash}`;
         if (await this.hashDirExists(dir)) {
-            const data = await this.getMockFile(hashBasedPath, true, identity);
-            return data;
+            const exactMatch = await this.getMockFile(hashBasedPath, false, identity);
+            if (exactMatch) {
+                return exactMatch;
+            }
+            // Hash didn't match - try to find by params (handles legacy pagination bug)
+            const paramMatch = await this.findMockByParams(dir, identity);
+            if (paramMatch) {
+                return paramMatch;
+            }
+            throw new Error(`Failed to load mock data for ${identity.method.toUpperCase()} ${identity.endpoint}\n` +
+                `Hash ${identity.requestIdentityHash} not found in ${dir}\n` +
+                `Request params: ${JSON.stringify(identity.requestIdentity.params)}\n` +
+                `This may be due to missing pagination mock files. Re-record with: nango dryrun <sync> <connection> --save`);
         }
         else {
-            return {
-                response: await this.getMockFile(`nango/${identity.method}/proxy/${identity.endpoint}/${this.name}`, true, identity)
+            return { response: await this.getMockFile(`nango/${identity.method}/proxy/${identity.endpoint}/${this.name}`, true, identity) };
+        }
+    }
+    async getBatchSaveData(modelName) {
+        return this.getMockFile(`${this.name}/${modelName}/batchSave`, true);
+    }
+    async getBatchDeleteData(modelName) {
+        return this.getMockFile(`${this.name}/${modelName}/batchDelete`, true);
+    }
+    async getInput() {
+        return this.getMockFile(`${this.name}/input`, false);
+    }
+    async getOutput() {
+        return this.getMockFile(`${this.name}/output`, true);
+    }
+    async getConnectionData() {
+        return this.getMockFile(`nango/getConnection`, true);
+    }
+    async getMetadataData() {
+        return this.getMockFile('nango/getMetadata', true);
+    }
+    async getUpdateMetadata() {
+        return this.getMockFile('nango/updateMetadata', false);
+    }
+    async getDeleteRecordsFromPreviousExecutions() {
+        return this.getMockFile('nango/deleteRecordsFromPreviousExecutions', false);
+    }
+    isUnifiedMocks() {
+        return false;
+    }
+    async getAllMocksForEndpoint(method, endpoint) {
+        const normalizedEndpoint = endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+        const dir = `nango/${method.toLowerCase()}/proxy/${normalizedEndpoint}/${this.name}/`;
+        // Check for hash-based directory format (used for paginated endpoints)
+        if (await this.hashDirExists(dir)) {
+            const files = await this.getFilesInDir(dir);
+            const mocks = [];
+            for (const filename of files) {
+                const mockFile = await this.parseMockFile(dir, filename);
+                if (mockFile) {
+                    mocks.push(mockFile);
+                }
+            }
+            return mocks;
+        }
+        const nameBasedPath = `nango/${method.toLowerCase()}/proxy/${normalizedEndpoint}/${this.name}`;
+        const response = await this.getMockFile(nameBasedPath, false);
+        if (response) {
+            const syntheticMock = {
+                method: method.toLowerCase(),
+                endpoint: normalizedEndpoint,
+                requestIdentityHash: '',
+                requestIdentity: {
+                    method: method.toLowerCase(),
+                    endpoint: normalizedEndpoint,
+                    params: [],
+                    headers: []
+                },
+                response
             };
+            return [syntheticMock];
+        }
+        return [];
+    }
+}
+class UnifiedFixtureProvider {
+    mockData;
+    isMigrated;
+    constructor(mockData) {
+        this.mockData = mockData;
+        this.isMigrated = mockData._migrated === true;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getBatchSaveData(modelName) {
+        return this.mockData.nango?.batchSave?.[modelName];
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getBatchDeleteData(modelName) {
+        return this.mockData.nango?.batchDelete?.[modelName];
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getInput() {
+        return this.mockData.input;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getOutput() {
+        const data = this.mockData.output;
+        if (data === undefined) {
+            throw new Error(`Missing mock data for output`);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getConnectionData() {
+        const data = this.mockData.nango?.getConnection;
+        if (data === undefined) {
+            throw new Error(`Missing mock data for getConnection`);
+        }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getMetadataData() {
+        const data = this.mockData.nango?.getMetadata;
+        if (data === undefined) {
+            throw new Error(`Missing mock data for getMetadata`);
         }
+        return data;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getUpdateMetadata() {
+        return this.mockData.nango?.updateMetadata;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getDeleteRecordsFromPreviousExecutions() {
+        return this.mockData.nango?.deleteRecordsFromPreviousExecutions;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getCachedResponse(identity) {
+        const { method, endpoint, requestIdentityHash } = identity;
+        const normalizedEndpoint = endpoint.startsWith('/') ? endpoint.slice(1) : endpoint;
+        let apiMock = this.mockData.api?.[method.toUpperCase()]?.[normalizedEndpoint];
+        if (!apiMock) {
+            apiMock = this.mockData.api?.[method.toUpperCase()]?.[`/${normalizedEndpoint}`];
+        }
+        if (apiMock) {
+            // Normalize to array for consistent matching logic
+            const mocks = Array.isArray(apiMock) ? apiMock : [apiMock];
+            const matchedMock = mocks.find((mock) => {
+                // Try exact hash match first
+                if (mock.hash && mock.hash === requestIdentityHash) {
+                    return true;
+                }
+                // Try matching by request params/headers/data
+                if (mock.request) {
+                    const mockParamCount = mock.request.params ? Object.keys(mock.request.params).length : 0;
+                    const requestParamCount = identity.requestIdentity.params.length;
+                    // Params must match exactly (same count and same values)
+                    if (mockParamCount !== requestParamCount) {
+                        return false;
+                    }
+                    if (mock.request.params) {
+                        for (const [key, value] of Object.entries(mock.request.params)) {
+                            const actualParam = identity.requestIdentity.params.find(([k]) => k === key);
+                            if (!actualParam || String(actualParam[1]) !== String(value)) {
+                                return false;
+                            }
+                        }
+                    }
+                    const mockHeaderCount = mock.request.headers ? Object.keys(mock.request.headers).length : 0;
+                    const requestHeaderCount = identity.requestIdentity.headers.length;
+                    // Headers must match exactly (same count and same values)
+                    if (mockHeaderCount !== requestHeaderCount) {
+                        return false;
+                    }
+                    if (mock.request.headers) {
+                        for (const [key, value] of Object.entries(mock.request.headers)) {
+                            const actualHeader = identity.requestIdentity.headers.find(([k]) => k.toLowerCase() === key.toLowerCase());
+                            if (!actualHeader || String(actualHeader[1]) !== String(value)) {
+                                return false;
+                            }
+                        }
+                    }
+                    if (mock.request.data !== undefined) {
+                        const expectedDataIdentity = computeDataIdentity({ data: mock.request.data });
+                        if (expectedDataIdentity !== identity.requestIdentity.data) {
+                            return false;
+                        }
+                    }
+                    return true;
+                }
+                // For mocks without request info or hash, only match if there's exactly one mock
+                // and no params in the request (i.e., it's an unpaginated endpoint)
+                if (mocks.length === 1 && identity.requestIdentity.params.length === 0) {
+                    return true;
+                }
+                return false;
+            });
+            if (matchedMock) {
+                return matchedMock;
+            }
+        }
+        const baseError = `No mock found for ${method.toUpperCase()} ${endpoint} (normalized: ${normalizedEndpoint}) with hash ${requestIdentityHash}`;
+        if (this.isMigrated) {
+            throw new Error(`${baseError}\n\n` +
+                `This mock file was migrated from the legacy format.\n` +
+                `The migration only captures mocks that were accessed during the test run.\n` +
+                `Due to a pagination bug in the legacy format, some pagination responses may not have been recorded.\n\n` +
+                `To fix this, re-record your mocks by running:\n` +
+                `  nango dryrun <sync-name> <connection-id> --save`);
+        }
+        throw new Error(`${baseError}\n\n` + `To fix this, record the missing mock by running:\n` + `  nango dryrun <sync-name> <connection-id> --save`);
+    }
+    isUnifiedMocks() {
+        return true;
+    }
+}
+class RecordingFixtureProvider {
+    delegate;
+    outputPath;
+    recordedData = {
+        input: null,
+        output: null,
+        nango: {},
+        api: {},
+        _migrated: true
+    };
+    constructor(delegate, outputPath) {
+        this.delegate = delegate;
+        this.outputPath = outputPath;
+    }
+    async save() {
+        const dataToSave = JSON.parse(JSON.stringify(this.recordedData));
+        // Prevent empty keys
+        if (Object.keys(dataToSave.nango?.batchSave || {}).length === 0)
+            delete dataToSave.nango?.batchSave;
+        if (Object.keys(dataToSave.nango?.batchDelete || {}).length === 0)
+            delete dataToSave.nango?.batchDelete;
+        if (Object.keys(dataToSave.nango || {}).length === 0)
+            delete dataToSave.nango;
+        if (Object.keys(dataToSave.api || {}).length === 0)
+            delete dataToSave.api;
+        if (dataToSave.input === null)
+            delete dataToSave.input;
+        if (dataToSave.output === null)
+            delete dataToSave.output;
+        await fs.writeFile(this.outputPath, JSON.stringify(dataToSave, null, 4));
     }
     async getBatchSaveData(modelName) {
-        const data = await this.getMockFile(`${this.name}/${modelName}/batchSave`, true);
+        const data = await this.delegate.getBatchSaveData(modelName);
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        if (!this.recordedData.nango.batchSave)
+            this.recordedData.nango.batchSave = {};
+        this.recordedData.nango.batchSave[modelName] = data;
+        await this.save();
         return data;
     }
     async getBatchDeleteData(modelName) {
-        const data = await this.getMockFile(`${this.name}/${modelName}/batchDelete`, true);
+        const data = await this.delegate.getBatchDeleteData(modelName);
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        if (!this.recordedData.nango.batchDelete)
+            this.recordedData.nango.batchDelete = {};
+        this.recordedData.nango.batchDelete[modelName] = data;
+        await this.save();
         return data;
     }
     async getInput() {
-        const data = await this.getMockFile(`${this.name}/input`, false);
+        const data = await this.delegate.getInput();
+        this.recordedData.input = data;
+        await this.save();
         return data;
     }
     async getOutput() {
-        const data = await this.getMockFile(`${this.name}/output`, true);
+        const data = await this.delegate.getOutput();
+        this.recordedData.output = data;
+        await this.save();
         return data;
     }
     async getConnectionData() {
-        const data = await this.getMockFile(`nango/getConnection`, true);
+        const data = await this.delegate.getConnectionData();
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        this.recordedData.nango.getConnection = data;
+        await this.save();
         return data;
     }
     async getMetadataData() {
-        const data = await this.getMockFile('nango/getMetadata', true);
+        const data = await this.delegate.getMetadataData();
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        this.recordedData.nango.getMetadata = data;
+        await this.save();
+        return data;
+    }
+    async getUpdateMetadata() {
+        const data = await this.delegate.getUpdateMetadata();
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        this.recordedData.nango.updateMetadata = data;
+        await this.save();
+        return data;
+    }
+    async getDeleteRecordsFromPreviousExecutions() {
+        const data = await this.delegate.getDeleteRecordsFromPreviousExecutions();
+        if (!this.recordedData.nango)
+            this.recordedData.nango = {};
+        this.recordedData.nango.deleteRecordsFromPreviousExecutions = data;
+        await this.save();
+        return data;
+    }
+    async getCachedResponse(identity) {
+        const data = await this.delegate.getCachedResponse(identity);
+        const method = identity.method.toUpperCase();
+        const endpoint = identity.endpoint;
+        if (!this.recordedData.api)
+            this.recordedData.api = {};
+        if (!this.recordedData.api[method])
+            this.recordedData.api[method] = {};
+        if (!this.recordedData.api[method][endpoint])
+            this.recordedData.api[method][endpoint] = [];
+        // Fetch ALL mocks for this endpoint from the legacy provider
+        // This captures pagination pages that weren't accessed due to the legacy pagination bug
+        const allMocksForEndpoint = await this.delegate.getAllMocksForEndpoint(identity.method, endpoint);
+        for (const legacyMock of allMocksForEndpoint) {
+            const mockParams = Object.fromEntries(legacyMock.requestIdentity.params);
+            const mockHeaders = Object.fromEntries(legacyMock.requestIdentity.headers);
+            const record = {
+                request: {
+                    params: Object.keys(mockParams).length > 0 ? mockParams : undefined,
+                    headers: Object.keys(mockHeaders).length > 0 ? mockHeaders : undefined,
+                    data: legacyMock.requestIdentity.data
+                },
+                response: legacyMock.response,
+                hash: legacyMock.requestIdentityHash,
+                ...(legacyMock.headers && { headers: legacyMock.headers }),
+                ...(legacyMock.status !== undefined && { status: legacyMock.status })
+            };
+            const currentMocks = this.recordedData.api[method][endpoint];
+            const mocksArray = Array.isArray(currentMocks) ? currentMocks : [currentMocks];
+            // Use requestIdentityHash from the file content (not filename) for deduplication
+            const exists = mocksArray.some((r) => r.hash === record.hash);
+            if (!exists) {
+                this.recordedData.api[method][endpoint].push(record);
+            }
+        }
+        await this.save();
         return data;
     }
+    isUnifiedMocks() {
+        return false;
+    }
+}
+async function getFixtureProvider(dirname, name) {
+    let testFileName = name;
+    // Inspect the stack trace to automatically determine the name of the test file that is currently running.
+    // This allows it to locate the corresponding `.test.json` mock file (e.g., `my-test.test.ts` uses `my-test.test.json`).
+    // The `name` parameter serves as a fallback if the test file cannot be determined from the stack trace, or its missing
+    try {
+        const stack = new Error().stack;
+        if (stack) {
+            const lines = stack.split('\n');
+            for (const line of lines) {
+                if (line.includes(dirname) && line.includes('.test.ts')) {
+                    const match = line.match(/\/([^/]+\.test\.ts)/);
+                    if (match && match[1]) {
+                        testFileName = match[1].replace('.test.ts', '');
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+        return Promise.reject(err);
+    }
+    let unifiedMockPath = path.resolve(dirname, `${testFileName}.test.json`);
+    let unifiedFileExists = false;
+    try {
+        await fs.stat(unifiedMockPath);
+        unifiedFileExists = true;
+    }
+    catch (_) {
+        if (testFileName !== name) {
+            const fallbackPath = path.resolve(dirname, `${name}.test.json`);
+            try {
+                await fs.stat(fallbackPath);
+                unifiedMockPath = fallbackPath;
+                unifiedFileExists = true;
+            }
+            catch (_) {
+                unifiedFileExists = false;
+            }
+        }
+    }
+    if (unifiedFileExists) {
+        const fileContent = await fs.readFile(unifiedMockPath, 'utf-8');
+        return new UnifiedFixtureProvider(JSON.parse(fileContent));
+    }
+    // This section supports the migration of tests from the legacy mock format (multiple files per test)
+    // to the new unified format (a single `.test.json` file). When the `MIGRATE_MOCKS` environment variable is set,
+    // it uses the `RecordingFixtureProvider` to intercept calls to the old mock loader, run the test, and then
+    // save all the mock data that was accessed into a single new `.test.json` file.
+    if (process.env?.['MIGRATE_MOCKS']) {
+        const legacyLoader = new LegacyFixtureProvider(dirname, name);
+        return new RecordingFixtureProvider(legacyLoader, unifiedMockPath);
+    }
+    return new LegacyFixtureProvider(dirname, name);
+}
+class NangoActionMock {
+    dirname;
+    name;
+    Model;
+    providerConfigKey;
+    fixtureProvider;
+    log;
+    ActionError = vi.fn();
+    getConnection;
+    getMetadata;
+    updateMetadata;
+    paginate;
+    get;
+    post;
+    patch;
+    put;
+    delete;
+    proxy;
+    getWebhookURL;
+    zodValidateInput;
+    deleteRecordsFromPreviousExecutions;
+    constructor({ dirname, name, Model }) {
+        this.dirname = dirname;
+        this.providerConfigKey = path.basename(path.dirname(dirname));
+        this.name = name;
+        this.Model = Model;
+        this.fixtureProvider = getFixtureProvider(dirname, name);
+        this.log = vi.fn();
+        this.getConnection = vi.fn(this.getConnectionData.bind(this));
+        this.getMetadata = vi.fn(this.getMetadataData.bind(this));
+        this.updateMetadata = vi.fn(this.getUpdateMetadata.bind(this));
+        this.deleteRecordsFromPreviousExecutions = vi.fn(this.getDeleteRecordsFromPreviousExecutions.bind(this));
+        this.paginate = vi.fn(this.getProxyPaginateData.bind(this));
+        this.get = vi.fn(this.proxyGetData.bind(this));
+        this.post = vi.fn(this.proxyPostData.bind(this));
+        this.patch = vi.fn(this.proxyPatchData.bind(this));
+        this.put = vi.fn(this.proxyPutData.bind(this));
+        this.delete = vi.fn(this.proxyDeleteData.bind(this));
+        this.proxy = vi.fn(this.proxyData.bind(this));
+        this.getWebhookURL = vi.fn(() => 'https://example.com/webhook');
+        this.zodValidateInput = vi.fn(this.mockZodValidateInput.bind(this));
+    }
+    mockZodValidateInput({ input }) {
+        return {
+            data: input
+        };
+    }
+    async getBatchSaveData(modelName) {
+        return (await this.fixtureProvider).getBatchSaveData(modelName);
+    }
+    async getBatchDeleteData(modelName) {
+        return (await this.fixtureProvider).getBatchDeleteData(modelName);
+    }
+    async getInput() {
+        return (await this.fixtureProvider).getInput();
+    }
+    async getOutput() {
+        return (await this.fixtureProvider).getOutput();
+    }
+    async getConnectionData() {
+        return (await this.fixtureProvider).getConnectionData();
+    }
+    async getMetadataData() {
+        return (await this.fixtureProvider).getMetadataData();
+    }
+    async getUpdateMetadata() {
+        return (await this.fixtureProvider).getUpdateMetadata();
+    }
+    async getDeleteRecordsFromPreviousExecutions() {
+        return (await this.fixtureProvider).getDeleteRecordsFromPreviousExecutions();
+    }
     async *getProxyPaginateData(args) {
         const providerConfig = getProvider(this.providerConfigKey);
         if (!providerConfig) {
@@ -186,36 +606,213 @@ class NangoActionMock {
             ...args.paginate
         };
         const paginateInBody = ['post', 'put', 'patch'].includes(args.method.toLowerCase());
-        const updatedBodyOrParams = paginateInBody ? args.data || {} : args.params || {};
+        const updatedBodyOrParams = (paginateInBody ? args.data || {} : args.params || {});
         if (args.paginate['limit']) {
             const limitParameterName = args.paginate.limit_name_in_request;
-            if (typeof updatedBodyOrParams === 'object') {
-                updatedBodyOrParams[limitParameterName] = args.paginate['limit'];
-            }
-        }
-        const proxyFunction = async (config) => {
-            const response = await this.proxyData(config);
-            return {
-                data: response.data,
-                status: response.status,
-                statusText: 'OK',
-                headers: response.headers,
-                config: {}
+            updatedBodyOrParams[limitParameterName] = args.paginate['limit'];
+        }
+        const fixtureProvider = await this.fixtureProvider;
+        // For unified mocks, use Nango's pagination implementation to be consistent on how Nango would do it on an actual run
+        // For legacy mocks, use the legacy (bugged) pagination implementation to avoid breaking existing tests
+        if (fixtureProvider.isUnifiedMocks()) {
+            const paginationConfig = args.paginate;
+            paginateService.validateConfiguration(paginationConfig);
+            const proxyAdapter = async (config) => {
+                const response = await this.proxyData(config);
+                return {
+                    data: response.data,
+                    status: response.status || 200,
+                    statusText: 'OK',
+                    headers: response.headers || {},
+                    config: {}
+                };
             };
-        };
-        if (args.paginate.type === 'cursor') {
-            yield* this.paginationService.cursor(args, args.paginate, updatedBodyOrParams, paginateInBody, proxyFunction);
+            switch (paginationConfig.type) {
+                case 'cursor':
+                    return yield* paginateService.cursor(args, paginationConfig, updatedBodyOrParams, paginateInBody, proxyAdapter);
+                case 'link':
+                    return yield* paginateService.link(args, paginationConfig, updatedBodyOrParams, paginateInBody, proxyAdapter);
+                case 'offset':
+                    return yield* paginateService.offset(args, paginationConfig, updatedBodyOrParams, paginateInBody, proxyAdapter);
+                default:
+                    throw new Error(`Invalid pagination type: ${paginationConfig.type}`);
+            }
+        }
+        // Legacy pagination implementation for tests using legacy mocks format
+        if (args.paginate?.type === 'cursor') {
+            yield* this.cursorPaginate(args, updatedBodyOrParams, paginateInBody);
         }
-        else if (args.paginate.type === 'link') {
-            yield* this.paginationService.link(args, args.paginate, updatedBodyOrParams, paginateInBody, proxyFunction);
+        else if (args.paginate?.type === 'link') {
+            yield* this.linkPaginate(args, updatedBodyOrParams, paginateInBody);
         }
-        else if (args.paginate.type === 'offset') {
-            yield* this.paginationService.offset(args, args.paginate, updatedBodyOrParams, paginateInBody, proxyFunction);
+        else if (args.paginate?.type === 'offset') {
+            yield* this.offsetPaginate(args, updatedBodyOrParams, paginateInBody);
         }
         else {
             throw new Error(`Invalid pagination type: ${args.paginate?.type}`);
         }
     }
+    async *cursorPaginate(args, updatedBodyOrParams, paginateInBody) {
+        const cursorPagination = args.paginate;
+        let nextCursor;
+        do {
+            if (typeof nextCursor !== 'undefined') {
+                updatedBodyOrParams[cursorPagination.cursor_name_in_request] = nextCursor;
+            }
+            if (paginateInBody) {
+                args.data = updatedBodyOrParams;
+            }
+            else {
+                args.params = updatedBodyOrParams;
+            }
+            const response = await this.proxyData(args);
+            if (!response.headers) {
+                const data = response.data;
+                const paginate = args.paginate;
+                if (Array.isArray(data)) {
+                    yield data;
+                }
+                if (paginate && paginate.response_path) {
+                    yield data[paginate.response_path];
+                }
+                else {
+                    const keys = Object.keys(data);
+                    for (const key of keys) {
+                        if (Array.isArray(data[key])) {
+                            yield data[key];
+                        }
+                    }
+                }
+                return;
+            }
+            const responseData = cursorPagination.response_path ? response.data[cursorPagination.response_path] : response.data;
+            if (!responseData || !responseData.length) {
+                return;
+            }
+            yield responseData;
+            nextCursor = response.data[cursorPagination.cursor_path_in_response];
+            if (typeof nextCursor === 'string') {
+                nextCursor = nextCursor.trim();
+                if (!nextCursor) {
+                    nextCursor = undefined;
+                }
+            }
+            else if (typeof nextCursor !== 'number') {
+                nextCursor = undefined;
+            }
+        } while (typeof nextCursor !== 'undefined');
+    }
+    async *linkPaginate(args, updatedBodyOrParams, paginateInBody) {
+        const linkPagination = args.paginate;
+        if (paginateInBody) {
+            args.data = updatedBodyOrParams;
+        }
+        else {
+            args.params = updatedBodyOrParams;
+        }
+        while (true) {
+            const response = await this.proxyData(args);
+            if (!response.headers) {
+                const data = response.data;
+                const paginate = args.paginate;
+                if (Array.isArray(data)) {
+                    yield data;
+                }
+                if (paginate && paginate.response_path) {
+                    yield data[paginate.response_path];
+                }
+                else {
+                    const keys = Object.keys(data);
+                    for (const key of keys) {
+                        if (Array.isArray(data[key])) {
+                            yield data[key];
+                        }
+                    }
+                }
+                return;
+            }
+            const data = response.data;
+            const responseData = linkPagination.response_path ? data[linkPagination.response_path] : data;
+            if (!responseData.length) {
+                return;
+            }
+            yield responseData;
+            const nextPageLink = this.getNextPageLinkFromBodyOrHeaders(linkPagination, response, args.paginate);
+            if (!nextPageLink) {
+                return;
+            }
+            if (!isValidHttpUrl(nextPageLink)) {
+                args.endpoint = nextPageLink;
+            }
+            else {
+                const url = new URL(nextPageLink);
+                args.endpoint = url.pathname + url.search;
+            }
+            args.params = {};
+        }
+    }
+    getNextPageLinkFromBodyOrHeaders(linkPagination, response, paginationConfig) {
+        if (linkPagination.link_rel_in_response_header) {
+            const linkHeader = parseLinksHeader(response.headers['link']);
+            return linkHeader?.[linkPagination.link_rel_in_response_header]?.url;
+        }
+        else if (linkPagination.link_path_in_response_body) {
+            return get(response.data, linkPagination.link_path_in_response_body);
+        }
+        throw Error(`Either 'link_rel_in_response_header' or 'link_path_in_response_body' should be specified for '${paginationConfig.type}' pagination`);
+    }
+    async *offsetPaginate(args, updatedBodyOrParams, paginateInBody) {
+        const offsetPagination = args.paginate;
+        const offsetParameterName = offsetPagination.offset_name_in_request;
+        const offsetCalculationMethod = offsetPagination.offset_calculation_method || 'by-response-size';
+        let offset = offsetPagination.offset_start_value || 0;
+        while (true) {
+            updatedBodyOrParams[offsetParameterName] = paginateInBody ? offset : String(offset);
+            if (paginateInBody) {
+                args.data = updatedBodyOrParams;
+            }
+            else {
+                args.params = updatedBodyOrParams;
+            }
+            const response = await this.proxyData(args);
+            if (!response.headers) {
+                const data = response.data;
+                const paginate = args.paginate;
+                if (Array.isArray(data)) {
+                    yield data;
+                }
+                if (paginate && paginate.response_path) {
+                    yield data[paginate.response_path];
+                }
+                else {
+                    const keys = Object.keys(data);
+                    for (const key of keys) {
+                        if (Array.isArray(data[key])) {
+                            yield data[key];
+                        }
+                    }
+                }
+                return;
+            }
+            const responseData = args.paginate?.response_path ? get(response.data, args.paginate?.response_path) : response.data;
+            if (!responseData || !responseData.length) {
+                return;
+            }
+            yield responseData;
+            if (args.paginate?.limit && responseData.length < args.paginate?.limit) {
+                return;
+            }
+            if (responseData.length < 1) {
+                return;
+            }
+            if (offsetCalculationMethod === 'per-page') {
+                offset++;
+            }
+            else {
+                offset += responseData.length;
+            }
+        }
+    }
     async proxyGetData(args) {
         return this.proxyData({ ...args, method: 'get' });
     }
@@ -233,39 +830,18 @@ class NangoActionMock {
     }
     async proxyData(args) {
         const identity = computeConfigIdentity(args);
-        const cached = await this.getCachedResponse(identity);
-        return {
-            data: cached.response,
-            headers: cached.headers,
-            status: cached.status
-        };
+        const cached = await (await this.fixtureProvider).getCachedResponse(identity);
+        return { data: cached.response, headers: cached.headers, status: cached.status };
     }
 }
 class NangoSyncMock extends NangoActionMock {
-    variant = 'base';
-    track_deletes = false;
+    lastSyncDate = null;
     batchSave;
     batchDelete;
-    batchUpdate;
-    getRecordsByIds;
-    deleteRecordsFromPreviousExecutions;
-    setMergingStrategy;
-    batchSend;
-    modelFullName(model) {
-        if (this.variant === 'base') {
-            return model;
-        }
-        return `${model}::${this.variant}`;
-    }
     constructor({ dirname, name, Model }) {
         super({ dirname, name, Model });
         this.batchSave = vi.fn();
         this.batchDelete = vi.fn();
-        this.batchUpdate = vi.fn();
-        this.getRecordsByIds = vi.fn();
-        this.deleteRecordsFromPreviousExecutions = vi.fn();
-        this.setMergingStrategy = vi.fn();
-        this.batchSend = vi.fn();
     }
 }
 const FILTER_HEADERS = ['authorization', 'user-agent', 'nango-proxy-user-agent', 'accept-encoding', 'retries', 'host', 'connection-id', 'provider-config-key'];
@@ -295,13 +871,6 @@ function computeConfigIdentity(config) {
 function sortEntries(entries) {
     return entries.sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0));
 }
-function computeNormalizedHash(requestIdentity) {
-    const normalized = {
-        ...requestIdentity,
-        params: requestIdentity.params.map(([k, v]) => [k, String(v)])
-    };
-    return crypto.createHash('sha1').update(JSON.stringify(normalized)).digest('hex');
-}
 function computeDataIdentity(config) {
     const data = config.data;
     if (!data) {
@@ -334,5 +903,19 @@ function computeDataIdentity(config) {
         return dataString;
     }
 }
-export { NangoActionMock, NangoSyncMock };
+function isValidHttpUrl(str) {
+    try {
+        const url = new URL(str);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch (_) {
+        return false;
+    }
+}
+function get(obj, path, defaultValue = undefined) {
+    const pathArray = path.split('.').filter(Boolean);
+    const result = pathArray.reduce((acc, part) => acc && acc[part], obj);
+    return result === undefined ? defaultValue : result;
+}
+export { LegacyFixtureProvider, NangoActionMock, NangoSyncMock, RecordingFixtureProvider, UnifiedFixtureProvider };
 //# sourceMappingURL=utils.js.map