@kabyeon/nexusjs 0.6.5

package/dist/logger/logger.service.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `Logger` — the user-facing logging interface.
+ *
+ * Logger is request-scoped via `AsyncLocalStorage`: any `logger.info(...)`
+ * call inside a request automatically merges in fields set by
+ * `logger.with({ requestId, userId, ... })`.
+ *
+ * Usage:
+ *   constructor(@Inject(Logger.TOKEN) private logger: Logger) {}
+ *
+ *   this.logger.info({ userId: 'u-1' }, 'user signed in');
+ *   this.logger.error({ err }, 'failed to save');
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { LogLevel, LogTransport, LoggerOptions, LogContext } from "./types.js";
+import { NullTransport } from "./transports/index.js";
+export declare class Logger {
+    /** DI token — use with `@Inject(Logger.TOKEN)`. */
+    static readonly TOKEN: unique symbol;
+    transports: LogTransport[];
+    silent: boolean;
+    base: Record<string, unknown>;
+    level: LogLevel;
+    als: AsyncLocalStorage<LogContext>;
+    constructor(options?: LoggerOptions);
+    trace(meta: Record<string, unknown>, msg: string): void;
+    trace(msg: string): void;
+    debug(meta: Record<string, unknown>, msg: string): void;
+    debug(msg: string): void;
+    info(meta: Record<string, unknown>, msg: string): void;
+    info(msg: string): void;
+    warn(meta: Record<string, unknown>, msg: string): void;
+    warn(msg: string): void;
+    error(meta: Record<string, unknown>, msg: string): void;
+    error(msg: string): void;
+    fatal(meta: Record<string, unknown>, msg: string): void;
+    fatal(msg: string): void;
+    /**
+     * Run `fn` inside a logger context — every log emitted during
+     * `fn()` is tagged with `meta`.
+     */
+    with<T>(meta: LogContext, fn: () => T): T;
+    /** Read the current request context (or empty object). */
+    get context(): LogContext;
+    /**
+     * Derive a child logger that always merges `bindings` into every
+     * record. Useful for service-scoped loggers.
+     */
+    child(bindings: Record<string, unknown>): Logger;
+    /** Wait for transports to finish loading (Pino is async). */
+    ready(): Promise<void>;
+    private emit;
+}
+export { NullTransport };
+//# sourceMappingURL=logger.service.d.ts.map

package/dist/logger/logger.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.service.d.ts","sourceRoot":"","sources":["../../src/logger/logger.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EACX,QAAQ,EAER,YAAY,EACZ,aAAa,EACb,UAAU,EACV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAkC,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAWtF,qBACa,MAAM;IAClB,mDAAmD;IACnD,MAAM,CAAC,QAAQ,CAAC,KAAK,gBAA8B;IAEnD,UAAU,EAAE,YAAY,EAAE,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,gCAAuC;gBAEJ,OAAO,GAAE,aAAkB;IAoBjE,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACvD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKxB,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACvD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKxB,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACtD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKvB,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACtD,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKvB,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACvD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAKxB,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IACvD,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASxB;;;OAGG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAMzC,0DAA0D;IAC1D,IAAI,OAAO,IAAI,UAAU,CAExB;IAMD;;;OAGG;IACH,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM;IAchD,6DAA6D;IACvD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAW5B,OAAO,CAAC,IAAI;CA8BZ;AAGD,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/logger/transports/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Built-in transports.
+ *
+ * - **PinoTransport** — JSON output via `pino` (production).
+ * - **PrettyTransport** — colorized via `pino-pretty` (development).
+ *
+ * Both wrap the pino API and feed records into the same write loop,
+ * so switching is one config flag.
+ */
+import type { LogLevel, LogRecord, LogTransport } from "../types.js";
+/** JSON transport via pino. */
+export declare class PinoTransport implements LogTransport {
+    #private;
+    readonly name = "pino";
+    readonly isDefault = true;
+    constructor(level: LogLevel, base?: Record<string, unknown>);
+    ready(): Promise<void>;
+    write(record: LogRecord): void;
+}
+/** Pretty-print transport via pino-pretty (development). */
+export declare class PrettyTransport implements LogTransport {
+    #private;
+    readonly name = "pretty";
+    readonly isDefault = true;
+    constructor(level: LogLevel, base?: Record<string, unknown>);
+    ready(): Promise<void>;
+    write(record: LogRecord): void;
+}
+/** Null transport — drops everything. For tests. */
+export declare class NullTransport implements LogTransport {
+    readonly name = "null";
+    readonly isDefault = false;
+    write(_record: LogRecord): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/logger/transports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/logger/transports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiErE,+BAA+B;AAC/B,qBAAa,aAAc,YAAW,YAAY;;IACjD,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,SAAS,QAAQ;gBAId,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;CA6B9B;AAED,4DAA4D;AAC5D,qBAAa,eAAgB,YAAW,YAAY;;IACnD,QAAQ,CAAC,IAAI,YAAY;IACzB,QAAQ,CAAC,SAAS,QAAQ;gBAId,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;CA6B9B;AAED,oDAAoD;AACpD,qBAAa,aAAc,YAAW,YAAY;IACjD,QAAQ,CAAC,IAAI,UAAU;IACvB,QAAQ,CAAC,SAAS,SAAS;IAC3B,KAAK,CAAC,OAAO,EAAE,SAAS,GAAG,IAAI;CAG/B"}

package/dist/logger/types.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Logger types — the contract for `nexusjs/logger`.
+ *
+ * Mirrors `@adonisjs/logger` + NestJS's built-in Logger. One logger
+ * class, two transports:
+ *
+ *   - **Pino** (production default) — JSON output, fast
+ *   - **Pretty** (development) — colorized, human-readable
+ *
+ * Logs are request-scoped via AsyncLocalStorage: any `logger.info(...)`
+ * inside a request automatically includes `requestId`, `userId`,
+ * `tenantId` if those have been set.
+ */
+export type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+/** A single log record (Pino-compatible shape). */
+export interface LogRecord {
+    level: LogLevel;
+    time: number;
+    msg: string;
+    [key: string]: unknown;
+}
+/** Transport: receives every record, writes it somewhere. */
+export interface LogTransport {
+    /** Display name. */
+    readonly name: string;
+    /** Whether this transport is the active default. */
+    readonly isDefault?: boolean;
+    /** Write a record. Must be sync; queue async work internally. */
+    write(record: LogRecord): void;
+}
+/** Configuration for the LoggerModule. */
+export interface LoggerOptions {
+    /** Minimum level to emit. Default: `'info'` in production, `'debug'` in dev. */
+    level?: LogLevel;
+    /** Pretty-print (dev mode). Default: `NODE_ENV !== 'production'`. */
+    pretty?: boolean;
+    /**
+     * Custom transports. The first one with `isDefault: true` (or the
+     * first one if none is default) is used as the active transport.
+     */
+    transports?: LogTransport[];
+    /**
+     * Static fields attached to every record (e.g. service name).
+     */
+    base?: Record<string, unknown>;
+    /**
+     * Disable all logging. Useful in tests.
+     */
+    silent?: boolean;
+}
+/** Per-request context (AsyncLocalStorage value). */
+export interface LogContext {
+    requestId?: string;
+    userId?: string;
+    tenantId?: string;
+    [key: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/logger/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/logger/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAE/E,mDAAmD;AACnD,MAAM,WAAW,SAAS;IACzB,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB;AAED,6DAA6D;AAC7D,MAAM,WAAW,YAAY;IAC5B,oBAAoB;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,oDAAoD;IACpD,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,iEAAiE;IACjE,KAAK,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;CAC/B;AAED,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC7B,gFAAgF;IAChF,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,qEAAqE;IACrE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,UAAU,CAAC,EAAE,YAAY,EAAE,CAAC;IAC5B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B;;OAEG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,qDAAqD;AACrD,MAAM,WAAW,UAAU;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACvB"}

package/dist/mail/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Public entry point for `nexusjs/mail`.
+ */
+export * from "./types.js";
+export { NullTransport, FileTransport, SmtpTransport, } from "./transports/index.js";
+export type { FileTransportOptions, SmtpTransportOptions, } from "./transports/index.js";
+export { MailService } from "./mail.service.js";
+export { MailModule } from "./mail.module.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/mail/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mail/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,cAAc,YAAY,CAAC;AAC3B,OAAO,EACN,aAAa,EACb,aAAa,EACb,aAAa,GACb,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACX,oBAAoB,EACpB,oBAAoB,GACpB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/mail/index.js

@@ -0,0 +1,479 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/constants.ts
+var METADATA_KEY, PARAM_TYPES, HTTP_METHODS;
+var init_constants = __esm(() => {
+  METADATA_KEY = {
+    CONTROLLER: "nexus:controller",
+    INJECTABLE: "nexus:injectable",
+    REPOSITORY: "nexus:repository",
+    MODULE: "nexus:module",
+    ROUTES: "nexus:routes",
+    PARAMS: "nexus:params",
+    VALIDATE: "nexus:validate",
+    PARAMTYPES: "design:paramtypes",
+    TYPE: "design:type",
+    RETURNTYPE: "design:returntype",
+    INJECT: "nexus:inject"
+  };
+  PARAM_TYPES = {
+    REQUEST: 0,
+    RESPONSE: 1,
+    NEXT: 2,
+    BODY: 3,
+    QUERY: 4,
+    PARAM: 5,
+    HEADERS: 6,
+    CTX: 7,
+    USER: 8
+  };
+  HTTP_METHODS = [
+    "GET",
+    "POST",
+    "PUT",
+    "DELETE",
+    "PATCH",
+    "OPTIONS",
+    "HEAD"
+  ];
+});
+
+// src/core/decorators/controller.ts
+import"reflect-metadata";
+function Controller(prefix = "/") {
+  return (target) => {
+    const normalized = normalizePrefix(prefix);
+    const meta = { prefix: normalized };
+    Reflect.defineMetadata(METADATA_KEY.CONTROLLER, meta, target);
+  };
+}
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.CONTROLLER, target) ?? { prefix: "/" };
+}
+function isController(target) {
+  return Reflect.hasMetadata(METADATA_KEY.CONTROLLER, target);
+}
+function normalizePrefix(prefix) {
+  if (!prefix)
+    return "";
+  if (prefix !== "/" && prefix.endsWith("/")) {
+    return prefix.slice(0, -1);
+  }
+  return prefix;
+}
+var init_controller = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/http-methods.ts
+import"reflect-metadata";
+function defineRoute(method, path) {
+  return (target, propertyKey, descriptor) => {
+    const routes = Reflect.getMetadata(METADATA_KEY.ROUTES, target.constructor) ?? [];
+    routes.push({
+      method,
+      path: normalizePath(path),
+      propertyKey,
+      handler: descriptor.value
+    });
+    Reflect.defineMetadata(METADATA_KEY.ROUTES, routes, target.constructor);
+  };
+}
+function normalizePath(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.startsWith("/") ? path : `/${path}`;
+}
+function getRoutes(target) {
+  return Reflect.getMetadata(METADATA_KEY.ROUTES, target) ?? [];
+}
+var Get = (path = "/") => defineRoute("GET", path), Post = (path = "/") => defineRoute("POST", path), Put = (path = "/") => defineRoute("PUT", path), Delete = (path = "/") => defineRoute("DELETE", path), Patch = (path = "/") => defineRoute("PATCH", path), Options = (path = "/") => defineRoute("OPTIONS", path), Head = (path = "/") => defineRoute("HEAD", path);
+var init_http_methods = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/params.ts
+import"reflect-metadata";
+function createParamDecorator(type, data) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target, propertyKey);
+    } else {
+      const params = Reflect.getMetadata(METADATA_KEY.PARAMS, target) ?? [];
+      params.push({
+        index: parameterIndex,
+        type,
+        name: typeof data === "string" ? data : undefined,
+        data: typeof data === "object" ? data : undefined
+      });
+      Reflect.defineMetadata(METADATA_KEY.PARAMS, params, target);
+    }
+  };
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.PARAMS, target, propertyKey) ?? [];
+}
+var Req = () => createParamDecorator(PARAM_TYPES.REQUEST), Res = () => createParamDecorator(PARAM_TYPES.RESPONSE), Next = () => createParamDecorator(PARAM_TYPES.NEXT), Body = (key) => createParamDecorator(PARAM_TYPES.BODY, key), Query = (key) => createParamDecorator(PARAM_TYPES.QUERY, key), Param = (key) => createParamDecorator(PARAM_TYPES.PARAM, key), Headers = (key) => createParamDecorator(PARAM_TYPES.HEADERS, key), Ctx = () => createParamDecorator(PARAM_TYPES.CTX), User = () => createParamDecorator(PARAM_TYPES.USER);
+var init_params = __esm(() => {
+  init_constants();
+});
+
+// src/core/decorators/validate.ts
+import"reflect-metadata";
+function Validate(options) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(METADATA_KEY.VALIDATE, options, target.constructor, propertyKey);
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(METADATA_KEY.VALIDATE, target, propertyKey);
+}
+var init_validate = __esm(() => {
+  init_constants();
+});
+
+// src/mail/types.ts
+import"reflect-metadata";
+// src/mail/transports/null.ts
+class NullTransport {
+  kind = "null";
+  sent = [];
+  async send(msg) {
+    this.sent.push(msg);
+    return {
+      id: `null-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      sentAt: Date.now()
+    };
+  }
+}
+// src/mail/transports/file.ts
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+
+class FileTransport {
+  kind = "file";
+  opts;
+  constructor(opts) {
+    this.opts = {
+      dir: opts.dir,
+      includeHeaders: opts.includeHeaders ?? true,
+      pretty: opts.pretty ?? true
+    };
+  }
+  async send(msg) {
+    await mkdir(this.opts.dir, { recursive: true });
+    const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const filename = `${id}.eml`;
+    const body = this.opts.includeHeaders ? this.toEml(msg) : this.toBody(msg);
+    await writeFile(join(this.opts.dir, filename), body, "utf-8");
+    return { id, sentAt: Date.now() };
+  }
+  toEml(msg) {
+    const headers = [];
+    if (msg.from)
+      headers.push(`From: ${this.formatAddr(msg.from)}`);
+    headers.push(`To: ${this.formatAddr(msg.to)}`);
+    if (msg.cc)
+      headers.push(`Cc: ${this.formatAddr(msg.cc)}`);
+    if (msg.replyTo)
+      headers.push(`Reply-To: ${this.formatAddr(msg.replyTo)}`);
+    headers.push(`Subject: ${msg.subject}`);
+    headers.push(`Date: ${new Date().toUTCString()}`);
+    headers.push(`MIME-Version: 1.0`);
+    if (msg.html) {
+      headers.push(`Content-Type: text/html; charset=utf-8`);
+    } else {
+      headers.push(`Content-Type: text/plain; charset=utf-8`);
+    }
+    const body = msg.html ?? msg.text ?? "";
+    return `${headers.join(`\r
+`)}\r
+\r
+${body}`;
+  }
+  toBody(msg) {
+    return msg.html ?? msg.text ?? "";
+  }
+  formatAddr(a) {
+    if (Array.isArray(a))
+      return a.map((x) => this.formatAddr(x)).join(", ");
+    if (typeof a === "string")
+      return a;
+    return a.name ? `${a.name} <${a.address}>` : a.address;
+  }
+}
+// src/mail/transports/smtp.ts
+class SmtpTransport {
+  kind = "smtp";
+  opts;
+  _transporter = null;
+  constructor(opts) {
+    this.opts = opts;
+  }
+  async transporter() {
+    if (this._transporter)
+      return this._transporter;
+    try {
+      const mod = await import("nodemailer");
+      this._transporter = mod.default.createTransport({
+        host: this.opts.host,
+        port: this.opts.port,
+        secure: this.opts.secure,
+        auth: this.opts.auth,
+        pool: this.opts.pool,
+        maxConnections: this.opts.maxConnections,
+        ...this.opts.extras
+      });
+    } catch (err) {
+      throw new Error("SmtpTransport requires nodemailer. Install it with: bun add nodemailer");
+    }
+    return this._transporter;
+  }
+  async send(msg) {
+    const t = await this.transporter();
+    const from = this.formatAddr(msg.from ?? this.opts.defaultFrom);
+    const res = await t.sendMail({
+      from,
+      to: this.formatAddr(msg.to),
+      cc: msg.cc ? this.formatAddr(msg.cc) : undefined,
+      bcc: msg.bcc ? this.formatAddr(msg.bcc) : undefined,
+      replyTo: msg.replyTo ? this.formatAddr(msg.replyTo) : undefined,
+      subject: msg.subject,
+      text: msg.text,
+      html: msg.html,
+      attachments: msg.attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        contentType: a.contentType,
+        cid: a.cid
+      })),
+      headers: msg.headers,
+      priority: msg.priority
+    });
+    return {
+      id: res.messageId ?? `smtp-${Date.now()}`,
+      sentAt: Date.now()
+    };
+  }
+  async close() {
+    if (this._transporter) {
+      await this._transporter.close();
+      this._transporter = null;
+    }
+  }
+  formatAddr(a) {
+    if (!a)
+      return "";
+    if (Array.isArray(a))
+      return a.map((x) => this.formatAddr(x)).join(", ");
+    if (typeof a === "string")
+      return a;
+    return a.name ? `${a.name} <${a.address}>` : a.address;
+  }
+}
+// src/core/decorators/module.ts
+init_constants();
+import"reflect-metadata";
+function Module(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.MODULE, options, target);
+  };
+}
+function getModuleOptions(target) {
+  return Reflect.getMetadata(METADATA_KEY.MODULE, target) ?? {};
+}
+
+// src/core/decorators/index.ts
+init_controller();
+
+// src/core/decorators/injectable.ts
+init_constants();
+import"reflect-metadata";
+function Injectable(options = {}) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+    if (options.scope) {
+      Reflect.defineMetadata("nexus:di:scope", options.scope, target);
+    }
+  };
+}
+function isInjectable(target) {
+  return Reflect.hasMetadata(METADATA_KEY.INJECTABLE, target);
+}
+function getScope(target) {
+  return Reflect.getMetadata("nexus:di:scope", target);
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const existing = Reflect.getMetadata(METADATA_KEY.INJECT, target) ?? new Map;
+    existing.set(parameterIndex, token);
+    Reflect.defineMetadata(METADATA_KEY.INJECT, existing, target);
+  };
+}
+
+// src/core/decorators/index.ts
+init_http_methods();
+init_params();
+init_validate();
+
+// src/core/decorators/repository.ts
+init_constants();
+import"reflect-metadata";
+function Repository(entityToken) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEY.REPOSITORY, { entity: entityToken }, target);
+    Reflect.defineMetadata(METADATA_KEY.INJECTABLE, true, target);
+  };
+}
+function getRepositoryMetadata(target) {
+  return Reflect.getMetadata(METADATA_KEY.REPOSITORY, target);
+}
+function isRepository(target) {
+  return Reflect.hasMetadata(METADATA_KEY.REPOSITORY, target);
+}
+// src/core/decorators/metadata.ts
+init_constants();
+// src/mail/mail.service.ts
+class MailService {
+  static TOKEN = Symbol.for("nexus:MailService");
+  transport;
+  defaultFrom;
+  constructor(config = {}) {
+    this.transport = config.transport ?? new NullTransport;
+    this.defaultFrom = config.defaultFrom;
+  }
+  async send(msg) {
+    const full = { ...msg, from: msg.from ?? this.defaultFrom };
+    return this.transport.send(full);
+  }
+  async sendBatch(msg, recipients) {
+    const results = [];
+    for (const to of recipients) {
+      results.push(await this.send({ ...msg, to }));
+    }
+    return results;
+  }
+  async renderMjml(template, _vars) {
+    try {
+      const mod = await import("mjml");
+      const { html } = mod.mjml2html(template);
+      return html;
+    } catch (err) {
+      throw new Error("renderMjml requires the 'mjml' package. Install it with: bun add mjml");
+    }
+  }
+}
+MailService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject("MAIL_CONFIG")),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof MailConfig === "undefined" ? Object : MailConfig
+  ])
+], MailService);
+// src/mail/mail.module.ts
+import"reflect-metadata";
+class MailModule {
+  static forRoot(config = {}) {
+    const cfg = {
+      transport: new NullTransport,
+      ...config
+    };
+
+    class ConfiguredMailModule {
+    }
+    ConfiguredMailModule = __legacyDecorateClassTS([
+      Module({
+        providers: [
+          MailService,
+          { provide: MailService.TOKEN, useExisting: MailService },
+          { provide: "MAIL_CONFIG", useValue: cfg }
+        ],
+        exports: [MailService, MailService.TOKEN]
+      })
+    ], ConfiguredMailModule);
+    Object.defineProperty(ConfiguredMailModule, "name", {
+      value: "ConfiguredMailModule"
+    });
+    return ConfiguredMailModule;
+  }
+}
+MailModule = __legacyDecorateClassTS([
+  Module({
+    providers: [
+      MailService,
+      { provide: MailService.TOKEN, useExisting: MailService }
+    ],
+    exports: [MailService, MailService.TOKEN]
+  })
+], MailModule);
+export {
+  SmtpTransport,
+  NullTransport,
+  MailService,
+  MailModule,
+  FileTransport
+};
+
+//# debugId=EF3070FAE1F17C4164756E2164756E21
+//# sourceMappingURL=index.js.map