@forestadmin-experimental/datasource-cosmos 1.6.2 → 1.6.4

package/dist/utils/query-validator.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryValidator = exports.QueryValidationErrorCode = exports.QueryValidationError = void 0;
+const query_validation_error_1 = __importStar(require("./query-validation-error"));
+exports.QueryValidationError = query_validation_error_1.default;
+Object.defineProperty(exports, "QueryValidationErrorCode", { enumerable: true, get: function () { return query_validation_error_1.QueryValidationErrorCode; } });
+// Characters that are dangerous in Cosmos DB SQL queries
+// These patterns could be used for injection attacks
+const DANGEROUS_PATTERNS = [
+    /[;'"\\]/, // SQL injection characters
+    /--/, // SQL comment
+    /\/\*/, // Block comment start
+    /\*\//, // Block comment end
+    /\bSELECT\b/i, // SQL keyword
+    /\bFROM\b/i, // SQL keyword
+    /\bWHERE\b/i, // SQL keyword
+    /\bDROP\b/i, // SQL keyword
+    /\bDELETE\b/i, // SQL keyword
+    /\bUPDATE\b/i, // SQL keyword
+    /\bINSERT\b/i, // SQL keyword
+    /\bEXEC\b/i, // SQL keyword
+    /\bUNION\b/i, // SQL keyword
+    /\0/, // Null byte
+];
+// Valid field name pattern: alphanumeric, underscore, and arrow notation for nesting
+// Must start with a letter or underscore
+const VALID_FIELD_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(?:->?[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+// Special Cosmos DB system fields that are always valid
+const SYSTEM_FIELDS = new Set(['id', '_ts', '_etag', '_rid', '_self', '_attachments']);
+class QueryValidator {
+    constructor(schemaFields, options = {}) {
+        this.schema = null;
+        this.conditionCount = 0;
+        this.options = {
+            maxFieldDepth: options.maxFieldDepth ?? 10,
+            validateAgainstSchema: options.validateAgainstSchema ?? schemaFields !== undefined,
+            allowUnknownFields: options.allowUnknownFields ?? false,
+            maxFieldNameLength: options.maxFieldNameLength ?? 256,
+            maxConditions: options.maxConditions ?? 100,
+        };
+        if (schemaFields) {
+            this.schema = new Map();
+            for (const field of schemaFields) {
+                this.schema.set(field, true);
+                // Also add parent paths as valid for nested fields
+                // e.g., for 'address->city', 'address' is also valid
+                const parts = field.split('->');
+                for (let i = 1; i < parts.length; i += 1) {
+                    const parentPath = parts.slice(0, i).join('->');
+                    this.schema.set(parentPath, true);
+                }
+            }
+        }
+    }
+    /**
+     * Validate a field name for security and correctness
+     */
+    validateFieldName(field, context = 'field') {
+        // Check length
+        if (field.length > this.options.maxFieldNameLength) {
+            throw new query_validation_error_1.default(`${context} name exceeds maximum length of ${this.options.maxFieldNameLength} characters`, query_validation_error_1.QueryValidationErrorCode.INVALID_FIELD_NAME, field);
+        }
+        // Check for empty field
+        if (!field || field.trim() === '') {
+            throw new query_validation_error_1.default(`${context} name cannot be empty`, query_validation_error_1.QueryValidationErrorCode.INVALID_FIELD_NAME, field);
+        }
+        // Check for dangerous patterns (potential injection)
+        for (const pattern of DANGEROUS_PATTERNS) {
+            if (pattern.test(field)) {
+                throw new query_validation_error_1.default(`${context} contains potentially dangerous characters or patterns`, query_validation_error_1.QueryValidationErrorCode.POTENTIAL_INJECTION, field);
+            }
+        }
+        // Skip further validation for system fields
+        if (SYSTEM_FIELDS.has(field)) {
+            return;
+        }
+        // Check valid field name pattern
+        if (!VALID_FIELD_NAME_PATTERN.test(field)) {
+            throw new query_validation_error_1.default(`${context} '${field}' contains invalid characters. ` +
+                `Field names must start with a letter or underscore and contain only ` +
+                `alphanumeric characters, underscores, and '->' for nesting.`, query_validation_error_1.QueryValidationErrorCode.INVALID_FIELD_NAME, field);
+        }
+        // Check nesting depth
+        const depth = (field.match(/->/g) || []).length + 1;
+        if (depth > this.options.maxFieldDepth) {
+            throw new query_validation_error_1.default(`${context} '${field}' exceeds maximum nesting depth of ${this.options.maxFieldDepth}`, query_validation_error_1.QueryValidationErrorCode.MAX_DEPTH_EXCEEDED, field);
+        }
+        // Validate against schema if enabled
+        if (this.options.validateAgainstSchema && this.schema && !this.options.allowUnknownFields) {
+            if (!this.schema.has(field) && !SYSTEM_FIELDS.has(field)) {
+                throw new query_validation_error_1.default(`${context} '${field}' is not defined in the collection schema`, query_validation_error_1.QueryValidationErrorCode.FIELD_NOT_IN_SCHEMA, field);
+            }
+        }
+    }
+    /**
+     * Validate a complete condition tree
+     */
+    validateConditionTree(conditionTree) {
+        if (!conditionTree)
+            return;
+        this.conditionCount = 0;
+        this.validateConditionTreeRecursive(conditionTree);
+    }
+    validateConditionTreeRecursive(conditionTree) {
+        // Check condition count limit
+        this.conditionCount += 1;
+        if (this.conditionCount > this.options.maxConditions) {
+            throw new query_validation_error_1.default(`Condition tree exceeds maximum of ${this.options.maxConditions} conditions`, query_validation_error_1.QueryValidationErrorCode.MAX_DEPTH_EXCEEDED);
+        }
+        if (conditionTree.aggregator !== undefined) {
+            const { conditions } = conditionTree;
+            if (conditions) {
+                for (const condition of conditions) {
+                    this.validateConditionTreeRecursive(condition);
+                }
+            }
+            return;
+        }
+        if (conditionTree.operator !== undefined) {
+            const { field, value } = conditionTree;
+            this.validateFieldName(field, 'Filter field');
+            this.validateValue(value, field);
+        }
+    }
+    /**
+     * Validate a value for potential injection
+     */
+    validateValue(value, field) {
+        if (value === null || value === undefined) {
+            return;
+        }
+        // Check string values for injection attempts
+        if (typeof value === 'string') {
+            // Only check for null bytes in string values - other characters are safe
+            // when used with parameterized queries
+            if (value.includes('\0')) {
+                throw new query_validation_error_1.default(`Value for field '${field}' contains null bytes`, query_validation_error_1.QueryValidationErrorCode.POTENTIAL_INJECTION, field);
+            }
+        }
+        // Recursively check array values
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                this.validateValue(item, field);
+            }
+        }
+        // Check object values (for complex filters)
+        if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            for (const key of Object.keys(value)) {
+                this.validateFieldName(key, `Object key in value for '${field}'`);
+                this.validateValue(value[key], `${field}.${key}`);
+            }
+        }
+    }
+    /**
+     * Validate sort fields
+     */
+    validateSort(sort) {
+        if (!sort || sort.length === 0)
+            return;
+        for (const sortClause of sort) {
+            this.validateFieldName(sortClause.field, 'Sort field');
+            // Ensure ascending is a boolean
+            if (typeof sortClause.ascending !== 'boolean') {
+                throw new query_validation_error_1.default(`Sort direction for '${sortClause.field}' must be a boolean`, query_validation_error_1.QueryValidationErrorCode.INVALID_SORT_FIELD, sortClause.field);
+            }
+        }
+    }
+    /**
+     * Validate projection fields
+     */
+    validateProjection(projection) {
+        if (!projection || projection.length === 0)
+            return;
+        for (const field of projection) {
+            this.validateFieldName(field, 'Projection field');
+        }
+    }
+    /**
+     * Validate all query parameters at once
+     */
+    validateQuery(conditionTree, sort, projection) {
+        this.validateConditionTree(conditionTree);
+        this.validateSort(sort);
+        this.validateProjection(projection);
+    }
+}
+exports.default = QueryValidator;
+/**
+ * Create a validator instance for a given schema
+ */
+function createQueryValidator(schemaFields, options) {
+    return new QueryValidator(schemaFields, options);
+}
+exports.createQueryValidator = createQueryValidator;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query-validator.js","sourceRoot":"","sources":["../../src/utils/query-validator.ts"],"names":[],"mappings":"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"}

package/dist/utils/retry-handler.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Retry handler for Cosmos DB rate limiting (429 errors)
+ *
+ * Cosmos DB returns 429 (Too Many Requests) when RU/s limits are exceeded.
+ * The response includes a 'x-ms-retry-after-ms' header indicating how long to wait.
+ * This handler implements exponential backoff with respect to Cosmos DB's retry-after hints.
+ */
+export interface RetryOptions {
+    /**
+     * Maximum number of retry attempts
+     * Default: 9 (aligns with Azure SDK default)
+     */
+    maxRetries?: number;
+    /**
+     * Initial delay in milliseconds before first retry
+     * Default: 1000 (1 second)
+     */
+    initialDelayMs?: number;
+    /**
+     * Maximum delay in milliseconds between retries
+     * Default: 30000 (30 seconds)
+     */
+    maxDelayMs?: number;
+    /**
+     * Multiplier for exponential backoff
+     * Default: 2
+     */
+    backoffMultiplier?: number;
+    /**
+     * Add random jitter to prevent thundering herd
+     * Default: true
+     */
+    useJitter?: boolean;
+    /**
+     * Optional callback for retry events (useful for logging/monitoring)
+     */
+    onRetry?: (attempt: number, delayMs: number, error: Error) => void;
+}
+export interface RetryableError extends Error {
+    code?: number | string;
+    headers?: {
+        'x-ms-retry-after-ms'?: string;
+        [key: string]: string | undefined;
+    };
+}
+/**
+ * Check if an error is a retryable rate limit error (429)
+ */
+export declare function isRateLimitError(error: unknown): error is RetryableError;
+/**
+ * Check if an error is a retryable transient error (e.g., network issues, service unavailable)
+ */
+export declare function isTransientError(error: unknown): boolean;
+/**
+ * Extract retry-after delay from Cosmos DB error response
+ */
+export declare function getRetryAfterMs(error: RetryableError): number | null;
+/**
+ * Calculate delay for the next retry attempt using exponential backoff
+ */
+export declare function calculateBackoffDelay(attempt: number, options: Required<Omit<RetryOptions, 'onRetry'>>, retryAfterMs?: number | null): number;
+/**
+ * Execute an async operation with retry logic for rate limiting
+ *
+ * @param operation The async operation to execute
+ * @param options Retry configuration options
+ * @returns The result of the operation
+ * @throws The last error if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => container.items.create(item),
+ *   { maxRetries: 5, onRetry: (attempt, delay) => console.log(`Retry ${attempt}`) }
+ * );
+ * ```
+ */
+export declare function withRetry<T>(operation: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Create a retry wrapper with pre-configured options
+ *
+ * @param defaultOptions Default retry options to use
+ * @returns A withRetry function with the default options applied
+ *
+ * @example
+ * ```typescript
+ * const retryWithDefaults = createRetryWrapper({ maxRetries: 5 });
+ * const result = await retryWithDefaults(() => container.items.create(item));
+ * ```
+ */
+export declare function createRetryWrapper(defaultOptions: RetryOptions): <T>(operation: () => Promise<T>, overrideOptions?: RetryOptions) => Promise<T>;
+/**
+ * Configure the shared retry options for all Cosmos DB operations
+ * @param options Retry configuration
+ */
+export declare function configureRetryOptions(options: RetryOptions): void;
+/**
+ * Get the current shared retry options
+ */
+export declare function getSharedRetryOptions(): RetryOptions;
+//# sourceMappingURL=retry-handler.d.ts.map

package/dist/utils/retry-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.d.ts","sourceRoot":"","sources":["../../src/utils/retry-handler.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CACpE;AAED,MAAM,WAAW,cAAe,SAAQ,KAAK;IAC3C,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE;QACR,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;KACnC,CAAC;CACH;AAaD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAmBxE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAoBxD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,GAAG,IAAI,CAwBpE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC,EAChD,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAC3B,MAAM,CA6BR;AAWD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,CAAC,CAAC,CA4CZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,YAAY,GAC3B,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,CAGhF;AAQD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAEjE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,YAAY,CAEpD"}

package/dist/utils/retry-handler.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Retry handler for Cosmos DB rate limiting (429 errors)
+ *
+ * Cosmos DB returns 429 (Too Many Requests) when RU/s limits are exceeded.
+ * The response includes a 'x-ms-retry-after-ms' header indicating how long to wait.
+ * This handler implements exponential backoff with respect to Cosmos DB's retry-after hints.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSharedRetryOptions = exports.configureRetryOptions = exports.createRetryWrapper = exports.withRetry = exports.calculateBackoffDelay = exports.getRetryAfterMs = exports.isTransientError = exports.isRateLimitError = void 0;
+/**
+ * Default retry configuration
+ */
+const DEFAULT_OPTIONS = {
+    maxRetries: 9,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+    useJitter: true,
+};
+/**
+ * Check if an error is a retryable rate limit error (429)
+ */
+function isRateLimitError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const err = error;
+    // Check for Cosmos DB 429 error code
+    if (err.code === 429)
+        return true;
+    // Check message for rate limiting indicators
+    if (err.message?.includes('429') || err.message?.toLowerCase().includes('too many requests')) {
+        return true;
+    }
+    // Check for TooManyRequests in error name or message
+    if (err.name === 'TooManyRequests' || err.message?.includes('TooManyRequests')) {
+        return true;
+    }
+    return false;
+}
+exports.isRateLimitError = isRateLimitError;
+/**
+ * Check if an error is a retryable transient error (e.g., network issues, service unavailable)
+ */
+function isTransientError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const err = error;
+    const { code } = err;
+    // Service unavailable (503), Gateway timeout (504), Request timeout (408)
+    if (code === 503 || code === 504 || code === 408)
+        return true;
+    // Network-related errors
+    if (err.message?.includes('ECONNRESET') ||
+        err.message?.includes('ETIMEDOUT') ||
+        err.message?.includes('ENOTFOUND') ||
+        err.message?.includes('socket hang up')) {
+        return true;
+    }
+    return false;
+}
+exports.isTransientError = isTransientError;
+/**
+ * Extract retry-after delay from Cosmos DB error response
+ */
+function getRetryAfterMs(error) {
+    // Check for x-ms-retry-after-ms header (Cosmos DB specific)
+    const retryAfterMs = error.headers?.['x-ms-retry-after-ms'];
+    if (retryAfterMs) {
+        const parsed = parseInt(retryAfterMs, 10);
+        if (!Number.isNaN(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    // Check for standard Retry-After header (in seconds)
+    const retryAfter = error.headers?.['retry-after'];
+    if (retryAfter) {
+        const parsed = parseInt(retryAfter, 10);
+        if (!Number.isNaN(parsed) && parsed > 0) {
+            return parsed * 1000; // Convert to milliseconds
+        }
+    }
+    return null;
+}
+exports.getRetryAfterMs = getRetryAfterMs;
+/**
+ * Calculate delay for the next retry attempt using exponential backoff
+ */
+function calculateBackoffDelay(attempt, options, retryAfterMs) {
+    // If Cosmos DB specified a retry-after delay, use it as the base
+    if (retryAfterMs && retryAfterMs > 0) {
+        // Add a small buffer to the Cosmos DB suggested delay
+        const bufferedDelay = Math.min(retryAfterMs * 1.1, options.maxDelayMs);
+        if (options.useJitter) {
+            // Add up to 20% jitter
+            const jitter = Math.random() * 0.2 * bufferedDelay;
+            return Math.min(bufferedDelay + jitter, options.maxDelayMs);
+        }
+        return bufferedDelay;
+    }
+    // Calculate exponential backoff: initialDelay * (multiplier ^ attempt)
+    const exponentialDelay = options.initialDelayMs * options.backoffMultiplier ** attempt;
+    const cappedDelay = Math.min(exponentialDelay, options.maxDelayMs);
+    if (options.useJitter) {
+        // Add jitter: randomize between 50% and 100% of the delay
+        const jitterMin = cappedDelay * 0.5;
+        const jitterMax = cappedDelay;
+        return jitterMin + Math.random() * (jitterMax - jitterMin);
+    }
+    return cappedDelay;
+}
+exports.calculateBackoffDelay = calculateBackoffDelay;
+/**
+ * Sleep for the specified duration
+ */
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * Execute an async operation with retry logic for rate limiting
+ *
+ * @param operation The async operation to execute
+ * @param options Retry configuration options
+ * @returns The result of the operation
+ * @throws The last error if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => container.items.create(item),
+ *   { maxRetries: 5, onRetry: (attempt, delay) => console.log(`Retry ${attempt}`) }
+ * );
+ * ```
+ */
+async function withRetry(operation, options) {
+    const config = { ...DEFAULT_OPTIONS, ...options };
+    let lastError = null;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt += 1) {
+        try {
+            // eslint-disable-next-line no-await-in-loop -- Sequential retry logic
+            return await operation();
+        }
+        catch (error) {
+            lastError = error;
+            // Check if error is retryable
+            const isRateLimit = isRateLimitError(error);
+            const isTransient = isTransientError(error);
+            if (!isRateLimit && !isTransient) {
+                // Non-retryable error, throw immediately
+                throw error;
+            }
+            // Check if we've exhausted retries
+            if (attempt >= config.maxRetries) {
+                throw new Error(`Operation failed after ${config.maxRetries} retries. Last error: ${lastError.message}`);
+            }
+            // Calculate delay for next retry
+            const retryAfterMs = isRateLimit ? getRetryAfterMs(error) : null;
+            const delayMs = calculateBackoffDelay(attempt, config, retryAfterMs);
+            // Call onRetry callback if provided
+            if (options?.onRetry) {
+                options.onRetry(attempt + 1, delayMs, lastError);
+            }
+            // Wait before retrying
+            // eslint-disable-next-line no-await-in-loop -- Required for retry delay
+            await sleep(delayMs);
+        }
+    }
+    // This should never be reached, but TypeScript needs it
+    throw lastError || new Error('Retry failed unexpectedly');
+}
+exports.withRetry = withRetry;
+/**
+ * Create a retry wrapper with pre-configured options
+ *
+ * @param defaultOptions Default retry options to use
+ * @returns A withRetry function with the default options applied
+ *
+ * @example
+ * ```typescript
+ * const retryWithDefaults = createRetryWrapper({ maxRetries: 5 });
+ * const result = await retryWithDefaults(() => container.items.create(item));
+ * ```
+ */
+function createRetryWrapper(defaultOptions) {
+    return (operation, overrideOptions) => withRetry(operation, { ...defaultOptions, ...overrideOptions });
+}
+exports.createRetryWrapper = createRetryWrapper;
+/**
+ * Shared retry options instance for all models
+ * This allows centralized configuration of retry behavior
+ */
+let sharedRetryOptions = {};
+/**
+ * Configure the shared retry options for all Cosmos DB operations
+ * @param options Retry configuration
+ */
+function configureRetryOptions(options) {
+    sharedRetryOptions = { ...options };
+}
+exports.configureRetryOptions = configureRetryOptions;
+/**
+ * Get the current shared retry options
+ */
+function getSharedRetryOptions() {
+    return { ...sharedRetryOptions };
+}
+exports.getSharedRetryOptions = getSharedRetryOptions;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forestadmin-experimental/datasource-cosmos",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "main": "dist/index.js",
   "license": "GPL-3.0",
   "publishConfig": {