@de-otio/trellis 0.4.0

package/dist/lib/media-handler.js

@@ -0,0 +1,1544 @@
+"use strict";
+/**
+ * Media Handler
+ *
+ * Handles media collection operations: listing, details, hide/unhide, delete.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaHandler = void 0;
+const logger_1 = require("./logger");
+const media_metrics_1 = require("./media-metrics");
+class MediaHandler {
+    logger;
+    metrics;
+    constructor(env) {
+        this.logger = env ? logger_1.Logger.getInstance(env) : {};
+        this.metrics = new media_metrics_1.MediaMetrics(env);
+    }
+    /**
+     * Get API domain consistently across all media operations
+     * Respects APP_DOMAIN environment variable, converts www. to api., or uses default
+     */
+    static getApiDomain(env) {
+        if (env.APP_DOMAIN) {
+            try {
+                const url = new URL(env.APP_DOMAIN);
+                let hostname = url.hostname;
+                // Convert www. to api.
+                if (hostname.startsWith("www.")) {
+                    hostname = hostname.replace("www.", "api.");
+                }
+                else if (!hostname.includes("api.")) {
+                    // If no api. subdomain, add it
+                    const parts = hostname.split(".");
+                    if (parts.length >= 2) {
+                        hostname = `api.${parts.slice(-2).join(".")}`;
+                    }
+                }
+                return `${url.protocol}//${hostname}`;
+            }
+            catch {
+                // Invalid URL, fall through to default
+            }
+        }
+        // Default fallback
+        return "https://api.rkm1.de";
+    }
+    /**
+     * Get media grouped by month or year
+     */
+    async listUserMediaGrouped(userId, groupBy, options, env, request) {
+        const startTime = Date.now();
+        const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+        const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+        const { DataRouter } = await Promise.resolve().then(() => __importStar(require("./data-router")));
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        // Multi-region awareness: detect region from request/session
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            const db = request
+                ? DataRouter.getDatabaseForRegion(region, env, request, userId)
+                : DataRouter.getDatabaseForRegion(region, env);
+            const includeHidden = options.includeHidden || false;
+            const type = options.type || "all";
+            // Pagination guardrails: cap limit to prevent excessive load
+            const MAX_LIMIT = 10000;
+            const DEFAULT_LIMIT = 5000;
+            const requestedLimit = options.limit || DEFAULT_LIMIT;
+            const fetchLimit = Math.min(requestedLimit, MAX_LIMIT);
+            // Warn if limit was truncated (will be logged in response metadata)
+            const wasTruncated = requestedLimit > MAX_LIMIT;
+            // Get post IDs for the user
+            const userPosts = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                return await dbClient.post.findMany({
+                    where: {
+                        authorId: userId,
+                        deletedAt: null,
+                    },
+                    select: { id: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMediaGrouped_userPosts",
+                    userId,
+                },
+            });
+            const postIds = userPosts.map((p) => p.id);
+            if (postIds.length === 0) {
+                return { groups: [] };
+            }
+            // Get media IDs for those posts
+            const postMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                return await dbClient.postMedia.findMany({
+                    where: {
+                        postId: { in: postIds },
+                    },
+                    select: { mediaId: true },
+                    distinct: ["mediaId"],
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMediaGrouped_postMedia",
+                    userId,
+                },
+            });
+            const mediaIds = postMedia.map((pm) => pm.mediaId);
+            if (mediaIds.length === 0) {
+                return { groups: [] };
+            }
+            // Build where clause
+            const where = {
+                id: { in: mediaIds },
+                deletedAt: null,
+            };
+            if (!includeHidden) {
+                where.hidden = false;
+            }
+            if (type === "photo") {
+                where.mimeType = { startsWith: "image/" };
+            }
+            else if (type === "video") {
+                where.mimeType = { startsWith: "video/" };
+            }
+            // Fetch media (limited to avoid excessive load)
+            const media = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                const dbAny = dbClient;
+                return await dbAny.mediaFile.findMany({
+                    where,
+                    orderBy: { createdAt: "desc" },
+                    take: fetchLimit,
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMediaGrouped_mediaFiles",
+                    userId,
+                },
+            });
+            if (media.length === 0) {
+                return { groups: [] };
+            }
+            // Precompute post counts for each media
+            const mediaWithPostCounts = await Promise.all(media.map(async (m) => {
+                const postCount = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                    return await dbClient.postMedia.count({
+                        where: {
+                            mediaId: m.id,
+                            post: {
+                                authorId: userId,
+                                deletedAt: null,
+                            },
+                        },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "listUserMediaGrouped_postCount",
+                        userId,
+                        mediaId: m.id,
+                    },
+                });
+                const apiDomain = MediaHandler.getApiDomain(env);
+                return {
+                    id: m.id,
+                    contentHash: m.contentHash,
+                    mimeType: m.mimeType,
+                    size: m.size,
+                    thumbnailUrl: `${apiDomain}/api/media/${m.contentHash}?variant=thumbnail`,
+                    optimizedUrl: `${apiDomain}/api/media/${m.contentHash}?variant=optimized`,
+                    createdAt: m.createdAt.toISOString(),
+                    hidden: m.hidden || false,
+                    postCount,
+                };
+            }));
+            // Group by period
+            const groupsMap = new Map();
+            for (const item of mediaWithPostCounts) {
+                const date = new Date(item.createdAt);
+                let period;
+                if (groupBy === "month") {
+                    const year = date.getFullYear();
+                    const month = String(date.getMonth() + 1).padStart(2, "0");
+                    period = `${year}-${month}`;
+                }
+                else {
+                    period = String(date.getFullYear());
+                }
+                if (!groupsMap.has(period)) {
+                    groupsMap.set(period, []);
+                }
+                groupsMap.get(period).push(item);
+            }
+            // Convert to array and sort newest-first
+            const groups = Array.from(groupsMap.entries())
+                .map(([period, items]) => {
+                const displayName = groupBy === "month"
+                    ? new Date(`${period}-01`).toLocaleDateString("en-US", {
+                        month: "long",
+                        year: "numeric",
+                    })
+                    : period;
+                return {
+                    period,
+                    displayName,
+                    count: items.length,
+                    media: items.sort((a, b) => new Date(b.createdAt).getTime() -
+                        new Date(a.createdAt).getTime()),
+                };
+            })
+                .sort((a, b) => b.period.localeCompare(a.period));
+            const result = {
+                groups,
+                ...(wasTruncated && {
+                    warning: `Limit was capped at ${MAX_LIMIT} items. Requested limit (${requestedLimit}) exceeded maximum.`,
+                    truncated: true,
+                }),
+            };
+            const duration = Date.now() - startTime;
+            const totalItems = groups.reduce((sum, g) => sum + g.count, 0);
+            // Structured logging
+            this.logger.info("[MediaHandler] Media grouped", {
+                operation: "listUserMediaGrouped",
+                userId,
+                region,
+                duration,
+                result: {
+                    groupCount: groups.length,
+                    totalItems,
+                    truncated: wasTruncated,
+                },
+                metadata: {
+                    groupBy,
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                    limit: options.limit || 5000,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to group media", {
+                operation: "listUserMediaGrouped",
+                userId,
+                region,
+                duration,
+                error: error?.message,
+                errorType,
+                metadata: {
+                    groupBy,
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                },
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get statistics for a user's media collection
+     */
+    async getUserMediaStats(userId, options, env, request) {
+        const startTime = Date.now();
+        const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+        const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+        const { DataRouter } = await Promise.resolve().then(() => __importStar(require("./data-router")));
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        // Multi-region awareness: detect region from request/session
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            const db = request
+                ? DataRouter.getDatabaseForRegion(region, env, request, userId)
+                : DataRouter.getDatabaseForRegion(region, env);
+            const includeHidden = options.includeHidden || false;
+            const type = options.type || "all";
+            // Get user's post IDs
+            const userPosts = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                return await dbClient.post.findMany({
+                    where: {
+                        authorId: userId,
+                        deletedAt: null,
+                    },
+                    select: { id: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getUserMediaStats_userPosts",
+                    userId,
+                },
+            });
+            const postIds = userPosts.map((p) => p.id);
+            // Get media IDs from posts
+            const postMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                if (postIds.length === 0) {
+                    return [];
+                }
+                return await dbClient.postMedia.findMany({
+                    where: {
+                        postId: { in: postIds },
+                    },
+                    select: { mediaId: true },
+                    distinct: ["mediaId"],
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getUserMediaStats_postMedia",
+                    userId,
+                },
+            });
+            const mediaIdsFromPosts = postMedia.map((pm) => pm.mediaId);
+            // Get all Entity avatars owned by the user - with timeout/retry
+            const userEntities = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                return await dbClient.entity.findMany({
+                    where: {
+                        owners: { some: { userId: userId, status: 'ACTIVE' } },
+                    },
+                    select: { metadata: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getUserMediaStats_userEntities",
+                    userId,
+                },
+            });
+            // Extract contentHashes and media IDs from Entity avatar URLs
+            // Avatar URLs can be stored in multiple formats:
+            // 1. Full URL: https://api.rkm1.de/api/media/{contentHash}?variant=...
+            // 2. ContentHash: just the hash string
+            // 3. Media ID: the media ID (CUID) directly
+            const avatarContentHashes = new Set();
+            const avatarMediaIdsDirect = new Set();
+            for (const entity of userEntities) {
+                if (entity.metadata && typeof entity.metadata === "object") {
+                    const metadata = entity.metadata;
+                    const avatarUrl = metadata.avatar;
+                    if (typeof avatarUrl === "string" && avatarUrl) {
+                        // Check if avatar URL is a media ID directly (CUID format: starts with 'c' and has alphanumeric chars)
+                        // Media IDs are typically CUIDs like 'cmji7uq2l0000l1j23af3r8bo'
+                        if (/^c[a-z0-9]{24}$/i.test(avatarUrl)) {
+                            avatarMediaIdsDirect.add(avatarUrl);
+                            continue;
+                        }
+                        // Check if it's a contentHash (hex string, typically 64 chars)
+                        if (/^[a-f0-9]{32,64}$/i.test(avatarUrl)) {
+                            avatarContentHashes.add(avatarUrl);
+                            continue;
+                        }
+                        // Extract contentHash from URL format: /api/media/{contentHash}?variant=...
+                        // Or: https://api.rkm1.de/api/media/{contentHash}?variant=...
+                        const match = avatarUrl.match(/\/api\/media\/([a-f0-9]+)(?:\?|$)/i);
+                        if (match && match[1]) {
+                            avatarContentHashes.add(match[1]);
+                            continue;
+                        }
+                        // Extract media ID from URL format: /api/media/{mediaId}
+                        // Or: https://api.rkm1.de/api/media/{mediaId}
+                        const mediaIdMatch = avatarUrl.match(/\/api\/media\/([a-z0-9]+)(?:\?|$)/i);
+                        if (mediaIdMatch &&
+                            mediaIdMatch[1] &&
+                            /^c[a-z0-9]{24}$/i.test(mediaIdMatch[1])) {
+                            avatarMediaIdsDirect.add(mediaIdMatch[1]);
+                        }
+                    }
+                }
+            }
+            // Get media IDs from avatar contentHashes - with timeout/retry
+            const avatarMediaIds = [...avatarMediaIdsDirect];
+            if (avatarContentHashes.size > 0) {
+                const avatarMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                    const dbAny = dbClient;
+                    return await dbAny.mediaFile.findMany({
+                        where: {
+                            contentHash: { in: Array.from(avatarContentHashes) },
+                            deletedAt: null,
+                        },
+                        select: { id: true },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "getUserMediaStats_avatarMedia",
+                        userId,
+                    },
+                });
+                avatarMediaIds.push(...avatarMedia.map((m) => m.id));
+            }
+            // Combine media IDs from posts and avatars
+            const allMediaIds = [
+                ...new Set([...mediaIdsFromPosts, ...avatarMediaIds]),
+            ];
+            if (allMediaIds.length === 0) {
+                return {
+                    totalCount: 0,
+                    photoCount: 0,
+                    videoCount: 0,
+                    hiddenCount: 0,
+                    totalSize: 0,
+                    oldestMedia: null,
+                    newestMedia: null,
+                    byMonth: [],
+                };
+            }
+            const whereBase = {
+                id: { in: allMediaIds },
+                deletedAt: null,
+            };
+            if (!includeHidden) {
+                whereBase.hidden = false;
+            }
+            // Type filter for top-level total (when requested)
+            const applyType = (where) => {
+                if (type === "photo") {
+                    where.mimeType = { startsWith: "image/" };
+                }
+                else if (type === "video") {
+                    where.mimeType = { startsWith: "video/" };
+                }
+                return where;
+            };
+            // Fetch all media metadata (minimal fields)
+            const mediaRows = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (dbClient) => {
+                const dbAny = dbClient;
+                return await dbAny.mediaFile.findMany({
+                    where: applyType({ ...whereBase }),
+                    select: {
+                        id: true,
+                        mimeType: true,
+                        size: true,
+                        hidden: true,
+                        createdAt: true,
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getUserMediaStats_mediaRows",
+                    userId,
+                },
+            });
+            if (mediaRows.length === 0) {
+                return {
+                    totalCount: 0,
+                    photoCount: 0,
+                    videoCount: 0,
+                    hiddenCount: 0,
+                    totalSize: 0,
+                    oldestMedia: null,
+                    newestMedia: null,
+                    byMonth: [],
+                };
+            }
+            // Aggregate stats
+            let totalSize = 0;
+            let photoCount = 0;
+            let videoCount = 0;
+            let hiddenCount = 0;
+            let oldestMedia = null;
+            let newestMedia = null;
+            const byMonthMap = new Map();
+            for (const row of mediaRows) {
+                totalSize += row.size || 0;
+                if (row.mimeType?.startsWith("image/"))
+                    photoCount += 1;
+                if (row.mimeType?.startsWith("video/"))
+                    videoCount += 1;
+                if (row.hidden)
+                    hiddenCount += 1;
+                const created = row.createdAt instanceof Date
+                    ? row.createdAt
+                    : new Date(row.createdAt);
+                const iso = created.toISOString();
+                if (!newestMedia || created > new Date(newestMedia)) {
+                    newestMedia = iso;
+                }
+                if (!oldestMedia || created < new Date(oldestMedia)) {
+                    oldestMedia = iso;
+                }
+                const period = `${created.getFullYear()}-${String(created.getMonth() + 1).padStart(2, "0")}`;
+                byMonthMap.set(period, (byMonthMap.get(period) || 0) + 1);
+            }
+            const totalCount = mediaRows.length;
+            const byMonth = Array.from(byMonthMap.entries())
+                .map(([period, count]) => ({ period, count }))
+                .sort((a, b) => b.period.localeCompare(a.period));
+            const result = {
+                totalCount,
+                photoCount,
+                videoCount,
+                hiddenCount,
+                totalSize,
+                oldestMedia,
+                newestMedia,
+                byMonth,
+            };
+            const duration = Date.now() - startTime;
+            // Structured logging
+            this.logger.info("[MediaHandler] Media stats retrieved", {
+                operation: "getUserMediaStats",
+                userId,
+                region,
+                duration,
+                result: {
+                    totalCount,
+                    photoCount,
+                    videoCount,
+                    hiddenCount,
+                    totalSize,
+                    monthCount: byMonth.length,
+                },
+                metadata: {
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to get media stats", {
+                operation: "getUserMediaStats",
+                userId,
+                region,
+                duration,
+                error: error?.message,
+                errorType,
+                metadata: {
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                },
+            });
+            throw error;
+        }
+    }
+    /**
+     * Factory function to create MediaHandler instance
+     * Makes testing easier by allowing dependency injection
+     */
+    static create(env) {
+        return new MediaHandler(env);
+    }
+    /**
+     * Get all media files for a user with pagination and filtering
+     */
+    async listUserMedia(userId, options, env, request) {
+        const startTime = Date.now();
+        const { DataRouter } = await Promise.resolve().then(() => __importStar(require("./data-router")));
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        // Multi-region awareness: detect region from request/session
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            const db = request
+                ? DataRouter.getDatabaseForRegion(region, env, request, userId)
+                : DataRouter.getDatabaseForRegion(region, env);
+            const limit = Math.min(options.limit || 50, 100);
+            const sort = options.sort || "newest";
+            const includeHidden = options.includeHidden || false;
+            const type = options.type || "all";
+            // Use timeout/retry for all database queries
+            const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+            const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+            // Get all post IDs by user - with timeout/retry
+            const userPosts = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.post.findMany({
+                    where: {
+                        authorId: userId,
+                        deletedAt: null,
+                    },
+                    select: { id: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMedia_userPosts",
+                    userId,
+                },
+            });
+            const postIds = userPosts.map((p) => p.id);
+            // Get all media IDs from user's posts - with timeout/retry
+            const postMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                if (postIds.length === 0) {
+                    return [];
+                }
+                return await db.postMedia.findMany({
+                    where: {
+                        postId: { in: postIds },
+                    },
+                    select: { mediaId: true },
+                    distinct: ["mediaId"],
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMedia_postMedia",
+                    userId,
+                },
+            });
+            const mediaIdsFromPosts = postMedia.map((pm) => pm.mediaId);
+            // Get all Entity avatars owned by the user - with timeout/retry
+            const userEntities = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.entity.findMany({
+                    where: {
+                        owners: { some: { userId: userId, status: 'ACTIVE' } },
+                    },
+                    select: { metadata: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMedia_userEntities",
+                    userId,
+                },
+            });
+            // Extract contentHashes and media IDs from Entity avatar URLs
+            // Avatar URLs can be stored in multiple formats:
+            // 1. Full URL: https://api.rkm1.de/api/media/{contentHash}?variant=...
+            // 2. ContentHash: just the hash string
+            // 3. Media ID: the media ID (CUID) directly
+            const avatarContentHashes = new Set();
+            const avatarMediaIdsDirect = new Set();
+            for (const entity of userEntities) {
+                if (entity.metadata && typeof entity.metadata === "object") {
+                    const metadata = entity.metadata;
+                    const avatarUrl = metadata.avatar;
+                    if (typeof avatarUrl === "string" && avatarUrl) {
+                        // Check if avatar URL is a media ID directly (CUID format: starts with 'c' and has alphanumeric chars)
+                        // Media IDs are typically CUIDs like 'cmji7uq2l0000l1j23af3r8bo'
+                        if (/^c[a-z0-9]{24}$/i.test(avatarUrl)) {
+                            avatarMediaIdsDirect.add(avatarUrl);
+                            continue;
+                        }
+                        // Check if it's a contentHash (hex string, typically 64 chars)
+                        if (/^[a-f0-9]{32,64}$/i.test(avatarUrl)) {
+                            avatarContentHashes.add(avatarUrl);
+                            continue;
+                        }
+                        // Extract contentHash from URL format: /api/media/{contentHash}?variant=...
+                        // Or: https://api.rkm1.de/api/media/{contentHash}?variant=...
+                        const match = avatarUrl.match(/\/api\/media\/([a-f0-9]+)(?:\?|$)/i);
+                        if (match && match[1]) {
+                            avatarContentHashes.add(match[1]);
+                            continue;
+                        }
+                        // Extract media ID from URL format: /api/media/{mediaId}
+                        // Or: https://api.rkm1.de/api/media/{mediaId}
+                        const mediaIdMatch = avatarUrl.match(/\/api\/media\/([a-z0-9]+)(?:\?|$)/i);
+                        if (mediaIdMatch &&
+                            mediaIdMatch[1] &&
+                            /^c[a-z0-9]{24}$/i.test(mediaIdMatch[1])) {
+                            avatarMediaIdsDirect.add(mediaIdMatch[1]);
+                        }
+                    }
+                }
+            }
+            // Get media IDs from avatar contentHashes - with timeout/retry
+            const avatarMediaIds = [...avatarMediaIdsDirect];
+            if (avatarContentHashes.size > 0) {
+                const avatarMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                    const dbAny = db;
+                    return await dbAny.mediaFile.findMany({
+                        where: {
+                            contentHash: { in: Array.from(avatarContentHashes) },
+                            deletedAt: null,
+                        },
+                        select: { id: true },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "listUserMedia_avatarMedia",
+                        userId,
+                    },
+                });
+                avatarMediaIds.push(...avatarMedia.map((m) => m.id));
+            }
+            // Combine media IDs from posts and avatars
+            const allMediaIds = [
+                ...new Set([...mediaIdsFromPosts, ...avatarMediaIds]),
+            ];
+            if (allMediaIds.length === 0) {
+                return { media: [], cursor: null };
+            }
+            // Build where clause
+            const where = {
+                id: { in: allMediaIds },
+                deletedAt: null, // Exclude permanently deleted
+            };
+            if (!includeHidden) {
+                where.hidden = false; // Exclude hidden media
+            }
+            // Filter by type
+            if (type === "photo") {
+                where.mimeType = { startsWith: "image/" };
+            }
+            else if (type === "video") {
+                where.mimeType = { startsWith: "video/" };
+            }
+            // Cursor pagination
+            if (options.cursor) {
+                const cursorDate = new Date(options.cursor);
+                if (sort === "oldest") {
+                    where.createdAt = { gt: cursorDate };
+                }
+                else {
+                    where.createdAt = { lt: cursorDate };
+                }
+            }
+            // Fetch media - with timeout/retry
+            const media = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                const dbAny = db;
+                return await dbAny.mediaFile.findMany({
+                    where,
+                    orderBy: {
+                        createdAt: sort === "oldest" ? "asc" : "desc",
+                    },
+                    take: limit + 1, // Fetch one extra to check if there's more
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "listUserMedia_mediaFiles",
+                    userId,
+                },
+            });
+            // Check if there's more
+            const hasMore = media.length > limit;
+            const paginatedMedia = hasMore ? media.slice(0, limit) : media;
+            const nextCursor = hasMore && paginatedMedia.length > 0
+                ? paginatedMedia[paginatedMedia.length - 1].createdAt.toISOString()
+                : null;
+            // Get post counts for each media - with timeout/retry
+            const mediaWithPostCounts = await Promise.all(paginatedMedia.map(async (m) => {
+                const postCount = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                    return await db.postMedia.count({
+                        where: {
+                            mediaId: m.id,
+                            post: {
+                                authorId: userId,
+                                deletedAt: null,
+                            },
+                        },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "listUserMedia_postCount",
+                        userId,
+                        mediaId: m.id,
+                    },
+                });
+                // Generate URLs for media variants
+                // Always use API domain for media URLs (not frontend domain)
+                const apiDomain = MediaHandler.getApiDomain(env);
+                const thumbnailUrl = `${apiDomain}/api/media/${m.contentHash}?variant=thumbnail`;
+                const optimizedUrl = `${apiDomain}/api/media/${m.contentHash}?variant=optimized`;
+                const originalUrl = `${apiDomain}/api/media/${m.contentHash}?variant=original`;
+                // Check if this media is used as an Entity avatar (for postCount calculation)
+                // Avatar images will have postCount = 0, which is correct
+                const isAvatar = avatarContentHashes.has(m.contentHash);
+                return {
+                    id: m.id,
+                    contentHash: m.contentHash,
+                    mimeType: m.mimeType,
+                    size: m.size,
+                    thumbnailUrl,
+                    optimizedUrl,
+                    originalUrl,
+                    createdAt: m.createdAt.toISOString(),
+                    hidden: m.hidden || false,
+                    postCount, // Will be 0 for avatar images, which is correct
+                };
+            }));
+            // Calculate total count if requested
+            let totalCount;
+            if (options.includeTotalCount) {
+                const totalMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                    const dbAny = db;
+                    return await dbAny.mediaFile.count({
+                        where,
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "listUserMedia_totalCount",
+                        userId,
+                    },
+                });
+                totalCount = totalMedia;
+            }
+            const result = {
+                media: mediaWithPostCounts,
+                cursor: nextCursor,
+                ...(totalCount !== undefined && { totalCount }),
+            };
+            const duration = Date.now() - startTime;
+            // Structured logging
+            this.logger.info("[MediaHandler] Media listed", {
+                operation: "listUserMedia",
+                userId,
+                region,
+                duration,
+                result: {
+                    mediaCount: result.media.length,
+                    totalCount: result.totalCount,
+                    hasMore: result.cursor !== null,
+                },
+                metadata: {
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                    sort: options.sort || "newest",
+                    limit: options.limit || 50,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to list media", {
+                operation: "listUserMedia",
+                userId,
+                region,
+                duration,
+                error: error?.message,
+                errorType,
+                metadata: {
+                    includeHidden: options.includeHidden || false,
+                    type: options.type || "all",
+                    sort: options.sort || "newest",
+                },
+            });
+            throw error;
+        }
+    }
+    /**
+     * Get detailed information about a specific media file
+     */
+    async getMediaDetails(mediaId, userId, env, request) {
+        const startTime = Date.now();
+        const { DataRouter } = await Promise.resolve().then(() => __importStar(require("./data-router")));
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        // Multi-region awareness: detect region from request/session
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            // Use timeout/retry for all database queries
+            const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+            const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+            // Get media file - with timeout/retry
+            const media = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                const dbAny = db;
+                return await dbAny.mediaFile.findUnique({
+                    where: { id: mediaId },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getMediaDetails_findMedia",
+                    userId,
+                    mediaId,
+                },
+            });
+            if (!media) {
+                throw new Error("Media not found");
+            }
+            // Verify user owns this media (check if it's in any of their posts OR used as Entity avatar) - with timeout/retry
+            const userPosts = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.post.findMany({
+                    where: {
+                        authorId: userId,
+                        deletedAt: null,
+                    },
+                    select: { id: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getMediaDetails_userPosts",
+                    userId,
+                    mediaId,
+                },
+            });
+            const postIds = userPosts.map((p) => p.id);
+            // Check if media is in user's posts - with timeout/retry
+            let isInPosts = false;
+            if (postIds.length > 0) {
+                const postMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                    return await db.postMedia.findFirst({
+                        where: {
+                            mediaId: media.id,
+                            postId: { in: postIds },
+                        },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "getMediaDetails_verifyOwnership",
+                        userId,
+                        mediaId,
+                    },
+                });
+                isInPosts = !!postMedia;
+            }
+            // Check if media is used as Entity avatar - with timeout/retry
+            const userEntities = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.entity.findMany({
+                    where: {
+                        owners: { some: { userId: userId, status: 'ACTIVE' } },
+                    },
+                    select: { metadata: true },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getMediaDetails_userEntities",
+                    userId,
+                    mediaId,
+                },
+            });
+            // Extract contentHashes from Entity avatar URLs
+            // Avatar URLs can be stored in multiple formats:
+            // 1. Full URL: https://api.rkm1.de/api/media/{contentHash}?variant=...
+            // 2. ContentHash: just the hash string
+            // 3. Media ID: the media ID (CUID)
+            let isAvatar = false;
+            for (const entity of userEntities) {
+                if (entity.metadata && typeof entity.metadata === "object") {
+                    const metadata = entity.metadata;
+                    const avatarUrl = metadata.avatar;
+                    if (typeof avatarUrl === "string" && avatarUrl) {
+                        // Check if avatar URL matches media ID directly
+                        if (avatarUrl === media.id) {
+                            isAvatar = true;
+                            break;
+                        }
+                        // Check if avatar URL matches contentHash directly
+                        if (avatarUrl === media.contentHash) {
+                            isAvatar = true;
+                            break;
+                        }
+                        // Extract contentHash from URL format: /api/media/{contentHash}?variant=...
+                        // Or: https://api.rkm1.de/api/media/{contentHash}?variant=...
+                        const match = avatarUrl.match(/\/api\/media\/([a-f0-9]+)(?:\?|$)/i);
+                        if (match && match[1] === media.contentHash) {
+                            isAvatar = true;
+                            break;
+                        }
+                        // Also check if URL contains media ID (for URLs like /api/media/{mediaId})
+                        const mediaIdMatch = avatarUrl.match(/\/api\/media\/([a-z0-9]+)(?:\?|$)/i);
+                        if (mediaIdMatch && mediaIdMatch[1] === media.id) {
+                            isAvatar = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            // User must own the media either through posts OR as Entity avatar
+            if (!isInPosts && !isAvatar) {
+                throw new Error("Media not found");
+            }
+            // Get all posts using this media (only user's posts) - with timeout/retry
+            // For Entity avatars, postIds will be empty, so return empty array
+            const postsWithMedia = postIds.length > 0
+                ? await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                    return await db.post.findMany({
+                        where: {
+                            id: { in: postIds },
+                            deletedAt: null,
+                            media: {
+                                some: {
+                                    mediaId: media.id,
+                                },
+                            },
+                        },
+                        select: {
+                            id: true,
+                            text: true,
+                            createdAt: true,
+                            radius: true,
+                        },
+                    });
+                }, {
+                    ...QueryTimeoutPresets.USER_FACING,
+                    maxRetries: 3,
+                    baseDelayMs: 100,
+                    context: {
+                        operation: "getMediaDetails_postsWithMedia",
+                        userId,
+                        mediaId,
+                    },
+                })
+                : [];
+            // Check if media is shared with other users' posts - with timeout/retry
+            const allPostsWithMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.postMedia.findMany({
+                    where: { mediaId: media.id },
+                    include: {
+                        post: {
+                            select: {
+                                authorId: true,
+                            },
+                        },
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "getMediaDetails_checkShared",
+                    userId,
+                    mediaId,
+                },
+            });
+            const otherUsersPosts = allPostsWithMedia.filter((pm) => pm.post.authorId !== userId);
+            const isShared = otherUsersPosts.length > 0;
+            // Generate URLs
+            const apiDomain = MediaHandler.getApiDomain(env);
+            const thumbnailUrl = `${apiDomain}/api/media/${media.contentHash}?variant=thumbnail`;
+            const optimizedUrl = `${apiDomain}/api/media/${media.contentHash}?variant=optimized`;
+            const originalUrl = `${apiDomain}/api/media/${media.contentHash}?variant=original`;
+            // This endpoint is owner-only (ownership verified above).
+            // Always return full metadata to the owner — privacy flags control
+            // what OTHER users see, not the owner. The flags are still included
+            // in the response so the frontend can render the toggle state.
+            const result = {
+                id: media.id,
+                contentHash: media.contentHash,
+                cid: media.cid || null,
+                mimeType: media.mimeType,
+                size: media.size,
+                thumbnailUrl,
+                optimizedUrl,
+                originalUrl,
+                width: media.width ?? undefined,
+                height: media.height ?? undefined,
+                duration: media.duration ?? undefined,
+                exifData: media.exifData ?? undefined,
+                iptcData: media.iptcData ?? undefined,
+                videoMetadata: media.videoMetadata ?? undefined,
+                dateTaken: media.dateTaken?.toISOString(),
+                metadataVisible: media.metadataVisible ?? false,
+                locationVisible: media.locationVisible ?? false,
+                createdAt: media.createdAt.toISOString(),
+                updatedAt: media.updatedAt.toISOString(),
+                hidden: media.hidden || false,
+                hiddenAt: media.hiddenAt?.toISOString() || null,
+                deletedAt: media.deletedAt?.toISOString() || null,
+                posts: postsWithMedia.map((post) => ({
+                    id: post.id,
+                    text: post.text || "",
+                    createdAt: post.createdAt.toISOString(),
+                    visibility: post.visibility,
+                    url: `/posts/${post.id}`,
+                })),
+                canDelete: !isShared && !media.deletedAt, // Can delete if not shared and not already deleted
+                canHide: !media.hidden && !media.deletedAt, // Can hide if not already hidden/deleted
+            };
+            const duration = Date.now() - startTime;
+            // Structured logging
+            this.logger.info("[MediaHandler] Media details retrieved", {
+                operation: "getMediaDetails",
+                userId,
+                region,
+                duration,
+                result: {
+                    mediaId,
+                    postCount: result.posts.length,
+                    isShared,
+                    canDelete: result.canDelete,
+                    canHide: result.canHide,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to get media details", {
+                operation: "getMediaDetails",
+                userId,
+                region,
+                duration,
+                mediaId,
+                error: error?.message,
+                errorType,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Hide a media file
+     */
+    async hideMedia(mediaId, userId, env, request) {
+        const startTime = Date.now();
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            // Verify ownership and get media
+            const details = await this.getMediaDetails(mediaId, userId, env, request);
+            if (details.deletedAt) {
+                throw new Error("Cannot hide deleted media");
+            }
+            if (details.hidden) {
+                throw new Error("Media is already hidden");
+            }
+            // Update media - with timeout/retry
+            const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+            const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+            const { AuditLogger } = await Promise.resolve().then(() => __importStar(require("./audit-logger")));
+            const auditLogger = new AuditLogger(env);
+            const updated = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                const dbAny = db;
+                return await dbAny.mediaFile.update({
+                    where: { id: mediaId },
+                    data: {
+                        hidden: true,
+                        hiddenAt: new Date(),
+                        hiddenBy: userId,
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "hideMedia",
+                    userId,
+                    mediaId,
+                },
+            });
+            // Audit logging
+            try {
+                const ipAddress = request?.headers.get("CF-Connecting-IP") ||
+                    request?.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() ||
+                    undefined;
+                const userAgent = request?.headers.get("User-Agent") || undefined;
+                await auditLogger.log({
+                    type: "data_update",
+                    action: "media_hidden",
+                    resource: "media",
+                    resourceId: mediaId,
+                    userId,
+                    region,
+                    ipAddress,
+                    userAgent,
+                    metadata: { mediaId, hidden: true },
+                    severity: "low",
+                    success: true,
+                }, env);
+            }
+            catch (auditError) {
+                // Don't fail the operation if audit logging fails
+                this.logger.warn("[MediaHandler] Audit logging failed for hideMedia", {
+                    error: auditError,
+                });
+            }
+            const duration = Date.now() - startTime;
+            const result = {
+                id: updated.id,
+                hidden: updated.hidden,
+                hiddenAt: updated.hiddenAt.toISOString(),
+            };
+            // Structured logging
+            this.logger.info("[MediaHandler] Media hidden", {
+                operation: "hideMedia",
+                userId,
+                region,
+                duration,
+                result: {
+                    mediaId,
+                    hidden: result.hidden,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to hide media", {
+                operation: "hideMedia",
+                userId,
+                region,
+                duration,
+                mediaId,
+                error: error?.message,
+                errorType,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Unhide a media file
+     */
+    async unhideMedia(mediaId, userId, env, request) {
+        const startTime = Date.now();
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            // Verify ownership and get media
+            const details = await this.getMediaDetails(mediaId, userId, env, request);
+            if (details.deletedAt) {
+                throw new Error("Cannot unhide deleted media");
+            }
+            if (!details.hidden) {
+                throw new Error("Media is not hidden");
+            }
+            // Update media - with timeout/retry
+            const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+            const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+            const { AuditLogger } = await Promise.resolve().then(() => __importStar(require("./audit-logger")));
+            const auditLogger = new AuditLogger(env);
+            const updated = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                const dbAny = db;
+                return await dbAny.mediaFile.update({
+                    where: { id: mediaId },
+                    data: {
+                        hidden: false,
+                        hiddenAt: null,
+                        hiddenBy: null,
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "unhideMedia",
+                    userId,
+                    mediaId,
+                },
+            });
+            // Audit logging
+            try {
+                const ipAddress = request?.headers.get("CF-Connecting-IP") ||
+                    request?.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() ||
+                    undefined;
+                const userAgent = request?.headers.get("User-Agent") || undefined;
+                await auditLogger.log({
+                    type: "data_update",
+                    action: "media_unhidden",
+                    resource: "media",
+                    resourceId: mediaId,
+                    userId,
+                    region,
+                    ipAddress,
+                    userAgent,
+                    metadata: { mediaId, hidden: false },
+                    severity: "low",
+                    success: true,
+                }, env);
+            }
+            catch (auditError) {
+                // Don't fail the operation if audit logging fails
+                this.logger.warn("[MediaHandler] Audit logging failed for unhideMedia", { error: auditError });
+            }
+            const duration = Date.now() - startTime;
+            const result = {
+                id: updated.id,
+                hidden: updated.hidden,
+                hiddenAt: null,
+            };
+            // Structured logging
+            this.logger.info("[MediaHandler] Media unhidden", {
+                operation: "unhideMedia",
+                userId,
+                region,
+                duration,
+                result: {
+                    mediaId,
+                    hidden: result.hidden,
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to unhide media", {
+                operation: "unhideMedia",
+                userId,
+                region,
+                duration,
+                mediaId,
+                error: error?.message,
+                errorType,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Delete a media file (soft delete)
+     */
+    async deleteMedia(mediaId, userId, env, request) {
+        const startTime = Date.now();
+        const { RegionDetector } = await Promise.resolve().then(() => __importStar(require("./region-detection")));
+        const regionDetector = new RegionDetector(env);
+        const region = request
+            ? await regionDetector.detectRegion(request, undefined, undefined)
+            : env.DEFAULT_REGION || "EU";
+        try {
+            // Verify ownership and get media
+            const details = await this.getMediaDetails(mediaId, userId, env, request);
+            if (details.deletedAt) {
+                throw new Error("Media is already deleted");
+            }
+            // Check if shared with other users - with timeout/retry
+            const { sharedDatabaseConnectionManager } = await Promise.resolve().then(() => __importStar(require("./database-connection-manager")));
+            const { withQueryTimeoutAndRetry, QueryTimeoutPresets } = await Promise.resolve().then(() => __importStar(require("./db-query-helper")));
+            const { AuditLogger } = await Promise.resolve().then(() => __importStar(require("./audit-logger")));
+            const auditLogger = new AuditLogger(env);
+            const allPostsWithMedia = await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                return await db.postMedia.findMany({
+                    where: { mediaId },
+                    include: {
+                        post: {
+                            select: {
+                                authorId: true,
+                            },
+                        },
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "deleteMedia_checkShared",
+                    userId,
+                    mediaId,
+                },
+            });
+            const otherUsersPosts = allPostsWithMedia.filter((pm) => pm.post.authorId !== userId);
+            if (otherUsersPosts.length > 0) {
+                // If shared, hide instead of delete
+                await this.hideMedia(mediaId, userId, env, request);
+                // Audit logging for hide (instead of delete)
+                try {
+                    const ipAddress = request?.headers.get("CF-Connecting-IP") ||
+                        request?.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() ||
+                        undefined;
+                    const userAgent = request?.headers.get("User-Agent") || undefined;
+                    await auditLogger.log({
+                        type: "data_update",
+                        action: "media_delete_attempted_shared",
+                        resource: "media",
+                        resourceId: mediaId,
+                        userId,
+                        region,
+                        ipAddress,
+                        userAgent,
+                        metadata: {
+                            mediaId,
+                            action: "hidden_instead_of_deleted",
+                            reason: "shared_with_other_users",
+                            otherUsersCount: otherUsersPosts.length,
+                        },
+                        severity: "medium",
+                        success: true,
+                    }, env);
+                }
+                catch (auditError) {
+                    this.logger.warn("[MediaHandler] Audit logging failed for deleteMedia (shared)", { error: auditError });
+                }
+                throw new Error("Media is used by other users. It has been hidden instead of deleted.");
+            }
+            // Soft delete - with timeout/retry
+            await withQueryTimeoutAndRetry(sharedDatabaseConnectionManager, region, env, async (db) => {
+                const dbAny = db;
+                return await dbAny.mediaFile.update({
+                    where: { id: mediaId },
+                    data: {
+                        deletedAt: new Date(),
+                    },
+                });
+            }, {
+                ...QueryTimeoutPresets.USER_FACING,
+                maxRetries: 3,
+                baseDelayMs: 100,
+                context: {
+                    operation: "deleteMedia",
+                    userId,
+                    mediaId,
+                },
+            });
+            // Audit logging
+            try {
+                const ipAddress = request?.headers.get("CF-Connecting-IP") ||
+                    request?.headers.get("X-Forwarded-For")?.split(",")[0]?.trim() ||
+                    undefined;
+                const userAgent = request?.headers.get("User-Agent") || undefined;
+                await auditLogger.log({
+                    type: "data_delete",
+                    action: "media_deleted",
+                    resource: "media",
+                    resourceId: mediaId,
+                    userId,
+                    region,
+                    ipAddress,
+                    userAgent,
+                    metadata: { mediaId, softDelete: true },
+                    severity: "medium",
+                    success: true,
+                }, env);
+            }
+            catch (auditError) {
+                // Don't fail the operation if audit logging fails
+                this.logger.warn("[MediaHandler] Audit logging failed for deleteMedia", { error: auditError });
+            }
+            const duration = Date.now() - startTime;
+            // Structured logging
+            this.logger.info("[MediaHandler] Media deleted", {
+                operation: "deleteMedia",
+                userId,
+                region,
+                duration,
+                result: {
+                    mediaId,
+                    softDelete: true,
+                },
+            });
+            // R2 object deletion is handled by MediaCleanupHandler scheduled job
+            // See: apps/api/src/lib/media-cleanup-handler.ts
+            // Runs daily at 3:00 AM UTC with 7-day grace period
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorType = error?.name || "UnknownError";
+            // Error logging
+            this.logger.error("[MediaHandler] Failed to delete media", {
+                operation: "deleteMedia",
+                userId,
+                region,
+                duration,
+                mediaId,
+                error: error?.message,
+                errorType,
+            });
+            throw error;
+        }
+    }
+}
+exports.MediaHandler = MediaHandler;
+//# sourceMappingURL=media-handler.js.map