@guren/server 1.0.0-rc.9 → 1.0.0

package/dist/lambda/index.d.ts

@@ -1,22 +1,24 @@
 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 { A as Application } from '../Application-BnsyCKXY.js';
 import { S as Scheduler } from '../Scheduler-BstvSca7.js';
-import { C as ConsoleKernel } from '../ConsoleKernel-CqCVrdZs.js';
+import { C as ConsoleKernel } from '../ConsoleKernel-BDtBETjm.js';
 import 'hono';
-import '../api-token-JOif2CtG.js';
+import '../api-token-BSSCLlFW.js';
+import '../AuthManager-SfhCNkAU.js';
+import '@guren/orm';
 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 '../I18nManager-BiSoczfV.js';
+import '../BroadcastManager-CGWl9rUO.js';
 import '../index-9_Jzj5jo.js';
 import '../app-key-CsBfRC_Q.js';
 import '../StorageManager-oZTHqaza.js';
 import '../HealthManager-DUyMIzsZ.js';
-import '../Gate-CNkBYf8m.js';
+import '../Gate-CynjZCtS.js';
 
 /**
  * SQS event record from AWS Lambda.
@@ -68,7 +70,7 @@ declare function createLambdaHandler(app: Application): <L extends hono_aws_lamb
     headers?: undefined;
     multiValueHeaders: Record<string, string[]>;
 } : {
-    headers: Record<string, string>;
+    headers: Record<string, string | string[]>;
     multiValueHeaders?: undefined;
 })>;
 /**

package/dist/lambda/index.js

@@ -1,14 +1,9 @@
-// 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);
-}
+import {
+  getJob
+} from "../chunk-R2TCP7D7.js";
 
 // src/lambda/index.ts
+import { handle } from "hono/aws-lambda";
 function createLambdaHandler(app) {
   return handle(app.hono);
 }

package/dist/logging/index.js

@@ -1,548 +1,15 @@
-// src/logging/types.ts
-var LOG_LEVEL_PRIORITY = {
-  emergency: 0,
-  alert: 1,
-  critical: 2,
-  error: 3,
-  warning: 4,
-  notice: 5,
-  info: 6,
-  debug: 7
-};
-
-// src/logging/Logger.ts
-var DEFAULT_FILTER_KEYS = [
-  "password",
-  "password_confirmation",
-  "token",
-  "secret",
-  "credit_card",
-  "creditCard",
-  "card_number",
-  "cardNumber",
-  "cvv",
-  "ssn",
-  "authorization"
-];
-function filterSensitiveData(data, filterKeys, replacement = "[FILTERED]") {
-  if (filterKeys.length === 0) return data;
-  const keySet = new Set(filterKeys.map((k) => k.toLowerCase()));
-  return filterObject(data, keySet, replacement);
-}
-function filterObject(obj, keySet, replacement) {
-  const result = {};
-  for (const [key, value] of Object.entries(obj)) {
-    if (keySet.has(key.toLowerCase())) {
-      result[key] = replacement;
-    } else if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-      result[key] = filterObject(value, keySet, replacement);
-    } else if (Array.isArray(value)) {
-      result[key] = value.map(
-        (item) => item !== null && typeof item === "object" && !Array.isArray(item) ? filterObject(item, keySet, replacement) : item
-      );
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-var Logger = class _Logger {
-  channels;
-  baseContext;
-  filterKeys;
-  replacement;
-  constructor(channels, context = {}, options = {}) {
-    this.channels = channels;
-    this.baseContext = context;
-    this.filterKeys = options.filterKeys ?? DEFAULT_FILTER_KEYS;
-    this.replacement = options.replacement ?? "[FILTERED]";
-  }
-  /**
-   * Log at emergency level (system is unusable).
-   */
-  emergency(message, context = {}) {
-    this.log("emergency", message, context);
-  }
-  /**
-   * Log at alert level (action must be taken immediately).
-   */
-  alert(message, context = {}) {
-    this.log("alert", message, context);
-  }
-  /**
-   * Log at critical level (critical conditions).
-   */
-  critical(message, context = {}) {
-    this.log("critical", message, context);
-  }
-  /**
-   * Log at error level (error conditions).
-   */
-  error(message, context = {}) {
-    this.log("error", message, context);
-  }
-  /**
-   * Log at warning level (warning conditions).
-   */
-  warning(message, context = {}) {
-    this.log("warning", message, context);
-  }
-  /**
-   * Alias for warning().
-   */
-  warn(message, context = {}) {
-    this.warning(message, context);
-  }
-  /**
-   * Log at notice level (normal but significant conditions).
-   */
-  notice(message, context = {}) {
-    this.log("notice", message, context);
-  }
-  /**
-   * Log at info level (informational messages).
-   */
-  info(message, context = {}) {
-    this.log("info", message, context);
-  }
-  /**
-   * Log at debug level (debug-level messages).
-   */
-  debug(message, context = {}) {
-    this.log("debug", message, context);
-  }
-  /**
-   * Log a message at the specified level.
-   */
-  log(level, message, context = {}) {
-    const merged = { ...this.baseContext, ...context };
-    const filtered = this.filterKeys.length > 0 ? filterSensitiveData(merged, this.filterKeys, this.replacement) : merged;
-    const entry = {
-      level,
-      message,
-      context: filtered,
-      timestamp: /* @__PURE__ */ new Date()
-    };
-    for (const channel of this.channels) {
-      try {
-        channel.log(entry);
-      } catch (error) {
-        console.error("Logging error:", error);
-      }
-    }
-  }
-  /**
-   * Create a new logger with additional context.
-   */
-  withContext(context) {
-    return new _Logger(this.channels, { ...this.baseContext, ...context }, {
-      filterKeys: this.filterKeys,
-      replacement: this.replacement
-    });
-  }
-  /**
-   * Create a child logger with additional context (alias for withContext).
-   */
-  child(context) {
-    return this.withContext(context);
-  }
-  /**
-   * Close all channels.
-   */
-  async close() {
-    for (const channel of this.channels) {
-      if (channel.close) {
-        await channel.close();
-      }
-    }
-  }
-};
-
-// src/logging/channels/ConsoleChannel.ts
-var LEVEL_COLORS = {
-  emergency: "\x1B[41m\x1B[37m",
-  // White on red background
-  alert: "\x1B[41m\x1B[37m",
-  // White on red background
-  critical: "\x1B[31m",
-  // Red
-  error: "\x1B[31m",
-  // Red
-  warning: "\x1B[33m",
-  // Yellow
-  notice: "\x1B[36m",
-  // Cyan
-  info: "\x1B[32m",
-  // Green
-  debug: "\x1B[90m"
-  // Gray
-};
-var RESET = "\x1B[0m";
-var ConsoleChannel = class {
-  config;
-  minLevel;
-  constructor(config) {
-    this.config = {
-      colors: true,
-      timestamps: true,
-      format: "text",
-      ...config
-    };
-    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
-  }
-  log(entry) {
-    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
-    if (entryLevel > this.minLevel) {
-      return;
-    }
-    const output = this.format(entry);
-    if (entryLevel <= LOG_LEVEL_PRIORITY.error) {
-      console.error(output);
-    } else if (entryLevel <= LOG_LEVEL_PRIORITY.warning) {
-      console.warn(output);
-    } else if (entryLevel <= LOG_LEVEL_PRIORITY.info) {
-      console.info(output);
-    } else {
-      console.log(output);
-    }
-  }
-  format(entry) {
-    if (this.config.format === "json") {
-      return JSON.stringify({
-        timestamp: entry.timestamp.toISOString(),
-        level: entry.level,
-        message: entry.message,
-        ...entry.context
-      });
-    }
-    const parts = [];
-    if (this.config.timestamps) {
-      const time = entry.timestamp.toISOString();
-      parts.push(this.config.colors ? `\x1B[90m[${time}]\x1B[0m` : `[${time}]`);
-    }
-    const levelStr = entry.level.toUpperCase().padEnd(9);
-    if (this.config.colors) {
-      parts.push(`${LEVEL_COLORS[entry.level]}${levelStr}${RESET}`);
-    } else {
-      parts.push(levelStr);
-    }
-    parts.push(entry.message);
-    if (Object.keys(entry.context).length > 0) {
-      const contextStr = JSON.stringify(entry.context);
-      if (this.config.colors) {
-        parts.push(`\x1B[90m${contextStr}${RESET}`);
-      } else {
-        parts.push(contextStr);
-      }
-    }
-    return parts.join(" ");
-  }
-};
-
-// src/logging/channels/FileChannel.ts
-import * as fs from "fs";
-import * as path from "path";
-var FileChannel = class {
-  config;
-  minLevel;
-  initialized = false;
-  constructor(config) {
-    this.config = {
-      format: "text",
-      ...config
-    };
-    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
-  }
-  log(entry) {
-    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
-    if (entryLevel > this.minLevel) {
-      return;
-    }
-    const line = this.format(entry) + "\n";
-    this.write(line);
-  }
-  write(data) {
-    if (!this.initialized) {
-      this.ensureDirectory();
-      this.initialized = true;
-    }
-    fs.appendFileSync(this.config.path, data);
-  }
-  ensureDirectory() {
-    const dir = path.dirname(this.config.path);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-  format(entry) {
-    if (this.config.format === "json") {
-      return JSON.stringify({
-        timestamp: entry.timestamp.toISOString(),
-        level: entry.level,
-        message: entry.message,
-        ...entry.context
-      });
-    }
-    const timestamp = entry.timestamp.toISOString();
-    const level = entry.level.toUpperCase().padEnd(9);
-    const context = Object.keys(entry.context).length > 0 ? " " + JSON.stringify(entry.context) : "";
-    return `[${timestamp}] ${level} ${entry.message}${context}`;
-  }
-  close() {
-  }
-};
-
-// src/logging/channels/DailyFileChannel.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-var DailyFileChannel = class {
-  config;
-  minLevel;
-  currentDate = null;
-  currentFilePath = null;
-  constructor(config) {
-    this.config = {
-      days: 14,
-      format: "text",
-      ...config
-    };
-    this.minLevel = LOG_LEVEL_PRIORITY[this.config.level ?? "debug"];
-  }
-  log(entry) {
-    const entryLevel = LOG_LEVEL_PRIORITY[entry.level];
-    if (entryLevel > this.minLevel) {
-      return;
-    }
-    const dateStr = this.getDateString(entry.timestamp);
-    if (this.currentDate !== dateStr) {
-      this.rotate(dateStr);
-    }
-    const line = this.format(entry) + "\n";
-    this.write(line);
-  }
-  write(data) {
-    if (this.currentFilePath) {
-      fs2.appendFileSync(this.currentFilePath, data);
-    }
-  }
-  rotate(dateStr) {
-    this.currentDate = dateStr;
-    this.currentFilePath = this.getFilePath(dateStr);
-    this.ensureDirectory(this.currentFilePath);
-    this.cleanup();
-  }
-  getFilePath(dateStr) {
-    const { dir, name, ext } = path2.parse(this.config.path);
-    return path2.join(dir, `${name}-${dateStr}${ext}`);
-  }
-  getDateString(date) {
-    return date.toISOString().split("T")[0];
-  }
-  ensureDirectory(filePath) {
-    const dir = path2.dirname(filePath);
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
-    }
-  }
-  cleanup() {
-    const { dir, name, ext } = path2.parse(this.config.path);
-    if (!fs2.existsSync(dir)) {
-      return;
-    }
-    const files = fs2.readdirSync(dir);
-    const pattern = new RegExp(`^${name}-(\\d{4}-\\d{2}-\\d{2})${ext.replace(".", "\\.")}$`);
-    const cutoff = /* @__PURE__ */ new Date();
-    cutoff.setDate(cutoff.getDate() - (this.config.days ?? 14));
-    for (const file of files) {
-      const match = file.match(pattern);
-      if (match) {
-        const fileDate = new Date(match[1]);
-        if (fileDate < cutoff) {
-          fs2.unlinkSync(path2.join(dir, file));
-        }
-      }
-    }
-  }
-  format(entry) {
-    if (this.config.format === "json") {
-      return JSON.stringify({
-        timestamp: entry.timestamp.toISOString(),
-        level: entry.level,
-        message: entry.message,
-        ...entry.context
-      });
-    }
-    const timestamp = entry.timestamp.toISOString();
-    const level = entry.level.toUpperCase().padEnd(9);
-    const context = Object.keys(entry.context).length > 0 ? " " + JSON.stringify(entry.context) : "";
-    return `[${timestamp}] ${level} ${entry.message}${context}`;
-  }
-  close() {
-  }
-};
-
-// src/logging/LogManager.ts
-var LogManager = class {
-  config;
-  channelFactories = /* @__PURE__ */ new Map();
-  channelInstances = /* @__PURE__ */ new Map();
-  loggers = /* @__PURE__ */ new Map();
-  loggerOptions;
-  constructor(config) {
-    this.config = config;
-    this.loggerOptions = {
-      filterKeys: config.filterKeys,
-      replacement: config.filterReplacement
-    };
-    this.registerDefaultDrivers();
-  }
-  registerDefaultDrivers() {
-    this.registerDriver("console", (config) => {
-      return new ConsoleChannel(config);
-    });
-    this.registerDriver("file", (config) => {
-      return new FileChannel(config);
-    });
-    this.registerDriver("daily", (config) => {
-      return new DailyFileChannel(config);
-    });
-    this.registerDriver("stack", (config) => {
-      return this.createStackChannel(config);
-    });
-  }
-  createStackChannel(config) {
-    const channels = config.channels.map((name) => this.resolveChannel(name));
-    return {
-      log: (entry) => {
-        for (const channel of channels) {
-          channel.log(entry);
-        }
-      },
-      close: async () => {
-        for (const channel of channels) {
-          if (channel.close) {
-            await channel.close();
-          }
-        }
-      }
-    };
-  }
-  /**
-   * Register a custom channel driver.
-   */
-  registerDriver(name, factory) {
-    this.channelFactories.set(name, factory);
-  }
-  /**
-   * Get a logger for a specific channel.
-   */
-  channel(name) {
-    const channelName = name ?? this.config.default;
-    if (!this.loggers.has(channelName)) {
-      const channel = this.resolveChannel(channelName);
-      this.loggers.set(channelName, new Logger([channel], {}, this.loggerOptions));
-    }
-    return this.loggers.get(channelName);
-  }
-  /**
-   * Get a logger that writes to multiple channels.
-   */
-  stack(channelNames) {
-    const key = `stack:${channelNames.join(",")}`;
-    if (!this.loggers.has(key)) {
-      const channels = channelNames.map((name) => this.resolveChannel(name));
-      this.loggers.set(key, new Logger(channels, {}, this.loggerOptions));
-    }
-    return this.loggers.get(key);
-  }
-  resolveChannel(name) {
-    if (this.channelInstances.has(name)) {
-      return this.channelInstances.get(name);
-    }
-    const config = this.config.channels[name];
-    if (!config) {
-      throw new Error(`Log channel [${name}] is not defined`);
-    }
-    const factory = this.channelFactories.get(config.driver);
-    if (!factory) {
-      throw new Error(`Log driver [${config.driver}] is not supported`);
-    }
-    const channel = factory(config);
-    this.channelInstances.set(name, channel);
-    return channel;
-  }
-  /**
-   * Create a logger with additional context using the default channel.
-   */
-  withContext(context) {
-    return this.channel().withContext(context);
-  }
-  // Convenience methods that delegate to default channel
-  emergency(message, context) {
-    this.channel().emergency(message, context);
-  }
-  alert(message, context) {
-    this.channel().alert(message, context);
-  }
-  critical(message, context) {
-    this.channel().critical(message, context);
-  }
-  error(message, context) {
-    this.channel().error(message, context);
-  }
-  warning(message, context) {
-    this.channel().warning(message, context);
-  }
-  warn(message, context) {
-    this.channel().warn(message, context);
-  }
-  notice(message, context) {
-    this.channel().notice(message, context);
-  }
-  info(message, context) {
-    this.channel().info(message, context);
-  }
-  debug(message, context) {
-    this.channel().debug(message, context);
-  }
-  /**
-   * Close all channel instances.
-   */
-  async close() {
-    for (const channel of this.channelInstances.values()) {
-      if (channel.close) {
-        await channel.close();
-      }
-    }
-    this.channelInstances.clear();
-    this.loggers.clear();
-  }
-  /**
-   * Get the default channel name.
-   */
-  getDefaultChannel() {
-    return this.config.default;
-  }
-  /**
-   * Get available channel names.
-   */
-  getChannelNames() {
-    return Object.keys(this.config.channels);
-  }
-};
-function createLogManager(config) {
-  return new LogManager(config);
-}
-var globalLogManager = null;
-function setLogManager(manager) {
-  globalLogManager = manager;
-}
-function getLogManager() {
-  if (!globalLogManager) {
-    throw new Error("Log manager has not been initialized. Call setLogManager() first.");
-  }
-  return globalLogManager;
-}
+import {
+  ConsoleChannel,
+  DailyFileChannel,
+  FileChannel,
+  LOG_LEVEL_PRIORITY,
+  LogManager,
+  Logger,
+  createLogManager,
+  filterSensitiveData,
+  getLogManager,
+  setLogManager
+} from "../chunk-IOTWFHZU.js";
 export {
   ConsoleChannel,
   DailyFileChannel,

package/dist/mail/index.d.ts

@@ -157,6 +157,25 @@ declare class MemoryTransport implements MailTransport {
     assertSentCount(count: number): void;
 }
 
+interface LogTransportOptions {
+    /**
+     * Log function to write to.
+     * @default console.log
+     */
+    logger?: (message: string) => void;
+}
+/**
+ * Log mail transport: writes each email to the log instead of sending it.
+ * This is the development default (`MAIL_MAILER=log`) — every send succeeds
+ * and the full message is visible in the server output.
+ */
+declare class LogTransport implements MailTransport {
+    readonly name = "log";
+    private readonly logger;
+    constructor(options?: LogTransportOptions);
+    send(message: MailMessage): Promise<SendResult>;
+}
+
 /**
  * Fluent mail builder for composing and sending emails.
  *
@@ -244,6 +263,7 @@ declare class Mail {
     attach(attachment: MailAttachment): this;
     /**
      * Add a custom header.
+     * Rejects CR/LF characters to prevent SMTP header injection.
      */
     header(key: string, value: string): this;
     /**
@@ -253,6 +273,14 @@ declare class Mail {
     /**
      * Build the final message.
      */
+    /**
+     * Mailable subclasses define their content in build() (subject, body, ...).
+     * It runs automatically before sending, so `new WelcomeMail(manager).to(x).send()`
+     * works without a manual build() call.
+     */
+    protected build?(): this;
+    private hasRunBuild;
+    private runBuildOnce;
     buildMessage(): MailMessage;
     /**
      * Send the email immediately.
@@ -285,4 +313,4 @@ declare function getMailManager(): MailManager | null;
  */
 declare function mail(manager: MailManager): Mail;
 
-export { Mail, MailAddress, MailAttachment, MailManager, MailMessage, MailTransport, MemoryTransport, MemoryTransportOptions, ResendTransport, ResendTransportOptions, SendResult, SmtpTransport, SmtpTransportOptions, getMailManager, mail, setMailManager };
+export { LogTransport, type LogTransportOptions, Mail, MailAddress, MailAttachment, MailManager, MailMessage, MailTransport, MemoryTransport, MemoryTransportOptions, ResendTransport, ResendTransportOptions, SendResult, SmtpTransport, SmtpTransportOptions, getMailManager, mail, setMailManager };