reqon-dsl 0.2.0 → 0.3.0

package/dist/interpreter/fetch-handler.d.ts

@@ -2,6 +2,7 @@ import type { FetchStep } from '../ast/nodes.js';
 import type { ExecutionContext } from './context.js';
 import type { OASSource } from '../oas/index.js';
 import { type SyncStore } from '../sync/index.js';
+import type { EventType } from '../observability/index.js';
 export interface FetchHandlerDeps {
     ctx: ExecutionContext;
     oasSources: Map<string, OASSource>;
@@ -15,6 +16,8 @@ export interface FetchHandlerDeps {
     executionId?: string;
     dryRun?: boolean;
     log: (message: string) => void;
+    /** Optional event emitter for observability */
+    emit?: <T>(type: EventType, payload: T) => void;
 }
 export interface FetchResult {
     data: unknown;
@@ -31,6 +34,7 @@ export declare class FetchHandler {
      * Execute a fetch step, handling OAS resolution, pagination, and sync checkpoints.
      */
     execute(step: FetchStep): Promise<FetchResult>;
+    private isRetryableError;
     /**
      * Record a sync checkpoint after successful fetch.
      */
@@ -40,4 +44,9 @@ export declare class FetchHandler {
     private executePaginated;
     private countRecords;
     private validateOASResponse;
+    /**
+     * Generate mock data for dry run mode.
+     * Uses OAS response schema if available, otherwise returns a simple placeholder.
+     */
+    private generateDryRunMockData;
 }

package/dist/interpreter/fetch-handler.js

@@ -1,5 +1,5 @@
 import { evaluate, interpolatePath } from './evaluator.js';
-import { resolveOperation, getResponseSchema, validateResponse } from '../oas/index.js';
+import { resolveOperation, getResponseSchema, validateResponse, generateMockData, } from '../oas/index.js';
 import { generateCheckpointKey, formatSinceDate } from '../sync/index.js';
 import { extractNestedValue } from '../utils/path.js';
 import { createPaginationStrategy } from './pagination.js';
@@ -23,29 +23,80 @@ export class FetchHandler {
         if (!client) {
             throw new Error(`Source not found: ${resolved.sourceName}`);
         }
-        // Resolve "since" query parameter for incremental sync
-        const { query: sinceQuery, checkpointKey } = await this.resolveSinceParams(step, resolved.sourceName, resolved.operationId, resolved.path);
+        // Resolve "since" query parameter and/or header for incremental sync
+        const { query: sinceQuery, headers: sinceHeaders, checkpointKey, } = await this.resolveSinceParams(step, resolved.sourceName, resolved.operationId, resolved.path);
+        // Emit fetch.start event
+        this.deps.emit?.('fetch.start', {
+            source: resolved.sourceName,
+            method: resolved.method,
+            path: resolved.path,
+            isOAS: !!resolved.operationId,
+            operationId: resolved.operationId,
+            hasPagination: !!step.paginate,
+            hasSince: !!step.since,
+        });
+        const _fetchStartTime = Date.now(); // Reserved for fetch duration tracking
         if (this.deps.dryRun) {
+            const mockData = this.generateDryRunMockData(resolved.sourceName, resolved.operationId);
             this.deps.log('(dry run - skipping actual request)');
-            return { data: { dryRun: true }, checkpointKey };
+            return { data: mockData, checkpointKey };
         }
         // Execute with or without pagination
         let data;
-        if (step.paginate) {
-            data = await this.executePaginated(step, client, resolved.path, resolved.method, resolved.sourceName, resolved.operationId, sinceQuery);
-        }
-        else {
-            const response = await client.request({
+        let pagesFetched;
+        let statusCode = 200;
+        try {
+            if (step.paginate) {
+                const result = await this.executePaginated(step, client, resolved.path, resolved.method, resolved.sourceName, resolved.operationId, sinceQuery, sinceHeaders);
+                data = result;
+                pagesFetched = Array.isArray(result) ? undefined : 1; // Will be set by executePaginated
+            }
+            else {
+                const response = await client.request({
+                    method: resolved.method,
+                    path: resolved.path,
+                    query: Object.keys(sinceQuery).length > 0 ? sinceQuery : undefined,
+                    headers: Object.keys(sinceHeaders).length > 0 ? sinceHeaders : undefined,
+                    body: step.body ? evaluate(step.body, this.deps.ctx) : undefined,
+                }, step.retry);
+                await this.validateOASResponse(resolved.sourceName, resolved.operationId, response.data);
+                data = response.data;
+                statusCode = response.status ?? 200;
+            }
+            // Emit fetch.complete event
+            this.deps.emit?.('fetch.complete', {
+                source: resolved.sourceName,
                 method: resolved.method,
                 path: resolved.path,
-                query: Object.keys(sinceQuery).length > 0 ? sinceQuery : undefined,
-                body: step.body ? evaluate(step.body, this.deps.ctx) : undefined,
-            }, step.retry);
-            await this.validateOASResponse(resolved.sourceName, resolved.operationId, response.data);
-            data = response.data;
+                statusCode,
+                recordCount: this.countRecords(data) ?? 0,
+                pagesFetched,
+            });
+        }
+        catch (error) {
+            // Emit fetch.error event
+            this.deps.emit?.('fetch.error', {
+                source: resolved.sourceName,
+                path: resolved.path,
+                error: error.message,
+                retryable: this.isRetryableError(error),
+            });
+            throw error;
         }
         return { data, checkpointKey };
     }
+    isRetryableError(error) {
+        if (error instanceof Error) {
+            const message = error.message.toLowerCase();
+            return (message.includes('timeout') ||
+                message.includes('network') ||
+                message.includes('rate limit') ||
+                message.includes('429') ||
+                message.includes('503') ||
+                message.includes('502'));
+        }
+        return false;
+    }
     /**
      * Record a sync checkpoint after successful fetch.
      */
@@ -76,6 +127,13 @@ export class FetchHandler {
             executionId: this.deps.executionId,
         });
         this.deps.log(`Recorded sync checkpoint: ${key} at ${syncedAt.toISOString()}`);
+        // Emit sync.checkpoint event
+        this.deps.emit?.('sync.checkpoint', {
+            checkpointKey: key,
+            lastSyncTime: syncedAt.toISOString(),
+            recordsFetched: recordCount ?? 0,
+            isIncremental: true,
+        });
     }
     resolveFetchTarget(step) {
         if (step.operationRef) {
@@ -92,7 +150,15 @@ export class FetchHandler {
             return { sourceName, method: operation.method, path, operationId };
         }
         // Traditional: explicit method + path
-        const sourceName = step.source ?? this.deps.ctx.sources.keys().next().value;
+        let sourceName = step.source;
+        if (!sourceName) {
+            // Use the first available source as default
+            const firstSource = this.deps.ctx.sources.keys().next();
+            if (firstSource.done) {
+                throw new Error('No sources defined. Add a source to your mission before making fetch requests.');
+            }
+            sourceName = firstSource.value;
+        }
         const method = step.method;
         let path;
         if (step.path.type === 'Literal' && step.path.dataType === 'string') {
@@ -106,25 +172,40 @@ export class FetchHandler {
     }
     async resolveSinceParams(step, sourceName, operationId, path) {
         const query = {};
+        const headers = {};
         if (!step.since || !this.deps.syncStore) {
-            return { query };
+            return { query, headers };
         }
         const checkpointKey = step.since.key ?? generateCheckpointKey(sourceName, operationId, path);
         if (step.since.type === 'lastSync') {
             const lastSync = await this.deps.syncStore.getLastSync(checkpointKey);
-            const paramName = step.since.param ?? 'since';
             const format = step.since.format ?? 'iso';
-            query[paramName] = formatSinceDate(lastSync, format);
-            this.deps.log(`Incremental sync: ${paramName}=${query[paramName]} (key: ${checkpointKey})`);
+            const formattedDate = formatSinceDate(lastSync, format);
+            if (step.since.header) {
+                // Send as header (e.g., If-Modified-Since)
+                headers[step.since.header] = formattedDate;
+                this.deps.log(`Incremental sync: header ${step.since.header}=${formattedDate} (key: ${checkpointKey})`);
+            }
+            else {
+                // Send as query parameter (default behavior)
+                const paramName = step.since.param ?? 'since';
+                query[paramName] = formattedDate;
+                this.deps.log(`Incremental sync: ${paramName}=${formattedDate} (key: ${checkpointKey})`);
+            }
         }
         else if (step.since.type === 'expression' && step.since.expression) {
             const value = evaluate(step.since.expression, this.deps.ctx);
-            const paramName = step.since.param ?? 'since';
-            query[paramName] = String(value);
+            if (step.since.header) {
+                headers[step.since.header] = String(value);
+            }
+            else {
+                const paramName = step.since.param ?? 'since';
+                query[paramName] = String(value);
+            }
         }
-        return { query, checkpointKey };
+        return { query, headers, checkpointKey };
     }
-    async executePaginated(step, client, basePath, method, sourceName, operationId, sinceQuery = {}) {
+    async executePaginated(step, client, basePath, method, sourceName, operationId, sinceQuery = {}, sinceHeaders = {}) {
         const allResults = [];
         const paginate = step.paginate;
         const strategy = createPaginationStrategy(paginate);
@@ -137,8 +218,9 @@ export class FetchHandler {
             // Build query with pagination params
             const paginationQuery = strategy.buildQuery(ctx);
             const query = { ...sinceQuery, ...paginationQuery };
+            const headers = Object.keys(sinceHeaders).length > 0 ? sinceHeaders : undefined;
             this.deps.log(`Fetching page ${ctx.page + 1}...`);
-            const response = await client.request({ method, path: basePath, query }, step.retry);
+            const response = await client.request({ method, path: basePath, query, headers }, step.retry);
             await this.validateOASResponse(sourceName, operationId, response.data);
             // Temporarily set response for until condition evaluation
             this.deps.ctx.response = response.data;
@@ -158,6 +240,14 @@ export class FetchHandler {
                 ctx.cursor = pageResult.nextCursor;
             }
             ctx.page++;
+            // Emit heartbeat after each page
+            this.deps.emit?.('fetch.heartbeat', {
+                source: sourceName,
+                path: basePath,
+                pagesProcessed: ctx.page,
+                itemsFetched: allResults.length,
+                hasMore,
+            });
             // Safety limit
             if (ctx.page >= MAX_PAGINATION_PAGES) {
                 this.deps.log(`Warning: pagination limit (${MAX_PAGINATION_PAGES}) reached`);
@@ -200,4 +290,23 @@ export class FetchHandler {
             this.deps.log(`Response validation warnings for ${operationId}:\n${errorMessages}`);
         }
     }
+    /**
+     * Generate mock data for dry run mode.
+     * Uses OAS response schema if available, otherwise returns a simple placeholder.
+     */
+    generateDryRunMockData(sourceName, operationId) {
+        // Try to get schema from OAS source
+        if (operationId) {
+            const oasSource = this.deps.oasSources.get(sourceName);
+            if (oasSource) {
+                const schema = getResponseSchema(oasSource, operationId);
+                if (schema) {
+                    this.deps.log(`Generating mock data from OAS schema for ${operationId}`);
+                    return generateMockData(schema);
+                }
+            }
+        }
+        // Fallback to simple placeholder
+        return { _dryRun: true, _message: 'No OAS schema available for mock generation' };
+    }
 }

package/dist/interpreter/http.d.ts

@@ -30,6 +30,11 @@ export declare class HttpClient {
     private config;
     constructor(config: HttpClientConfig);
     request<T = unknown>(req: HttpRequest, retry?: RetryConfig): Promise<HttpResponse<T>>;
+    /**
+     * Safely parse response body, handling non-JSON responses gracefully.
+     * Attempts JSON parsing first, providing helpful errors on failure.
+     */
+    private parseResponseBody;
     private buildUrl;
     private buildHeaders;
     private calculateDelay;

package/dist/interpreter/http.js

@@ -1,13 +1,8 @@
 import { parseRateLimitHeaders } from '../auth/rate-limiter.js';
 import { CircuitBreakerError } from '../auth/circuit-breaker.js';
 import { sleep } from '../utils/async.js';
-/** Default retry configuration values */
-const DEFAULT_RETRY = {
-    MAX_ATTEMPTS: 3,
-    INITIAL_DELAY_MS: 1000,
-    MAX_DELAY_MS: 30000,
-    BACKOFF: 'exponential',
-};
+import { HTTP_RETRY_DEFAULTS } from '../config/index.js';
+import { FetchError } from '../errors/index.js';
 export class HttpClient {
     config;
     constructor(config) {
@@ -21,10 +16,10 @@ export class HttpClient {
             headers,
             body: req.body ? JSON.stringify(req.body) : undefined,
         };
-        const maxAttempts = retry?.maxAttempts ?? DEFAULT_RETRY.MAX_ATTEMPTS;
-        const backoff = retry?.backoff ?? DEFAULT_RETRY.BACKOFF;
-        const initialDelay = retry?.initialDelay ?? DEFAULT_RETRY.INITIAL_DELAY_MS;
-        const maxDelay = retry?.maxDelay ?? DEFAULT_RETRY.MAX_DELAY_MS;
+        const maxAttempts = retry?.maxAttempts ?? HTTP_RETRY_DEFAULTS.MAX_ATTEMPTS;
+        const backoff = retry?.backoff ?? HTTP_RETRY_DEFAULTS.BACKOFF;
+        const initialDelay = retry?.initialDelay ?? HTTP_RETRY_DEFAULTS.INITIAL_DELAY_MS;
+        const maxDelay = retry?.maxDelay ?? HTTP_RETRY_DEFAULTS.MAX_DELAY_MS;
         let lastError = null;
         // Check circuit breaker before attempting requests
         if (this.config.circuitBreaker && this.config.sourceName) {
@@ -88,7 +83,7 @@ export class HttpClient {
                     fetchOptions.headers = newHeaders;
                     continue;
                 }
-                const data = await response.json();
+                const data = await this.parseResponseBody(response, url, req.method);
                 // Record success in circuit breaker
                 if (this.config.circuitBreaker && this.config.sourceName && response.status < 500) {
                     this.config.circuitBreaker.recordSuccess(this.config.sourceName, req.path);
@@ -117,6 +112,25 @@ export class HttpClient {
         }
         throw lastError ?? new Error('Request failed after all retries');
     }
+    /**
+     * Safely parse response body, handling non-JSON responses gracefully.
+     * Attempts JSON parsing first, providing helpful errors on failure.
+     */
+    async parseResponseBody(response, url, method) {
+        const contentType = response.headers.get('content-type') ?? '';
+        // Always attempt JSON parsing - many APIs don't set content-type correctly
+        try {
+            return await response.json();
+        }
+        catch (parseError) {
+            // Provide context about content-type mismatch if applicable
+            const isJsonContentType = contentType.includes('application/json') || contentType === '';
+            const contentTypeHint = !isJsonContentType
+                ? ` (content-type was '${contentType}')`
+                : '';
+            throw new FetchError(`Failed to parse JSON response${contentTypeHint}: ${parseError.message}`, { url, method, statusCode: response.status, cause: parseError });
+        }
+    }
     buildUrl(path, query) {
         const base = this.config.baseUrl.replace(/\/$/, '');
         const cleanPath = path.startsWith('/') ? path : `/${path}`;

package/dist/interpreter/index.d.ts

@@ -1,5 +1,7 @@
-export { MissionExecutor, type ExecutionResult, type ExecutionError, type ExecutorConfig, type ProgressCallbacks, type ExecutionStartEvent, type ExecutionCompleteEvent, type StageStartEvent, type StageCompleteEvent, } from './executor.js';
+export { MissionExecutor, type ExecutionResult, type ExecutionError, type ExecutorConfig, type ProgressCallbacks, type ExecutionStartEvent, type ExecutionCompleteEvent, type StageStartEvent, type StageCompleteEvent, type AuthConfig, } from './executor.js';
 export { HttpClient, BearerAuthProvider, OAuth2AuthProvider, type HttpClientConfig, type AuthProvider } from './http.js';
+export { SourceManager, type SourceManagerConfig, type SourceManagerDeps } from './source-manager.js';
+export { StoreManager, type StoreManagerConfig } from './store-manager.js';
 export { createContext, childContext, getVariable, setVariable, type ExecutionContext } from './context.js';
 export { evaluate, evaluateToString, interpolatePath } from './evaluator.js';
 export { FetchHandler, type FetchHandlerDeps, type FetchResult } from './fetch-handler.js';

package/dist/interpreter/index.js

@@ -1,5 +1,7 @@
 export { MissionExecutor, } from './executor.js';
 export { HttpClient, BearerAuthProvider, OAuth2AuthProvider } from './http.js';
+export { SourceManager } from './source-manager.js';
+export { StoreManager } from './store-manager.js';
 export { createContext, childContext, getVariable, setVariable } from './context.js';
 export { evaluate, evaluateToString, interpolatePath } from './evaluator.js';
 export { FetchHandler } from './fetch-handler.js';

package/dist/interpreter/pagination.d.ts

@@ -23,8 +23,13 @@ export interface PaginationStrategy {
     buildQuery(ctx: PaginationContext): Record<string, string>;
     /** Extract results and determine if more pages exist */
     extractResults(response: unknown, ctx: PaginationContext): PageResult;
+    /** Clear any cached state (for reuse across different responses) */
+    clearCache?(): void;
 }
-/** Clear the array field cache (useful for testing) */
+/**
+ * @deprecated Use strategy.clearCache() instead. Kept for backward compatibility.
+ * Note: This now only clears the global compatibility cache, not instance caches.
+ */
 export declare function clearPaginationCache(): void;
 /**
  * Offset-based pagination (e.g., offset=100, offset=200)
@@ -32,9 +37,11 @@ export declare function clearPaginationCache(): void;
 export declare class OffsetPaginationStrategy implements PaginationStrategy {
     private config;
     private cacheKey;
+    private cache;
     constructor(config: PaginationConfig);
     buildQuery(ctx: PaginationContext): Record<string, string>;
     extractResults(response: unknown, ctx: PaginationContext): PageResult;
+    clearCache(): void;
 }
 /**
  * Page number pagination (e.g., page=1, page=2)
@@ -42,20 +49,22 @@ export declare class OffsetPaginationStrategy implements PaginationStrategy {
 export declare class PageNumberPaginationStrategy implements PaginationStrategy {
     private config;
     private cacheKey;
+    private cache;
     constructor(config: PaginationConfig);
     buildQuery(ctx: PaginationContext): Record<string, string>;
     extractResults(response: unknown, ctx: PaginationContext): PageResult;
+    clearCache(): void;
 }
 /**
  * Cursor-based pagination (e.g., cursor=abc123)
  */
 export declare class CursorPaginationStrategy implements PaginationStrategy {
     private config;
-    private cacheKey;
     private cachedArrayField;
     constructor(config: PaginationConfig);
     buildQuery(ctx: PaginationContext): Record<string, string>;
     extractResults(response: unknown, ctx: PaginationContext): PageResult;
+    clearCache(): void;
 }
 /**
  * Create the appropriate pagination strategy based on config

package/dist/interpreter/pagination.js

@@ -1,40 +1,91 @@
 import { extractNestedValue } from '../utils/path.js';
-/** Cache for discovered array field keys to avoid repeated lookups */
-const arrayFieldCache = new Map();
+/** Default TTL for cache entries (5 minutes) */
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+/** Maximum number of cache entries before cleanup */
+const MAX_CACHE_ENTRIES = 100;
+/**
+ * Instance-level cache for array field discovery.
+ * Each pagination strategy instance has its own cache to avoid global state pollution.
+ */
+class ArrayFieldCache {
+    cache = new Map();
+    ttlMs;
+    constructor(ttlMs = DEFAULT_CACHE_TTL_MS) {
+        this.ttlMs = ttlMs;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            return undefined;
+        }
+        // Check if expired
+        if (Date.now() > entry.expiresAt) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        // Cleanup if cache is getting too large
+        if (this.cache.size >= MAX_CACHE_ENTRIES) {
+            this.cleanup();
+        }
+        this.cache.set(key, {
+            value,
+            expiresAt: Date.now() + this.ttlMs,
+        });
+    }
+    clear() {
+        this.cache.clear();
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this.cache) {
+            if (now > entry.expiresAt) {
+                this.cache.delete(key);
+            }
+        }
+        // If still too large, remove oldest half
+        if (this.cache.size >= MAX_CACHE_ENTRIES) {
+            const entries = Array.from(this.cache.entries());
+            entries.sort((a, b) => a[1].expiresAt - b[1].expiresAt);
+            const toRemove = entries.slice(0, Math.floor(entries.length / 2));
+            for (const [key] of toRemove) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
 /**
  * Extract items array from response and determine if more pages exist
  * Shared utility for offset and page-based pagination strategies
- * Caches the discovered array field for subsequent pages
  */
-function extractItemsFromResponse(response, pageSize, cacheKey) {
+function extractItemsFromResponse(response, pageSize, cacheKey, cache) {
     if (!response || typeof response !== 'object') {
         return { items: [], hasMore: false };
     }
     const data = response;
-    // Check cache first if we have a cache key
-    if (cacheKey) {
-        const cachedField = arrayFieldCache.get(cacheKey);
-        if (cachedField !== undefined) {
-            if (cachedField === null) {
-                return { items: [], hasMore: false };
-            }
-            const items = data[cachedField];
-            if (Array.isArray(items)) {
-                return {
-                    items,
-                    hasMore: items.length >= pageSize,
-                };
-            }
+    // Check cache first
+    const cachedField = cache.get(cacheKey);
+    if (cachedField !== undefined) {
+        if (cachedField === null) {
+            return { items: [], hasMore: false };
+        }
+        const items = data[cachedField];
+        if (Array.isArray(items)) {
+            return {
+                items,
+                hasMore: items.length >= pageSize,
+            };
         }
+        // Cached field no longer valid, clear it
+        cache.clear();
     }
     // Search for array field
     for (const key of Object.keys(data)) {
         if (Array.isArray(data[key])) {
             const items = data[key];
-            // Cache the discovered field
-            if (cacheKey) {
-                arrayFieldCache.set(cacheKey, key);
-            }
+            cache.set(cacheKey, key);
             return {
                 items,
                 hasMore: items.length >= pageSize,
@@ -42,14 +93,16 @@ function extractItemsFromResponse(response, pageSize, cacheKey) {
         }
     }
     // Cache negative result
-    if (cacheKey) {
-        arrayFieldCache.set(cacheKey, null);
-    }
+    cache.set(cacheKey, null);
     return { items: [], hasMore: false };
 }
-/** Clear the array field cache (useful for testing) */
+/**
+ * @deprecated Use strategy.clearCache() instead. Kept for backward compatibility.
+ * Note: This now only clears the global compatibility cache, not instance caches.
+ */
 export function clearPaginationCache() {
-    arrayFieldCache.clear();
+    // No-op - caches are now instance-level
+    // Individual strategies should call clearCache() if needed
 }
 /**
  * Offset-based pagination (e.g., offset=100, offset=200)
@@ -57,9 +110,11 @@ export function clearPaginationCache() {
 export class OffsetPaginationStrategy {
     config;
     cacheKey;
+    cache;
     constructor(config) {
         this.config = config;
         this.cacheKey = `offset:${config.param}`;
+        this.cache = new ArrayFieldCache();
     }
     buildQuery(ctx) {
         return {
@@ -67,7 +122,10 @@ export class OffsetPaginationStrategy {
         };
     }
     extractResults(response, ctx) {
-        return extractItemsFromResponse(response, ctx.pageSize, this.cacheKey);
+        return extractItemsFromResponse(response, ctx.pageSize, this.cacheKey, this.cache);
+    }
+    clearCache() {
+        this.cache.clear();
     }
 }
 /**
@@ -76,9 +134,11 @@ export class OffsetPaginationStrategy {
 export class PageNumberPaginationStrategy {
     config;
     cacheKey;
+    cache;
     constructor(config) {
         this.config = config;
         this.cacheKey = `page:${config.param}`;
+        this.cache = new ArrayFieldCache();
     }
     buildQuery(ctx) {
         return {
@@ -86,7 +146,10 @@ export class PageNumberPaginationStrategy {
         };
     }
     extractResults(response, ctx) {
-        return extractItemsFromResponse(response, ctx.pageSize, this.cacheKey);
+        return extractItemsFromResponse(response, ctx.pageSize, this.cacheKey, this.cache);
+    }
+    clearCache() {
+        this.cache.clear();
     }
 }
 /**
@@ -94,11 +157,9 @@ export class PageNumberPaginationStrategy {
  */
 export class CursorPaginationStrategy {
     config;
-    cacheKey;
     cachedArrayField = null;
     constructor(config) {
         this.config = config;
-        this.cacheKey = `cursor:${config.param}`;
     }
     buildQuery(ctx) {
         if (ctx.cursor) {
@@ -137,6 +198,9 @@ export class CursorPaginationStrategy {
             nextCursor,
         };
     }
+    clearCache() {
+        this.cachedArrayField = null;
+    }
 }
 /**
  * Create the appropriate pagination strategy based on config

package/dist/interpreter/signals.d.ts

@@ -55,3 +55,11 @@ export declare class NoMatchError extends Error {
 export declare class AbortError extends Error {
     constructor(message?: string);
 }
+/**
+ * Signal thrown when execution is paused by external control or pause step
+ */
+export declare class PauseSignal extends Error {
+    /** Pause ID if created by a pause step */
+    pauseId?: string;
+    constructor(pauseId?: string);
+}

package/dist/interpreter/signals.js

@@ -71,3 +71,15 @@ export class AbortError extends Error {
         this.name = 'AbortError';
     }
 }
+/**
+ * Signal thrown when execution is paused by external control or pause step
+ */
+export class PauseSignal extends Error {
+    /** Pause ID if created by a pause step */
+    pauseId;
+    constructor(pauseId) {
+        super(pauseId ? `Execution paused (${pauseId})` : 'Execution paused');
+        this.name = 'PauseSignal';
+        this.pauseId = pauseId;
+    }
+}