@paroicms/server/dist/request-tracking/request-state.js

The ParoiCMS server

let requestIdSeq = 0;
export function generateRequestId() {
    return String(++requestIdSeq);
}
export function trackRequest(siteContext, requestId) {
    siteContext.requestTracker.pendingRequests.add(requestId);
}
export function untrackRequest(siteContext, requestId) {
    siteContext.requestTracker.pendingRequests.delete(requestId);
}
export async function waitForPendingRequests(siteContext, timeoutMs, options) {
    const { logger, requestTracker } = siteContext;
    if (requestTracker.pendingRequests.size === 0 ||
        (options?.acceptOnePending && requestTracker.pendingRequests.size === 1)) {
        return;
    }
    logger.info(`Waiting for ${requestTracker.pendingRequests.size} pending requests...`);
    return new Promise((resolve) => {
        const timeout = setTimeout(() => {
            logger.warn(`Timeout waiting for pending requests. Proceeding with ${requestTracker.pendingRequests.size} requests still active.`);
            resolve();
        }, timeoutMs);
        const checkInterval = setInterval(() => {
            if (requestTracker.pendingRequests.size === 0) {
                clearTimeout(timeout);
                clearInterval(checkInterval);
                logger.info("All pending requests completed");
                resolve();
            }
        }, 100);
    });
}
export function initializeRequestTracker(siteContext) {
    siteContext.requestTracker = {
        pendingRequests: new Set(),
        requestQueue: [],
        state: "normal",
    };
}
export function setRequestTrackerState(siteContext, state) {
    siteContext.requestTracker.state = state;
}
export function logRequestTrackerStats(siteContext) {
    const { pendingRequests, requestQueue, state } = siteContext.requestTracker;
    siteContext.logger.debug(`Request tracker stats: state=${state}, pending=${pendingRequests.size}, queued=${requestQueue.length}`);
}
export function processQueuedRequests(siteContext) {
    const { requestQueue } = siteContext.requestTracker;
    const queuedCount = requestQueue.length;
    if (queuedCount > 0) {
        siteContext.logger.info(`Processing ${queuedCount} queued requests`);
        while (requestQueue.length > 0) {
            const queued = requestQueue.shift();
            if (queued) {
                clearTimeout(queued.timeout);
                queued.resolve();
            }
        }
    }
}
export function rejectQueuedRequests(siteContext, error) {
    const { requestQueue } = siteContext.requestTracker;
    const queuedCount = requestQueue.length;
    if (queuedCount > 0) {
        siteContext.logger.warn(`Rejecting ${queuedCount} queued requests due to error`);
        while (requestQueue.length > 0) {
            const queued = requestQueue.shift();
            if (queued) {
                clearTimeout(queued.timeout);
                queued.reject(error);
            }
        }
    }
}
export async function queueRequest(siteContext, timeoutMs) {
    const { requestQueue } = siteContext.requestTracker;
    const maxQueueSize = 100;
    if (requestQueue.length >= maxQueueSize) {
        throw new Error("Request queue is full. Please try again later.");
    }
    return new Promise((resolve, reject) => {
        const timeout = setTimeout(() => {
            const index = requestQueue.findIndex((q) => q.resolve === resolve);
            if (index >= 0) {
                requestQueue.splice(index, 1);
            }
            reject(new Error("Request timeout while waiting for backup to complete"));
        }, timeoutMs);
        requestQueue.push({
            resolve,
            reject,
            timeout,
        });
    });
}
//# sourceMappingURL=request-state.js.map