@paroicms/server-image-cache-engine/dist/internal/task-processor.js

The image variant engine that we use at Paroi.

import { fetchImageVariantWithBinary, insertIntoImageVariant, insertIntoPaImageCacheOwner, } from "./queries.js";
import { resizeImage } from "./resizer.js";
export async function processAllPending(context) {
    while (true) {
        const taskKey = context.queue.shift();
        if (!taskKey)
            break;
        const pth = context.pendingTasks.get(taskKey);
        if (!pth) {
            context.logger.error(`Missing pending variant '${taskKey}'`);
            continue;
        }
        const { task, resolve, reject } = pth;
        try {
            const result = await executeTask(task, context);
            resolve(result);
        }
        catch (error) {
            context.logger.error(`[image-cache-engine] image '${task.variant.mediaId}', '${task.variant.rawSizeName}':`, error, task);
            reject(error);
        }
        context.pendingTasks.delete(taskKey);
        for (const oneOwnerKey of pth.ownerKeys) {
            context.pendingTaskByOwnerKeys.delete(oneOwnerKey);
        }
    }
}
async function executeTask(task, ctx) {
    const found = await fetchImageVariantWithBinary(ctx, task.variant);
    if (found) {
        if (task.owners.size > 0) {
            await insertIntoPaImageCacheOwner(ctx, {
                imageCacheId: found.id,
                owners: Array.from(task.owners.values()),
            });
        }
        return found.variant;
    }
    const origBinaryFile = await ctx.getOriginalImage(task.variant.mediaId);
    const result = await resizeImage({
        binaryFile: origBinaryFile,
        rawSize: task.variant,
        formatTo: task.variant.mediaType !== task.input.sourceImage.mediaType
            ? {
                mediaType: task.variant.mediaType,
            }
            : undefined,
        qualityPolicy: ctx.qualityPolicy,
    });
    const { lastModified } = await insertIntoImageVariant(ctx, {
        resourceVersion: task.variant.resourceVersion,
        mediaId: task.variant.mediaId,
        mediaType: result.mediaType,
        rawWidth: result.rawWidth,
        rawHeight: result.rawHeight,
        weightB: result.weightB,
        binaryFile: result.binaryFile,
        slug: task.variant.slug,
    }, Array.from(task.owners.values()));
    return {
        ...result,
        mediaId: task.variant.mediaId,
        resourceVersion: task.variant.resourceVersion,
        rawSizeName: task.variant.rawSizeName,
        slug: task.variant.slug,
        lastModified,
    };
}
//# sourceMappingURL=task-processor.js.map