@lgriffin/esi.ts 7.4.0 → 9.0.0

package/dist/core/ApiClient.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClient = void 0;
-const Middleware_1 = require("./middleware/Middleware");
-class ApiClient {
-    clientId;
-    link;
-    accessToken;
-    datasource;
-    tokenProvider;
-    refreshInFlight;
-    middleware = new Middleware_1.MiddlewareManager();
-    cache = null;
-    rateLimiter = null;
-    circuitBreaker = null;
-    timeout = 30_000;
-    deduplicator = null;
-    retryConfig = null;
-    validateResponse = true;
-    language;
-    constructor(clientId, link, accessToken) {
-        this.clientId = clientId;
-        this.link = link;
-        this.accessToken = accessToken;
-        this.link = this.link.replace(/\/$/, '');
-    }
-    getTimeout() {
-        return this.timeout;
-    }
-    setTimeout(timeout) {
-        this.timeout = timeout;
-    }
-    getCache() {
-        return this.cache;
-    }
-    setCache(cache) {
-        this.cache = cache;
-    }
-    getRateLimiter() {
-        return this.rateLimiter;
-    }
-    setRateLimiter(limiter) {
-        this.rateLimiter = limiter;
-    }
-    getCircuitBreaker() {
-        return this.circuitBreaker;
-    }
-    setCircuitBreaker(cb) {
-        this.circuitBreaker = cb;
-    }
-    getDeduplicator() {
-        return this.deduplicator;
-    }
-    setDeduplicator(dedup) {
-        this.deduplicator = dedup;
-    }
-    getRetryConfig() {
-        return this.retryConfig;
-    }
-    setRetryConfig(config) {
-        this.retryConfig = config;
-    }
-    getValidateResponse() {
-        return this.validateResponse;
-    }
-    setValidateResponse(validate) {
-        this.validateResponse = validate;
-    }
-    getMiddleware() {
-        return this.middleware;
-    }
-    addRequestInterceptor(fn) {
-        return this.middleware.addRequestInterceptor(fn);
-    }
-    addResponseInterceptor(fn) {
-        return this.middleware.addResponseInterceptor(fn);
-    }
-    getAuthorizationHeader() {
-        return this.accessToken ? `Bearer ${this.accessToken}` : undefined;
-    }
-    getLink() {
-        return this.link;
-    }
-    getDatasource() {
-        return this.datasource;
-    }
-    setDatasource(datasource) {
-        this.datasource = datasource;
-    }
-    getLanguage() {
-        return this.language;
-    }
-    setLanguage(language) {
-        this.language = language;
-    }
-    setAccessToken(token) {
-        this.accessToken = token;
-    }
-    setTokenProvider(provider) {
-        this.tokenProvider = provider;
-    }
-    hasTokenProvider() {
-        return this.tokenProvider !== undefined;
-    }
-    async refreshToken() {
-        if (!this.tokenProvider) {
-            throw new Error('No token provider configured');
-        }
-        if (this.refreshInFlight) {
-            return this.refreshInFlight;
-        }
-        this.refreshInFlight = this.tokenProvider().then((token) => {
-            this.accessToken = token;
-            this.refreshInFlight = undefined;
-            return token;
-        }, (err) => {
-            this.refreshInFlight = undefined;
-            throw err;
-        });
-        return this.refreshInFlight;
-    }
-}
-exports.ApiClient = ApiClient;

package/dist/core/ApiClientBuilder.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiClientBuilder = void 0;
-const ApiClient_1 = require("./ApiClient");
-const RateLimiter_1 = require("./rateLimiter/RateLimiter");
-class ApiClientBuilder {
-    clientId;
-    link;
-    accessToken;
-    rateLimiter;
-    cache;
-    circuitBreaker;
-    _timeout;
-    setClientId(clientId) {
-        this.clientId = clientId;
-        return this;
-    }
-    setLink(link) {
-        this.link = link;
-        return this;
-    }
-    setAccessToken(accessToken) {
-        this.accessToken = accessToken;
-        return this;
-    }
-    setRateLimiter(limiter) {
-        this.rateLimiter = limiter;
-        return this;
-    }
-    setCache(cache) {
-        this.cache = cache;
-        return this;
-    }
-    setCircuitBreaker(cb) {
-        this.circuitBreaker = cb;
-        return this;
-    }
-    setTimeout(timeout) {
-        this._timeout = timeout;
-        return this;
-    }
-    build() {
-        const client = new ApiClient_1.ApiClient(this.clientId, this.link, this.accessToken);
-        client.setRateLimiter(this.rateLimiter ?? new RateLimiter_1.RateLimiter());
-        if (this.cache)
-            client.setCache(this.cache);
-        if (this.circuitBreaker)
-            client.setCircuitBreaker(this.circuitBreaker);
-        if (this._timeout !== undefined)
-            client.setTimeout(this._timeout);
-        return client;
-    }
-}
-exports.ApiClientBuilder = ApiClientBuilder;

package/dist/core/ApiRequestHandler.js

@@ -1,444 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRequest = exports.handleSinglePageRequest = void 0;
-const error_1 = require("../core/util/error");
-const loggerUtil_1 = require("../core/logger/loggerUtil");
-const headersUtil_1 = require("../core/util/headersUtil");
-const PaginationHandler_1 = require("./pagination/PaginationHandler");
-const constants_1 = require("./constants");
-const esi_cache_ttls_generated_1 = require("./endpoints/esi-cache-ttls.generated");
-const retry_1 = require("./util/retry");
-const sleep_1 = require("./util/sleep");
-const CircuitBreaker_1 = require("./circuitBreaker/CircuitBreaker");
-const STATUS_MESSAGES = {
-    201: 'Created',
-    204: 'No Content',
-    304: 'Not Modified',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Resource not found',
-    420: 'Error Limited',
-    422: 'Unprocessable Entity',
-    429: 'Too many requests',
-    500: 'Internal server error',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-    520: 'Internal server error, did the request terminate too soon?',
-};
-// --- Dependency resolution ---
-function resolveCache(client) {
-    return client.getCache();
-}
-function resolveRateLimiter(client) {
-    const limiter = client.getRateLimiter();
-    if (!limiter) {
-        throw (0, error_1.buildError)('No rate limiter configured on ApiClient. ' +
-            'Set one via apiClient.setRateLimiter(new RateLimiter()).', 'CONFIGURATION_ERROR');
-    }
-    return limiter;
-}
-function resolveCircuitBreaker(client) {
-    return client.getCircuitBreaker();
-}
-// --- Pure helpers ---
-const stringUtil_1 = require("./util/stringUtil");
-function lookupSpecTtl(method, templatePath) {
-    const normalized = templatePath
-        .replace(/\/$/, '')
-        .replace(/\{(\w+)\}/g, (_, name) => `{${(0, stringUtil_1.camelToSnake)(name)}}`);
-    const key = `${method}:${normalized}`;
-    const seconds = esi_cache_ttls_generated_1.esiCacheTtls[key];
-    return typeof seconds === 'number' ? seconds * 1000 : undefined;
-}
-function trySpecAwareCacheHit(client, url, method, templatePath) {
-    if (method !== 'GET' || !templatePath)
-        return null;
-    const specTtlMs = lookupSpecTtl(method, templatePath);
-    if (!specTtlMs)
-        return null;
-    const cache = resolveCache(client);
-    if (!cache)
-        return null;
-    const entry = cache.get(url);
-    if (!entry)
-        return null;
-    const age = Date.now() - entry.timestamp;
-    if (age < specTtlMs) {
-        (0, loggerUtil_1.logDebug)(`Spec-aware cache hit for ${url} (age=${Math.round(age / 1000)}s, ttl=${Math.round(specTtlMs / 1000)}s)`);
-        return {
-            headers: entry.headers,
-            body: entry.data,
-            fromCache: true,
-            cacheHitType: 'spec-ttl',
-        };
-    }
-    return null;
-}
-const parseCacheControlTtl = (headers) => {
-    const cacheControl = headers['cache-control'] ?? headers['Cache-Control'];
-    if (!cacheControl)
-        return undefined;
-    const match = /max-age=(\d+)/.exec(cacheControl);
-    return match ? parseInt(match[1], 10) * 1000 : undefined;
-};
-function buildRequestHeaders(client, url, method, requiresAuth, useETag, body) {
-    const headers = {
-        accept: 'gzip, deflate, br',
-        'User-Agent': constants_1.USER_AGENT,
-        'X-Compatibility-Date': constants_1.COMPATIBILITY_DATE,
-    };
-    const language = client.getLanguage();
-    if (language) {
-        headers['Accept-Language'] = language;
-    }
-    if (requiresAuth) {
-        const authHeader = client.getAuthorizationHeader();
-        if (!authHeader) {
-            throw (0, error_1.buildError)('Authorization header is required but not provided', 'NO_AUTH_TOKEN');
-        }
-        headers['Authorization'] = authHeader;
-    }
-    const cache = resolveCache(client);
-    if (useETag && method === 'GET' && cache) {
-        const cachedETag = cache.getETag(url);
-        if (cachedETag) {
-            headers['If-None-Match'] = cachedETag;
-            (0, loggerUtil_1.logDebug)(`Adding If-None-Match header: ${cachedETag}`);
-        }
-    }
-    if (body) {
-        headers['Content-Type'] = 'application/json';
-    }
-    return headers;
-}
-function handleEarlyStatus(client, status, url, parsed, useETag) {
-    if (status === 201) {
-        return { headers: parsed.raw, body: undefined };
-    }
-    if (status === 204) {
-        (0, loggerUtil_1.logInfo)(`No Content for endpoint: ${url}`);
-        return { headers: parsed.raw, body: undefined };
-    }
-    if (status === 304) {
-        const cache = resolveCache(client);
-        if (useETag && cache) {
-            const cachedEntry = cache.get(url);
-            if (cachedEntry) {
-                (0, loggerUtil_1.logInfo)(`Cache hit (304) for endpoint: ${url}`);
-                return {
-                    headers: { ...cachedEntry.headers, ...parsed.raw },
-                    body: cachedEntry.data,
-                    fromCache: true,
-                    cacheHitType: 'etag-304',
-                };
-            }
-        }
-        throw new error_1.EsiError(304, 'Not Modified — no cached data available', url, parsed.requestId ?? undefined);
-    }
-    return null;
-}
-function tryStaleCacheResponse(client, url, parsed) {
-    const cache = resolveCache(client);
-    if (!cache)
-        return null;
-    const cachedEntry = cache.get(url);
-    if (!cachedEntry)
-        return null;
-    return {
-        headers: { ...cachedEntry.headers, ...parsed.raw },
-        body: cachedEntry.data,
-        fromCache: true,
-        stale: true,
-        cacheHitType: 'stale-on-error',
-    };
-}
-function cacheResponse(client, url, method, endpoint, parsed, data, useETag) {
-    const cache = resolveCache(client);
-    if (useETag && method === 'GET' && cache && parsed.etag) {
-        const ttl = parseCacheControlTtl(parsed.raw);
-        cache.set(url, parsed.etag, data, parsed.raw, ttl);
-        const ttlInfo = ttl ? ` (ttl=${ttl}ms)` : '';
-        (0, loggerUtil_1.logDebug)(`Cached response for ${url} with ETag ${parsed.etag}${ttlInfo}`);
-    }
-    if (method !== 'GET' && cache) {
-        cache.deleteByPath(endpoint.split('?')[0]);
-    }
-}
-async function parseJsonBody(response, _url) {
-    try {
-        return (await response.json());
-    }
-    catch (jsonError) {
-        const msg = jsonError instanceof Error ? jsonError.message : String(jsonError);
-        (0, loggerUtil_1.logError)(`Failed to parse JSON response: ${msg}`);
-        throw (0, error_1.buildError)(`Invalid JSON response: ${msg}`, 'JSON_PARSE_ERROR');
-    }
-}
-function handleCursorPagination(parsed, data) {
-    if (!parsed.hasCursorPagination)
-        return null;
-    const cursors = {
-        before: parsed.cursorBefore,
-        after: parsed.cursorAfter,
-    };
-    return { headers: parsed.raw, body: data, cursors };
-}
-async function handleOffsetPagination(client, endpoint, method, requiresAuth, parsed, data, body, url, useETag, pageFetch, templatePath) {
-    const totalPages = parsed.xPages;
-    if (totalPages <= 1) {
-        return { headers: parsed.raw, body: data };
-    }
-    (0, loggerUtil_1.logInfo)(`Found ${totalPages} pages, fetching additional pages with rate limiting...`);
-    try {
-        const firstPageData = Array.isArray(data) ? data : [data];
-        const allData = await PaginationHandler_1.PaginationHandler.fetchRemainingPages(client, endpoint, method, requiresAuth, firstPageData, totalPages, body, {
-            maxPages: Math.min(totalPages, 1000),
-            stopOnEmptyPage: true,
-            maxRetries: 3,
-        }, pageFetch, templatePath);
-        cacheResponse(client, url, method, endpoint, parsed, allData, useETag);
-        return { headers: parsed.raw, body: allData };
-    }
-    catch (paginationError) {
-        const msg = paginationError instanceof Error
-            ? paginationError.message
-            : String(paginationError);
-        (0, loggerUtil_1.logWarn)(`Pagination failed, returning first page only: ${msg}`);
-        return { headers: parsed.raw, body: data };
-    }
-}
-// --- Response interceptor wrapper ---
-async function applyResponseInterceptors(client, result, url, endpoint, method, startTime) {
-    const middleware = client.getMiddleware();
-    if (!middleware.hasInterceptors())
-        return result;
-    const responseCtx = {
-        url,
-        endpoint,
-        method,
-        status: 200,
-        headers: result.headers,
-        body: result.body,
-        durationMs: Date.now() - startTime,
-        fromCache: result.fromCache ?? false,
-    };
-    const modified = await middleware.applyResponseInterceptors(responseCtx);
-    return {
-        ...result,
-        headers: modified.headers,
-        body: modified.body,
-    };
-}
-// --- Main request functions ---
-async function applyRequestMiddleware(client, url, endpoint, method, headers, body) {
-    const middleware = client.getMiddleware();
-    if (!middleware.hasInterceptors()) {
-        return { url, headers, body };
-    }
-    const reqCtx = {
-        url,
-        endpoint,
-        method,
-        headers: { ...headers },
-        body,
-    };
-    const modified = await middleware.applyRequestInterceptors(reqCtx);
-    return {
-        url: modified.url,
-        headers: modified.headers,
-        body: modified.body,
-    };
-}
-function handleErrorResponse(client, response, url, parsed, useETag) {
-    const errorMessage = STATUS_MESSAGES[response.status] || response.statusText;
-    if (response.status >= 500 && useETag) {
-        const staleResult = tryStaleCacheResponse(client, url, parsed);
-        if (staleResult) {
-            (0, loggerUtil_1.logWarn)(`${errorMessage} for ${url} — serving stale cache`);
-            return staleResult;
-        }
-    }
-    if (response.status === 420 || response.status === 429) {
-        (0, loggerUtil_1.logWarn)(`Rate limited (${response.status}) on ${url}`);
-    }
-    throw new error_1.EsiError(response.status, errorMessage, url, parsed.requestId ?? undefined);
-}
-function wrapError(error) {
-    if (error instanceof error_1.EsiError || error instanceof CircuitBreaker_1.CircuitOpenError) {
-        throw error;
-    }
-    if (error instanceof Error) {
-        (0, loggerUtil_1.logError)(`Unexpected error: ${error.message}`);
-        throw (0, error_1.buildError)(error.message, 'ESIJS_ERROR');
-    }
-    (0, loggerUtil_1.logError)(`Unexpected error: ${String(error)}`);
-    throw (0, error_1.buildError)(String(error), 'ESIJS_ERROR');
-}
-async function executeSingleFetch(client, endpoint, method, body, requiresAuth, useETag, requestTimeout, templatePath) {
-    const rawUrl = `${client.getLink()}/${endpoint}`;
-    const builtHeaders = buildRequestHeaders(client, rawUrl, method, requiresAuth, useETag, body);
-    const req = await applyRequestMiddleware(client, rawUrl, endpoint, method, builtHeaders, body);
-    const options = {
-        method,
-        headers: req.headers,
-        body: req.body ? JSON.stringify(req.body) : undefined,
-    };
-    const url = req.url;
-    (0, loggerUtil_1.logInfo)(`Hitting endpoint: ${url}`);
-    const cb = resolveCircuitBreaker(client);
-    if (cb)
-        cb.checkCircuit(endpoint);
-    const rateLimiter = resolveRateLimiter(client);
-    await rateLimiter.checkRateLimit(templatePath, method, req.headers);
-    const timeoutMs = requestTimeout ?? client.getTimeout();
-    const controller = new AbortController();
-    const timer = globalThis.setTimeout(() => controller.abort(), timeoutMs);
-    options.signal = controller.signal;
-    let response;
-    try {
-        response = await fetch(url, options);
-    }
-    catch (err) {
-        clearTimeout(timer);
-        if (err instanceof Error && err.name === 'AbortError') {
-            throw new error_1.TimeoutError(timeoutMs, url);
-        }
-        throw err;
-    }
-    clearTimeout(timer);
-    const parsed = (0, headersUtil_1.parseHeaders)(response.headers);
-    rateLimiter.updateFromResponse(parsed.raw, response.status, templatePath, method, req.headers);
-    if (cb) {
-        if (response.status >= 500 ||
-            response.status === 420 ||
-            response.status === 429) {
-            cb.recordFailure(endpoint, response.status);
-        }
-        else {
-            cb.recordSuccess(endpoint);
-        }
-    }
-    if (parsed.warning) {
-        (0, loggerUtil_1.logWarn)(`ESI Warning ${parsed.warning.code} for ${url}: ${parsed.warning.message}`);
-    }
-    return { response, parsed, url };
-}
-async function fetchOnePage(client, endpoint, method, body, requiresAuth = false, useETag = false, requestTimeout, templatePath) {
-    const { response, parsed, url } = await executeSingleFetch(client, endpoint, method, body, requiresAuth, useETag, requestTimeout, templatePath);
-    if (!response.ok) {
-        throw new error_1.EsiError(response.status, STATUS_MESSAGES[response.status] || response.statusText, url, parsed.requestId ?? undefined);
-    }
-    const data = await parseJsonBody(response, url);
-    return { data, parsed, url };
-}
-const executeRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, requestTimeout, templatePath) => {
-    const startTime = Date.now();
-    const finish = (r) => {
-        r.responseTimeMs = Date.now() - startTime;
-        const rawUrl = `${client.getLink()}/${endpoint}`;
-        return applyResponseInterceptors(client, r, rawUrl, endpoint, method, startTime);
-    };
-    try {
-        const { response, parsed, url } = await executeSingleFetch(client, endpoint, method, body, requiresAuth, useETag, requestTimeout, templatePath);
-        if (response.status === 201) {
-            let data;
-            try {
-                data = (await response.json());
-            }
-            catch {
-                data = undefined;
-            }
-            return finish({ headers: parsed.raw, body: data });
-        }
-        const earlyResult = handleEarlyStatus(client, response.status, url, parsed, useETag);
-        if (earlyResult)
-            return finish(earlyResult);
-        if (!response.ok) {
-            const staleOrThrow = handleErrorResponse(client, response, url, parsed, useETag);
-            return finish(staleOrThrow);
-        }
-        const data = await parseJsonBody(response, url);
-        cacheResponse(client, url, method, endpoint, parsed, data, useETag);
-        const cursorResult = handleCursorPagination(parsed, data);
-        if (cursorResult)
-            return finish(cursorResult);
-        const pageFetch = async (paginatedEndpoint) => {
-            const result = await fetchOnePage(client, paginatedEndpoint, method, body, requiresAuth, false, requestTimeout, templatePath);
-            return Array.isArray(result.data)
-                ? result.data
-                : [result.data];
-        };
-        const paginatedResult = await handleOffsetPagination(client, endpoint, method, requiresAuth, parsed, data, body, url, useETag, pageFetch, templatePath);
-        return finish(paginatedResult);
-    }
-    catch (error) {
-        wrapError(error);
-    }
-};
-const handleSinglePageRequest = async (client, endpoint, method, body, requiresAuth = false) => {
-    const { data, parsed } = await fetchOnePage(client, endpoint, method, body, requiresAuth);
-    return { headers: parsed.raw, body: data };
-};
-exports.handleSinglePageRequest = handleSinglePageRequest;
-const handleRequest = async (client, endpoint, method, body, requiresAuth = false, useETag = true, templatePath, requestTimeout) => {
-    const rawUrl = `${client.getLink()}/${endpoint}`;
-    const specHit = trySpecAwareCacheHit(client, rawUrl, method, templatePath);
-    if (specHit)
-        return specHit;
-    const doExecute = () => executeRequest(client, endpoint, method, body, requiresAuth, useETag, requestTimeout, templatePath);
-    const dedup = client.getDeduplicator();
-    const canDedup = dedup && method === 'GET' && !body;
-    const retryConfig = client.getRetryConfig();
-    const maxRetries = retryConfig?.maxRetries ?? 0;
-    const canRetryMethod = method === 'GET' || retryConfig?.retryMutations === true;
-    const baseDelayMs = retryConfig?.baseDelayMs ?? 1000;
-    const maxDelayMs = retryConfig?.maxDelayMs ?? 30000;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        try {
-            return canDedup
-                ? await dedup.dedupe(endpoint, doExecute)
-                : await doExecute();
-        }
-        catch (error) {
-            if (error instanceof CircuitBreaker_1.CircuitOpenError) {
-                throw error;
-            }
-            if (error instanceof error_1.EsiError &&
-                error.statusCode === 401 &&
-                requiresAuth &&
-                client.hasTokenProvider()) {
-                (0, loggerUtil_1.logInfo)('Received 401, attempting token refresh...');
-                try {
-                    await client.refreshToken();
-                    (0, loggerUtil_1.logInfo)('Token refreshed, retrying request');
-                    return await executeRequest(client, endpoint, method, body, requiresAuth, useETag, requestTimeout);
-                }
-                catch (refreshError) {
-                    if (refreshError instanceof error_1.EsiError) {
-                        throw refreshError;
-                    }
-                    const msg = refreshError instanceof Error
-                        ? refreshError.message
-                        : String(refreshError);
-                    (0, loggerUtil_1.logError)(`Token refresh failed: ${msg}`);
-                    throw (0, error_1.buildError)(`Token refresh failed: ${msg}`, 'TOKEN_REFRESH_FAILED');
-                }
-            }
-            if (error instanceof error_1.EsiError &&
-                error.retryable &&
-                canRetryMethod &&
-                attempt < maxRetries) {
-                const delay = (0, retry_1.retryDelay)(attempt, baseDelayMs, maxDelayMs);
-                (0, loggerUtil_1.logWarn)(`Request to ${endpoint} failed (${error.statusCode}), retrying in ${Math.round(delay)}ms (attempt ${attempt + 1}/${maxRetries})`);
-                await (0, sleep_1.sleep)(delay);
-                lastError = error;
-                continue;
-            }
-            throw error;
-        }
-    }
-    throw lastError;
-};
-exports.handleRequest = handleRequest;

package/dist/core/BatchRequestHandler.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.batchFetch = batchFetch;
-exports.batchPost = batchPost;
-const error_1 = require("./util/error");
-const loggerUtil_1 = require("./logger/loggerUtil");
-async function batchFetch(keys, fetcher, options = {}) {
-    const concurrency = options.concurrency ?? 20;
-    const results = new Map();
-    const errors = new Map();
-    let completed = 0;
-    let running = 0;
-    let index = 0;
-    (0, loggerUtil_1.logInfo)(`Batch fetch: ${keys.length} items, concurrency=${concurrency}`);
-    return new Promise((resolve) => {
-        function next() {
-            while (running < concurrency && index < keys.length) {
-                const currentIndex = index++;
-                const key = keys[currentIndex];
-                running++;
-                fetcher(key)
-                    .then((result) => {
-                    results.set(key, result);
-                })
-                    .catch((err) => {
-                    const error = err instanceof error_1.EsiError || err instanceof Error
-                        ? err
-                        : new Error(String(err));
-                    errors.set(key, error);
-                })
-                    .finally(() => {
-                    running--;
-                    completed++;
-                    if (options.onProgress) {
-                        options.onProgress(completed, keys.length);
-                    }
-                    if (completed === keys.length) {
-                        (0, loggerUtil_1.logDebug)(`Batch complete: ${results.size} succeeded, ${errors.size} failed`);
-                        resolve({ results, errors });
-                    }
-                    else {
-                        next();
-                    }
-                });
-            }
-        }
-        if (keys.length === 0) {
-            resolve({ results, errors });
-            return;
-        }
-        next();
-    });
-}
-async function batchPost(ids, poster, chunkSize = 1000) {
-    const chunks = [];
-    for (let i = 0; i < ids.length; i += chunkSize) {
-        chunks.push(ids.slice(i, i + chunkSize));
-    }
-    (0, loggerUtil_1.logInfo)(`Batch POST: ${ids.length} IDs in ${chunks.length} chunks of ${chunkSize}`);
-    const results = [];
-    for (const chunk of chunks) {
-        const chunkResult = await poster(chunk);
-        results.push(...chunkResult);
-    }
-    return results;
-}