@everystack/server 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/server",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Server runtime primitives for Lambda — event adapters, routing, SSR, image processing",
   "license": "AGPL-3.0-only",
   "publishConfig": {
@@ -59,12 +59,13 @@
     "lint": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "3.1045.0",
-    "@aws-sdk/s3-request-presigner": "3.1045.0",
+    "@aws-sdk/client-s3": "3.1053.0",
+    "@aws-sdk/s3-request-presigner": "3.1053.0",
     "@everystack/auth": ">=0.1.0",
     "@everystack/cli": ">=0.1.0",
     "drizzle-orm": "0.41.0",
     "postgres": "3.4.9",
+    "heic-decode": "2.1.0",
     "sharp": "0.34.5",
     "sst": "4.13.1"
   },
@@ -78,6 +79,9 @@
     "@everystack/cli": {
       "optional": true
     },
+    "heic-decode": {
+      "optional": true
+    },
     "sharp": {
       "optional": true
     },

package/src/heic-decode.d.ts

@@ -0,0 +1,9 @@
+declare module 'heic-decode' {
+  interface DecodedImage {
+    width: number;
+    height: number;
+    data: Uint8ClampedArray;
+  }
+  function decode(opts: { buffer: Buffer | ArrayBuffer }): Promise<DecodedImage>;
+  export default decode;
+}

package/src/image.ts

@@ -142,15 +142,17 @@ function isNotFound(error: any): boolean {
 
 export async function processImage(
   data: Buffer,
-  params: TransformParams
+  params: TransformParams,
+  raw?: { width: number; height: number; channels: 1 | 2 | 3 | 4 }
 ): Promise<{ data: Buffer; contentType: string }> {
   // Sharp is provided via Lambda layer
   const sharp = (await import('sharp')).default;
 
-  let pipeline = sharp(data);
+  let pipeline = raw ? sharp(data, { raw }) : sharp(data);
 
   // Auto-orient based on EXIF metadata (fixes rotated portrait thumbnails)
-  pipeline = pipeline.rotate();
+  // Skip for raw pixel input — no EXIF to orient
+  if (!raw) pipeline = pipeline.rotate();
 
   // Resize
   if (params.w || params.h) {
@@ -201,10 +203,17 @@ export function createImageHandler(
       const path = event.rawPath;
       const key = path.replace(new RegExp(`^${pathPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`), '');
 
+      // Error responses must never be cached by CloudFront — stale 500s
+      // are invisible and hard to debug.
+      const errorHeaders = {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      };
+
       if (!key) {
         return {
           statusCode: 400,
-          headers: { 'Content-Type': 'application/json' },
+          headers: errorHeaders,
           body: JSON.stringify({ error: 'Missing image key' }),
         };
       }
@@ -213,7 +222,7 @@ export function createImageHandler(
       if (key.includes('..') || key.startsWith('/')) {
         return {
           statusCode: 403,
-          headers: { 'Content-Type': 'application/json' },
+          headers: errorHeaders,
           body: JSON.stringify({ error: 'Forbidden' }),
         };
       }
@@ -224,7 +233,7 @@ export function createImageHandler(
         if (!allowed) {
           return {
             statusCode: 403,
-            headers: { 'Content-Type': 'application/json' },
+            headers: errorHeaders,
             body: JSON.stringify({ error: 'Forbidden' }),
           };
         }
@@ -280,7 +289,7 @@ export function createImageHandler(
         if (!result.Body) {
           return {
             statusCode: 404,
-            headers: { 'Content-Type': 'application/json' },
+            headers: errorHeaders,
             body: JSON.stringify({ error: 'Image not found' }),
           };
         }
@@ -291,17 +300,39 @@ export function createImageHandler(
         if (isNotFound(error)) {
           return {
             statusCode: 404,
-            headers: { 'Content-Type': 'application/json' },
+            headers: errorHeaders,
             body: JSON.stringify({ error: 'Image not found' }),
           };
         }
         throw error;
       }
 
-      // Pass through non-image files (fonts, CSS, etc.) without processing
-      const isImage = originalContentType?.startsWith('image/') ??
-        /\.(jpe?g|png|webp|avif|gif|tiff?|svg)$/i.test(key);
-      if (!isImage) {
+      // Detect actual image format from magic bytes — content types from
+      // user uploads are frequently wrong (e.g. application/x-www-form-urlencoded
+      // on a 19 MB JPEG).  Trust the bytes, not the metadata.
+      const sharp = (await import('sharp')).default;
+      let detectedFormat: string | undefined;
+      try {
+        const meta = await sharp(originalData).metadata();
+        detectedFormat = meta.format; // jpeg, png, webp, gif, tiff, heif, etc.
+      } catch {
+        // Sharp can't parse it — not an image
+      }
+
+      if (!detectedFormat) {
+        // Not an image — pass through non-image files (fonts, CSS, etc.)
+        // Lambda responses are capped at 6 MB. Base64 inflates ~33%.
+        const MAX_PASSTHROUGH = 4_500_000; // ~4.5 MB raw → ~6 MB base64
+        if (originalData.length > MAX_PASSTHROUGH) {
+          log('warn', 'File too large for passthrough', {
+            key, size: originalData.length, contentType: originalContentType,
+          });
+          return {
+            statusCode: 413,
+            headers: errorHeaders,
+            body: JSON.stringify({ error: 'File too large' }),
+          };
+        }
         return {
           statusCode: 200,
           headers: {
@@ -316,10 +347,54 @@ export function createImageHandler(
       // No transform params — serve original image as-is (EXIF-corrected webp)
       const hasTransforms = params.w || params.h || params.fit || params.fm || params.q;
 
-      // Process with Sharp
-      const processed = hasTransforms
-        ? await processImage(originalData, params)
-        : await processImage(originalData, { fm: 'webp', q: 80 });
+      // Process with Sharp — catch decode failures (e.g. HEIC without libheif)
+      let processed: { data: Buffer; contentType: string } | undefined;
+      try {
+        processed = hasTransforms
+          ? await processImage(originalData, params)
+          : await processImage(originalData, { fm: 'webp', q: 80 });
+      } catch (sharpError) {
+        // HEIC fallback: decode via WASM (heic-decode) then re-process with Sharp
+        if (detectedFormat === 'heif') {
+          try {
+            const decode = (await import('heic-decode')).default;
+            const { width, height, data } = await decode({ buffer: originalData });
+            const rawBuffer = Buffer.from(data.buffer);
+            const transformParams = hasTransforms ? params : { fm: 'webp' as const, q: 80 };
+            processed = await processImage(rawBuffer, transformParams, { width, height, channels: 4 });
+          } catch (heicError) {
+            log('warn', 'HEIC decode failed, passing through original', {
+              key, contentType: originalContentType,
+              error: String(heicError),
+            });
+          }
+        }
+
+        if (!processed) {
+          log('warn', 'Sharp decode failed, passing through original', {
+            key, format: detectedFormat, contentType: originalContentType,
+            error: String(sharpError),
+          });
+          // Can't decode — pass through original bytes (better than 422)
+          const MAX_PASSTHROUGH = 4_500_000;
+          if (originalData.length > MAX_PASSTHROUGH) {
+            return {
+              statusCode: 422,
+              headers: errorHeaders,
+              body: JSON.stringify({ error: 'Unsupported image format' }),
+            };
+          }
+          return {
+            statusCode: 200,
+            headers: {
+              'Content-Type': originalContentType || 'application/octet-stream',
+              ...cacheHeaders,
+            },
+            body: originalData.toString('base64'),
+            isBase64Encoded: true,
+          };
+        }
+      }
 
       // --- Write rendered image to S3 cache (fire-and-forget) ---
       if (useCache && s3CacheKey) {
@@ -351,7 +426,7 @@ export function createImageHandler(
       log('error', 'Image processing error', { error: String(error), path: event.rawPath });
       return {
         statusCode: 500,
-        headers: { 'Content-Type': 'application/json' },
+        headers: { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' },
         body: JSON.stringify({ error: 'Image processing failed' }),
       };
     }