lambder 2.0.8 → 2.0.10

package/dist/LambderResponseBuilder.js

@@ -28,7 +28,8 @@ export default class LambderResponseBuilder {
             throw new Error("File system operations are not available in browser environment");
         }
         const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.resolve(publicPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(publicPath, normalizedFilePath);
         if (!absolutePath.startsWith(publicPath)) {
             return "forbidden-public-path";
         }
@@ -42,7 +43,8 @@ export default class LambderResponseBuilder {
             return false;
         }
         const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.resolve(publicPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(publicPath, normalizedFilePath);
         if (!absolutePath.startsWith(publicPath)) {
             return false;
         }
@@ -147,7 +149,7 @@ export default class LambderResponseBuilder {
         return this.raw({
             statusCode: 200,
             isBase64Encoded: true,
-            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) },
+            multiValueHeaders: { "Content-Type": [mimeType || "application/octet-stream"], ...convertToMultiHeader(headers) },
             body: fileBase64,
         });
     }
@@ -171,7 +173,7 @@ export default class LambderResponseBuilder {
         const bodyBuffer = Buffer.isBuffer(body) ? body : Buffer.from(body);
         const bodyBase64 = bodyBuffer.toString("base64");
         console.log("bodyBase64.length", bodyBase64.length);
-        return this.fileBase64(bodyBase64, mimeType || "", headers);
+        return this.fileBase64(bodyBase64, mimeType || "application/octet-stream", headers);
     }
     ;
     async ejsTemplate(template, pageData, headers) {

package/dist/LambderUtils.js

@@ -16,7 +16,8 @@ export default class LambderUtils {
             return "EJS PATH NOT SET!";
         }
         const ejsPath = path.resolve(this.ejsPath);
-        const absolutePath = path.resolve(ejsPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
         if (!absolutePath.startsWith(ejsPath)) {
             return "forbidden-ejs-path";
         }
@@ -33,7 +34,8 @@ export default class LambderUtils {
             return "EJS PATH NOT SET!";
         }
         const ejsPath = path.resolve(this.ejsPath);
-        const absolutePath = path.resolve(ejsPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
         if (!absolutePath.startsWith(ejsPath)) {
             return false;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "2.0.8",
+  "version": "2.0.10",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/LambderResponseBuilder.ts

@@ -69,7 +69,8 @@ export default class LambderResponseBuilder<TResponse = any> {
         }
         
         const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.resolve(publicPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(publicPath, normalizedFilePath);
         if(!absolutePath.startsWith(publicPath)){ return "forbidden-public-path"; }
         return await fs.promises.readFile(absolutePath);
     };
@@ -81,7 +82,8 @@ export default class LambderResponseBuilder<TResponse = any> {
         if (!fs || !path) { return false; }
         
         const publicPath = path.resolve(this.publicPath);
-        const absolutePath = path.resolve(publicPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(publicPath, normalizedFilePath);
         if(!absolutePath.startsWith(publicPath)){ return false; }
         try {
             const stat = await fs.promises.stat(absolutePath);
@@ -200,7 +202,7 @@ export default class LambderResponseBuilder<TResponse = any> {
         return this.raw({ 
             statusCode: 200, 
             isBase64Encoded: true, 
-            multiValueHeaders: { "Content-Type": [mimeType || "text/html"], ...convertToMultiHeader(headers) }, 
+            multiValueHeaders: { "Content-Type": [mimeType || "application/octet-stream"], ...convertToMultiHeader(headers) }, 
             body: fileBase64, 
         });
     };
@@ -228,7 +230,7 @@ export default class LambderResponseBuilder<TResponse = any> {
         const bodyBuffer: Buffer =  Buffer.isBuffer(body) ? body : Buffer.from(body);
         const bodyBase64 = bodyBuffer.toString("base64");
         console.log("bodyBase64.length",bodyBase64.length);
-        return this.fileBase64(bodyBase64, mimeType || "", headers);
+        return this.fileBase64(bodyBase64, mimeType || "application/octet-stream", headers);
     };
 
 	async ejsTemplate(

package/src/LambderUtils.ts

@@ -21,7 +21,8 @@ export default class LambderUtils {
         }
         if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
         const ejsPath = path.resolve(this.ejsPath);
-        const absolutePath = path.resolve(ejsPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
         if(!absolutePath.startsWith(ejsPath)){ return "forbidden-ejs-path"; }
         return await fs.promises.readFile(absolutePath, 'utf-8');
     };
@@ -35,7 +36,8 @@ export default class LambderUtils {
         }
         if(!this.ejsPath){ return "EJS PATH NOT SET!"; }
         const ejsPath = path.resolve(this.ejsPath);
-        const absolutePath = path.resolve(ejsPath, filePath);
+        const normalizedFilePath = filePath.startsWith('/') ? filePath.slice(1) : filePath;
+        const absolutePath = path.resolve(ejsPath, normalizedFilePath);
         if(!absolutePath.startsWith(ejsPath)){ return false; }
         try {
             const stat = await fs.promises.stat(absolutePath);

package/tests/file-serving.test.ts

@@ -0,0 +1,194 @@
+/**
+ * File Serving Tests
+ * 
+ * Tests for file serving functionality including:
+ * - Serving existing files correctly
+ * - Fallback to index.html for non-existent files
+ * - Not serving index.html when the requested file exists
+ */
+
+import { describe, it, expect } from 'vitest';
+import Lambder from '../src/Lambder.js';
+import type { APIGatewayProxyEvent, Context } from 'aws-lambda';
+import path from 'path';
+
+const createMockEvent = (path: string, method: string = 'GET'): APIGatewayProxyEvent => ({
+    body: null,
+    headers: { 
+        Host: 'localhost',
+    },
+    multiValueHeaders: {},
+    httpMethod: method,
+    isBase64Encoded: false,
+    path,
+    pathParameters: null,
+    queryStringParameters: null,
+    multiValueQueryStringParameters: null,
+    stageVariables: null,
+    requestContext: {} as any,
+    resource: '',
+});
+
+const createMockContext = (): Context => ({
+    callbackWaitsForEmptyEventLoop: false,
+    functionName: 'test',
+    functionVersion: '1',
+    invokedFunctionArn: 'arn',
+    memoryLimitInMB: '128',
+    awsRequestId: '123',
+    logGroupName: 'group',
+    logStreamName: 'stream',
+    getRemainingTimeInMillis: () => 1000,
+    done: () => {},
+    fail: () => {},
+    succeed: () => {},
+});
+
+describe('File Serving with Fallback', () => {
+    it('should serve main.css when it exists, NOT index.html', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path, {}, 'index.html');
+            });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/main.css');
+        const result = await handler(event, createMockContext());
+
+        expect(result.statusCode).toBe(200);
+        
+        // Check content type is CSS
+        expect(result.multiValueHeaders?.['Content-Type']).toContain('text/css');
+        
+        // Check body contains CSS content
+        const body = Buffer.from(result.body || '', 'base64').toString();
+        expect(body).toContain('body { margin: 0; }');
+        expect(body).not.toContain('<h1>Test HTML</h1>');
+    });
+
+    it('should serve index.html when requested file does not exist', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path, {}, 'index.html');
+            });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/non-existent-file.js');
+        const result = await handler(event, createMockContext());
+
+        expect(result.statusCode).toBe(200);
+        
+        // Check content type is HTML
+        expect(result.multiValueHeaders?.['Content-Type']).toContain('text/html');
+        
+        // Check body contains HTML content from index.html
+        const body = Buffer.from(result.body || '', 'base64').toString();
+        expect(body).toContain('<h1>Test HTML</h1>');
+    });
+
+    it('should serve index.html when requested directly', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path, {}, 'index.html');
+            });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/index.html');
+        const result = await handler(event, createMockContext());
+
+        expect(result.statusCode).toBe(200);
+        
+        // Check content type is HTML
+        expect(result.multiValueHeaders?.['Content-Type']).toContain('text/html');
+        
+        // Check body contains HTML content
+        const body = Buffer.from(result.body || '', 'base64').toString();
+        expect(body).toContain('<h1>Test HTML</h1>');
+    });
+
+    it('should return error when both requested file and fallback do not exist', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path, {}, 'non-existent-fallback.html');
+            });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/non-existent-file.js');
+        const result = await handler(event, createMockContext());
+
+        expect(result.statusCode).toBe(200);
+        
+        // Should return JSON error
+        const body = JSON.parse(result.body || '{}');
+        expect(body.error).toContain('File not found');
+    });
+
+    it('should serve correct file even when catch-all route is last', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/specific', (ctx, res) => {
+                return res.html('Specific Route');
+            })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path, {}, 'index.html');
+            });
+
+        const handler = lambder.getHandler();
+        
+        // Test specific route still works
+        const specificEvent = createMockEvent('/specific');
+        const specificResult = await handler(specificEvent, createMockContext());
+        const specificBody = Buffer.from(specificResult.body || '', 'base64').toString();
+        expect(specificBody).toBe('Specific Route');
+        
+        // Test main.css is served correctly
+        const cssEvent = createMockEvent('/main.css');
+        const cssResult = await handler(cssEvent, createMockContext());
+        const cssBody = Buffer.from(cssResult.body || '', 'base64').toString();
+        expect(cssBody).toContain('body { margin: 0; }');
+        
+        // Test fallback to index.html for non-existent files
+        const fallbackEvent = createMockEvent('/some-route');
+        const fallbackResult = await handler(fallbackEvent, createMockContext());
+        const fallbackBody = Buffer.from(fallbackResult.body || '', 'base64').toString();
+        expect(fallbackBody).toContain('<h1>Test HTML</h1>');
+    });
+
+    it('should serve CSS file with correct text/css MIME type', async () => {
+        const lambder = new Lambder({
+            publicPath: path.resolve('./tests/fixtures/public'),
+            apiPath: '/api'
+        })
+            .addRoute('/(.*)', (ctx, res) => {
+                return res.file(ctx.path);
+            });
+
+        const handler = lambder.getHandler();
+        const event = createMockEvent('/main.css');
+        const result = await handler(event, createMockContext());
+
+        expect(result.statusCode).toBe(200);
+        
+        // Verify Content-Type header is exactly text/css
+        expect(result.multiValueHeaders?.['Content-Type']).toBeDefined();
+        expect(result.multiValueHeaders?.['Content-Type']?.[0]).toBe('text/css');
+        
+        // Verify body contains CSS content
+        const body = Buffer.from(result.body || '', 'base64').toString();
+        expect(body).toContain('body { margin: 0; }');
+    });
+});

package/tests/fixtures/public/index.html

@@ -0,0 +1 @@
+<h1>Test HTML</h1>

package/tests/fixtures/public/main.css

@@ -0,0 +1 @@
+body { margin: 0; }