@openinary/core 1.1.0

package/dist/routes/video-status.js

@@ -0,0 +1,208 @@
+import { Hono } from "hono";
+import { parseParams } from "../utils/parser.js";
+import { getCachePath, existsInCache } from "../utils/cache.js";
+import logger, { serializeError } from "../utils/logger.js";
+export function createVideoStatusRoute(deps) {
+    const { storage, queue: videoJobQueue } = deps;
+    const videoStatus = new Hono();
+    /**
+     * GET /video-status/:path/size
+     * Get optimized video size
+     * This must be before the /* route to be matched first
+     */
+    videoStatus.get("/*/size", async (c) => {
+        const path = c.req.path;
+        // Remove '/video-status' prefix and '/size' suffix
+        const segments = path.split("/").slice(2, -1); // Remove 'video-status' and 'size'
+        const filePath = segments.join("/");
+        // Parse params from query string or path
+        // Use the same path format as transform.ts: /t/{filePath}
+        const fullPath = `/t/${filePath}`;
+        const params = parseParams(fullPath);
+        // Get job status first - if job is completed, we know the cache exists
+        const job = videoJobQueue.getJobByPath(filePath, params);
+        logger.info({
+            requestPath: path,
+            filePath,
+            fullPath,
+            params: JSON.stringify(params),
+            jobStatus: job?.status,
+            jobId: job?.id,
+        }, "Fetching optimized video size");
+        // Check cloud storage first (most reliable for optimized videos)
+        if (storage) {
+            try {
+                const existsInCloud = await storage.exists(filePath, params);
+                if (existsInCloud) {
+                    // Get the size from cloud storage
+                    const metadata = await storage.getOptimizedMetadata(filePath, params);
+                    if (metadata) {
+                        logger.info({
+                            filePath,
+                            size: metadata.size,
+                            source: "cloud_storage",
+                        }, "Got optimized size from cloud storage");
+                        return c.json({
+                            size: metadata.size,
+                            status: "ready",
+                        });
+                    }
+                    else {
+                        logger.warn({ filePath }, "Optimized video exists in cloud but metadata unavailable");
+                    }
+                }
+            }
+            catch (error) {
+                logger.error({ error: serializeError(error), filePath }, "Failed to get optimized size from cloud storage");
+            }
+        }
+        // Fallback: Check if optimized video exists in local cache
+        // Use the same path format as transform.ts uses for getCachePath
+        const cachePath = getCachePath(fullPath);
+        const existsLocally = await existsInCache(cachePath);
+        logger.info({
+            cachePath,
+            existsLocally,
+            jobStatus: job?.status,
+            jobCompleted: job?.status === "completed",
+        }, "Local cache check result");
+        if (existsLocally || job?.status === "completed") {
+            try {
+                const fs = await import("fs/promises");
+                const stats = await fs.stat(cachePath);
+                const fileAge = Date.now() - stats.mtime.getTime();
+                const minAge = 5000; // 5 seconds minimum age
+                logger.info({
+                    cachePath,
+                    size: stats.size,
+                    fileAge,
+                    minAge,
+                    isValid: fileAge >= minAge || job?.status === "completed",
+                }, "Local cache file stats");
+                // If job is completed, trust the cache file even if it's new
+                // Otherwise, check file age
+                if (job?.status === "completed" || fileAge >= minAge) {
+                    // File is old enough to be considered valid or job is completed
+                    return c.json({
+                        size: stats.size,
+                        status: "ready",
+                    });
+                }
+                else {
+                    logger.debug({ filePath, fileAge, jobStatus: job?.status }, "Cache file too new and job not completed");
+                }
+            }
+            catch (error) {
+                logger.error({ error: serializeError(error), cachePath, jobStatus: job?.status }, "Failed to get cache file stats");
+                // If job is completed but we can't read the file, something is wrong
+                if (job?.status === "completed") {
+                    return c.json({
+                        error: "Cache file exists but cannot be read",
+                        status: "error",
+                    }, 500);
+                }
+            }
+        }
+        else {
+            logger.warn({
+                cachePath,
+                filePath,
+                jobStatus: job?.status,
+                jobExists: !!job,
+            }, "Cache file does not exist and job not completed");
+        }
+        // No optimized video found
+        return c.json({
+            status: "not_found",
+            message: "Optimized video not found",
+        }, 404);
+    });
+    /**
+     * GET /video-status/:path
+     * Check video processing status
+     */
+    videoStatus.get("/*", async (c) => {
+        const path = c.req.path;
+        const segments = path.split("/").slice(2); // Remove '/video-status' prefix
+        const filePath = segments.join("/");
+        // Parse params from query string or path
+        const fullPath = `/t/${filePath}`;
+        const params = parseParams(fullPath);
+        // Get job status
+        const job = videoJobQueue.getJobByPath(filePath, params);
+        if (!job) {
+            // Job doesn't exist - check if optimized video exists in cache/storage
+            // BUT: Only return "completed" if the file is recent enough to be valid
+            // This prevents false positives for newly uploaded videos
+            const cachePath = getCachePath(fullPath);
+            const existsLocally = await existsInCache(cachePath);
+            if (existsLocally) {
+                // Check file age to ensure it's not a stale cache entry
+                // If file was created less than 5 seconds ago, it might be incomplete
+                try {
+                    const fs = await import("fs/promises");
+                    const stats = await fs.stat(cachePath);
+                    const fileAge = Date.now() - stats.mtime.getTime();
+                    const minAge = 5000; // 5 seconds minimum age
+                    if (fileAge >= minAge) {
+                        // File is old enough to be considered valid
+                        return c.json({
+                            status: "completed",
+                            progress: 100,
+                        });
+                    }
+                    else {
+                        // File is too new - might be incomplete, return not_found to trigger job creation
+                        logger.debug({ filePath, fileAge }, "Cache file too new, treating as not found");
+                    }
+                }
+                catch (error) {
+                    // If we can't check file stats, don't assume it's ready
+                    logger.warn({ error: serializeError(error), cachePath }, "Failed to check cache file stats");
+                }
+            }
+            // Check cloud storage if configured
+            if (storage) {
+                try {
+                    const existsInCloud = await storage.exists(filePath, params);
+                    if (existsInCloud) {
+                        // For cloud storage, we trust the exists check
+                        // Cloud storage typically handles this correctly
+                        return c.json({
+                            status: "completed",
+                            progress: 100,
+                        });
+                    }
+                }
+                catch (error) {
+                    logger.warn({ error: serializeError(error), filePath }, "Failed to check cloud storage for video status");
+                }
+            }
+            // No job and no valid cached video found
+            return c.json({
+                status: "not_found",
+                message: "No processing job found for this video",
+            }, 404);
+        }
+        // Return job status
+        // Only return error status if the job has actually failed (not just if error field exists)
+        const status = job.status === "error" && job.error ? "error" : job.status;
+        return c.json({
+            status,
+            progress: job.progress || 0,
+            startedAt: job.startedAt,
+            completedAt: job.completedAt,
+            error: job.error,
+        });
+    });
+    /**
+     * GET /video-status-stats
+     * Get queue statistics (for debugging)
+     */
+    videoStatus.get("/stats", (c) => {
+        const stats = videoJobQueue.getStats();
+        return c.json(stats);
+    });
+    return videoStatus;
+}
+//# sourceMappingURL=video-status.js.map

package/dist/routes/video-status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"video-status.js","sourceRoot":"","sources":["../../src/routes/video-status.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,MAAM,EAAE,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEzD,MAAM,UAAU,sBAAsB,CAAC,IAAe;IACpD,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,IAAI,CAAC;IAC/C,MAAM,WAAW,GAAG,IAAI,IAAI,EAAE,CAAC;IAE/B;;;;OAIG;IACH,WAAW,CAAC,GAAG,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;QACrC,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;QACxB,mDAAmD;QACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,mCAAmC;QAClF,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEpC,yCAAyC;QACzC,0DAA0D;QAC1D,MAAM,QAAQ,GAAG,MAAM,QAAQ,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;QAErC,uEAAuE;QACvE,MAAM,GAAG,GAAG,aAAa,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEzD,MAAM,CAAC,IAAI,CACT;YACE,WAAW,EAAE,IAAI;YACjB,QAAQ;YACR,QAAQ;YACR,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;YAC9B,SAAS,EAAE,GAAG,EAAE,MAAM;YACtB,KAAK,EAAE,GAAG,EAAE,EAAE;SACf,EACD,+BAA+B,CAChC,CAAC;QAEF,iEAAiE;QACjE,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;gBAC7D,IAAI,aAAa,EAAE,CAAC;oBAClB,kCAAkC;oBAClC,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,oBAAoB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;oBACtE,IAAI,QAAQ,EAAE,CAAC;wBACb,MAAM,CAAC,IAAI,CACT;4BACE,QAAQ;4BACR,IAAI,EAAE,QAAQ,CAAC,IAAI;4BACnB,MAAM,EAAE,eAAe;yBACxB,EACD,uCAAuC,CACxC,CAAC;wBACF,OAAO,CAAC,CAAC,IAAI,CAAC;4BACZ,IAAI,EAAE,QAAQ,CAAC,IAAI;4BACnB,MAAM,EAAE,OAAO;yBAChB,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,MAAM,CAAC,IAAI,CACT,EAAE,QAAQ,EAAE,EACZ,0DAA0D,CAC3D,CAAC;oBACJ,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,KAAK,CACV,EAAE,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAC1C,iDAAiD,CAClD,CAAC;YACJ,CAAC;QACH,CAAC;QAED,2DAA2D;QAC3D,iEAAiE;QACjE,MAAM,SAAS,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;QAEzC,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,SAAS,CAAC,CAAC;QAErD,MAAM,CAAC,IAAI,CACT;YACE,SAAS;YACT,aAAa;YACb,SAAS,EAAE,GAAG,EAAE,MAAM;YACtB,YAAY,EAAE,GAAG,EAAE,MAAM,KAAK,WAAW;SAC1C,EACD,0BAA0B,CAC3B,CAAC;QAEF,IAAI,aAAa,IAAI,GAAG,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;gBACvC,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBACvC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;gBACnD,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,wBAAwB;gBAE7C,MAAM,CAAC,IAAI,CACT;oBACE,SAAS;oBACT,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,OAAO;oBACP,MAAM;oBACN,OAAO,EAAE,OAAO,IAAI,MAAM,IAAI,GAAG,EAAE,MAAM,KAAK,WAAW;iBAC1D,EACD,wBAAwB,CACzB,CAAC;gBAEF,6DAA6D;gBAC7D,4BAA4B;gBAC5B,IAAI,GAAG,EAAE,MAAM,KAAK,WAAW,IAAI,OAAO,IAAI,MAAM,EAAE,CAAC;oBACrD,gEAAgE;oBAChE,OAAO,CAAC,CAAC,IAAI,CAAC;wBACZ,IAAI,EAAE,KAAK,CAAC,IAAI;wBAChB,MAAM,EAAE,OAAO;qBAChB,CAAC,CAAC;gBACL,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,KAAK,CACV,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,EAC7C,0CAA0C,CAC3C,CAAC;gBACJ,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,KAAK,CACV,EAAE,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,EAAE,EACnE,gCAAgC,CACjC,CAAC;gBACF,qEAAqE;gBACrE,IAAI,GAAG,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;oBAChC,OAAO,CAAC,CAAC,IAAI,CACX;wBACE,KAAK,EAAE,sCAAsC;wBAC7C,MAAM,EAAE,OAAO;qBAChB,EACD,GAAG,CACJ,CAAC;gBACJ,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CACT;gBACE,SAAS;gBACT,QAAQ;gBACR,SAAS,EAAE,GAAG,EAAE,MAAM;gBACtB,SAAS,EAAE,CAAC,CAAC,GAAG;aACjB,EACD,iDAAiD,CAClD,CAAC;QACJ,CAAC;QAED,2BAA2B;QAC3B,OAAO,CAAC,CAAC,IAAI,CACX;YACE,MAAM,EAAE,WAAW;YACnB,OAAO,EAAE,2BAA2B;SACrC,EACD,GAAG,CACJ,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH;;;OAGG;IACH,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE;QAChC,MAAM,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC;QACxB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,gCAAgC;QAC3E,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEpC,yCAAyC;QACzC,MAAM,QAAQ,GAAG,MAAM,QAAQ,EAAE,CAAC;QAClC,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC;QAErC,iBAAiB;QACjB,MAAM,GAAG,GAAG,aAAa,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAEzD,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,uEAAuE;YACvE,wEAAwE;YACxE,0DAA0D;YAE1D,MAAM,SAAS,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAC;YACzC,MAAM,aAAa,GAAG,MAAM,aAAa,CAAC,SAAS,CAAC,CAAC;YAErD,IAAI,aAAa,EAAE,CAAC;gBAClB,wDAAwD;gBACxD,sEAAsE;gBACtE,IAAI,CAAC;oBACH,MAAM,EAAE,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;oBACvC,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBACvC,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;oBACnD,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,wBAAwB;oBAE7C,IAAI,OAAO,IAAI,MAAM,EAAE,CAAC;wBACtB,4CAA4C;wBAC5C,OAAO,CAAC,CAAC,IAAI,CAAC;4BACZ,MAAM,EAAE,WAAW;4BACnB,QAAQ,EAAE,GAAG;yBACd,CAAC,CAAC;oBACL,CAAC;yBAAM,CAAC;wBACN,kFAAkF;wBAClF,MAAM,CAAC,KAAK,CACV,EAAE,QAAQ,EAAE,OAAO,EAAE,EACrB,2CAA2C,CAC5C,CAAC;oBACJ,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,wDAAwD;oBACxD,MAAM,CAAC,IAAI,CACT,EAAE,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,EAC3C,kCAAkC,CACnC,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,oCAAoC;YACpC,IAAI,OAAO,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,MAAM,aAAa,GAAG,MAAM,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;oBAC7D,IAAI,aAAa,EAAE,CAAC;wBAClB,+CAA+C;wBAC/C,iDAAiD;wBACjD,OAAO,CAAC,CAAC,IAAI,CAAC;4BACZ,MAAM,EAAE,WAAW;4BACnB,QAAQ,EAAE,GAAG;yBACd,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CACT,EAAE,KAAK,EAAE,cAAc,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,EAC1C,gDAAgD,CACjD,CAAC;gBACJ,CAAC;YACH,CAAC;YAED,yCAAyC;YACzC,OAAO,CAAC,CAAC,IAAI,CACX;gBACE,MAAM,EAAE,WAAW;gBACnB,OAAO,EAAE,wCAAwC;aAClD,EACD,GAAG,CACJ,CAAC;QACJ,CAAC;QAED,oBAAoB;QACpB,2FAA2F;QAC3F,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,KAAK,OAAO,IAAI,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC;QAE1E,OAAO,CAAC,CAAC,IAAI,CAAC;YACZ,MAAM;YACN,QAAQ,EAAE,GAAG,CAAC,QAAQ,IAAI,CAAC;YAC3B,SAAS,EAAE,GAAG,CAAC,SAAS;YACxB,WAAW,EAAE,GAAG,CAAC,WAAW;YAC5B,KAAK,EAAE,GAAG,CAAC,KAAK;SACjB,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH;;;OAGG;IACH,WAAW,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE;QAC9B,MAAM,KAAK,GAAG,aAAa,CAAC,QAAQ,EAAE,CAAC;QACvC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC,CAAC,CAAC;IAEH,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/services/transform.service.d.ts

@@ -0,0 +1,71 @@
+import { Context } from "hono";
+import { CloudStorage } from "../utils/storage/index";
+import type { VideoJobQueue } from "../utils/video-job-queue";
+export interface TransformRequest {
+    path: string;
+    userAgent: string;
+    acceptHeader?: string;
+    context: Context;
+}
+export interface TransformResult {
+    buffer?: Buffer;
+    /** Set instead of buffer for large payloads served without in-memory buffering */
+    stream?: ReadableStream<Uint8Array>;
+    contentType: string;
+    headers: Record<string, string>;
+    isProcessing?: boolean;
+    optimizationResult?: any;
+}
+export interface CacheCheckResult {
+    cloudCacheBuffer?: Buffer;
+    localCacheBuffer?: Buffer;
+    cachePath?: string;
+    effectiveParams: any;
+}
+export declare class TransformService {
+    private storage;
+    private compression;
+    private queue;
+    constructor(storage: CloudStorage | null, queue: VideoJobQueue);
+    /**
+     * Main transformation method that handles the complete flow
+     */
+    transform(request: TransformRequest): Promise<TransformResult>;
+    /**
+     * Check if the first segment is a transformation string
+     */
+    private hasTransformSegment;
+    /**
+     * Get effective parameters with format optimization and cache path
+     */
+    private getEffectiveParamsAndCachePath;
+    /**
+     * Check both cloud and local caches
+     */
+    private checkCaches;
+    /**
+     * Format response for cached content
+     */
+    private formatCacheResponse;
+    /**
+     * Process the file (images and videos)
+     */
+    private processFile;
+    /**
+     * Process image file
+     */
+    private processImageFile;
+    /**
+     * Handle video job queue management
+     */
+    private handleVideoJobQueue;
+    /**
+     * Handle file not found scenario
+     */
+    private handleFileNotFound;
+    /**
+     * Handle transformation errors
+     */
+    private handleTransformationError;
+}
+//# sourceMappingURL=transform.service.d.ts.map

package/dist/services/transform.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.service.d.ts","sourceRoot":"","sources":["../../src/services/transform.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAG/B,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAGtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAe9D,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kFAAkF;IAClF,MAAM,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kBAAkB,CAAC,EAAE,GAAG,CAAC;CAC1B;AAED,MAAM,WAAW,gBAAgB;IAC/B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,GAAG,CAAC;CACtB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,KAAK,CAAgB;gBAEjB,OAAO,EAAE,YAAY,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa;IAM9D;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IA4EpE;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;OAEG;YACW,8BAA8B;IA8B5C;;OAEG;YACW,WAAW;IA+BzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAyB3B;;OAEG;YACW,WAAW;IAuHzB;;OAEG;YACW,gBAAgB;IAmB9B;;OAEG;YACW,mBAAmB;IAuIjC;;OAEG;YACW,kBAAkB;IAWhC;;OAEG;YACW,yBAAyB;CAsDxC"}

package/dist/services/transform.service.js

@@ -0,0 +1,362 @@
+import { getCachePath, existsInCache, deleteCachedFiles } from "../utils/cache.js";
+import { parseParams, isTransformSegment } from "../utils/parser.js";
+import { Compression } from "../utils/image/compression.js";
+import logger, { serializeError } from "../utils/logger.js";
+import { checkCloudCache, checkLocalCache, verifyFileExists, prepareSourceFile, processImage, processVideo, saveToCaches, cleanupTempFile, performPeriodicCacheCleanup, } from "../routes/transform-helpers.js";
+import { TRANSFORMATION_PRIORITY } from "../utils/video/config.js";
+export class TransformService {
+    storage;
+    compression;
+    queue;
+    constructor(storage, queue) {
+        this.storage = storage;
+        this.queue = queue;
+        this.compression = new Compression();
+    }
+    /**
+     * Main transformation method that handles the complete flow
+     */
+    async transform(request) {
+        const { path, userAgent, acceptHeader } = request;
+        try {
+            // Parse path and parameters
+            const segments = path.split("/").slice(2); // Remove '/t' prefix
+            const params = parseParams(path);
+            // Determine file path segments
+            const hasTransform = this.hasTransformSegment(segments);
+            const fileSegments = hasTransform ? segments.slice(1) : segments;
+            const filePath = fileSegments.join("/");
+            const localPath = `./public/${filePath}`;
+            const ext = filePath.split(".").pop()?.toLowerCase();
+            // Get effective parameters with format optimization
+            const { effectiveParams, cachePath } = await this.getEffectiveParamsAndCachePath(path, params, userAgent, acceptHeader);
+            // Verify original file exists
+            const fileCheck = await verifyFileExists(this.storage, filePath, localPath);
+            if (!fileCheck.exists) {
+                await this.handleFileNotFound(filePath);
+                throw new Error(fileCheck.error || "File not found");
+            }
+            // Check caches
+            const cacheResult = await this.checkCaches(this.storage, filePath, effectiveParams, cachePath);
+            if (cacheResult.cloudCacheBuffer) {
+                return this.formatCacheResponse(cacheResult.cloudCacheBuffer, effectiveParams, ext, "cloud");
+            }
+            if (cacheResult.localCacheBuffer) {
+                return this.formatCacheResponse(cacheResult.localCacheBuffer, effectiveParams, ext, "local");
+            }
+            // Process the file
+            return await this.processFile(filePath, localPath, ext, effectiveParams, cachePath, userAgent, acceptHeader);
+        }
+        catch (error) {
+            return this.handleTransformationError(error, request);
+        }
+    }
+    /**
+     * Check if the first segment is a transformation string
+     */
+    hasTransformSegment(segments) {
+        return segments.length > 0 && isTransformSegment(segments[0]);
+    }
+    /**
+     * Get effective parameters with format optimization and cache path
+     */
+    async getEffectiveParamsAndCachePath(path, params, userAgent, acceptHeader) {
+        const ext = path.split(".").pop()?.toLowerCase();
+        let effectiveParams = { ...params };
+        let cachePath = getCachePath(path);
+        // Determine optimal format if not explicitly specified
+        if (!params.format && ext?.match(/jpe?g|png|webp|avif|gif|psd/)) {
+            const optimalFormat = this.compression.determineOptimalFormatForCache(userAgent, acceptHeader, ext);
+            effectiveParams = { ...params, format: optimalFormat };
+            // Update cache path to include the optimal format
+            const pathWithFormat = path.replace(/\/t\/(.*)$/, `/t/format:${optimalFormat}/$1`);
+            cachePath = getCachePath(pathWithFormat);
+        }
+        return { effectiveParams, cachePath };
+    }
+    /**
+     * Check both cloud and local caches
+     */
+    async checkCaches(storage, filePath, effectiveParams, cachePath) {
+        const result = {
+            effectiveParams,
+            cachePath,
+        };
+        // Check cloud cache first
+        const cloudCacheBuffer = await checkCloudCache(storage, filePath, effectiveParams);
+        if (cloudCacheBuffer) {
+            result.cloudCacheBuffer = cloudCacheBuffer;
+            return result;
+        }
+        // Check local cache
+        const localCacheBuffer = await checkLocalCache(cachePath);
+        if (localCacheBuffer) {
+            result.localCacheBuffer = localCacheBuffer;
+        }
+        return result;
+    }
+    /**
+     * Format response for cached content
+     */
+    formatCacheResponse(buffer, effectiveParams, ext, _cacheType) {
+        const headers = {
+            "Cache-Control": "public, max-age=31536000, must-revalidate",
+            ETag: `"${JSON.stringify(effectiveParams)}"`,
+            "Content-Length": buffer.length.toString(),
+        };
+        // For videos, add video-specific headers
+        if (ext?.match(/mp4|mov|webm/)) {
+            headers["X-Video-Status"] = "ready";
+        }
+        return {
+            buffer,
+            contentType: "", // Will be determined by the route handler
+            headers,
+            isProcessing: false,
+        };
+    }
+    /**
+     * Process the file (images and videos)
+     */
+    async processFile(filePath, localPath, ext, effectiveParams, cachePath, userAgent, acceptHeader) {
+        // Video transformations (non-thumbnail) are processed by the background
+        // job queue, which downloads its own source copy. Skip prepareSourceFile
+        // entirely: downloading the full original here would only delay the
+        // response and waste memory/bandwidth.
+        const isThumbnailRequest = effectiveParams.thumbnail === "true" || effectiveParams.thumbnail === "1";
+        if (ext?.match(/mp4|mov|webm/) && !isThumbnailRequest) {
+            return await this.handleVideoJobQueue(filePath, localPath, effectiveParams, cachePath);
+        }
+        // Prepare source file
+        const sourcePath = await prepareSourceFile(this.storage, filePath, localPath);
+        const isTempFile = !!this.storage;
+        try {
+            let buffer;
+            let contentType;
+            let optimizationResult;
+            // Process based on file type
+            if (ext?.match(/jpe?g|png|webp|avif|gif|psd/)) {
+                const result = await this.processImageFile(sourcePath, effectiveParams, userAgent, acceptHeader);
+                buffer = result.buffer;
+                contentType = result.contentType;
+                optimizationResult = result.optimizationResult;
+            }
+            else if (ext?.match(/mp4|mov|webm/)) {
+                // Only thumbnail requests reach this point (non-thumbnail video
+                // transformations are intercepted before prepareSourceFile above);
+                // thumbnails are extracted synchronously like images
+                const result = await processVideo(sourcePath, effectiveParams);
+                return {
+                    buffer: result.buffer,
+                    contentType: result.contentType,
+                    headers: {
+                        "Content-Length": result.buffer.length.toString(),
+                        "Cache-Control": "public, max-age=31536000, must-revalidate",
+                    },
+                };
+            }
+            else {
+                throw new Error("Unsupported file type");
+            }
+            // Save to caches
+            if (cachePath) {
+                await saveToCaches(this.storage, filePath, effectiveParams, cachePath, buffer, contentType);
+            }
+            // Periodic cache cleanup
+            await performPeriodicCacheCleanup();
+            // Format response
+            // encodeURIComponent keeps ETag ASCII-only: HTTP header values must be a
+            // ByteString, and raw file paths can contain non-ASCII or NFD-decomposed
+            // accented characters (e.g. a combining accent has a code point > 255)
+            const headers = {
+                "Content-Length": buffer.length.toString(),
+                "Cache-Control": "public, max-age=31536000, must-revalidate",
+                ETag: `"${encodeURIComponent(filePath)}-${JSON.stringify(effectiveParams)}"`,
+            };
+            // Add optimization headers if available
+            if (optimizationResult) {
+                headers["X-Original-Size"] = optimizationResult.originalSize.toString();
+                headers["X-Optimized-Size"] =
+                    optimizationResult.optimizedSize.toString();
+                headers["X-Compression-Ratio"] =
+                    optimizationResult.compressionRatio.toFixed(2);
+                headers["X-Savings-Percent"] = optimizationResult.savings.toFixed(1);
+            }
+            // For videos, indicate this is the optimized version
+            if (ext?.match(/mp4|mov|webm/)) {
+                headers["X-Video-Status"] = "ready";
+            }
+            return {
+                buffer,
+                contentType,
+                headers,
+                optimizationResult,
+            };
+        }
+        finally {
+            // Clean up temporary source file if used
+            if (isTempFile) {
+                await cleanupTempFile(sourcePath);
+            }
+        }
+    }
+    /**
+     * Process image file
+     */
+    async processImageFile(sourcePath, effectiveParams, userAgent, acceptHeader) {
+        return await processImage(sourcePath, effectiveParams, userAgent, acceptHeader, this.compression);
+    }
+    /**
+     * Handle video job queue management
+     */
+    async handleVideoJobQueue(filePath, localPath, params, cachePath) {
+        // Check if already being processed
+        let existingJob = this.queue.getJobByPath(filePath, params);
+        let shouldRequeue = false;
+        if (existingJob) {
+            logger.debug({ jobId: existingJob.id, status: existingJob.status }, "Video job exists");
+            // If completed, verify cache actually exists before serving
+            if (existingJob.status === "completed" && cachePath) {
+                const localCacheExists = await existsInCache(cachePath);
+                const cloudCacheExists = this.storage
+                    ? await this.storage.exists(filePath, params)
+                    : false;
+                if (localCacheExists || cloudCacheExists) {
+                    // Cache exists, try to serve from local cache first
+                    const cachedBuffer = await checkLocalCache(cachePath);
+                    if (cachedBuffer) {
+                        return {
+                            buffer: cachedBuffer,
+                            contentType: `video/${filePath.split(".").pop()}`,
+                            headers: {
+                                "X-Video-Status": "ready",
+                                "Content-Length": cachedBuffer.length.toString(),
+                                "Cache-Control": "public, max-age=31536000, must-revalidate",
+                            },
+                        };
+                    }
+                }
+                else {
+                    // Job is marked as completed but cache doesn't exist
+                    logger.warn({ jobId: existingJob.id, filePath, cachePath }, "Job marked as completed but cache missing - resetting to pending");
+                    try {
+                        this.queue.getStore().updateJobStatus(existingJob.id, "pending", 0);
+                        shouldRequeue = true;
+                        existingJob = { ...existingJob, status: "pending" };
+                    }
+                    catch (error) {
+                        logger.error({ error: serializeError(error), jobId: existingJob.id }, "Failed to reset job status");
+                        shouldRequeue = true;
+                    }
+                }
+            }
+        }
+        // Add to background processing queue
+        if (!existingJob ||
+            existingJob.status === "error" ||
+            existingJob.status === "pending" ||
+            shouldRequeue) {
+            this.queue
+                .addJob(filePath, params, cachePath, localPath, this.storage, TRANSFORMATION_PRIORITY)
+                .catch((error) => {
+                logger.error({ error: serializeError(error), filePath }, "Failed to add video job");
+            });
+        }
+        // Stream the original video immediately, without buffering it in memory:
+        // originals can weigh hundreds of MB and buffering both delays the first
+        // byte and pressures the container memory while ffmpeg jobs are running
+        // encodeURIComponent keeps ETag ASCII-only: HTTP header values must be a
+        // ByteString, and raw file paths can contain non-ASCII or NFD-decomposed
+        // accented characters (e.g. a combining accent has a code point > 255)
+        const processingHeaders = {
+            "X-Video-Status": "processing",
+            "X-Original-Video": "true",
+            "Cache-Control": "public, max-age=0, must-revalidate",
+            ETag: `"${encodeURIComponent(filePath)}-processing-${Date.now()}"`,
+            Vary: "Accept",
+        };
+        try {
+            if (this.storage) {
+                const { stream, contentLength } = await this.storage.downloadOriginalStream(filePath);
+                if (contentLength) {
+                    processingHeaders["Content-Length"] = contentLength.toString();
+                }
+                return {
+                    stream,
+                    contentType: `video/${filePath.split(".").pop()}`,
+                    headers: processingHeaders,
+                    isProcessing: true,
+                };
+            }
+            const { createReadStream } = await import("fs");
+            const { stat } = await import("fs/promises");
+            const stats = await stat(localPath);
+            processingHeaders["Content-Length"] = stats.size.toString();
+            const { Readable } = await import("stream");
+            return {
+                stream: Readable.toWeb(createReadStream(localPath)),
+                contentType: `video/${filePath.split(".").pop()}`,
+                headers: processingHeaders,
+                isProcessing: true,
+            };
+        }
+        catch (error) {
+            logger.error({ error: serializeError(error), filePath }, "Failed to serve original video");
+            throw new Error("Failed to load video");
+        }
+    }
+    /**
+     * Handle file not found scenario
+     */
+    async handleFileNotFound(filePath) {
+        try {
+            await deleteCachedFiles(filePath);
+        }
+        catch (error) {
+            logger.warn({ error: serializeError(error), filePath }, "Failed to delete cached files");
+        }
+    }
+    /**
+     * Handle transformation errors
+     */
+    async handleTransformationError(error, request) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error({
+            error: serializeError(error),
+            path: request.path,
+        }, "Processing error");
+        // Check if this is a "file not found" error from cloud storage
+        const isNotFoundError = errorMessage.includes("NoSuchKey") ||
+            errorMessage.includes("NotFound") ||
+            errorMessage.includes("404") ||
+            errorMessage.includes("does not exist") ||
+            errorMessage.includes("not found");
+        if (isNotFoundError && this.storage) {
+            // Invalidate cache since the file doesn't exist
+            const pathSegments = request.path.split("/").slice(2);
+            const hasTransform = pathSegments.length > 0 && isTransformSegment(pathSegments[0]);
+            const filePath = hasTransform
+                ? pathSegments.slice(1).join("/")
+                : pathSegments.join("/");
+            this.storage.invalidateAllCacheEntries(filePath);
+            // Delete local cache files
+            try {
+                await deleteCachedFiles(filePath);
+            }
+            catch (cleanupError) {
+                logger.warn({ error: serializeError(cleanupError), filePath }, "Failed to cleanup cache after not found error");
+            }
+        }
+        // Return error result (route handler will convert to appropriate HTTP response)
+        return {
+            buffer: Buffer.from(`Processing failed: ${errorMessage}`),
+            contentType: "text/plain",
+            headers: {
+                "Cache-Control": "no-store, no-cache, must-revalidate, max-age=0",
+                Pragma: "no-cache",
+                Expires: "0",
+            },
+        };
+    }
+}
+//# sourceMappingURL=transform.service.js.map