includio-cms 0.36.6 → 0.36.8

package/dist/core/server/media/jobs/startWorker.js

@@ -0,0 +1,29 @@
+import { randomUUID } from 'node:crypto';
+import { getCMS } from '../../../cms.js';
+import { startMediaWorker } from './worker.js';
+import { processImageStyleJob } from './processImageStyleJob.js';
+import { createImageStyle } from '../styles/operations/createMediaStyle.js';
+import { applySharpLimits } from '../styles/sharp/sharpConfig.js';
+/** Składa zależności i startuje in-process worker generacji wariantów. */
+export function startMediaOptimizationWorker() {
+    const cms = getCMS();
+    const opt = cms.mediaConfig.optimization ?? {};
+    const cfg = {
+        concurrency: opt.concurrency ?? 1,
+        maxAttempts: opt.maxAttempts ?? 3,
+        backoffBaseMs: opt.backoffBaseMs ?? 30_000,
+        staleLockMs: opt.staleLockMs ?? 300_000,
+        pollIntervalMs: opt.pollIntervalMs ?? 2_000,
+        limitPixels: opt.limitPixels ?? 100_000_000,
+        lockedBy: randomUUID()
+    };
+    applySharpLimits({ concurrency: cfg.concurrency, cacheMemoryMB: opt.cacheMemoryMB ?? 50 });
+    startMediaWorker(cfg, {
+        adapter: cms.databaseAdapter,
+        process: (job) => processImageStyleJob(job, {
+            createImageStyle,
+            getMediaFile: (id) => cms.databaseAdapter.getMediaFile({ data: { id } }),
+            limitPixels: cfg.limitPixels
+        })
+    });
+}

package/dist/core/server/media/jobs/worker.d.ts

@@ -0,0 +1,29 @@
+import type { MediaJob } from '../../../../types/adapters/db.js';
+import type { JobResult } from './processImageStyleJob.js';
+export interface WorkerConfig {
+    concurrency: number;
+    maxAttempts: number;
+    backoffBaseMs: number;
+    staleLockMs: number;
+    pollIntervalMs: number;
+    limitPixels: number;
+    lockedBy: string;
+}
+export interface WorkerAdapter {
+    claimNextMediaJob: (lockedBy: string) => Promise<MediaJob | null>;
+    completeMediaJob: (id: string) => Promise<void>;
+    failMediaJob: (id: string, error: string, opts: {
+        retry: boolean;
+        runAfter?: Date;
+    }) => Promise<void>;
+    resetStaleMediaJobs: (olderThan: Date) => Promise<number>;
+}
+export interface RunOnceDeps {
+    adapter: WorkerAdapter;
+    process: (job: MediaJob) => Promise<JobResult>;
+}
+/** Jeden cykl: claim → process → complete/fail (backoff + circuit-breaker). */
+export declare function runOnce(cfg: WorkerConfig, deps: RunOnceDeps): Promise<'processed' | 'idle'>;
+/** Startuje ciągłą pętlę workera (idempotentne). Concurrency=1: jeden job naraz. */
+export declare function startMediaWorker(cfg: WorkerConfig, deps: RunOnceDeps): void;
+export declare function stopMediaWorker(): void;

package/dist/core/server/media/jobs/worker.js

@@ -0,0 +1,54 @@
+/** Jeden cykl: claim → process → complete/fail (backoff + circuit-breaker). */
+export async function runOnce(cfg, deps) {
+    const job = await deps.adapter.claimNextMediaJob(cfg.lockedBy);
+    if (!job)
+        return 'idle';
+    const res = await deps.process(job);
+    if (res.ok) {
+        await deps.adapter.completeMediaJob(job.id);
+        return 'processed';
+    }
+    const willExhaust = job.attempts + 1 >= (job.maxAttempts ?? cfg.maxAttempts);
+    const retry = res.retry && !willExhaust;
+    const runAfter = new Date(Date.now() + cfg.backoffBaseMs * 2 ** job.attempts);
+    await deps.adapter.failMediaJob(job.id, res.error, { retry, runAfter });
+    return 'processed';
+}
+let running = false;
+let started = false;
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** Startuje ciągłą pętlę workera (idempotentne). Concurrency=1: jeden job naraz. */
+export function startMediaWorker(cfg, deps) {
+    if (started)
+        return;
+    started = true;
+    running = true;
+    const staleEvery = Math.max(1, Math.floor(cfg.staleLockMs / Math.max(1, cfg.pollIntervalMs)));
+    let cyclesSinceStale = 0;
+    const loop = async () => {
+        console.info(`[media] worker started (${cfg.lockedBy})`);
+        while (running) {
+            try {
+                if (cyclesSinceStale++ >= staleEvery) {
+                    cyclesSinceStale = 0;
+                    await deps.adapter.resetStaleMediaJobs(new Date(Date.now() - cfg.staleLockMs));
+                }
+                const r = await runOnce(cfg, deps);
+                if (r === 'idle')
+                    await sleep(cfg.pollIntervalMs);
+            }
+            catch (e) {
+                console.warn('[media] worker cycle error:', e);
+                await sleep(cfg.pollIntervalMs);
+            }
+        }
+        started = false;
+        console.info('[media] worker stopped');
+    };
+    void loop();
+}
+export function stopMediaWorker() {
+    running = false;
+}

package/dist/core/server/media/operations/replaceFile.js

@@ -1,7 +1,7 @@
 import { getCMS } from '../../../cms.js';
 import { generateBlurDataUrl } from '../utils/generateBlurDataUrl.js';
 import { generateAdminThumbnail } from '../utils/generateAdminThumbnail.js';
-import { generateDefaultStylesInBackground } from '../styles/operations/generateDefaultStyles.js';
+import { enqueueStyleSpecs } from '../jobs/enqueue.js';
 import { generateDefaultVideoStylesInBackground } from '../styles/operations/generateDefaultVideoStyles.js';
 export async function replaceFile(fileId, newFile) {
     const cms = getCMS();
@@ -76,7 +76,7 @@ export async function replaceFile(fileId, newFile) {
             blurDataUrl
         }
     });
-    generateDefaultStylesInBackground(updated);
+    void enqueueStyleSpecs(updated, undefined, {}).catch((e) => console.warn('[media] replace enqueue failed:', e));
     generateDefaultVideoStylesInBackground(updated);
     return updated;
 }

package/dist/core/server/media/operations/uploadFile.js

@@ -1,7 +1,9 @@
 import { getCMS } from '../../../cms.js';
 import { generateBlurDataUrl } from '../utils/generateBlurDataUrl.js';
 import { generateAdminThumbnail } from '../utils/generateAdminThumbnail.js';
-import { generateDefaultStylesInBackground } from '../styles/operations/generateDefaultStyles.js';
+import { generateFallbackVariant } from '../styles/operations/generateFallbackVariant.js';
+import { resolveImagesConfig } from '../styles/imagesConfig.js';
+import { enqueueStyleSpecs } from '../jobs/enqueue.js';
 import { generateDefaultVideoStylesInBackground } from '../styles/operations/generateDefaultVideoStyles.js';
 import sharp from 'sharp';
 import { withTimeout, sharpTimeoutMs } from '../../../../server/utils/withTimeout.js';
@@ -40,15 +42,18 @@ export async function uploadFile(file) {
     const uploadedFile = await getCMS().filesAdapter.uploadFile(file);
     let blurDataUrl = null;
     let thumbnailUrl = uploadedFile.thumbnailUrl ?? null;
+    let fallbackUrl = null;
     const isProcessableImage = uploadedFile.type === 'image' && !file.name.toLowerCase().endsWith('.svg');
     if (isProcessableImage) {
         try {
             const buffer = Buffer.from(await file.arrayBuffer());
             blurDataUrl = await generateBlurDataUrl(buffer);
             thumbnailUrl = await generateAdminThumbnail(buffer, uploadedFile);
+            const fallbackCfg = resolveImagesConfig(getCMS().mediaConfig.images).fallback;
+            fallbackUrl = await generateFallbackVariant(buffer, uploadedFile, fallbackCfg);
         }
         catch (e) {
-            console.warn('LQIP/thumbnail generation failed:', e);
+            console.warn('LQIP/thumbnail/fallback generation failed:', e);
         }
     }
     const created = await getCMS().databaseAdapter.createMediaFile({
@@ -61,12 +66,14 @@ export async function uploadFile(file) {
         posterUrl: uploadedFile.posterUrl ?? null,
         mimeType: uploadedFile.mimeType ?? null,
         blurDataUrl,
+        fallbackUrl,
         focalX: null,
         focalY: null,
         transcriptFileId: null,
         audioDescriptionFileId: null
     });
-    generateDefaultStylesInBackground(created);
+    // Kolejkuj generację wariantów w tle (worker media_job) zamiast fire-and-forget bez retry.
+    await enqueueStyleSpecs(created, undefined, {});
     generateDefaultVideoStylesInBackground(created);
     return created;
 }

package/dist/core/server/media/styles/buildStyleSpecs.d.ts

@@ -0,0 +1,12 @@
+import type { ImageFieldStyle } from '../../../../types/fields.js';
+import type { MediaFile } from '../../../../types/media.js';
+import type { ImagesConfig } from '../../../../types/cms.js';
+/**
+ * Zestaw konkretnych specyfikacji styli do wygenerowania dla danego media.
+ * - Jeśli pole ma własne `fieldStyles` — honorujemy je (mogą mieć własny format/crop/width).
+ * - Inaczej z configu: każdy format × każda szerokość ≤ min(oryginał, maxDimension).
+ *   BEZ wariantu bazowego pełno-res (to była bomba CPU i redundancja).
+ */
+export declare function buildStyleSpecs(mediaFile: Pick<MediaFile, 'id' | 'width' | 'height'>, fieldStyles: ImageFieldStyle[] | undefined, cfg: ImagesConfig): ImageFieldStyle[];
+/** Kanoniczny klucz dedupu po EFEKTYWNEJ specyfikacji (nie po nazwie). */
+export declare function styleDedupeKey(mediaFileId: string, s: ImageFieldStyle): string;

package/dist/core/server/media/styles/buildStyleSpecs.js

@@ -0,0 +1,36 @@
+/**
+ * Zestaw konkretnych specyfikacji styli do wygenerowania dla danego media.
+ * - Jeśli pole ma własne `fieldStyles` — honorujemy je (mogą mieć własny format/crop/width).
+ * - Inaczej z configu: każdy format × każda szerokość ≤ min(oryginał, maxDimension).
+ *   BEZ wariantu bazowego pełno-res (to była bomba CPU i redundancja).
+ */
+export function buildStyleSpecs(mediaFile, fieldStyles, cfg) {
+    if (fieldStyles && fieldStyles.length)
+        return fieldStyles;
+    const maxW = Math.min(mediaFile.width ?? cfg.maxDimension, cfg.maxDimension);
+    const widths = cfg.widths.filter((w) => w <= maxW);
+    const specs = [];
+    for (const format of cfg.formats) {
+        for (const w of widths) {
+            specs.push({
+                name: `default_${format}_${w}w`,
+                format: format,
+                width: w,
+                quality: cfg.quality[format]
+            });
+        }
+    }
+    return specs;
+}
+/** Kanoniczny klucz dedupu po EFEKTYWNEJ specyfikacji (nie po nazwie). */
+export function styleDedupeKey(mediaFileId, s) {
+    return [
+        mediaFileId,
+        s.format ?? '',
+        s.width ?? 0,
+        s.height ?? 0,
+        s.crop ? 1 : 0,
+        s.quality ?? 0,
+        s.aspectRatio ?? 0
+    ].join(':');
+}

package/dist/core/server/media/styles/imagesConfig.d.ts

@@ -0,0 +1,3 @@
+import type { ImagesConfig, ImagesConfigInput } from '../../../../types/cms.js';
+/** Łączy wejściową (płytko-partial) konfigurację obrazów z domyślną. */
+export declare function resolveImagesConfig(cfg?: ImagesConfigInput): ImagesConfig;

package/dist/core/server/media/styles/imagesConfig.js

@@ -0,0 +1,16 @@
+const DEFAULTS = {
+    formats: ['avif', 'webp'],
+    widths: [640, 1024, 1536, 2560],
+    quality: { avif: 52, webp: 78, jpeg: 80 },
+    maxDimension: 2560,
+    fallback: { width: 1280, format: 'jpeg' }
+};
+/** Łączy wejściową (płytko-partial) konfigurację obrazów z domyślną. */
+export function resolveImagesConfig(cfg) {
+    return {
+        ...DEFAULTS,
+        ...cfg,
+        quality: { ...DEFAULTS.quality, ...(cfg?.quality ?? {}) },
+        fallback: { ...DEFAULTS.fallback, ...(cfg?.fallback ?? {}) }
+    };
+}

package/dist/core/server/media/styles/operations/batchGenerateStyles.js

@@ -1,6 +1,7 @@
 import { getCMS } from '../../../../cms.js';
-import { isProcessableImage, defaultStyles, expandStyleFormats, getOriginalFormat } from '../../../fields/utils/imageStyles.js';
-import { getImageStyle } from './getImageStyle.js';
+import { isProcessableImage } from '../../../fields/utils/imageStyles.js';
+import { buildStyleSpecs, styleDedupeKey } from '../buildStyleSpecs.js';
+import { resolveImagesConfig } from '../imagesConfig.js';
 import { generateAndSaveAdminThumbnail } from '../../utils/generateAdminThumbnail.js';
 const IMAGE_MIME_TYPES = [
     'image/jpeg',
@@ -12,39 +13,26 @@ const IMAGE_MIME_TYPES = [
 ];
 async function generateStylesForFile(file) {
     const cms = getCMS();
-    const origFormat = getOriginalFormat(file);
-    const expanded = expandStyleFormats(defaultStyles, origFormat);
+    const specs = buildStyleSpecs(file, undefined, resolveImagesConfig(cms.mediaConfig.images));
     let created = 0;
     let skipped = 0;
-    for (const style of expanded) {
+    // Enqueue brakujących wariantów (worker w tle je wygeneruje) — sweep NIE generuje inline.
+    for (const style of specs) {
         const existing = await cms.databaseAdapter.getImageStyle(file.id, style);
         if (existing) {
             skipped++;
+            continue;
         }
-        else {
-            await getImageStyle(file.id, style);
-            created++;
-        }
-        if (style.srcset && file.width) {
-            const widths = style.srcset.filter((w) => w <= file.width);
-            for (const w of widths) {
-                const widthStyle = {
-                    ...style,
-                    name: `${style.name}_${w}w`,
-                    width: w,
-                    srcset: undefined,
-                    sizes: undefined
-                };
-                const existingW = await cms.databaseAdapter.getImageStyle(file.id, widthStyle);
-                if (existingW) {
-                    skipped++;
-                }
-                else {
-                    await getImageStyle(file.id, widthStyle);
-                    created++;
-                }
-            }
-        }
+        await cms.databaseAdapter
+            .enqueueMediaJob({
+            type: 'image_style',
+            mediaFileId: file.id,
+            payload: JSON.stringify(style),
+            dedupeKey: styleDedupeKey(file.id, style),
+            priority: 0
+        })
+            .catch((e) => console.warn('[media] sweep enqueue failed:', e));
+        created++;
     }
     // Generate admin thumbnail if missing
     if (!file.thumbnailUrl) {
@@ -99,18 +87,8 @@ export async function* batchGenerateAllStyles(signal) {
     yield { type: 'done', total, processed: total, created: totalCreated, skipped: totalSkipped };
 }
 function getExpectedStyleNames(file) {
-    const origFormat = getOriginalFormat(file);
-    const expanded = expandStyleFormats(defaultStyles, origFormat);
-    const names = [];
-    for (const style of expanded) {
-        names.push(style.name);
-        if (style.srcset && file.width) {
-            for (const w of style.srcset.filter((sw) => sw <= file.width)) {
-                names.push(`${style.name}_${w}w`);
-            }
-        }
-    }
-    return names;
+    const specs = buildStyleSpecs(file, undefined, resolveImagesConfig(getCMS().mediaConfig.images));
+    return specs.map((s) => s.name);
 }
 export async function getStylesStatus() {
     const cms = getCMS();

package/dist/core/server/media/styles/operations/generateFallbackVariant.d.ts

@@ -0,0 +1,10 @@
+import type { MediaFile } from '../../../../../types/media.js';
+/**
+ * Lekki, uniwersalny wariant (domyślnie jpeg ~1280) generowany synchronicznie przy uploadzie.
+ * Serwowany jako `<img src>` dopóki pełne warianty są pending — użytkownik nigdy nie dostaje
+ * ciężkiego oryginału. Tania operacja (mała szerokość, jpeg/webp), z timeoutem.
+ */
+export declare function generateFallbackVariant(buffer: Buffer, mediaFile: Pick<MediaFile, 'id'>, opts: {
+    width: number;
+    format: 'jpeg' | 'webp';
+}): Promise<string>;

package/dist/core/server/media/styles/operations/generateFallbackVariant.js

@@ -0,0 +1,21 @@
+import { getCMS } from '../../../../cms.js';
+import sharp from 'sharp';
+import { withTimeout, sharpTimeoutMs } from '../../../../../server/utils/withTimeout.js';
+const FALLBACK_QUALITY = 72;
+/**
+ * Lekki, uniwersalny wariant (domyślnie jpeg ~1280) generowany synchronicznie przy uploadzie.
+ * Serwowany jako `<img src>` dopóki pełne warianty są pending — użytkownik nigdy nie dostaje
+ * ciężkiego oryginału. Tania operacja (mała szerokość, jpeg/webp), z timeoutem.
+ */
+export async function generateFallbackVariant(buffer, mediaFile, opts) {
+    const output = await withTimeout(sharp(buffer)
+        .rotate()
+        .resize(opts.width, undefined, { withoutEnlargement: true })
+        .toFormat(opts.format, { quality: FALLBACK_QUALITY })
+        .toBuffer(), sharpTimeoutMs(), 'sharp.fallback');
+    const ext = opts.format === 'jpeg' ? 'jpg' : opts.format;
+    const mime = opts.format === 'jpeg' ? 'image/jpeg' : 'image/webp';
+    const filename = `${mediaFile.id}_fallback_${Date.now().toString(36)}.${ext}`;
+    const uploaded = await getCMS().filesAdapter.uploadFile(new File([new Uint8Array(output)], filename, { type: mime }));
+    return uploaded.url;
+}

package/dist/core/server/media/styles/operations/getImageStyle.js

@@ -1,6 +1,7 @@
 import { getCMS } from '../../../../cms.js';
 import { imageStyleKey } from '../../../../../types/adapters/db.js';
 import { createImageStyle } from './createMediaStyle.js';
+import { styleDedupeKey } from '../buildStyleSpecs.js';
 export async function getImageStyle(mediaFileId, style) {
     const imageStyle = await getCMS().databaseAdapter.getImageStyle(mediaFileId, style);
     if (imageStyle)
@@ -22,14 +23,17 @@ export async function getImageStylesBatch(requests) {
     const cache = await cms.databaseAdapter.getImageStylesBatch(requests);
     const missing = requests.filter((r) => !cache.has(imageStyleKey(r.mediaFileId, r.style)));
     for (const { mediaFileId, style } of missing) {
-        const key = imageStyleKey(mediaFileId, style);
-        try {
-            const created = await createImageStyle(mediaFileId, style);
-            cache.set(key, created);
-        }
-        catch (e) {
-            console.warn(`[CMS] Failed to generate missing image style "${style.name}" for media ${mediaFileId}:`, e);
-        }
+        // Render NIE generuje sharpem — kolejkujemy brakujący styl (priority=high) i zwracamy
+        // tylko istniejące. Worker w tle dogeneruje; frontend serwuje fallback w międzyczasie.
+        await cms.databaseAdapter
+            .enqueueMediaJob({
+            type: 'image_style',
+            mediaFileId,
+            payload: JSON.stringify(style),
+            dedupeKey: styleDedupeKey(mediaFileId, style),
+            priority: 10
+        })
+            .catch((e) => console.warn(`[media] enqueue failed for style "${style.name}" media ${mediaFileId}:`, e));
     }
     return cache;
 }

package/dist/core/server/media/styles/sharp/sharpConfig.d.ts

@@ -0,0 +1,7 @@
+/** Globalne limity sharp — wołane raz przy init CMS. Chroni proces przed wysyceniem CPU/RAM. */
+export declare function applySharpLimits(opts: {
+    concurrency: number;
+    cacheMemoryMB: number;
+}): void;
+/** Poison-guard: odrzuca „image bomby" zanim sharp spróbuje je przetworzyć. */
+export declare function assertWithinPixelLimit(width: number, height: number, limitPixels: number): void;

package/dist/core/server/media/styles/sharp/sharpConfig.js

@@ -0,0 +1,12 @@
+import sharp from 'sharp';
+/** Globalne limity sharp — wołane raz przy init CMS. Chroni proces przed wysyceniem CPU/RAM. */
+export function applySharpLimits(opts) {
+    sharp.concurrency(opts.concurrency);
+    sharp.cache({ memory: opts.cacheMemoryMB, files: 0 });
+}
+/** Poison-guard: odrzuca „image bomby" zanim sharp spróbuje je przetworzyć. */
+export function assertWithinPixelLimit(width, height, limitPixels) {
+    if (width * height > limitPixels) {
+        throw new Error(`image exceeds pixel limit (${width}x${height} > ${limitPixels}px)`);
+    }
+}

package/dist/db-postgres/index.js

@@ -688,7 +688,7 @@ export function pg(config) {
             const rows = await db.execute(sql `
 				INSERT INTO image_styles (id, media_file_id, name, url, width, height, crop, quality, media, mime_type, aspect_ratio)
 				VALUES (gen_random_uuid(), ${mediaFileId}, ${style.name}, ${file.url}, ${style.width ?? null}, ${style.height ?? null}, ${style.crop ?? false}, ${style.quality ?? null}, ${style.media ?? null}, ${mimeType}, ${style.aspectRatio ?? null})
-				ON CONFLICT (media_file_id, name, COALESCE(width, 0), COALESCE(height, 0), COALESCE(quality, 0), COALESCE(aspect_ratio, 0))
+				ON CONFLICT (media_file_id, name, COALESCE(width, 0), COALESCE(height, 0), COALESCE(quality, 0), COALESCE(aspect_ratio, 0), crop)
 				DO UPDATE SET url = EXCLUDED.url, mime_type = EXCLUDED.mime_type
 				RETURNING url, mime_type, media
 			`);
@@ -699,6 +699,118 @@ export function pg(config) {
                 media: row.media ? row.media : undefined
             };
         },
+        enqueueMediaJob: async (input) => {
+            await db
+                .insert(schema.mediaJobTable)
+                .values({
+                type: input.type,
+                mediaFileId: input.mediaFileId,
+                payload: input.payload,
+                dedupeKey: input.dedupeKey,
+                priority: input.priority ?? 0,
+                maxAttempts: input.maxAttempts ?? 3
+            })
+                .onConflictDoNothing({ target: schema.mediaJobTable.dedupeKey });
+        },
+        claimNextMediaJob: async (lockedBy) => {
+            return db.transaction(async (tx) => {
+                const rows = await tx.execute(sql `
+					SELECT id FROM media_job
+					WHERE status = 'pending' AND run_after <= now()
+					ORDER BY priority DESC, run_after ASC
+					LIMIT 1 FOR UPDATE SKIP LOCKED
+				`);
+                const id = rows[0]?.id;
+                if (!id)
+                    return null;
+                const [job] = await tx
+                    .update(schema.mediaJobTable)
+                    .set({ status: 'processing', lockedAt: new Date(), lockedBy, updatedAt: new Date() })
+                    .where(eq(schema.mediaJobTable.id, id))
+                    .returning();
+                return job ?? null;
+            });
+        },
+        completeMediaJob: async (id) => {
+            await db
+                .update(schema.mediaJobTable)
+                .set({
+                status: 'done',
+                completedAt: new Date(),
+                updatedAt: new Date(),
+                lockedAt: null,
+                lockedBy: null
+            })
+                .where(eq(schema.mediaJobTable.id, id));
+        },
+        failMediaJob: async (id, error, opts) => {
+            await db
+                .update(schema.mediaJobTable)
+                .set({
+                status: opts.retry ? 'pending' : 'failed',
+                attempts: sql `${schema.mediaJobTable.attempts} + 1`,
+                lastError: error,
+                runAfter: opts.runAfter ?? new Date(),
+                lockedAt: null,
+                lockedBy: null,
+                updatedAt: new Date(),
+                completedAt: opts.retry ? null : new Date()
+            })
+                .where(eq(schema.mediaJobTable.id, id));
+        },
+        resetStaleMediaJobs: async (olderThan) => {
+            const res = await db
+                .update(schema.mediaJobTable)
+                .set({ status: 'pending', lockedAt: null, lockedBy: null, updatedAt: new Date() })
+                .where(and(eq(schema.mediaJobTable.status, 'processing'), lte(schema.mediaJobTable.lockedAt, olderThan)))
+                .returning({ id: schema.mediaJobTable.id });
+            return res.length;
+        },
+        listMediaJobs: async (opts) => {
+            const conds = [];
+            if (opts.status)
+                conds.push(eq(schema.mediaJobTable.status, opts.status));
+            if (opts.type)
+                conds.push(eq(schema.mediaJobTable.type, opts.type));
+            const rows = await db
+                .select()
+                .from(schema.mediaJobTable)
+                .where(conds.length ? and(...conds) : undefined)
+                .orderBy(desc(schema.mediaJobTable.updatedAt))
+                .limit(opts.limit)
+                .offset(opts.offset ?? 0);
+            return rows;
+        },
+        countMediaJobs: async () => {
+            const rows = await db
+                .select({ status: schema.mediaJobTable.status, c: count() })
+                .from(schema.mediaJobTable)
+                .groupBy(schema.mediaJobTable.status);
+            const out = {
+                pending: 0,
+                processing: 0,
+                done: 0,
+                failed: 0,
+                skipped: 0
+            };
+            for (const r of rows)
+                out[r.status] = Number(r.c);
+            return out;
+        },
+        retryMediaJob: async (id) => {
+            await db
+                .update(schema.mediaJobTable)
+                .set({
+                status: 'pending',
+                attempts: 0,
+                lastError: null,
+                runAfter: new Date(),
+                lockedAt: null,
+                lockedBy: null,
+                updatedAt: new Date()
+            })
+                .where(eq(schema.mediaJobTable.id, id));
+        },
         deleteMediaFile: async (id) => {
             await db.delete(schema.mediaFilesTable).where(eq(schema.mediaFilesTable.id, id));
         },

package/dist/db-postgres/schema/imageStyle.js

@@ -13,5 +13,5 @@ export const imageStylesTable = pgTable('image_styles', {
     mimeType: text('mime_type').notNull(),
     aspectRatio: real('aspect_ratio')
 }, (t) => [
-    uniqueIndex('image_styles_unique_key').on(t.mediaFileId, t.name, sql `COALESCE(${t.width}, 0)`, sql `COALESCE(${t.height}, 0)`, sql `COALESCE(${t.quality}, 0)`, sql `COALESCE(${t.aspectRatio}, 0)`)
+    uniqueIndex('image_styles_unique_key').on(t.mediaFileId, t.name, sql `COALESCE(${t.width}, 0)`, sql `COALESCE(${t.height}, 0)`, sql `COALESCE(${t.quality}, 0)`, sql `COALESCE(${t.aspectRatio}, 0)`, t.crop)
 ]);

package/dist/db-postgres/schema/index.d.ts

@@ -7,4 +7,5 @@ export * from './formSubmission.js';
 export * from './consentLog.js';
 export * from './imageStyle.js';
 export * from './videoStyle.js';
+export * from './mediaJob.js';
 export * from './shop/index.js';

package/dist/db-postgres/schema/index.js

@@ -7,4 +7,5 @@ export * from './formSubmission.js';
 export * from './consentLog.js';
 export * from './imageStyle.js';
 export * from './videoStyle.js';
+export * from './mediaJob.js';
 export * from './shop/index.js';

package/dist/db-postgres/schema/mediaFile.d.ts

@@ -225,6 +225,23 @@ export declare const mediaFilesTable: import("drizzle-orm/pg-core/table", { with
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        fallbackUrl: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "fallback_url";
+            tableName: "media_file";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         focalX: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
             name: "focal_x";
             tableName: "media_file";

package/dist/db-postgres/schema/mediaFile.js

@@ -15,6 +15,7 @@ export const mediaFilesTable = pgTable('media_file', {
     posterUrl: text('poster_url'), // obraz poster (alternatywa dla thumbnail)
     mimeType: text('mime_type'), // dokładny typ MIME (np. video/mp4, video/webm)
     blurDataUrl: text('blur_data_url'), // LQIP placeholder for images
+    fallbackUrl: text('fallback_url'), // lekki fallback serwowany dopóki warianty pending
     focalX: real('focal_x'), // focal point X (0-1)
     focalY: real('focal_y'), // focal point Y (0-1)
     // Accessibility: powiązane pliki (transkrypcja, audiodeskrypcja)