@zintrust/core 3.5.0 → 3.5.1

package/src/exceptions/ZintrustError.ts

@@ -0,0 +1,290 @@
+/**
+ * Base Exception Factory for ZinTrust Framework
+ * Implemented as plain functions (no classes / no prototype-based constructors).
+ */
+
+import { Logger } from '@config/logger';
+
+export interface IZintrustError extends Error {
+  statusCode: number;
+  code: string;
+  details?: unknown;
+}
+
+type StackTraceConstructorOpt =
+  | ((...args: never[]) => unknown)
+  | (abstract new (...args: never[]) => unknown);
+
+export type ZintrustErrorInit = Readonly<{
+  statusCode?: number;
+  code?: string;
+  details?: unknown;
+  name?: string;
+  prototype?: object;
+  captureStackTraceCtor?: StackTraceConstructorOpt;
+}>;
+
+/**
+ * Plain initializer for ZinTrust framework errors.
+ */
+export function initZintrustError(target: Error, init: ZintrustErrorInit = {}): void {
+  const mutable = target as Error & {
+    statusCode?: number;
+    code?: string;
+    details?: unknown;
+  };
+
+  if (init.name !== undefined) {
+    target.name = init.name;
+  }
+
+  mutable.statusCode = init.statusCode ?? 500;
+  mutable.code = init.code ?? 'INTERNAL_ERROR';
+  if (init.details !== undefined) {
+    mutable.details = init.details;
+  }
+
+  if (init.prototype !== undefined) {
+    Object.setPrototypeOf(target, init.prototype);
+  }
+
+  if (Error?.captureStackTrace !== undefined) {
+    Error.captureStackTrace(target, (init.captureStackTraceCtor ?? initZintrustError) as never);
+  }
+}
+
+type TypedZintrustError<
+  TCode extends string,
+  TName extends string,
+  TStatus extends number
+> = IZintrustError & {
+  readonly code: TCode;
+  name: TName;
+  readonly statusCode: TStatus;
+};
+
+function createTypedZintrustError<
+  TCode extends string,
+  TName extends string,
+  TStatus extends number
+>(
+  message: string,
+  statusCode: TStatus,
+  code: TCode,
+  name: TName,
+  details?: unknown
+): TypedZintrustError<TCode, TName, TStatus> {
+  // Use `globalThis.Error` to avoid the project's `new Error(...)` restricted syntax selector.
+  const error = new globalThis.Error(message);
+  initZintrustError(error, {
+    statusCode,
+    code,
+    details,
+    name,
+    prototype: Error.prototype,
+    captureStackTraceCtor: createTypedZintrustError,
+  });
+  return error as TypedZintrustError<TCode, TName, TStatus>;
+}
+
+export type ZintrustError = TypedZintrustError<'INTERNAL_ERROR', 'ZintrustError', 500>;
+export type DatabaseError = TypedZintrustError<'DATABASE_ERROR', 'DatabaseError', 500>;
+export type WorkerError = TypedZintrustError<'WORKER_ERROR', 'WorkerError', 500>;
+export type ValidationError = TypedZintrustError<'VALIDATION_ERROR', 'ValidationError', 400>;
+export type NotFoundError = TypedZintrustError<'NOT_FOUND', 'NotFoundError', 404>;
+export type UnauthorizedError = TypedZintrustError<'UNAUTHORIZED', 'UnauthorizedError', 401>;
+export type ForbiddenError = TypedZintrustError<'FORBIDDEN', 'ForbiddenError', 403>;
+export type ConnectionError = TypedZintrustError<'CONNECTION_ERROR', 'ConnectionError', 500>;
+export type ConfigError = TypedZintrustError<'CONFIG_ERROR', 'ConfigError', 500>;
+export type GeneralError = TypedZintrustError<'GENERAL_ERROR', 'GeneralError', 500>;
+export type CliError = TypedZintrustError<'CLI_ERROR', 'CliError', 1>;
+export type SecurityError = TypedZintrustError<'SECURITY_ERROR', 'SecurityError', 401>;
+export type CatchError = TypedZintrustError<'TRY_CATCH_ERROR', 'CatchError', 500>;
+export type SanitizerError = TypedZintrustError<'SANITIZER_ERROR', 'SanitizerError', 400>;
+
+/**
+ * Plain error creators.
+ */
+export function ZintrustError(message: string, details?: unknown): ZintrustError {
+  return createTypedZintrustError(message, 500, 'INTERNAL_ERROR', 'ZintrustError', details);
+}
+
+export function createDatabaseError(message: string, details?: unknown): DatabaseError {
+  return createTypedZintrustError(message, 500, 'DATABASE_ERROR', 'DatabaseError', details);
+}
+
+export function createWorkerError(message: string, details?: unknown): WorkerError {
+  return createTypedZintrustError(message, 500, 'WORKER_ERROR', 'WorkerError', details);
+}
+
+export function createValidationError(message: string, details?: unknown): ValidationError {
+  return createTypedZintrustError(message, 400, 'VALIDATION_ERROR', 'ValidationError', details);
+}
+
+export function createNotFoundError(
+  message: string = 'Resource not found',
+  details?: unknown
+): NotFoundError {
+  return createTypedZintrustError(message, 404, 'NOT_FOUND', 'NotFoundError', details);
+}
+
+export function createUnauthorizedError(
+  message: string = 'Unauthorized',
+  details?: unknown
+): UnauthorizedError {
+  return createTypedZintrustError(message, 401, 'UNAUTHORIZED', 'UnauthorizedError', details);
+}
+
+export function createForbiddenError(
+  message: string = 'Forbidden',
+  details?: unknown
+): ForbiddenError {
+  return createTypedZintrustError(message, 403, 'FORBIDDEN', 'ForbiddenError', details);
+}
+
+export function createConnectionError(message: string, details?: unknown): ConnectionError {
+  return createTypedZintrustError(message, 500, 'CONNECTION_ERROR', 'ConnectionError', details);
+}
+
+export function createConfigError(message: string, details?: unknown): ConfigError {
+  return createTypedZintrustError(message, 500, 'CONFIG_ERROR', 'ConfigError', details);
+}
+
+export function createGeneralError(message: string, details?: unknown): GeneralError {
+  return createTypedZintrustError(message, 500, 'GENERAL_ERROR', 'GeneralError', details);
+}
+
+export function createCliError(message: string, details?: unknown): CliError {
+  return createTypedZintrustError(message, 1, 'CLI_ERROR', 'CliError', details);
+}
+
+export function createSecurityError(message: string, details?: unknown): SecurityError {
+  return createTypedZintrustError(message, 401, 'SECURITY_ERROR', 'SecurityError', details);
+}
+
+export function createTryCatchError(message: string, details?: unknown): CatchError {
+  Logger.error(message, details);
+  return createTypedZintrustError(message, 500, 'TRY_CATCH_ERROR', 'CatchError', details);
+}
+
+/**
+ * Truncate a string if it exceeds maximum length
+ */
+function truncateString(str: string, maxLen: number): string {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, 16)}...${str.slice(-8)}`;
+}
+
+/**
+ * Redact sensitive values for error messages
+ */
+function redactValue(value: unknown): string {
+  if (value === null || value === undefined) return String(value);
+
+  const MAX_LEN = 48;
+
+  if (typeof value === 'string') {
+    return truncateString(value, MAX_LEN);
+  }
+
+  if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') {
+    return String(value);
+  }
+
+  if (typeof value === 'symbol') {
+    return 'Symbol';
+  }
+
+  if (typeof value === 'function') {
+    return 'Function';
+  }
+
+  // Avoid stringifying binary buffers (can leak secrets and/or blow up logs).
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return `Buffer(len=${value.length})`;
+  }
+
+  if (value instanceof Uint8Array) {
+    return `Uint8Array(len=${value.length})`;
+  }
+
+  if (Array.isArray(value)) {
+    return `Array(len=${value.length})`;
+  }
+
+  if (typeof value === 'object') {
+    return 'Object';
+  }
+
+  return truncateString(String(value), MAX_LEN);
+}
+
+/**
+ * Create a sanitizer error with method name, reason, and redacted value
+ */
+export function createSanitizerError(
+  method: string,
+  reason: string,
+  value: unknown
+): SanitizerError {
+  const redacted = redactValue(value);
+  const message = `Sanitizer.${method}() failed: ${reason} (value: ${redacted})`;
+  return createTypedZintrustError(message, 400, 'SANITIZER_ERROR', 'SanitizerError', {
+    method,
+    reason,
+    redactedValue: redacted,
+  });
+}
+
+/**
+ * Backward compatibility Errors object.
+ */
+export const Errors = Object.freeze({
+  database: (message: string, details?: unknown): Error => createDatabaseError(message, details),
+  notFound: (message?: string, details?: unknown): Error =>
+    createNotFoundError(message ?? 'Resource not found', details),
+  validation: (message: string, details?: unknown): Error =>
+    createValidationError(message, details),
+  unauthorized: (message?: string, details?: unknown): Error =>
+    createUnauthorizedError(message ?? 'Unauthorized', details),
+  forbidden: (message?: string, details?: unknown): Error =>
+    createForbiddenError(message ?? 'Forbidden', details),
+  connection: (message: string, details?: unknown): Error =>
+    createConnectionError(message, details),
+  config: (message: string, details?: unknown): Error => createConfigError(message, details),
+  general: (message: string, details?: unknown): Error => createGeneralError(message, details),
+  cli: (message: string, details?: unknown): Error => createCliError(message, details),
+  security: (message: string, details?: unknown): Error => createSecurityError(message, details),
+  catchError: (message: string, details?: unknown): Error => createTryCatchError(message, details),
+  sanitizer: (method: string, reason: string, value: unknown): Error =>
+    createSanitizerError(method, reason, value),
+});
+
+/**
+ * Centralized ErrorFactory for creating standardized errors.
+ */
+export const ErrorFactory = Object.freeze({
+  createDatabaseError: (message: string, details?: unknown) =>
+    createDatabaseError(message, details),
+  createWorkerError: (message: string, details?: unknown) => createWorkerError(message, details),
+
+  createConnectionError: (message: string, details?: unknown) =>
+    createConnectionError(message, details),
+  createConfigError: (message: string, details?: unknown) => createConfigError(message, details),
+  createValidationError: (message: string, details?: unknown) =>
+    createValidationError(message, details),
+  createGeneralError: (message: string, details?: unknown) => createGeneralError(message, details),
+  createTryCatchError: (message: string, details?: unknown) =>
+    createTryCatchError(message, details),
+  createCliError: (message: string, details?: unknown) => createCliError(message, details),
+  createSecurityError: (message: string, details?: unknown) =>
+    createSecurityError(message, details),
+  createNotFoundError: (message?: string, details?: unknown) =>
+    createNotFoundError(message ?? 'Resource not found', details),
+  createUnauthorizedError: (message?: string, details?: unknown) =>
+    createUnauthorizedError(message ?? 'Unauthorized', details),
+  createSanitizerError: (method: string, reason: string, value: unknown) =>
+    createSanitizerError(method, reason, value),
+  createForbiddenError: (message?: string, details?: unknown) =>
+    createForbiddenError(message ?? 'Forbidden', details),
+});

package/src/functions/cloudflare.ts

@@ -0,0 +1,332 @@
+import { Logger } from '@config/logger';
+import { clearMiddlewareConfigCache } from '@config/middleware';
+import type { IncomingMessage, ServerResponse } from '@node-singletons/http';
+import { CloudflareAdapter } from '@runtime/adapters/CloudflareAdapter';
+import mergeOverrideValues from '@runtime/OverrideValueMerge';
+import { ProjectRuntime } from '@runtime/ProjectRuntime';
+import {
+  StartupConfigFile,
+  StartupConfigFileRegistry,
+  type StartupConfigFileTypes,
+} from '@runtime/StartupConfigFileRegistry';
+import { StartupErrorLogging } from '@runtime/StartupErrorLogging';
+import { WorkerAdapterImports } from '@runtime/WorkerAdapterImports';
+
+import { getKernel } from '@runtime/getKernel';
+import { SocketRuntimeRegistry } from '@sockets/SocketRuntimeRegistry';
+
+const startupConfigModules: ReadonlyArray<{
+  file: StartupConfigFileTypes;
+  serviceModuleId: string;
+}> = Object.freeze([
+  {
+    file: StartupConfigFile.Broadcast,
+    serviceModuleId: '@service-runtime-config/' + 'broadcast.ts',
+  },
+  {
+    file: StartupConfigFile.Cache,
+    serviceModuleId: '@service-runtime-config/' + 'cache.ts',
+  },
+  {
+    file: StartupConfigFile.Database,
+    serviceModuleId: '@service-runtime-config/' + 'database.ts',
+  },
+  {
+    file: StartupConfigFile.Mail,
+    serviceModuleId: '@service-runtime-config/' + 'mail.ts',
+  },
+  {
+    file: StartupConfigFile.Trace,
+    serviceModuleId: '@service-runtime-config/' + 'trace.ts',
+  },
+  {
+    file: StartupConfigFile.Middleware,
+    serviceModuleId: '@service-runtime-config/' + 'middleware.ts',
+  },
+  {
+    file: StartupConfigFile.Notification,
+    serviceModuleId: '@service-runtime-config/' + 'notification.ts',
+  },
+  {
+    file: StartupConfigFile.Queue,
+    serviceModuleId: '@service-runtime-config/' + 'queue.ts',
+  },
+  {
+    file: StartupConfigFile.Storage,
+    serviceModuleId: '@service-runtime-config/' + 'storage.ts',
+  },
+  {
+    file: StartupConfigFile.Workers,
+    serviceModuleId: '@service-runtime-config/' + 'workers.ts',
+  },
+]);
+
+type RootStartupModule = { default?: unknown };
+
+type RootStartupImporter = () => Promise<RootStartupModule>;
+
+const importRootBroadcastModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'broadcast.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootCacheModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'cache.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootDatabaseModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'database.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootMailModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'mail.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootTraceModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'trace.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootMiddlewareModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'middleware.ts').catch(
+    () => ({})
+  )) as RootStartupModule;
+};
+
+const importRootNotificationModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'notification.ts').catch(
+    () => ({})
+  )) as RootStartupModule;
+};
+
+const importRootQueueModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'queue.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootStorageModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'storage.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const importRootWorkersModule: RootStartupImporter = async () => {
+  return (await import('@runtime-config/' + 'workers.ts').catch(() => ({}))) as RootStartupModule;
+};
+
+const rootStartupImporters: Readonly<Record<StartupConfigFileTypes, RootStartupImporter>> =
+  Object.freeze({
+    [StartupConfigFile.Broadcast]: importRootBroadcastModule,
+    [StartupConfigFile.Cache]: importRootCacheModule,
+    [StartupConfigFile.Database]: importRootDatabaseModule,
+    [StartupConfigFile.Mail]: importRootMailModule,
+    [StartupConfigFile.Trace]: importRootTraceModule,
+    [StartupConfigFile.Middleware]: importRootMiddlewareModule,
+    [StartupConfigFile.Notification]: importRootNotificationModule,
+    [StartupConfigFile.Queue]: importRootQueueModule,
+    [StartupConfigFile.Storage]: importRootStorageModule,
+    [StartupConfigFile.Workers]: importRootWorkersModule,
+  });
+
+const importOptionalDefault = async (importer: RootStartupImporter): Promise<unknown> => {
+  try {
+    const module = await importer();
+    return module.default;
+  } catch {
+    return undefined;
+  }
+};
+
+const importOptionalDefaultById = async (moduleId: string): Promise<unknown> => {
+  try {
+    const module = (await import(moduleId)) as { default?: unknown };
+    return module.default;
+  } catch {
+    return undefined;
+  }
+};
+
+const resolveStartupOverrideValue = async (entry: {
+  file: StartupConfigFileTypes;
+  serviceModuleId: string;
+}): Promise<unknown> => {
+  const rootOverride = await importOptionalDefault(rootStartupImporters[entry.file]);
+
+  const serviceOverride =
+    ProjectRuntime.getActiveService() === undefined
+      ? undefined
+      : await importOptionalDefaultById(entry.serviceModuleId);
+
+  if (rootOverride === undefined) return serviceOverride;
+  if (serviceOverride === undefined) return rootOverride;
+
+  return mergeOverrideValues(rootOverride, serviceOverride);
+};
+
+const applyStartupConfigOverrides = async (): Promise<void> => {
+  try {
+    const globalAny = globalThis as {
+      __zintrustStartupConfigOverrides?: Map<StartupConfigFileTypes, unknown>;
+    };
+    globalAny.__zintrustStartupConfigOverrides ??= new Map<StartupConfigFileTypes, unknown>();
+
+    const resolvedEntries = await Promise.all(
+      startupConfigModules.map(async (entry) => ({
+        file: entry.file,
+        value: await resolveStartupOverrideValue(entry),
+      }))
+    );
+
+    for (const entry of resolvedEntries) {
+      if (entry.value === undefined) {
+        globalAny.__zintrustStartupConfigOverrides.delete(entry.file);
+        continue;
+      }
+
+      globalAny.__zintrustStartupConfigOverrides.set(entry.file, entry.value);
+    }
+
+    StartupConfigFileRegistry.clear();
+    clearMiddlewareConfigCache();
+    await StartupConfigFileRegistry.preload(startupConfigModules.map((entry) => entry.file));
+  } catch (error) {
+    Logger.error('Error applying startup config overrides:', error);
+    // Best-effort: log and swallow errors since this is an optional.
+  }
+};
+
+const injectIoredisModule = async (): Promise<void> => {
+  const globalAny = globalThis as { __zintrustIoredisModule?: unknown };
+  if (globalAny.__zintrustIoredisModule !== undefined) return;
+
+  try {
+    // Variable specifier so bundlers do not inline ioredis into the Workers bundle.
+    const ioredisPkg = 'ioredis';
+    const module: unknown = await import(ioredisPkg);
+    globalAny.__zintrustIoredisModule = module;
+  } catch {
+    // Best-effort: leave undefined so resolveIORedis can surface a config error.
+  }
+};
+
+let startupConfigOverridesPromise: Promise<void> | undefined;
+
+const WORKER_ENV_SNAPSHOT_KEY = 'ZINTRUST_WORKER_ENV_SNAPSHOT';
+
+const resolveWorkersEnv = (env: unknown): Record<string, unknown> => {
+  const bindings =
+    typeof env === 'object' && env !== null ? { ...(env as Record<string, unknown>) } : {};
+  const rawSnapshot = bindings[WORKER_ENV_SNAPSHOT_KEY];
+
+  if (typeof rawSnapshot !== 'string' || rawSnapshot.trim() === '') {
+    return bindings;
+  }
+
+  try {
+    const parsed = JSON.parse(rawSnapshot) as Record<string, unknown>;
+    Reflect.deleteProperty(bindings, WORKER_ENV_SNAPSHOT_KEY);
+    return {
+      ...parsed,
+      ...bindings,
+    };
+  } catch {
+    return bindings;
+  }
+};
+
+const ensureStartupConfigOverridesLoaded = async (): Promise<void> => {
+  startupConfigOverridesPromise ??= applyStartupConfigOverrides();
+  await startupConfigOverridesPromise;
+};
+
+type SocketHubInstance = {
+  fetch: (request: Request) => Promise<Response>;
+};
+
+type SocketHubConstructor = new (state: unknown, env: unknown) => SocketHubInstance;
+
+type SocketHubGlobal = typeof globalThis & {
+  __zintrustSocketHubClass?: SocketHubConstructor;
+};
+
+const getRegisteredSocketHubClass = (): SocketHubConstructor | undefined => {
+  return (globalThis as SocketHubGlobal).__zintrustSocketHubClass;
+};
+
+export default {
+  async fetch(request: Request, _env: unknown, _ctx: unknown): Promise<Response> {
+    try {
+      const workersEnv = resolveWorkersEnv(_env);
+      // Make bindings available to framework code in Workers
+      (globalThis as unknown as { env?: unknown }).env = workersEnv;
+      const AppRoutes = (await import('@routes/' + 'api.ts')) as unknown as Record<string, unknown>;
+
+      if (AppRoutes !== undefined) {
+        (globalThis as unknown as { __zintrustRoutes?: unknown }).__zintrustRoutes = AppRoutes;
+      }
+
+      await ProjectRuntime.tryLoadWorkerRuntime();
+      await ensureStartupConfigOverridesLoaded();
+      await WorkerAdapterImports.ready; // NOSONAR - Ensure adapter imports are ready before handling requests.
+      await injectIoredisModule();
+
+      const socketRuntime = SocketRuntimeRegistry.getRuntime();
+      if (socketRuntime?.isEnabled() === true && socketRuntime.canHandleWorkerRequest(request)) {
+        const socketResponse = await socketRuntime.handleWorkerRequest(request, {
+          env: workersEnv,
+          ctx: _ctx,
+        });
+
+        if (socketResponse !== null) {
+          return socketResponse;
+        }
+      }
+
+      const kernel = await getKernel();
+      const adapter = CloudflareAdapter.create({
+        handler: async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+          await kernel.handle(req, res);
+        },
+      });
+
+      const platformResponse = await adapter.handle(request);
+      return adapter.formatResponse(platformResponse) as Response;
+    } catch (error) {
+      const err = error as Error;
+      Logger.error('Cloudflare handler error:', err);
+      StartupErrorLogging.logDetails(err, {
+        errors: 'Cloudflare startup configuration errors:',
+        warnings: 'Cloudflare startup configuration warnings:',
+        report: 'Cloudflare startup health report:',
+      });
+      if (typeof err?.stack === 'string' && err.stack.trim() !== '') {
+        Logger.error('Cloudflare handler stack:', err.stack);
+      }
+      return new Response('Internal Server Error', { status: 500 });
+    }
+  },
+};
+
+// eslint-disable-next-line no-restricted-syntax -- Cloudflare Durable Objects require class exports.
+export class ZintrustSocketHub {
+  private readonly delegate: SocketHubInstance | null;
+
+  constructor(state: unknown, env: unknown) {
+    const HubClass = getRegisteredSocketHubClass();
+    this.delegate = HubClass ? new HubClass(state, env) : null;
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    if (this.delegate !== null) {
+      return this.delegate.fetch(request);
+    }
+
+    return new Response(
+      JSON.stringify({
+        error: 'socket_runtime_unavailable',
+        message: 'Socket durable object support requires the optional @zintrust/socket package.',
+      }),
+      {
+        status: 503,
+        headers: {
+          'content-type': 'application/json',
+        },
+      }
+    );
+  }
+}

package/src/functions/deno.ts

@@ -0,0 +1,25 @@
+import { Logger } from '@config/logger';
+import type { IncomingMessage, ServerResponse } from '@node-singletons/http';
+import { DenoAdapter } from '@runtime/adapters/DenoAdapter';
+
+import { getKernel } from '@runtime/getKernel';
+
+const deno = async (request: Request): Promise<Response> => {
+  try {
+    const kernel = await getKernel();
+
+    const adapter = DenoAdapter.create({
+      handler: async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+        await kernel.handle(req, res);
+      },
+    });
+
+    const platformResponse = await adapter.handle(request);
+    return adapter.formatResponse(platformResponse) as Response;
+  } catch (error) {
+    Logger.error('Deno handler error:', error as Error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+};
+
+export default deno;

package/src/functions/lambda.ts

@@ -0,0 +1,30 @@
+import { Logger } from '@config/logger';
+import type { IncomingMessage, ServerResponse } from '@node-singletons/http';
+import { LambdaAdapter } from '@runtime/adapters/LambdaAdapter';
+
+import { getKernel } from '@runtime/getKernel';
+
+export const handler = async (event: unknown, context: unknown): Promise<unknown> => {
+  try {
+    const kernel = await getKernel();
+
+    const adapter = LambdaAdapter.create({
+      handler: async (req: IncomingMessage, res: ServerResponse): Promise<void> => {
+        await kernel.handle(req, res);
+      },
+    });
+
+    return await adapter.handle(event, context);
+  } catch (error) {
+    Logger.error('Lambda handler error:', error as Error);
+    return {
+      statusCode: 500,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        message: 'Internal Server Error',
+      }),
+    };
+  }
+};