lambda.js

import serverlessExpress from "@codegenie/serverless-express";
import { Environment } from "./dist/shared/helpers/Environment.js";
import { createApp } from "./dist/app.js";
import { handleSocket } from "./dist/lambda/socket-handler.js";
import { handle30MinTimer, handleMidnightTimer, handleScheduledTasks, handleWebhookTimer } from "./dist/lambda/timer-handler.js";
import { handleSesFeedback } from "./dist/lambda/ses-feedback-handler.js";
import { handleMigrate } from "./dist/lambda/migrate-handler.js";

const initializeEnvironment = async () => {
  if (!Environment.currentEnvironment) {
    const stage = process.env.STAGE || process.env.ENVIRONMENT || "dev";
    console.log("Initializing environment with stage:", stage);
    console.log("Environment variables:", {
      STAGE: process.env.STAGE,
      ENVIRONMENT: process.env.ENVIRONMENT,
      APP_ENV: process.env.APP_ENV
    });
    try {
      await Environment.init(stage);
    } catch (err) {
      Environment.currentEnvironment = undefined;
      throw err;
    }
    console.log("Environment initialized, connection strings loaded");

    // Pools now auto-initialize on first use
  }
};

let cachedHandler;

export const web = async function (event, context) {
  try {
    await initializeEnvironment();

    if (!cachedHandler) {
      console.log("Creating Express app with fully initialized environment...");
      const app = await createApp();
      console.log("Express app created");

      cachedHandler = serverlessExpress({
        app,
        binarySettings: {
          contentTypes: ["application/octet-stream", "font/*", "image/*", "application/pdf"]
        }
      });
      console.log("Serverless Express handler created");
    }

    const result = await cachedHandler(event, context);
    return result;
  } catch (error) {
    console.error("Error in web handler:", error);
    console.error("Error stack:", error.stack);
    return {
      statusCode: 500,
      headers: {
        "Access-Control-Allow-Origin": "*",
        "Access-Control-Allow-Headers": "Content-Type,Authorization",
        "Access-Control-Allow-Methods": "GET,POST,PUT,DELETE,OPTIONS,PATCH"
      },
      body: JSON.stringify({
        error: "Internal server error",
        timestamp: new Date().toISOString()
      })
    };
  }
};

export const socket = async function (event, context) {
  try {
    await initializeEnvironment();
    return await handleSocket(event, context);
  } catch (error) {
    console.error("Error in socket handler:", error);
    return {
      statusCode: 500,
      body: JSON.stringify({ error: "Socket handler error" })
    };
  }
};

// Timer handlers. Export name "timer15Min" is legacy — kept as-is so it matches
// the serverless.yml function key/handler string (renaming would recreate the
// EventBridge rule); it actually runs every 30 minutes.
export const timer15Min = async function (event, context) {
  try {
    await initializeEnvironment();
    await handle30MinTimer(event, context);
    return { statusCode: 200, body: "Timer executed successfully" };
  } catch (error) {
    console.error("Error in 30-minute timer:", error);
    throw error;
  }
};

export const timerMidnight = async function (event, context) {
  try {
    await initializeEnvironment();
    await handleMidnightTimer(event, context);
    return { statusCode: 200, body: "Timer executed successfully" };
  } catch (error) {
    console.error("Error in midnight timer:", error);
    throw error;
  }
};

export const timerScheduledTasks = async function (event, context) {
  try {
    await initializeEnvironment();
    await handleScheduledTasks(event, context);
    return { statusCode: 200, body: "Scheduled tasks executed successfully" };
  } catch (error) {
    console.error("Error in scheduled tasks timer:", error);
    throw error;
  }
};

export const sesFeedback = async function (event) {
  try {
    await initializeEnvironment();
    await handleSesFeedback(event);
    return { statusCode: 200, body: "SES feedback processed" };
  } catch (error) {
    console.error("Error in SES feedback handler:", error);
    throw error;
  }
};

export const timerWebhooks = async function (event, context) {
  try {
    await initializeEnvironment();
    await handleWebhookTimer(event, context);
    return { statusCode: 200, body: "Webhook deliveries processed successfully" };
  } catch (error) {
    console.error("Error in webhook timer:", error);
    throw error;
  }
};

// Invoked by the deploy workflows after `serverless deploy`; see src/lambda/migrate-handler.ts.
export const migrate = async function () {
  await initializeEnvironment();
  return await handleMigrate();
};