@xrystal/dto 26.6.27-v12

package/dist/adapters/socketio.cjs

@@ -0,0 +1,767 @@
+'use strict';
+
+// 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/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/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/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/dto/shared/base-dto.ts
+var BaseDTO = class {
+};
+
+// 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/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/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)));
+      }
+    };
+  }
+};
+function socketIoMiddleware(options = {}) {
+  return new SocketIoAdapter(options).handler();
+}
+
+exports.SocketIoAdapter = SocketIoAdapter;
+exports.SocketIoDispatcher = SocketIoDispatcher;
+exports.socketIoMiddleware = socketIoMiddleware;