@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/lambda/index.d.ts

@@ -0,0 +1,156 @@
+import * as hono_aws_lambda from 'hono/aws-lambda';
+export { APIGatewayProxyResult, LambdaEvent } from 'hono/aws-lambda';
+import { A as Application } from '../Application-DtWDHXr1.js';
+import { S as Scheduler } from '../Scheduler-BstvSca7.js';
+import { C as ConsoleKernel } from '../ConsoleKernel-CqCVrdZs.js';
+import 'hono';
+import '../api-token-JOif2CtG.js';
+import 'vite';
+import '../EventManager-CmIoLt7r.js';
+import '../CacheManager-BkvHEOZX.js';
+import '../MailManager-DpMvYiP9.js';
+import '../LogManager-7mxnkaPM.js';
+import '../I18nManager-Dtgzsf5n.js';
+import '../BroadcastManager-AkIWUGJo.js';
+import '../index-9_Jzj5jo.js';
+import '../app-key-CsBfRC_Q.js';
+import '../StorageManager-oZTHqaza.js';
+import '../HealthManager-DUyMIzsZ.js';
+import '../Gate-CNkBYf8m.js';
+
+/**
+ * SQS event record from AWS Lambda.
+ */
+interface SqsRecord {
+    messageId: string;
+    receiptHandle: string;
+    body: string;
+    attributes: Record<string, string>;
+    messageAttributes: Record<string, unknown>;
+    md5OfBody: string;
+    eventSource: string;
+    eventSourceARN: string;
+    awsRegion: string;
+}
+/**
+ * SQS event payload from AWS Lambda.
+ */
+interface SqsEvent {
+    Records: SqsRecord[];
+}
+/**
+ * SQS batch item failure for partial batch response.
+ */
+interface SqsBatchItemFailure {
+    itemIdentifier: string;
+}
+/**
+ * SQS batch response with partial failures.
+ */
+interface SqsBatchResponse {
+    batchItemFailures: SqsBatchItemFailure[];
+}
+/**
+ * Create an AWS Lambda handler from a booted Guren application.
+ *
+ * @example
+ * ```typescript
+ * import app from './src/app'
+ * import { createLambdaHandler } from '@guren/server/lambda'
+ *
+ * await app.boot()
+ * export const handler = createLambdaHandler(app)
+ * ```
+ */
+declare function createLambdaHandler(app: Application): <L extends hono_aws_lambda.LambdaEvent>(event: L, lambdaContext?: hono_aws_lambda.LambdaContext) => Promise<hono_aws_lambda.APIGatewayProxyResult & (L extends {
+    multiValueHeaders: Record<string, string[]>;
+} ? {
+    headers?: undefined;
+    multiValueHeaders: Record<string, string[]>;
+} : {
+    headers: Record<string, string>;
+    multiValueHeaders?: undefined;
+})>;
+/**
+ * Create an AWS Lambda handler for processing SQS queue jobs.
+ *
+ * Supports partial batch failure reporting — only failed messages
+ * are returned to SQS for retry, while successful ones are deleted.
+ *
+ * @example
+ * ```typescript
+ * import app from './src/app'
+ * import { createSqsHandler } from '@guren/server/lambda'
+ *
+ * await app.boot()
+ * export const queue = createSqsHandler()
+ * ```
+ */
+declare function createSqsHandler(): (event: SqsEvent) => Promise<SqsBatchResponse>;
+/**
+ * Create an AWS Lambda handler for running scheduled tasks via EventBridge.
+ *
+ * @example
+ * ```typescript
+ * import { createScheduleHandler } from '@guren/server/lambda'
+ * import { scheduler } from './src/scheduler'
+ *
+ * export const schedule = createScheduleHandler(scheduler)
+ * ```
+ */
+declare function createScheduleHandler(scheduler: Scheduler): () => Promise<void>;
+/**
+ * Console command event payload for Lambda.
+ */
+interface ConsoleEvent {
+    /**
+     * Command string to execute (e.g. "db:migrate", "users:create john@example.com --admin").
+     */
+    command: string;
+}
+/**
+ * Console command result from Lambda.
+ */
+interface ConsoleResult {
+    exitCode: number;
+}
+/**
+ * Create an AWS Lambda handler for running console commands.
+ *
+ * Invoke via AWS CLI, SDK, or EventBridge with a JSON payload:
+ * `{ "command": "db:migrate" }`
+ *
+ * @example
+ * ```typescript
+ * import { createConsoleHandler } from '@guren/server/lambda'
+ * import { kernel } from './src/console'
+ *
+ * export const console = createConsoleHandler(kernel)
+ * ```
+ */
+declare function createConsoleHandler(kernel: ConsoleKernel): (event: ConsoleEvent) => Promise<ConsoleResult>;
+/**
+ * Detect if the current process is running inside AWS Lambda.
+ *
+ * Checks for the `AWS_LAMBDA_FUNCTION_NAME` environment variable,
+ * which AWS sets automatically in all Lambda runtimes.
+ */
+declare function isLambda(): boolean;
+/**
+ * Get Lambda environment metadata, or null if not running on Lambda.
+ */
+declare function getLambdaContext(): LambdaRuntimeContext | null;
+/**
+ * Lambda runtime context metadata.
+ */
+interface LambdaRuntimeContext {
+    functionName: string;
+    functionVersion: string;
+    memorySize: number;
+    region: string;
+    logGroup?: string;
+    logStream?: string;
+    tmpDir: string;
+}
+
+export { type ConsoleEvent, type ConsoleResult, type LambdaRuntimeContext, type SqsBatchItemFailure, type SqsBatchResponse, type SqsEvent, type SqsRecord, createConsoleHandler, createLambdaHandler, createScheduleHandler, createSqsHandler, getLambdaContext, isLambda };

package/dist/lambda/index.js

@@ -0,0 +1,91 @@
+// src/lambda/index.ts
+import { handle } from "hono/aws-lambda";
+
+// src/queue/Job.ts
+import { randomBytes } from "crypto";
+var jobRegistry = /* @__PURE__ */ new Map();
+function getJob(name) {
+  return jobRegistry.get(name);
+}
+
+// src/lambda/index.ts
+function createLambdaHandler(app) {
+  return handle(app.hono);
+}
+function createSqsHandler() {
+  return async (event) => {
+    const failures = [];
+    const results = await Promise.allSettled(
+      event.Records.map(async (record) => {
+        const job = deserializeSqsJob(record.body);
+        const JobClass = getJob(job.name);
+        if (!JobClass) {
+          throw new Error(`Job class not found: ${job.name}`);
+        }
+        const instance = new JobClass();
+        job.attempts++;
+        try {
+          await instance.handle(job.payload);
+        } catch (error) {
+          if (job.attempts >= job.maxAttempts && instance.failed) {
+            try {
+              await instance.failed(job.payload, error);
+            } catch {
+            }
+          }
+          throw error;
+        }
+      })
+    );
+    for (let i = 0; i < results.length; i++) {
+      if (results[i].status === "rejected") {
+        failures.push({ itemIdentifier: event.Records[i].messageId });
+      }
+    }
+    return { batchItemFailures: failures };
+  };
+}
+function createScheduleHandler(scheduler) {
+  return async () => {
+    await scheduler.runDueTasks();
+  };
+}
+function createConsoleHandler(kernel) {
+  return async (event) => {
+    const argv = event.command.split(/\s+/).filter(Boolean);
+    const exitCode = await kernel.handle(argv);
+    return { exitCode };
+  };
+}
+function isLambda() {
+  return typeof process !== "undefined" && !!process.env?.AWS_LAMBDA_FUNCTION_NAME;
+}
+function getLambdaContext() {
+  if (!isLambda()) return null;
+  return {
+    functionName: process.env.AWS_LAMBDA_FUNCTION_NAME,
+    functionVersion: process.env.AWS_LAMBDA_FUNCTION_VERSION ?? "$LATEST",
+    memorySize: parseInt(process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE ?? "128", 10),
+    region: process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? "us-east-1",
+    logGroup: process.env.AWS_LAMBDA_LOG_GROUP_NAME,
+    logStream: process.env.AWS_LAMBDA_LOG_STREAM_NAME,
+    tmpDir: "/tmp"
+  };
+}
+function deserializeSqsJob(body) {
+  const raw = JSON.parse(body);
+  return {
+    ...raw,
+    availableAt: new Date(raw.availableAt),
+    createdAt: new Date(raw.createdAt),
+    reservedAt: raw.reservedAt ? new Date(raw.reservedAt) : null
+  };
+}
+export {
+  createConsoleHandler,
+  createLambdaHandler,
+  createScheduleHandler,
+  createSqsHandler,
+  getLambdaContext,
+  isLambda
+};

package/dist/logging/index.d.ts

@@ -0,0 +1,50 @@
+import { b as LogChannel, C as ConsoleChannelConfig, g as LogEntry, F as FileChannelConfig, D as DailyFileChannelConfig } from '../LogManager-7mxnkaPM.js';
+export { a as LOG_LEVEL_PRIORITY, c as LogChannelConfig, d as LogChannelFactory, e as LogConfig, f as LogContext, h as LogFormatter, i as LogLevel, L as LogManager, j as Logger, k as LoggerOptions, S as StackChannelConfig, l as createLogManager, m as filterSensitiveData, n as getLogManager, s as setLogManager } from '../LogManager-7mxnkaPM.js';
+
+/**
+ * Console log channel.
+ */
+declare class ConsoleChannel implements LogChannel {
+    private readonly config;
+    private readonly minLevel;
+    constructor(config: ConsoleChannelConfig);
+    log(entry: LogEntry): void;
+    private format;
+}
+
+/**
+ * File log channel.
+ */
+declare class FileChannel implements LogChannel {
+    private readonly config;
+    private readonly minLevel;
+    private initialized;
+    constructor(config: FileChannelConfig);
+    log(entry: LogEntry): void;
+    private write;
+    private ensureDirectory;
+    private format;
+    close(): void;
+}
+
+/**
+ * Daily rotating file log channel.
+ */
+declare class DailyFileChannel implements LogChannel {
+    private readonly config;
+    private readonly minLevel;
+    private currentDate;
+    private currentFilePath;
+    constructor(config: DailyFileChannelConfig);
+    log(entry: LogEntry): void;
+    private write;
+    private rotate;
+    private getFilePath;
+    private getDateString;
+    private ensureDirectory;
+    private cleanup;
+    private format;
+    close(): void;
+}
+
+export { ConsoleChannel, ConsoleChannelConfig, DailyFileChannel, DailyFileChannelConfig, FileChannel, FileChannelConfig, LogChannel, LogEntry };