Fix deploy smoke test and normalize Lambda Function URL events (Refs #101)

Normalize Function URL events (requestContext.http.method / rawPath) into
the API-Gateway-shaped LambdaEvent the router expects, so / and /login
route correctly behind the deployed Function URL. Tighten the deploy
smoke step to assert root -> 200/301/302 and /login -> 200, and fix its
YAML indentation/continuation alignment. Add unit tests covering the
normalization (FU-shaped GET / and /api/health, plus FU-vs-APIGW parity).

Refs #101

Author: alexeygrigorev

.github/workflows/deploy-dataops-v1.yml

@@ -159,15 +159,19 @@ jobs:
       - name: Smoke test deployed single-origin backend
         run: |
           backend_url="$(aws cloudformation describe-stacks \
-          --stack-name dataops-v1 \
-          --query "Stacks[0].Outputs[?OutputKey=='BackendUrl'].OutputValue" \
-          --output text)"
-          # The deployed backend function should respond to any HTTP request.
-          # Any non-5xx response means the function is alive and routing.
+            --stack-name dataops-v1 \
+            --query "Stacks[0].Outputs[?OutputKey=='BackendUrl'].OutputValue" \
+            --output text)"
+          # The deployed backend should serve /login (200) and redirect / to /login (302).
+          # The Function URL event normalization in handler.ts must work for this.
           code=$(curl -sS -o /dev/null -w "%{http_code}" "$backend_url/")
-          if [ "$code" -ge 500 ]; then
-            echo "Backend smoke test failed: server error $code"
+          if [ "$code" != "200" ] && [ "$code" != "302" ] && [ "$code" != "301" ]; then
+            echo "Backend smoke test failed: root expected 200/301/302, got $code"
             exit 1
           fi
-          echo "Backend smoke OK: HTTP $code"
-
+          login_code=$(curl -sS -o /dev/null -w "%{http_code}" "$backend_url/login")
+          if [ "$login_code" != "200" ]; then
+            echo "Backend smoke test failed: /login expected 200, got $login_code"
+            exit 1
+          fi
+          echo "Backend smoke OK: root=$code login=$login_code"

backend/src/handler.ts

@@ -33,6 +33,25 @@ function isScheduledEvent(event: unknown): boolean {
 }
 
 async function handler(event: LambdaEvent | Record<string, unknown>, _context?: unknown): Promise<LambdaResponse | CronRunnerResult> {
+  // Normalize Lambda Function URL events to the API Gateway-shaped LambdaEvent
+  // the router expects. Function URLs send requestContext.http.method/path and
+  // rawPath, not httpMethod/path.
+  if (typeof event === 'object' && event !== null && !('httpMethod' in event)) {
+    const raw = event as Record<string, unknown>;
+    const requestContext = raw.requestContext as Record<string, unknown> | undefined;
+    const http = requestContext?.http as Record<string, unknown> | undefined;
+    if (http?.method || raw.rawPath) {
+      event = {
+        httpMethod: (http?.method as string) || 'GET',
+        path: (raw.rawPath as string) || (http?.path as string) || '/',
+        headers: (raw.headers as Record<string, string>) || {},
+        body: (raw.body as string) ?? null,
+        isBase64Encoded: (raw.isBase64Encoded as boolean) || false,
+        queryStringParameters: (raw.queryStringParameters as Record<string, string>) || null,
+      } as LambdaEvent;
+    }
+  }
+
   await ensureInitialized();
 
   // Handle EventBridge scheduled events

backend/tests/handler.test.ts

@@ -50,3 +50,50 @@ describe('handler', () => {
     assert.strictEqual(result.statusCode, 404);
   });
 });
+
+describe('handler Function URL event normalization', () => {
+  after(async () => {
+    await stopLocal();
+  });
+
+  it('FU-shaped GET / (requestContext.http.method + rawPath, no httpMethod) returns SPA HTML with status 200', async () => {
+    const event = {
+      requestContext: { http: { method: 'GET', path: '/' } },
+      rawPath: '/',
+    };
+    const result = await handler(event, {});
+
+    assert.strictEqual(result.statusCode, 200);
+    assert.strictEqual(result.headers!['Content-Type'], 'text/html');
+    assert.ok(result.body.includes('<title>DataOps</title>'));
+    assert.ok(result.body.includes('id="app"'));
+  });
+
+  it('FU-shaped GET /api/health returns {"status":"ok"} with status 200', async () => {
+    const event = {
+      requestContext: { http: { method: 'GET', path: '/api/health' } },
+      rawPath: '/api/health',
+    };
+    const result = await handler(event, {});
+
+    assert.strictEqual(result.statusCode, 200);
+    assert.strictEqual(result.headers!['Content-Type'], 'application/json');
+
+    const body = JSON.parse(result.body);
+    assert.deepStrictEqual(body, { status: 'ok' });
+  });
+
+  it('FU-shaped GET /api/health matches the equivalent API-Gateway-shaped event', async () => {
+    const fuEvent = {
+      requestContext: { http: { method: 'GET', path: '/api/health' } },
+      rawPath: '/api/health',
+    };
+    const apiGwEvent = { httpMethod: 'GET', path: '/api/health' };
+
+    const fuResult = await handler(fuEvent, {});
+    const apiGwResult = await handler(apiGwEvent, {});
+
+    assert.strictEqual(fuResult.statusCode, apiGwResult.statusCode);
+    assert.strictEqual(fuResult.body, apiGwResult.body);
+  });
+});