@xrystal/dto 26.6.27-v12

package/dist/dto/runtime/dto.cjs

@@ -0,0 +1,1318 @@
+'use strict';
+
+var elysia = require('elysia');
+
+// src/dto/log/assemble.ts
+function assembleLogBody(input) {
+  const ordered = {
+    level: input.level,
+    service: input.service
+  };
+  if (input.message !== void 0) {
+    ordered.message = input.message;
+  }
+  if (input.payload !== void 0 && Object.keys(input.payload).length > 0) {
+    ordered.payload = input.payload;
+  }
+  if (input.code !== void 0) {
+    ordered.code = input.code;
+  }
+  ordered.timestamp = input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  if (input.id !== void 0) {
+    ordered.id = input.id;
+  }
+  ordered.env = input.env;
+  return ordered;
+}
+
+// src/dto/shared/schema-utils.ts
+function assertRequiredFields(input, fields, label = "Missing required fields") {
+  const missing = fields.filter((field) => {
+    const value = input[field];
+    return value === void 0 || value === null || value === "";
+  });
+  if (missing.length > 0) {
+    throw new Error(`${label}: ${missing.join(", ")}`);
+  }
+}
+
+// src/dto/shared/base-dto.ts
+var BaseDTO = class {
+};
+
+// src/dto/log/builder.ts
+var LogDTO = class _LogDTO extends BaseDTO {
+  _level;
+  _service;
+  _env;
+  _message;
+  _payload = {};
+  _code;
+  _timestamp;
+  _id;
+  static level(value) {
+    return new _LogDTO().level(value);
+  }
+  static service(value) {
+    return new _LogDTO().service(value);
+  }
+  static env(value) {
+    return new _LogDTO().env(value);
+  }
+  static message(value) {
+    return new _LogDTO().message(value);
+  }
+  static code(value) {
+    return new _LogDTO().code(value);
+  }
+  static timestamp(value) {
+    return new _LogDTO().timestamp(value);
+  }
+  static id(value) {
+    return new _LogDTO().id(value);
+  }
+  static payload(partial) {
+    return new _LogDTO().payload(partial);
+  }
+  /** One-shot body input — same last-wins rules as the instance `.schema()`. */
+  static schema(input = {}) {
+    return new _LogDTO().schema(input);
+  }
+  level(value) {
+    this._level = value;
+    return this;
+  }
+  service(value) {
+    this._service = value;
+    return this;
+  }
+  env(value) {
+    this._env = value;
+    return this;
+  }
+  message(value) {
+    this._message = value;
+    return this;
+  }
+  code(value) {
+    this._code = value;
+    return this;
+  }
+  timestamp(value) {
+    this._timestamp = value;
+    return this;
+  }
+  id(value) {
+    this._id = value;
+    return this;
+  }
+  payload(partial) {
+    this._payload = { ...this._payload, ...partial };
+    return this;
+  }
+  schema(input = {}) {
+    const { level, service, message, env, code, timestamp, id, payload } = input;
+    if (level !== void 0) this.level(level);
+    if (service !== void 0) this.service(service);
+    if (env !== void 0) this.env(env);
+    if (message !== void 0) this.message(message);
+    if (code !== void 0) this.code(code);
+    if (timestamp !== void 0) this.timestamp(timestamp);
+    if (id !== void 0) this.id(id);
+    if (payload !== void 0) {
+      this._payload = { ...payload };
+    }
+    return this;
+  }
+  build() {
+    assertRequiredFields(
+      {
+        level: this._level,
+        service: this._service,
+        env: this._env
+      },
+      ["level", "service", "env"],
+      "Missing log fields"
+    );
+    const input = {
+      level: this._level,
+      service: this._service,
+      env: this._env,
+      message: this._message,
+      code: this._code,
+      timestamp: this._timestamp,
+      id: this._id
+    };
+    if (Object.keys(this._payload).length > 0) {
+      input.payload = this._payload;
+    }
+    return assembleLogBody(input);
+  }
+};
+
+// src/utils/helpers/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function isValidUUID(id) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+
+// src/dto/queue/assemble.ts
+function assembleQueueMessage(metadata, payload) {
+  const orderedMetadata = {
+    source: metadata.source,
+    eventType: metadata.eventType,
+    timestamp: metadata.timestamp,
+    correlationId: metadata.correlationId
+  };
+  if (metadata.userId !== void 0) {
+    orderedMetadata.userId = metadata.userId;
+  }
+  if (metadata.extraData !== void 0) {
+    orderedMetadata.extraData = metadata.extraData;
+  }
+  return {
+    metadata: orderedMetadata,
+    payload
+  };
+}
+
+// src/dto/queue/builder.ts
+var QueueDTO = class _QueueDTO extends BaseDTO {
+  _source;
+  _eventType;
+  _userId;
+  _correlationId;
+  _extraData;
+  _payload;
+  _timestamp;
+  static source(value) {
+    return new _QueueDTO().source(value);
+  }
+  static eventType(value) {
+    return new _QueueDTO().eventType(value);
+  }
+  static userId(value) {
+    return new _QueueDTO().userId(value);
+  }
+  static correlationId(value) {
+    return new _QueueDTO().correlationId(value);
+  }
+  static extraData(value) {
+    return new _QueueDTO().extraData(value);
+  }
+  static timestamp(value) {
+    return new _QueueDTO().timestamp(value);
+  }
+  static payload(value) {
+    return new _QueueDTO().payload(value);
+  }
+  static schema(input = {}) {
+    return new _QueueDTO().schema(input);
+  }
+  source(value) {
+    this._source = value;
+    return this;
+  }
+  eventType(value) {
+    this._eventType = value;
+    return this;
+  }
+  userId(value) {
+    this._userId = value;
+    return this;
+  }
+  correlationId(value) {
+    this._correlationId = value;
+    return this;
+  }
+  extraData(value) {
+    this._extraData = value;
+    return this;
+  }
+  timestamp(value) {
+    this._timestamp = value;
+    return this;
+  }
+  payload(value) {
+    this._payload = value;
+    return this;
+  }
+  schema(input = {}) {
+    const { metadata, payload } = input;
+    if (metadata?.source !== void 0) this.source(metadata.source);
+    if (metadata?.eventType !== void 0) this.eventType(metadata.eventType);
+    if (metadata?.userId !== void 0) this.userId(metadata.userId);
+    if (metadata?.correlationId !== void 0) this.correlationId(metadata.correlationId);
+    if (metadata?.extraData !== void 0) this.extraData(metadata.extraData);
+    if (payload !== void 0) {
+      this._payload = payload;
+    }
+    return this;
+  }
+  build() {
+    assertRequiredFields(
+      {
+        source: this._source,
+        eventType: this._eventType
+      },
+      ["source", "eventType"],
+      "Missing queue metadata fields"
+    );
+    return assembleQueueMessage(
+      {
+        source: this._source,
+        eventType: this._eventType,
+        timestamp: this._timestamp ?? Date.now(),
+        correlationId: this._correlationId ?? generateUUID(),
+        userId: this._userId,
+        extraData: this._extraData
+      },
+      this._payload
+    );
+  }
+};
+
+// src/utils/constants/status-codes.ts
+var StatusCodes = {
+  SUCCESSFUL: {
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NO_CONTENT: 204
+  },
+  CLIENT_ERROR: {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    UNPROCESSABLE_ENTITY: 422,
+    TOO_MANY_REQUESTS: 429
+  },
+  SERVER_ERROR: {
+    INTERNAL_SERVER_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504
+  }
+};
+
+// src/errors/codes.ts
+var DefaultCodes = {
+  SUCCESS: 0,
+  CLIENT: 1,
+  SERVER: 2,
+  VALIDATION: 3
+};
+function createCodeRegistry(overrides = {}) {
+  return { ...DefaultCodes, ...overrides };
+}
+function isSuccessCode(code, codes) {
+  return code === codes.SUCCESS;
+}
+function resolveCodeFromHttpStatus(statusCode, codes) {
+  if (statusCode >= 200 && statusCode < 300) return codes.SUCCESS;
+  if (statusCode === 422) return codes.VALIDATION;
+  if (statusCode >= 400 && statusCode < 500) return codes.CLIENT;
+  if (statusCode >= 500) return codes.SERVER;
+  if (statusCode >= 300 && statusCode < 400) return codes.SUCCESS;
+  return codes.CLIENT;
+}
+function defaultMessageForCode(code, codes) {
+  if (code === codes.SUCCESS) return "Operation successful";
+  if (code === codes.CLIENT) return "Client error";
+  if (code === codes.SERVER) return "Internal server error";
+  if (code === codes.VALIDATION) return "Validation failed";
+  return "Operation failed";
+}
+function resolveStatusFromCode(code, codes) {
+  return isSuccessCode(code, codes);
+}
+
+// src/core/assemble.ts
+function assembleResponseBody(input) {
+  const ordered = {
+    status: input.status,
+    message: input.message
+  };
+  if (input.payload !== void 0 && Object.keys(input.payload).length > 0) {
+    ordered.payload = input.payload;
+  }
+  ordered.code = input.code;
+  return ordered;
+}
+
+// src/dto/response/dto.ts
+var ResponseDTO = class _ResponseDTO extends BaseDTO {
+  _status;
+  _message;
+  _code;
+  _payload = {};
+  static status(value) {
+    return new _ResponseDTO().status(value);
+  }
+  static message(value) {
+    return new _ResponseDTO().message(value);
+  }
+  static code(value) {
+    return new _ResponseDTO().code(value);
+  }
+  static data(data) {
+    return new _ResponseDTO().data(data);
+  }
+  static payload(partial) {
+    return new _ResponseDTO().payload(partial);
+  }
+  static schema(input = {}, codes = DefaultCodes) {
+    return new _ResponseDTO().schema(input, codes);
+  }
+  status(value) {
+    this._status = value;
+    return this;
+  }
+  message(msg) {
+    this._message = msg;
+    return this;
+  }
+  code(code) {
+    this._code = code;
+    return this;
+  }
+  data(data) {
+    if (data === void 0) {
+      delete this._payload.data;
+    } else {
+      this._payload.data = data;
+    }
+    return this;
+  }
+  payload(partial) {
+    this._payload = { ...this._payload, ...partial };
+    return this;
+  }
+  setMeta(meta) {
+    this._payload.meta = { ...this._payload.meta ?? {}, ...meta };
+    return this;
+  }
+  paginate(total, page, limit) {
+    if (limit <= 0) {
+      throw new Error("ResponseDTO.paginate: limit must be greater than 0");
+    }
+    this._payload.pagination = {
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+      hasNext: page * limit < total
+    };
+    return this;
+  }
+  schema(input = {}, codes = DefaultCodes) {
+    const { status, message, code, payload } = input;
+    if (code !== void 0) {
+      this.code(code);
+    }
+    if (status !== void 0) {
+      this.status(status);
+    } else if (code !== void 0) {
+      this.status(resolveStatusFromCode(code, codes));
+    }
+    if (message !== void 0) {
+      this.message(message);
+    }
+    if (payload !== void 0) {
+      this._payload = { ...payload };
+    }
+    return this;
+  }
+  getCode() {
+    return this._code;
+  }
+  getMessage() {
+    return this._message;
+  }
+  setCodeFromHttpStatus(httpStatusCode, codes) {
+    if (this._code === void 0) {
+      this._code = resolveCodeFromHttpStatus(httpStatusCode, codes);
+    }
+    return this;
+  }
+  transformData(fn) {
+    const next = new _ResponseDTO();
+    next._status = this._status;
+    next._message = this._message;
+    next._code = this._code;
+    next._payload = { ...this._payload };
+    if (this._payload.data !== void 0) {
+      next._payload.data = fn(this._payload.data);
+    }
+    return next;
+  }
+  build(options = {}) {
+    const codes = options.codes ?? DefaultCodes;
+    const code = this._code ?? (options.httpStatusCode !== void 0 ? resolveCodeFromHttpStatus(options.httpStatusCode, codes) : codes.SUCCESS);
+    const status = this._status ?? isSuccessCode(code, codes);
+    const message = this._message ?? defaultMessageForCode(code, codes);
+    if (options.withDefaultBody === false) {
+      return assembleResponseBody({ status, message, code });
+    }
+    const payload = this.buildPayload();
+    return assembleResponseBody({
+      status,
+      message,
+      payload,
+      code
+    });
+  }
+  buildPayload() {
+    const entries = Object.entries(this._payload).filter(([, value]) => value !== void 0);
+    if (entries.length === 0) return void 0;
+    return Object.fromEntries(entries);
+  }
+};
+
+// src/utils/constants/security-headers.ts
+var DEFAULT_SECURITY_HEADERS = {
+  "X-Content-Type-Options": "nosniff",
+  "X-Frame-Options": "DENY",
+  "Referrer-Policy": "strict-origin-when-cross-origin",
+  "Content-Security-Policy": "default-src 'none'; frame-ancestors 'none';",
+  "Cross-Origin-Opener-Policy": "same-origin",
+  "Cache-Control": "no-store",
+  Pragma: "no-cache",
+  "X-DNS-Prefetch-Control": "off"
+};
+
+// src/utils/constants/http.ts
+var NO_BODY_STATUS_CODES = /* @__PURE__ */ new Set([204, 205, 304]);
+function shouldSendResponseBody(statusCode) {
+  return !NO_BODY_STATUS_CODES.has(statusCode);
+}
+
+// src/utils/helpers/request-id.ts
+var DEFAULT_REQUEST_ID_HEADERS = [
+  "x-request-id",
+  "x-correlation-id",
+  "traceparent"
+];
+function readHeader(req, name) {
+  const fromGet = req.get?.(name);
+  if (fromGet) return fromGet;
+  const headers = req.headers;
+  if (!headers) return void 0;
+  const direct = headers[name] ?? headers[name.toLowerCase()];
+  if (direct === void 0) return void 0;
+  return Array.isArray(direct) ? direct[0] : direct;
+}
+function traceIdFromTraceparent(traceparent) {
+  const parts = traceparent.trim().split("-");
+  if (parts.length < 2) return void 0;
+  const traceId = parts[1];
+  if (!traceId || !/^[0-9a-f]{32}$/i.test(traceId)) return void 0;
+  return `${traceId.slice(0, 8)}-${traceId.slice(8, 12)}-${traceId.slice(12, 16)}-${traceId.slice(16, 20)}-${traceId.slice(20)}`;
+}
+function resolveRequestId(req, headerNames = DEFAULT_REQUEST_ID_HEADERS) {
+  for (const name of headerNames) {
+    const raw = readHeader(req, name);
+    if (!raw?.trim()) continue;
+    if (name === "traceparent") {
+      const traceId = traceIdFromTraceparent(raw);
+      if (traceId) return traceId;
+      continue;
+    }
+    const id = raw.trim();
+    if (isValidUUID(id)) return id;
+    return id;
+  }
+  return generateUUID();
+}
+
+// src/core/context.ts
+var ContextFactory = class {
+  static create(req, options = {}) {
+    return {
+      requestId: resolveRequestId(req, options.requestIdHeaders),
+      startTime: Date.now()
+    };
+  }
+  static fromId(requestId) {
+    return {
+      requestId,
+      startTime: Date.now()
+    };
+  }
+};
+
+// src/core/config.ts
+function resolveBuilderConfig(options = {}) {
+  return {
+    verbose: options.verbose === true,
+    includeStack: options.includeStack,
+    withDefaultBody: options.withDefaultBody !== false,
+    codes: createCodeRegistry(options.codes),
+    hooks: options.hooks,
+    plugins: options.plugins ?? []
+  };
+}
+
+// src/core/metadata.ts
+var MetadataFactory = class {
+  static create(options = {}, context) {
+    return {
+      requestId: context?.requestId ?? generateUUID(),
+      serverTime: (/* @__PURE__ */ new Date()).toISOString(),
+      statusCode: 200,
+      ...options
+    };
+  }
+};
+
+// src/core/plugins.ts
+function sortPlugins(plugins) {
+  return [...plugins].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+}
+var PluginRegistry = class {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  runBeforeBuild(ctx) {
+    for (const plugin of this.plugins) {
+      plugin.beforeBuild?.(ctx);
+    }
+  }
+  runAfterBuild(result, ctx) {
+    let current = result;
+    for (const plugin of this.plugins) {
+      const next = plugin.afterBuild?.(current, ctx);
+      if (next) current = next;
+    }
+    return current;
+  }
+  runBeforeDispatch(result, ctx) {
+    let current = result;
+    for (const plugin of this.plugins) {
+      const next = plugin.beforeDispatch?.(current, ctx);
+      if (next) current = next;
+    }
+    return current;
+  }
+  runAfterDispatch(result, ctx) {
+    for (const plugin of this.plugins) {
+      plugin.afterDispatch?.(result, ctx);
+    }
+  }
+};
+
+// src/core/presets.ts
+var ResponsePresets = class {
+  builder;
+  codes;
+  constructor(builder, codes) {
+    this.builder = builder;
+    this.codes = codes;
+  }
+  applyExtras(extras) {
+    if (extras && Object.keys(extras).length > 0) {
+      this.builder.payload(extras);
+    }
+  }
+  dispatch() {
+    return this.builder.build();
+  }
+  resolveFailureArgs(dataOrMessage, messageOrExtras, extras) {
+    if (typeof dataOrMessage === "string") {
+      return {
+        message: dataOrMessage,
+        extras: typeof messageOrExtras === "string" ? extras : messageOrExtras
+      };
+    }
+    return {
+      data: dataOrMessage,
+      message: typeof messageOrExtras === "string" ? messageOrExtras : void 0,
+      extras: typeof messageOrExtras === "string" ? extras : messageOrExtras
+    };
+  }
+  failure(httpStatus, code, dataOrMessage, messageOrExtras, extras) {
+    const resolved = this.resolveFailureArgs(dataOrMessage, messageOrExtras, extras);
+    this.builder.httpStatus(httpStatus).code(code).status(false).message(resolved.message ?? defaultMessageForCode(code, this.codes)).data(resolved.data);
+    this.applyExtras(resolved.extras);
+    return this.dispatch();
+  }
+  ok(data, message, extras) {
+    this.builder.httpStatus(StatusCodes.SUCCESSFUL.OK).code(this.codes.SUCCESS).status(true).message(message ?? defaultMessageForCode(this.codes.SUCCESS, this.codes)).data(data);
+    this.applyExtras(extras);
+    return this.dispatch();
+  }
+  created(data, message, extras) {
+    this.builder.httpStatus(StatusCodes.SUCCESSFUL.CREATED).code(this.codes.SUCCESS).status(true).message(message ?? defaultMessageForCode(this.codes.SUCCESS, this.codes)).data(data);
+    this.applyExtras(extras);
+    return this.dispatch();
+  }
+  accepted(message, extras) {
+    this.builder.httpStatus(StatusCodes.SUCCESSFUL.ACCEPTED).code(this.codes.SUCCESS).status(true).message(message ?? defaultMessageForCode(this.codes.SUCCESS, this.codes));
+    this.applyExtras(extras);
+    return this.dispatch();
+  }
+  noContent(extras) {
+    this.builder.httpStatus(StatusCodes.SUCCESSFUL.NO_CONTENT).code(this.codes.SUCCESS).status(true).message("").data(void 0);
+    this.applyExtras(extras);
+    return this.dispatch();
+  }
+  /** Generic client failure — HTTP 400, CLIENT code */
+  fail(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.BAD_REQUEST, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  /** Generic server failure — HTTP 500, SERVER code */
+  error(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(
+      StatusCodes.SERVER_ERROR.INTERNAL_SERVER_ERROR,
+      this.codes.SERVER,
+      dataOrMessage,
+      messageOrExtras,
+      extras
+    );
+  }
+  badRequest(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.BAD_REQUEST, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  unauthorized(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.UNAUTHORIZED, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  forbidden(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.FORBIDDEN, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  notFound(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.NOT_FOUND, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  conflict(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.CONFLICT, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  unprocessable(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(
+      StatusCodes.CLIENT_ERROR.UNPROCESSABLE_ENTITY,
+      this.codes.VALIDATION,
+      dataOrMessage,
+      messageOrExtras,
+      extras
+    );
+  }
+  tooManyRequests(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(StatusCodes.CLIENT_ERROR.TOO_MANY_REQUESTS, this.codes.CLIENT, dataOrMessage, messageOrExtras, extras);
+  }
+  internalServerError(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(
+      StatusCodes.SERVER_ERROR.INTERNAL_SERVER_ERROR,
+      this.codes.SERVER,
+      dataOrMessage,
+      messageOrExtras,
+      extras
+    );
+  }
+  serviceUnavailable(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(
+      StatusCodes.SERVER_ERROR.SERVICE_UNAVAILABLE,
+      this.codes.SERVER,
+      dataOrMessage,
+      messageOrExtras,
+      extras
+    );
+  }
+  gatewayTimeout(dataOrMessage, messageOrExtras, extras) {
+    return this.failure(
+      StatusCodes.SERVER_ERROR.GATEWAY_TIMEOUT,
+      this.codes.SERVER,
+      dataOrMessage,
+      messageOrExtras,
+      extras
+    );
+  }
+};
+
+// src/errors/error.ts
+var ResponseError = class extends Error {
+  code;
+  httpStatus;
+  payload;
+  constructor(options = {}) {
+    const codes = createCodeRegistry(options.codes);
+    const code = options.code ?? codes.SERVER;
+    const message = options.message ?? defaultMessageForCode(code, codes);
+    super(message, { cause: options.cause });
+    this.name = "ResponseError";
+    this.code = code;
+    this.httpStatus = options.httpStatus ?? codeToDefaultHttpStatus(code, codes);
+    if (options.payload !== void 0) {
+      this.payload = options.payload;
+    }
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      httpStatus: this.httpStatus,
+      payload: this.payload
+    };
+  }
+};
+function isResponseError(value) {
+  return value instanceof ResponseError;
+}
+function codeToDefaultHttpStatus(code, codes) {
+  if (code === codes.SUCCESS) return 200;
+  if (code === codes.CLIENT) return 400;
+  if (code === codes.SERVER) return 500;
+  if (code === codes.VALIDATION) return 422;
+  return 500;
+}
+
+// src/core/builder.ts
+var Builder = class {
+  dispatcher;
+  options;
+  context;
+  plugins;
+  body;
+  _statusCode = StatusCodes.SUCCESSFUL.OK;
+  _headers = {};
+  _cookies = [];
+  _presets;
+  constructor(dispatcher, options = {}, context) {
+    this.dispatcher = dispatcher;
+    this.options = resolveBuilderConfig(options);
+    this.context = context;
+    this.plugins = new PluginRegistry(this.options.plugins);
+    this.body = new ResponseDTO();
+  }
+  get dto() {
+    return this.body;
+  }
+  httpStatus(code) {
+    this._statusCode = code;
+    this.body.setCodeFromHttpStatus(code, this.options.codes);
+    return this;
+  }
+  code(code) {
+    this.body.code(code);
+    return this;
+  }
+  status(value) {
+    this.body.status(value);
+    return this;
+  }
+  message(msg) {
+    this.body.message(msg);
+    return this;
+  }
+  data(data) {
+    this.body.data(data);
+    return this;
+  }
+  payload(partial) {
+    this.body.payload(partial);
+    return this;
+  }
+  schema(input = {}) {
+    this.body.schema(input, this.options.codes);
+    return this;
+  }
+  setMeta(meta) {
+    this.body.setMeta(meta);
+    return this;
+  }
+  withMetadata(options = {}) {
+    const generated = MetadataFactory.create(
+      { statusCode: this._statusCode, ...options },
+      { requestId: this.context?.requestId }
+    );
+    return this.setMeta(generated);
+  }
+  paginate(total, page, limit) {
+    this.body.paginate(total, page, limit);
+    return this;
+  }
+  setHeaders(keyOrHeaders, value) {
+    if (typeof keyOrHeaders === "string") {
+      if (value !== void 0) {
+        this._headers[keyOrHeaders] = value;
+      }
+    } else {
+      this._headers = { ...this._headers, ...keyOrHeaders };
+    }
+    return this;
+  }
+  header(key, value) {
+    return this.setHeaders(key, value);
+  }
+  setCookies(nameOrCookies, valueOrOptions, options) {
+    if (typeof nameOrCookies === "string") {
+      if (typeof valueOrOptions === "string") {
+        this._cookies.push({ name: nameOrCookies, value: valueOrOptions, options });
+      }
+    } else {
+      const sharedOptions = typeof valueOrOptions === "object" ? valueOrOptions : void 0;
+      for (const [name, value] of Object.entries(nameOrCookies)) {
+        this._cookies.push({ name, value, options: sharedOptions });
+      }
+    }
+    return this;
+  }
+  fromError(error) {
+    if (isResponseError(error)) {
+      return this.httpStatus(error.httpStatus).code(error.code).message(error.message).payload(error.payload ? { ...error.payload } : {}).data(void 0);
+    }
+    return this.httpStatus(StatusCodes.SERVER_ERROR.INTERNAL_SERVER_ERROR).code(this.options.codes.SERVER).message(this.resolvePublicErrorMessage(error)).data(void 0);
+  }
+  async wrap(promise) {
+    try {
+      this.data(await promise);
+      return this;
+    } catch (error) {
+      this.fromError(error);
+      this.options.hooks?.emit("error", {
+        error,
+        message: this.body.getMessage(),
+        statusCode: this._statusCode,
+        code: this.body.getCode() ?? resolveCodeFromHttpStatus(this._statusCode, this.options.codes)
+      });
+      return this;
+    }
+  }
+  transform(fn) {
+    const next = this;
+    next.body = this.body.transformData(fn);
+    return next;
+  }
+  when(condition, fn) {
+    if (condition) fn(this);
+    return this;
+  }
+  get as() {
+    if (!this._presets) {
+      this._presets = new ResponsePresets(this, this.options.codes);
+    }
+    return this._presets;
+  }
+  build() {
+    const pluginCtx = this.createPluginContext();
+    this.options.hooks?.emit("before_build", { statusCode: this._statusCode });
+    this.plugins.runBeforeBuild(pluginCtx);
+    const body = this.body.build({
+      codes: this.options.codes,
+      withDefaultBody: this.options.withDefaultBody,
+      httpStatusCode: this._statusCode
+    });
+    let result = {
+      body,
+      statusCode: this._statusCode,
+      headers: { ...this._headers },
+      cookies: [...this._cookies]
+    };
+    result = this.plugins.runAfterBuild(result, pluginCtx);
+    this.emitHook("after_build", result);
+    if (this.dispatcher) {
+      result = this.plugins.runBeforeDispatch(result, pluginCtx);
+      this.emitHook("before_dispatch", result);
+      const dispatched = this.dispatcher.dispatch(result);
+      this.plugins.runAfterDispatch(result, pluginCtx);
+      this.emitHook("after_dispatch", result);
+      return dispatched ?? result;
+    }
+    return result;
+  }
+  resolvePublicErrorMessage(error) {
+    if (!this.options.verbose && !isResponseError(error)) {
+      return defaultMessageForCode(this.options.codes.SERVER, this.options.codes);
+    }
+    if (error instanceof Error) {
+      if (this.options.includeStack && error.stack) return error.stack;
+      return error.message || defaultMessageForCode(this.options.codes.SERVER, this.options.codes);
+    }
+    if (typeof error === "string") return error;
+    return defaultMessageForCode(this.options.codes.SERVER, this.options.codes);
+  }
+  createPluginContext() {
+    return {
+      builder: this,
+      context: this.context,
+      options: this.options,
+      codes: this.options.codes
+    };
+  }
+  emitHook(event, result) {
+    const hooks = this.options.hooks;
+    if (!hooks?.hasListeners(event)) return;
+    hooks.emit(event, structuredClone(result));
+  }
+};
+function createBuilderProxy(dispatcher, options = {}, context) {
+  const instance = new Builder(dispatcher, options, context);
+  return new Proxy(instance, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver);
+      if (typeof value === "function") {
+        return value.bind(target);
+      }
+      return value;
+    }
+  });
+}
+
+// src/adapters/shared.ts
+function createBuilderRuntime(dispatcher, options, context) {
+  const builderOptions = {
+    verbose: options.verbose,
+    includeStack: options.includeStack,
+    withDefaultBody: options.withDefaultBody,
+    codes: options.codes,
+    hooks: options.hooks,
+    plugins: options.plugins
+  };
+  return {
+    context,
+    codes: resolveBuilderConfig(builderOptions).codes,
+    builder: createBuilderProxy(dispatcher, builderOptions, context)
+  };
+}
+
+// src/adapters/elysia.ts
+function createElysiaDerive(options = {}) {
+  return ({ request, set }) => {
+    const context = ContextFactory.create({
+      headers: headersToRecord(request.headers)
+    }, {
+      requestIdHeaders: options.requestIdHeaders
+    });
+    if (options.withDefaultHeaders !== false) {
+      const headers = options.defaultHeaders ?? DEFAULT_SECURITY_HEADERS;
+      set.headers = { ...set.headers ?? {}, ...headers };
+    }
+    const runtime = createBuilderRuntime(
+      {
+        dispatch(result) {
+          set.status = result.statusCode;
+          set.headers = {
+            ...set.headers ?? {},
+            ...normalizeHeaders(result.headers),
+            "Content-Type": "application/json; charset=utf-8"
+          };
+          if (!shouldSendResponseBody(result.statusCode)) {
+            return null;
+          }
+          return result.body;
+        }
+      },
+      options,
+      context
+    );
+    return {
+      builder: runtime.builder,
+      requestId: runtime.context.requestId,
+      startTime: runtime.context.startTime
+    };
+  };
+}
+var ElysiaAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /** Elysia plugin — adds `builder`, `requestId`, `startTime` to the handler context */
+  plugin() {
+    const derive = createElysiaDerive(this.options);
+    return new elysia.Elysia({ name: "x" }).derive(
+      { as: "scoped" },
+      (context) => derive({
+        request: context.request,
+        set: context.set
+      })
+    );
+  }
+  middleware() {
+    return this.plugin();
+  }
+  handler() {
+    return this.plugin();
+  }
+};
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+function normalizeHeaders(headers) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      normalized[key] = value.join(", ");
+    } else {
+      normalized[key] = String(value);
+    }
+  }
+  return normalized;
+}
+
+// src/adapters/express.ts
+var ExpressDispatcher = class {
+  res;
+  constructor(res) {
+    this.res = res;
+  }
+  dispatch(result) {
+    if (this.res.headersSent) {
+      return result;
+    }
+    for (const [key, value] of Object.entries(result.headers)) {
+      this.res.setHeader(key, value);
+    }
+    if (result.cookies.length && this.res.cookie) {
+      for (const cookie of result.cookies) {
+        this.res.cookie(cookie.name, cookie.value, cookie.options ?? {});
+      }
+    }
+    this.res.status(result.statusCode);
+    if (shouldSendResponseBody(result.statusCode)) {
+      this.res.json(result.body);
+    } else {
+      this.res.end();
+    }
+    return result;
+  }
+};
+var ExpressAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  handler() {
+    return this.middleware.bind(this);
+  }
+  middleware(req, res, next) {
+    const context = ContextFactory.create(req, {
+      requestIdHeaders: this.options.requestIdHeaders
+    });
+    if (this.options.withDefaultHeaders !== false) {
+      const headers = this.options.defaultHeaders ?? DEFAULT_SECURITY_HEADERS;
+      for (const [key, value] of Object.entries(headers)) {
+        res.setHeader(key, value);
+      }
+    }
+    const runtime = createBuilderRuntime(new ExpressDispatcher(res), this.options, context);
+    req.ctx = runtime.context;
+    res.builder = runtime.builder;
+    next();
+  }
+};
+
+// src/adapters/node.ts
+var NodeDispatcher = class {
+  res;
+  constructor(res) {
+    this.res = res;
+  }
+  dispatch(result) {
+    if (this.res.headersSent) {
+      return result;
+    }
+    for (const [key, value] of Object.entries(result.headers)) {
+      this.res.setHeader(key, value);
+    }
+    this.res.statusCode = result.statusCode;
+    if (!shouldSendResponseBody(result.statusCode)) {
+      this.res.end();
+      return result;
+    }
+    const body = JSON.stringify(result.body);
+    if (!this.res.getHeader("Content-Type")) {
+      this.res.setHeader("Content-Type", "application/json; charset=utf-8");
+    }
+    this.res.end(body);
+    return result;
+  }
+};
+var NodeAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  handler() {
+    return this.middleware.bind(this);
+  }
+  middleware(req, res, next) {
+    const context = ContextFactory.create(req, {
+      requestIdHeaders: this.options.requestIdHeaders
+    });
+    if (this.options.withDefaultHeaders !== false) {
+      const headers = this.options.defaultHeaders ?? DEFAULT_SECURITY_HEADERS;
+      for (const [key, value] of Object.entries(headers)) {
+        if (!res.getHeader(key)) {
+          res.setHeader(key, value);
+        }
+      }
+    }
+    const runtime = createBuilderRuntime(new NodeDispatcher(res), this.options, context);
+    req.ctx = runtime.context;
+    res.builder = runtime.builder;
+    next();
+  }
+};
+
+// src/adapters/socketio.ts
+var SocketIoDispatcher = class {
+  socket;
+  event;
+  constructor(socket, event = "response") {
+    this.socket = socket;
+    this.event = event;
+  }
+  dispatch(result) {
+    this.socket.emit(this.event, result.body);
+    return result;
+  }
+};
+var SocketIoAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      event: "response",
+      ...options
+    };
+  }
+  attach(socket) {
+    const context = ContextFactory.create({
+      headers: socket.handshake?.headers
+    }, {
+      requestIdHeaders: this.options.requestIdHeaders
+    });
+    const runtime = createBuilderRuntime(
+      new SocketIoDispatcher(socket, this.options.event),
+      this.options,
+      context
+    );
+    socket.ctx = runtime.context;
+    socket.builder = runtime.builder;
+    return runtime;
+  }
+  handler() {
+    return (socket, next) => {
+      try {
+        this.attach(socket);
+        next?.();
+      } catch (error) {
+        next?.(error instanceof Error ? error : new Error(String(error)));
+      }
+    };
+  }
+};
+
+// src/adapters/websocket.ts
+var WS_OPEN = 1;
+var WebSocketDispatcher = class {
+  socket;
+  constructor(socket) {
+    this.socket = socket;
+  }
+  dispatch(result) {
+    if (this.socket.readyState !== void 0 && this.socket.readyState !== WS_OPEN) {
+      return result;
+    }
+    this.socket.send(JSON.stringify(result.body));
+    return result;
+  }
+};
+var WebSocketAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  attach(socket, requestId) {
+    const context = requestId ? ContextFactory.fromId(requestId) : ContextFactory.fromId(generateUUID());
+    const runtime = createBuilderRuntime(
+      new WebSocketDispatcher(socket),
+      this.options,
+      context
+    );
+    socket.ctx = runtime.context;
+    socket.builder = runtime.builder;
+    return runtime;
+  }
+  handler() {
+    return (socket, next) => {
+      this.attach(socket);
+      next?.();
+    };
+  }
+};
+
+// src/types/plugin.ts
+function mergePlugins(...groups) {
+  return groups.flatMap((group) => group ?? []);
+}
+
+// src/dto/runtime/dto.ts
+var DTO = class _DTO {
+  static Log = LogDTO;
+  static Queue = QueueDTO;
+  static Response = ResponseDTO;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  use(...plugins) {
+    return new _DTO({
+      ...this.options,
+      plugins: mergePlugins(this.options.plugins, plugins)
+    });
+  }
+  express() {
+    return new ExpressAdapter(this.options).handler();
+  }
+  node() {
+    return new NodeAdapter(this.options).handler();
+  }
+  elysia() {
+    return new ElysiaAdapter(this.options).middleware();
+  }
+  websocket() {
+    return new WebSocketAdapter(this.socketOptions()).handler();
+  }
+  attachWebSocket(socket, requestId) {
+    return new WebSocketAdapter(this.socketOptions()).attach(socket, requestId);
+  }
+  socketIo() {
+    return new SocketIoAdapter(this.socketOptions()).handler();
+  }
+  attachSocketIo(socket) {
+    return new SocketIoAdapter(this.socketOptions()).attach(socket);
+  }
+  socketOptions() {
+    return {
+      ...this.options,
+      event: this.options.socket?.event ?? this.options.event ?? "response"
+    };
+  }
+};
+function createDTO(options = {}) {
+  return new DTO(options);
+}
+
+exports.DTO = DTO;
+exports.createDTO = createDTO;