@researchdatabox/redbox-core 5.1.0-beta.12568 → 5.1.0-beta.13939

package/dist/services/ExportService.js

@@ -0,0 +1,609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Services = exports.EXPORT_METADATA_RETENTION_MS = exports.EXPORT_STALE_MS = exports.EXPORT_HEARTBEAT_MS = exports.ExportServiceError = void 0;
+const node_crypto_1 = require("node:crypto");
+const rxjs_1 = require("rxjs");
+const luxon_1 = require("luxon");
+const CoreService_1 = require("../CoreService");
+const agendaQueue_config_1 = require("../config/agendaQueue.config");
+class ExportServiceError extends Error {
+    status;
+    code;
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.name = 'ExportServiceError';
+    }
+}
+exports.ExportServiceError = ExportServiceError;
+exports.EXPORT_HEARTBEAT_MS = 15000;
+exports.EXPORT_STALE_MS = 5 * 60 * 1000;
+exports.EXPORT_METADATA_RETENTION_MS = 24 * 60 * 60 * 1000;
+const PREFIX = 'exports/';
+const JOB_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+function roleBrandId(role) {
+    const branding = role.branding;
+    if (typeof branding === 'string' || typeof branding === 'number')
+        return String(branding);
+    return branding && typeof branding === 'object' && 'id' in branding ? String(branding.id) : '';
+}
+function authorizationContext(context) {
+    const roles = context.user.roles
+        .filter(role => roleBrandId(role) === String(context.brand.id))
+        .map(role => [String(role.id), role.name])
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify({ id: context.user.id, username: context.user.username, roles }))
+        .digest('hex');
+}
+function iso(value) {
+    return value === null ? null : new Date(value).toISOString();
+}
+function normalizeDate(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    if (typeof value !== 'string' || !/(?:Z|[+-]\d{2}:\d{2})$/.test(value)) {
+        throw new ExportServiceError(400, 'export-invalid-date', 'Export dates must be ISO timestamps with a timezone.');
+    }
+    const date = luxon_1.DateTime.fromISO(value, { setZone: true });
+    const normalized = date.isValid ? date.toUTC().toISO() : null;
+    if (normalized === null)
+        throw new ExportServiceError(400, 'export-invalid-date', 'Export dates must be valid timestamps.');
+    return normalized;
+}
+var Services;
+(function (Services) {
+    /** Background CSV lifecycle. All binary I/O stays behind the configured StorageManager disk. */
+    class Export extends CoreService_1.Services.Core.Service {
+        _exportedMethods = [
+            'init',
+            'createJob',
+            'listJobs',
+            'getJob',
+            'deleteJob',
+            'openDownload',
+            'generateCsvJob',
+            'maintenanceJob',
+        ];
+        indexesReady;
+        async init() {
+            // The storage manager creates disks after ready; config validation does not resolve a disk yet.
+            try {
+                this.settings();
+            }
+            catch (error) {
+                if (!(error instanceof ExportServiceError))
+                    throw error;
+                // Export availability must not prevent deployments with custom disk maps from lifting.
+                this.updateChronicle({ exportOperation: 'init-config' }, [error]);
+            }
+            await this.ensureIndexes();
+        }
+        collection() {
+            return ExportJob.getDatastore().manager.collection(ExportJob.tableName);
+        }
+        ensureIndexes() {
+            this.indexesReady ??= (async () => {
+                const collection = this.collection();
+                await collection.createIndex({ jobId: 1 }, { unique: true });
+                await collection.createIndex({ brandId: 1, portal: 1, requestedByUserId: 1, createdAt: -1 });
+                await collection.createIndex({ status: 1, heartbeatAt: 1 });
+                await collection.createIndex({ status: 1, expiresAt: 1 });
+                await collection.createIndex({ status: 1, createdAt: 1, enqueuedAt: 1 });
+                await collection.createIndex({ status: 1, enqueuedAt: 1 });
+                await collection.createIndex({ diskName: 1, objectKey: 1 });
+            })().catch(error => {
+                this.indexesReady = undefined;
+                throw error;
+            });
+            return this.indexesReady;
+        }
+        settings() {
+            const config = sails.config.record.export.background;
+            const diskName = config?.diskName ?? 'exports';
+            const retentionHours = config?.retentionHours ?? 24;
+            const maxRunMinutes = config?.maxRunMinutes ?? 60;
+            const maxQueueMinutes = config?.maxQueueMinutes ?? 24 * 60;
+            const queueMs = maxQueueMinutes * 60000;
+            const retentionMs = retentionHours * 3600000;
+            const runMs = maxRunMinutes * 60000;
+            if (typeof retentionHours !== 'number' ||
+                typeof maxRunMinutes !== 'number' ||
+                typeof maxQueueMinutes !== 'number' ||
+                !Number.isSafeInteger(queueMs) ||
+                queueMs <= 0 ||
+                typeof diskName !== 'string' ||
+                !diskName ||
+                !Number.isSafeInteger(retentionMs) ||
+                retentionMs <= 0 ||
+                !Number.isSafeInteger(runMs) ||
+                runMs <= 0 ||
+                runMs > 2147483647) {
+                throw new ExportServiceError(503, 'export-invalid-config', 'Background export configuration is invalid.');
+            }
+            this.validateDisk(diskName);
+            return { diskName, retentionMs, runMs, queueMs };
+        }
+        validateDisk(diskName) {
+            try {
+                const config = StorageManagerService.getDiskConfig(diskName);
+                if (config.config.visibility !== 'private')
+                    throw new Error('Export disk must be private.');
+            }
+            catch {
+                throw new ExportServiceError(503, 'export-storage-unavailable', 'The configured private export disk is unavailable.');
+            }
+        }
+        async disk(diskName) {
+            this.validateDisk(diskName);
+            await StorageManagerService.bootstrap();
+            return StorageManagerService.disk(diskName);
+        }
+        async effectiveContext(context) {
+            if (!context.brand?.id || !context.brand.name || !context.portal || !context.user?.id) {
+                throw new ExportServiceError(403, 'export-access-denied', 'Export access is unavailable.');
+            }
+            const user = await (0, rxjs_1.firstValueFrom)(UsersService.getEffectiveUser(context.user.id));
+            if (!user || user.loginDisabled || user.effectiveLoginDisabled || !user.id || !user.username) {
+                throw new ExportServiceError(403, 'export-access-denied', 'Export access is unavailable.');
+            }
+            const rules = PathRulesService.getRulesFromPath(`/${context.brand.name}/${context.portal}/export/record/download/csv`, context.brand);
+            const roles = user.roles.filter(role => roleBrandId(role) === String(context.brand.id));
+            const allowed = rules
+                ? PathRulesService.canRead(rules, roles.map(role => ({ id: role.id, name: role.name })), context.brand.name)
+                : roles.some(role => role.name === 'Admin' || role.name === 'Librarians');
+            if (!allowed)
+                throw new ExportServiceError(403, 'export-access-denied', 'You no longer have permission to export records.');
+            return { ...context, user };
+        }
+        scope(context) {
+            return { brandId: String(context.brand.id), portal: context.portal, requestedByUserId: String(context.user.id) };
+        }
+        dto(job) {
+            if (job.status === 'deleted')
+                throw new ExportServiceError(404, 'export-not-found', 'The export was not found.');
+            const expired = job.expiresAt !== null && job.expiresAt <= Date.now();
+            const status = expired ? 'expired' : job.status;
+            return {
+                id: job.jobId,
+                recordType: job.recordType,
+                format: job.format,
+                modifiedBefore: job.modifiedBefore,
+                modifiedAfter: job.modifiedAfter,
+                status,
+                createdAt: new Date(job.createdAt).toISOString(),
+                startedAt: iso(job.startedAt),
+                completedAt: iso(job.completedAt),
+                expiresAt: iso(job.expiresAt),
+                filename: job.filename,
+                byteLength: job.byteLength,
+                downloadUrl: status === 'ready' ? `export/jobs/${encodeURIComponent(job.jobId)}/download` : null,
+                errorCode: job.errorCode,
+                errorMessage: job.errorMessage,
+            };
+        }
+        async createJob(context, input, filename) {
+            const settings = this.settings();
+            const effective = await this.effectiveContext(context);
+            if (!input ||
+                input.format !== 'csv' ||
+                typeof input.recType !== 'string' ||
+                !input.recType ||
+                input.recType.length > 200) {
+                throw new ExportServiceError(400, 'export-invalid-request', 'Select a valid record type and CSV format.');
+            }
+            const modifiedBefore = normalizeDate(input.before);
+            const modifiedAfter = normalizeDate(input.after);
+            if (modifiedBefore && modifiedAfter && modifiedBefore < modifiedAfter) {
+                throw new ExportServiceError(400, 'export-invalid-range', 'The start date must not be after the end date.');
+            }
+            if (!(await (0, rxjs_1.firstValueFrom)(RecordTypesService.get(effective.brand, input.recType)))) {
+                throw new ExportServiceError(400, 'export-invalid-record-type', 'The selected record type does not exist.');
+            }
+            await this.ensureIndexes();
+            const row = {
+                jobId: (0, node_crypto_1.randomUUID)(),
+                brandId: String(effective.brand.id),
+                portal: effective.portal,
+                requestedByUserId: String(effective.user.id),
+                recordType: input.recType,
+                format: 'csv',
+                modifiedBefore,
+                modifiedAfter,
+                status: 'queued',
+                createdAt: Date.now(),
+                enqueuedAt: null,
+                startedAt: null,
+                completedAt: null,
+                expiresAt: null,
+                attemptId: null,
+                heartbeatAt: null,
+                deadlineAt: null,
+                cleanupAfter: null,
+                diskName: settings.diskName,
+                objectKey: null,
+                byteLength: null,
+                filename,
+                authorizationContext: null,
+                errorCode: null,
+                errorMessage: null,
+                cleanedAt: null,
+            };
+            await this.collection().insertOne(row);
+            try {
+                await AgendaQueueService.now(agendaQueue_config_1.EXPORT_GENERATE_JOB_NAME, { jobId: row.jobId });
+                row.enqueuedAt = Date.now();
+                await this.collection().updateOne({ jobId: row.jobId }, { $set: { enqueuedAt: row.enqueuedAt } });
+            }
+            catch (error) {
+                this.updateChronicle({ exportJobId: row.jobId, exportOperation: 'enqueue' }, [error]);
+                await this.fail(row.jobId, { status: 'queued' }, 'export-enqueue-failed', 'The export could not be queued. Prepare it again.');
+                throw new ExportServiceError(503, 'export-enqueue-failed', 'The export could not be queued. Prepare it again.');
+            }
+            return this.dto(row);
+        }
+        async listJobs(context) {
+            const effective = await this.effectiveContext(context);
+            const rows = await this.collection()
+                .find({ ...this.scope(effective), status: { $ne: 'deleted' } })
+                .sort({ createdAt: -1, jobId: -1 })
+                .limit(20)
+                .toArray();
+            return rows.map(row => this.dto(row));
+        }
+        async ownedJob(context, id, includeDeleted = false) {
+            const effective = await this.effectiveContext(context);
+            const row = typeof id === 'string' && JOB_ID.test(id)
+                ? await this.collection().findOne({
+                    ...this.scope(effective),
+                    jobId: id,
+                    ...(includeDeleted ? {} : { status: { $ne: 'deleted' } }),
+                })
+                : null;
+            if (!row)
+                throw new ExportServiceError(404, 'export-not-found', 'The export was not found.');
+            return { context: effective, row };
+        }
+        async getJob(context, id) {
+            return this.dto((await this.ownedJob(context, id)).row);
+        }
+        async deleteJob(context, id) {
+            const { context: effective, row } = await this.ownedJob(context, id, true);
+            if (row.status === 'queued' || row.status === 'running') {
+                throw new ExportServiceError(409, 'export-in-progress', 'Wait for export preparation to finish before deleting it.');
+            }
+            let deleted = row;
+            if (row.status !== 'deleted') {
+                const now = Date.now();
+                // Revoke access before touching storage. Keep any existing grace period for a failed
+                // worker whose remote upload might still be settling; its late cleanup can also retry.
+                const changed = await this.collection().findOneAndUpdate({ ...this.scope(effective), jobId: id, status: { $in: ['ready', 'failed', 'expired'] } }, {
+                    $set: {
+                        status: 'deleted',
+                        expiresAt: now,
+                        cleanupAfter: Math.max(now, row.cleanupAfter ?? now),
+                    },
+                }, { returnDocument: 'after', includeResultMetadata: false });
+                const current = changed ?? (await this.collection().findOne({ ...this.scope(effective), jobId: id }));
+                if (!current || current.status !== 'deleted')
+                    throw new ExportServiceError(404, 'export-not-found', 'The export was not found.');
+                deleted = current;
+            }
+            if (deleted.cleanedAt === null && deleted.cleanupAfter !== null && deleted.cleanupAfter <= Date.now()) {
+                await this.cleanupArtifact(deleted);
+            }
+        }
+        async openDownload(context, id) {
+            const { context: effective, row } = await this.ownedJob(context, id);
+            if (row.status === 'expired' || (row.expiresAt !== null && row.expiresAt <= Date.now())) {
+                throw new ExportServiceError(410, 'export-expired', 'This export has expired. Prepare another export.');
+            }
+            if (row.status !== 'ready' || !row.objectKey || row.byteLength === null) {
+                throw new ExportServiceError(409, 'export-not-ready', 'The export is not ready to download.');
+            }
+            if (row.authorizationContext !== authorizationContext(effective)) {
+                throw new ExportServiceError(403, 'export-authorization-changed', 'Your account permissions have changed. Prepare another export.');
+            }
+            try {
+                const disk = await this.disk(row.diskName);
+                const stream = await disk.getStream(row.objectKey);
+                let readError;
+                const keepReadError = (error) => {
+                    readError = error;
+                };
+                stream.on('error', keepReadError);
+                try {
+                    // Recheck after opening storage: deletion or expiry may have won during that await.
+                    const current = await this.collection().findOne({ ...this.scope(effective), jobId: id });
+                    if (!current || current.status === 'deleted')
+                        throw new ExportServiceError(404, 'export-not-found', 'The export was not found.');
+                    if (current.status === 'expired' || (current.expiresAt !== null && current.expiresAt <= Date.now()))
+                        throw new ExportServiceError(410, 'export-expired', 'This export has expired. Prepare another export.');
+                    if (readError)
+                        throw readError;
+                    return { stream, filename: row.filename, byteLength: row.byteLength };
+                }
+                catch (error) {
+                    stream.destroy();
+                    throw error;
+                }
+                finally {
+                    stream.off('error', keepReadError);
+                }
+            }
+            catch (error) {
+                if (error instanceof ExportServiceError)
+                    throw error;
+                this.updateChronicle({ exportJobId: row.jobId, exportOperation: 'download' }, [error]);
+                throw new ExportServiceError(503, 'export-file-unavailable', 'The prepared export is temporarily unavailable.');
+            }
+        }
+        async fail(jobId, filter, code, message) {
+            const now = Date.now();
+            await this.collection().updateOne({ jobId, ...filter }, {
+                $set: {
+                    status: 'failed',
+                    completedAt: now,
+                    expiresAt: now + this.settings().retentionMs,
+                    cleanupAfter: now + exports.EXPORT_STALE_MS,
+                    errorCode: code,
+                    errorMessage: message,
+                },
+            });
+        }
+        async generateCsvJob(job) {
+            const jobId = job.attrs?.data?.jobId;
+            if (typeof jobId !== 'string' || !JOB_ID.test(jobId))
+                return;
+            const settings = this.settings();
+            const now = Date.now();
+            const attemptId = (0, node_crypto_1.randomUUID)();
+            const row = await this.collection().findOneAndUpdate({ jobId, status: 'queued' }, {
+                $set: {
+                    status: 'running',
+                    attemptId,
+                    startedAt: now,
+                    heartbeatAt: now,
+                    deadlineAt: now + settings.runMs,
+                    objectKey: `${PREFIX}${jobId}/${attemptId}.csv`,
+                },
+            }, { returnDocument: 'after', includeResultMetadata: false });
+            if (!row)
+                return;
+            let source;
+            let stopped;
+            let rejectStop = () => { };
+            const stopping = new Promise((_resolve, reject) => {
+                rejectStop = reject;
+            });
+            const stop = (error) => {
+                if (stopped)
+                    return;
+                stopped = error;
+                source?.destroy(error);
+                rejectStop(error);
+            };
+            const assertActive = () => {
+                if (stopped)
+                    throw stopped;
+            };
+            let heartbeatBusy = false;
+            const heartbeat = setInterval(() => {
+                if (heartbeatBusy || stopped)
+                    return;
+                heartbeatBusy = true;
+                void (async () => {
+                    if (job.touch)
+                        await job.touch();
+                    const renewed = await this.collection().updateOne({ jobId, status: 'running', attemptId, heartbeatAt: { $gt: Date.now() - exports.EXPORT_STALE_MS } }, { $set: { heartbeatAt: Date.now() } });
+                    if (!renewed.matchedCount) {
+                        // Publication may win a race with an already-running heartbeat.
+                        const completed = await this.collection().findOne({ jobId, attemptId, status: 'ready' });
+                        if (!completed)
+                            throw new Error('Export claim is no longer active.');
+                    }
+                })()
+                    .catch(() => stop(new ExportServiceError(503, 'export-worker-interrupted', 'Export preparation was interrupted. Prepare it again.')))
+                    .finally(() => {
+                    heartbeatBusy = false;
+                });
+            }, exports.EXPORT_HEARTBEAT_MS);
+            heartbeat.unref();
+            const deadline = setTimeout(() => stop(new ExportServiceError(503, 'export-timed-out', 'Export preparation exceeded its time limit. Prepare it again.')), settings.runMs);
+            deadline.unref();
+            let settled = false;
+            const work = (async () => {
+                const brand = BrandingService.getBrandById(row.brandId);
+                const user = await (0, rxjs_1.firstValueFrom)(UsersService.getEffectiveUser(row.requestedByUserId));
+                if (!brand || !user)
+                    throw new ExportServiceError(403, 'export-access-denied', 'The requester no longer has export access.');
+                const effective = await this.effectiveContext({ brand, portal: row.portal, user });
+                const disk = await this.disk(row.diskName);
+                assertActive();
+                const roles = effective.user.roles.map(role => ({ ...role, branding: roleBrandId(role) }));
+                source = RecordsService.exportAllPlans(effective.user.username, roles, brand, 'csv', row.modifiedBefore, row.modifiedAfter, row.recordType);
+                // Keep errors handled even if a disk waits before attaching its stream consumer.
+                source.on('error', () => { });
+                await disk.putStream(row.objectKey, source, { visibility: 'private', contentType: 'text/csv' });
+                assertActive();
+                const metadata = await disk.getMetaData(row.objectKey);
+                assertActive();
+                if (!Number.isSafeInteger(metadata.contentLength) || metadata.contentLength < 0)
+                    throw new Error('Export storage returned an invalid length.');
+                const completedAt = Date.now();
+                const published = await this.collection().updateOne({
+                    jobId,
+                    status: 'running',
+                    attemptId,
+                    heartbeatAt: { $gt: completedAt - exports.EXPORT_STALE_MS },
+                    deadlineAt: { $gt: completedAt },
+                }, {
+                    $set: {
+                        status: 'ready',
+                        completedAt,
+                        expiresAt: completedAt + settings.retentionMs,
+                        byteLength: metadata.contentLength,
+                        authorizationContext: authorizationContext(effective),
+                    },
+                });
+                if (!published.matchedCount)
+                    throw new ExportServiceError(503, 'export-worker-interrupted', 'Export preparation was interrupted. Prepare it again.');
+            })().finally(() => {
+                settled = true;
+            });
+            // A deadline can win while a remote disk operation is still settling. Its late result must
+            // never publish; when it settles, remove its own attempt artifact through the same disk.
+            void work
+                .catch(async () => {
+                if (stopped)
+                    await this.cleanupArtifact(row);
+            })
+                .catch(error => {
+                this.updateChronicle({ exportJobId: jobId, exportOperation: 'late-cleanup' }, [error]);
+            });
+            try {
+                await Promise.race([work, stopping]);
+            }
+            catch (error) {
+                const failure = error instanceof ExportServiceError
+                    ? error
+                    : new ExportServiceError(503, 'export-generation-failed', 'The CSV could not be prepared. Prepare it again.');
+                source?.destroy();
+                this.updateChronicle({ exportJobId: jobId, exportOperation: 'generate' }, [error]);
+                await this.fail(jobId, { status: 'running', attemptId }, failure.code, failure.message);
+                if (settled)
+                    await this.cleanupArtifact(row);
+            }
+            finally {
+                clearInterval(heartbeat);
+                clearTimeout(deadline);
+            }
+        }
+        async cleanupArtifact(row) {
+            const current = await this.collection().findOne({ jobId: row.jobId, attemptId: row.attemptId });
+            // A storage acknowledgement or timer may race a successful publication. Never delete
+            // the published object, nor remove an object while its active worker still owns it.
+            if (current?.status === 'ready' || current?.status === 'running')
+                return;
+            if (!row.objectKey) {
+                await this.collection().updateOne({ jobId: row.jobId, status: { $in: ['failed', 'expired', 'deleted'] } }, { $set: { cleanedAt: Date.now() } });
+                return;
+            }
+            try {
+                const disk = await this.disk(row.diskName);
+                // Ordinary existence only promises readable files. GridFS also exposes incomplete
+                // uploads to cleanup, without changing availability checks for other disk consumers.
+                const exists = await disk.exists(row.objectKey);
+                const incomplete = !exists && (await disk.listIncompleteUploads?.(row.objectKey));
+                if (exists || (incomplete && incomplete.some(upload => upload.key === row.objectKey))) {
+                    await disk.delete(row.objectKey);
+                }
+                await this.collection().updateOne({ jobId: row.jobId, attemptId: row.attemptId, status: { $in: ['failed', 'expired', 'deleted'] } }, { $set: { cleanedAt: Date.now() } });
+            }
+            catch (error) {
+                this.updateChronicle({ exportJobId: row.jobId, exportOperation: 'cleanup' }, [error]);
+            }
+        }
+        async maintenanceJob(job) {
+            const { retentionMs, queueMs } = this.settings();
+            const collection = this.collection();
+            const now = Date.now();
+            await collection.updateMany({ status: 'queued', enqueuedAt: null, createdAt: { $lte: now - exports.EXPORT_STALE_MS } }, {
+                $set: {
+                    status: 'failed',
+                    completedAt: now,
+                    expiresAt: now + retentionMs,
+                    cleanupAfter: now,
+                    errorCode: 'export-enqueue-failed',
+                    errorMessage: 'Export submission was interrupted. Prepare it again.',
+                },
+            });
+            // An acknowledged delivery may be lost by the queue backend. Bound its wait
+            // separately from the short unacknowledged-submission and running-worker timeouts.
+            await collection.updateMany({ status: 'queued', enqueuedAt: { $ne: null, $lte: now - queueMs } }, {
+                $set: {
+                    status: 'failed',
+                    completedAt: now,
+                    expiresAt: now + retentionMs,
+                    cleanupAfter: now,
+                    errorCode: 'export-queue-timed-out',
+                    errorMessage: 'Export preparation did not start within its queue time limit. Prepare it again.',
+                },
+            });
+            await collection.updateMany({ status: 'running', $or: [{ heartbeatAt: { $lte: now - exports.EXPORT_STALE_MS } }, { deadlineAt: { $lte: now } }] }, {
+                $set: {
+                    status: 'failed',
+                    completedAt: now,
+                    expiresAt: now + retentionMs,
+                    cleanupAfter: now + exports.EXPORT_STALE_MS,
+                    errorCode: 'export-worker-interrupted',
+                    errorMessage: 'Export preparation was interrupted. Prepare it again.',
+                },
+            });
+            await collection.updateMany({ status: 'ready', expiresAt: { $lte: now } }, { $set: { status: 'expired', cleanupAfter: now } });
+            const cursor = collection
+                .find({ status: { $in: ['failed', 'expired', 'deleted'] }, cleanedAt: null, cleanupAfter: { $lte: now } })
+                .batchSize(100);
+            for await (const row of cursor) {
+                if (job?.touch)
+                    await job.touch();
+                await this.cleanupArtifact(row);
+            }
+            await collection.deleteMany({
+                status: { $in: ['failed', 'expired', 'deleted'] },
+                cleanedAt: { $ne: null },
+                expiresAt: { $lte: now - exports.EXPORT_METADATA_RETENTION_MS },
+            });
+            await this.reconcileOrphans(job);
+        }
+        async reconcileObject(diskName, disk, object, job) {
+            if (job?.touch)
+                await job.touch();
+            if (!object ||
+                typeof object !== 'object' ||
+                !('key' in object) ||
+                typeof object.key !== 'string' ||
+                !object.key.startsWith(PREFIX))
+                return;
+            // Cleanup listings may include uploads that cannot be read yet.
+            // Prefer a valid listing timestamp; only request metadata when it is absent.
+            const listedTime = 'lastModified' in object &&
+                object.lastModified instanceof Date &&
+                Number.isFinite(object.lastModified.getTime())
+                ? object.lastModified
+                : undefined;
+            const lastModified = listedTime ?? (await disk.getMetaData(object.key)).lastModified;
+            if (!Number.isFinite(lastModified.getTime()) || lastModified.getTime() > Date.now() - exports.EXPORT_STALE_MS)
+                return;
+            const referenced = await this.collection().findOne({ diskName, objectKey: object.key });
+            if (!referenced)
+                await disk.delete(object.key);
+        }
+        async reconcileOrphans(job) {
+            const diskNames = await this.collection().distinct('diskName');
+            diskNames.push(this.settings().diskName);
+            for (const diskName of new Set(diskNames)) {
+                try {
+                    const disk = await this.disk(diskName);
+                    let paginationToken;
+                    do {
+                        const page = await disk.listAll(PREFIX, { recursive: true, paginationToken });
+                        for (const object of page.objects) {
+                            await this.reconcileObject(diskName, disk, object, job);
+                        }
+                        paginationToken = page.paginationToken;
+                    } while (paginationToken);
+                    for (const upload of (await disk.listIncompleteUploads?.(PREFIX)) ?? []) {
+                        await this.reconcileObject(diskName, disk, upload, job);
+                    }
+                }
+                catch (error) {
+                    this.updateChronicle({ exportOperation: 'orphan-cleanup', exportDisk: diskName }, [error]);
+                }
+            }
+        }
+    }
+    Services.Export = Export;
+})(Services || (exports.Services = Services = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ExportService.js","sourceRoot":"","sources":["../../src/services/ExportService.ts"],"names":[],"mappings":"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"}