includio-cms 0.36.7 → 0.36.9

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)

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

@@ -0,0 +1,279 @@
+export declare const mediaJobTable: import("drizzle-orm/pg-core/table", { with: { "resolution-mode": "require" } }).PgTableWithColumns<{
+    name: "media_job";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "id";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        type: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "type";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        mediaFileId: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "media_file_id";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        payload: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "payload";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dedupeKey: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "dedupe_key";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "status";
+            tableName: "media_job";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priority: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "priority";
+            tableName: "media_job";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "attempts";
+            tableName: "media_job";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        maxAttempts: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "max_attempts";
+            tableName: "media_job";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lastError: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "last_error";
+            tableName: "media_job";
+            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;
+        }, {}, {}>;
+        runAfter: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "run_after";
+            tableName: "media_job";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lockedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "locked_at";
+            tableName: "media_job";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        lockedBy: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "locked_by";
+            tableName: "media_job";
+            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;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "created_at";
+            tableName: "media_job";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "updated_at";
+            tableName: "media_job";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        completedAt: import("drizzle-orm/pg-core", { with: { "resolution-mode": "require" } }).PgColumn<{
+            name: "completed_at";
+            tableName: "media_job";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

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

@@ -0,0 +1,23 @@
+import { integer, pgTable, text, timestamp, uniqueIndex, index, uuid } from 'drizzle-orm/pg-core';
+export const mediaJobTable = pgTable('media_job', {
+    id: uuid('id').primaryKey().defaultRandom(),
+    type: text('type').notNull(), // 'image_style' (na start; rozszerzalne: video_poster, video_transcode)
+    mediaFileId: uuid('media_file_id').notNull(),
+    payload: text('payload').notNull(), // JSON.stringify(ImageFieldStyle)
+    dedupeKey: text('dedupe_key').notNull(),
+    status: text('status').notNull().default('pending'), // pending|processing|done|failed|skipped
+    priority: integer('priority').notNull().default(0), // wyżej = pilniejsze
+    attempts: integer('attempts').notNull().default(0),
+    maxAttempts: integer('max_attempts').notNull().default(3),
+    lastError: text('last_error'),
+    runAfter: timestamp('run_after').notNull().defaultNow(),
+    lockedAt: timestamp('locked_at'),
+    lockedBy: text('locked_by'),
+    createdAt: timestamp('created_at').notNull().defaultNow(),
+    updatedAt: timestamp('updated_at').notNull().defaultNow(),
+    completedAt: timestamp('completed_at')
+}, (t) => [
+    uniqueIndex('media_job_dedupe_key').on(t.dedupeKey),
+    index('media_job_claim_idx').on(t.status, t.runAfter, t.priority),
+    index('media_job_media_idx').on(t.mediaFileId)
+]);