fa-consul 1.0.1

package/src/access-points/access-points-updater.ts

@@ -0,0 +1,154 @@
+/* eslint-disable no-console */
+// noinspection JSUnusedGlobalSymbols
+
+import { DEBUG, CONSUL_AP_UPDATE_TIMEOUT_MILLIS } from '../constants';
+import { getConsulApiCached } from '../index';
+import {
+  IAccessPoint,
+  IAccessPoints,
+  ICLOptions,
+  IConsulAPI,
+  IConsulHealthServiceInfo,
+} from '../interfaces';
+import { cyan, green, magenta, red, reset } from '../lib/color';
+import loggerStub from '../lib/logger-stub';
+import { sleep } from '../lib/utils';
+
+const PREFIX = 'AP-UPDATER';
+
+const dbg = { on: /\bAP-UPDATER\*?/i.test(DEBUG) || DEBUG === '*' };
+const debug = (msg: string) => {
+  if (dbg.on) {
+    console.log(`${magenta}${PREFIX}${reset}: ${msg}`);
+  }
+};
+
+const UPDATE_INTERVAL_IF_CONSUL_REGISTER_SUCCESS_MILLIS = Number(process.env.UPDATE_INTERVAL_IF_CONSUL_REGISTER_SUCCESS_MILLIS) || (2 * 60_000);
+
+// A stub in case such a function is not set for the access point in the configuration
+function retrieveProps (accessPoint: IAccessPoint, host: string, meta?: any) {
+  const port = Number(meta?.port) || accessPoint.port;
+  return { host, port };
+}
+
+// Служит для исключения повторного опроса consulID в пределах одного цикла updateAccessPoints
+let oneUpdateCache: { [consulServiceName: string]: IConsulHealthServiceInfo[] } = {};
+
+export async function updateAccessPoint (clOptions: ICLOptions, accessPoint: IAccessPoint): Promise<-2 | -1 | 0 | 1> {
+  if (!accessPoint.updateIntervalIfSuccessMillis) {
+    accessPoint.updateIntervalIfSuccessMillis = UPDATE_INTERVAL_IF_CONSUL_REGISTER_SUCCESS_MILLIS;
+  }
+  if (Date.now() - (accessPoint.lastSuccessUpdate || 0) < accessPoint.updateIntervalIfSuccessMillis) {
+    return 0;
+  }
+  const { consulServiceName } = accessPoint;
+  const CONSUL_ID = `${cyan}${consulServiceName}${reset}`;
+  let result = oneUpdateCache[consulServiceName];
+  if (result) {
+    if (result.length) {
+      // Точка доступа уже опрошена в этом цикле и она была недоступна
+      return 0;
+    }
+    // Точка доступа еще опрошена в этом цикле и есть сведения по ней. В этом просе будут взяты другие метаданные, нежели в предыдущем updateAccessPoint
+  } else {
+    // Точка доступа еще не опрошена в этом цикле
+    const consulApi: IConsulAPI = await getConsulApiCached(clOptions);
+    if (!consulApi) {
+      clOptions.logger?.warn(`${PREFIX}: Failed to get consul API`);
+      return -2;
+    }
+    debug(`${reset}Polling ${CONSUL_ID}`);
+    result = await consulApi.consulHealthService({ options: { service: consulServiceName, passing: true } });
+    oneUpdateCache[consulServiceName] = result;
+  }
+
+  const { Address: host, Meta: meta } = result?.[0]?.Service || {};
+  if (!host) {
+    clOptions.logger?.warn(`${red}There is no information for ${CONSUL_ID}`);
+    accessPoint.lastSuccessUpdate = 0;
+    const wasReachable = accessPoint.isReachable;
+    accessPoint.isReachable = false;
+    if (wasReachable) {
+      clOptions.em?.emit('access-point-updated', { accessPoint, changes: [['isReachable', true, false]] });
+    }
+    return -1;
+  }
+  accessPoint.isReachable = true;
+  accessPoint.lastSuccessUpdate = Date.now();
+
+  // If the retrieveProps function is not set for the access point in the configuration, use the stub
+  if (typeof accessPoint.retrieveProps !== 'function') {
+    accessPoint.retrieveProps = retrieveProps.bind(null, accessPoint);
+  }
+  const properties = accessPoint.retrieveProps!(host, meta);
+  const changes = accessPoint.setProps?.(properties)?.getChanges?.();
+
+  if (changes?.length) {
+    if (meta) {
+      accessPoint.meta = meta;
+    }
+    clOptions.em?.emit('access-point-updated', { accessPoint, changes });
+  } else {
+    debug(`${green}The data is up-to-date ${CONSUL_ID}`);
+  }
+  return 1;
+}
+
+export async function updateAccessPoints (clOptions: ICLOptions): Promise<boolean> {
+  const accessPoints = Object.values(<IAccessPoints>clOptions.config.accessPoints).filter((ap: any) => ap?.isAP && !ap.noConsul);
+  const result = [];
+  for (let i = 0; i < accessPoints.length; i++) {
+    const accessPoint = accessPoints[i];
+    if (!accessPoint) {continue;}
+    const res = await updateAccessPoint(clOptions, accessPoint);
+    result.push(res);
+  }
+  const updatedCount = result.filter((v) => v > 0);
+  if (updatedCount.length) {
+    clOptions.logger?.silly(`${PREFIX}: updated ${updatedCount.length} access point(s)`);
+    clOptions.em?.emit('access-points-updated');
+  }
+  return !!updatedCount;
+}
+
+export const accessPointsUpdater = {
+  isStarted: false,
+  isAnyUpdated: false,
+  _timerId: setTimeout(() => null, 0),
+  _logger: loggerStub,
+  start (clOptions: ICLOptions, updateInterval: number = 10_000): number {
+    if (this.isStarted) {
+      return 0;
+    }
+    this._logger = clOptions.logger || loggerStub;
+    const doLoop = async () => {
+      try {
+        oneUpdateCache = {};
+        const isAnyUpdated = await updateAccessPoints(clOptions);
+        if (isAnyUpdated) {
+          this.isAnyUpdated = true;
+        }
+      } catch (err) {
+        this._logger?.error(err);
+      }
+      clearTimeout(this._timerId);
+      this._timerId = setTimeout(doLoop, updateInterval);
+    };
+    doLoop().then((r) => r);
+    this.isStarted = true;
+    this._logger.info('Access point updater started');
+    return 1;
+  },
+  async waitForAnyUpdated (timeout: number = CONSUL_AP_UPDATE_TIMEOUT_MILLIS): Promise<boolean> {
+    const start = Date.now();
+    while (!this.isAnyUpdated && (Date.now() - start < timeout)) {
+      await sleep(100);
+    }
+    return this.isAnyUpdated;
+  },
+  stop () {
+    clearTimeout(this._timerId);
+    this.isStarted = false;
+    this._logger.info('Access point updater stopped');
+  },
+};

package/src/access-points/access-points-utils.ts

@@ -0,0 +1,31 @@
+import * as http from 'http';
+import * as https from 'https';
+
+import { CONSUL_AP_UPDATE_TIMEOUT_MILLIS } from '../constants';
+
+import { AccessPoints } from './access-points';
+
+export const isHttpAvailable = (url: string) => new Promise((resolve) => {
+  const client = /^https:/i.test(url) ? https : http;
+  client.request(url, (r: any) => resolve(r.statusCode > 0)).on('error', () => resolve(false)).end();
+});
+
+export const checkAccessPointAvailability = async (accessPoints: AccessPoints, accessPointId: string, onError: (errorMessage: string) => false) => {
+  const it = `Access point "${accessPointId}"`;
+  const ap = accessPoints.getAP(accessPointId);
+  if (!ap) {
+    return onError(`${it} is not found`);
+  }
+  if (!ap.waitForHostPortUpdated) {
+    return onError(`${it} has no method "waitForHostPortUpdated"`);
+  }
+  if (!(await ap.waitForHostPortUpdated(CONSUL_AP_UPDATE_TIMEOUT_MILLIS))) {
+    return onError(`${it} update timed out`);
+  }
+  const { host, port, protocol = 'http', path = '' } = ap;
+  const url = `${protocol}://${host}:${port}${path}`;
+  if (!(await isHttpAvailable(url))) {
+    return onError(`${it} is not available`);
+  }
+  return true;
+};

package/src/access-points/access-points.ts

@@ -0,0 +1,185 @@
+import { CONSUL_AP_UPDATE_TIMEOUT_MILLIS } from '../constants';
+import { IAccessPoint, IAccessPoints, ILogger } from '../interfaces';
+import { blue, cyan, green, magenta, reset } from '../lib/color';
+import loggerStub from '../lib/logger-stub';
+import { isObject, sleep } from '../lib/utils';
+
+const PREFIX = 'ACCESS-POINT';
+
+const _logger_ = Symbol.for('_logger_');
+
+const addAdditionalAPProps = (accessPoint: Record<string, any>) => {
+  if (accessPoint.noConsul) {
+    return;
+  }
+  Object.defineProperty(accessPoint, 'isAP', { value: true });
+  Object.defineProperty(accessPoint, 'lastSuccessUpdate', { value: 0, writable: true });
+  Object.defineProperty(accessPoint, 'idHostPortUpdated', { value: false, writable: true });
+  accessPoint.waitForHostPortUpdated = async (timeout: number = CONSUL_AP_UPDATE_TIMEOUT_MILLIS): Promise<boolean> => {
+    const start = Date.now();
+    while (!accessPoint.idHostPortUpdated && (Date.now() - start < timeout)) {
+      await sleep(100);
+    }
+    return !!accessPoint.idHostPortUpdated;
+  };
+};
+
+export class AccessPoints {
+  private readonly [_logger_]: ILogger;
+
+  constructor (accessPoints: IAccessPoints, logger?: ILogger) {
+    this[_logger_] = logger || loggerStub;
+    if (!accessPoints) {
+      const msg = 'Empty argument "accessPoints" passed to constructor';
+      this[_logger_].error(msg);
+      throw new Error(msg);
+    }
+    Object.entries(accessPoints).forEach(([apKey, apData]) => {
+      this.addAP(apKey, apData);
+    });
+  }
+
+  static normalizePort (port: unknown) {
+    return Number(port) || null;
+  }
+
+  static normalizeProtocol (protocol: string | null) {
+    if (!protocol || !/^https?$/i.test(protocol)) {
+      protocol = 'http';
+    }
+    return protocol?.toLowerCase();
+  }
+
+  static normalizeValue (propName: string, propValue: any) {
+    switch (propName) {
+      case 'port':
+        return AccessPoints.normalizePort(propValue);
+      case 'protocol':
+        return AccessPoints.normalizeProtocol(propValue);
+      default:
+        return propValue;
+    }
+  }
+
+  static getPureProps (accessPointSource: Record<string, any>): IAccessPoint {
+    const accessPoint = Object.create(null);
+    Object.entries(accessPointSource).forEach(([propName, propValue]) => {
+      if (propValue === undefined || typeof propValue === 'function') {
+        return;
+      }
+      if (typeof propValue === 'object' && propValue !== null) {
+        accessPoint[propName] = { ...propValue };
+        return;
+      }
+      accessPoint[propName] = propValue;
+    });
+    return accessPoint;
+  }
+
+  addAP (apKey: string, apData: any): IAccessPoint | undefined {
+    if (!apData || !isObject(apData)) {
+      return undefined;
+    }
+    if (apData.noConsul) {
+      // @ts-ignore
+      this[apKey] = apData;
+      return AccessPoints.getPureProps(apData);
+    }
+    if (!apData.consulServiceName) {
+      this[_logger_].error(`"${apKey}" access point not added because it lacks "consulServiceName" property`);
+      return undefined;
+    }
+    const accessPoint: Record<string, any> = {};
+    addAdditionalAPProps(accessPoint);
+
+    // @ts-ignore
+    this[apKey] = accessPoint;
+    Object.entries(apData).forEach(([propName, v]) => {
+      accessPoint[propName] = AccessPoints.normalizeValue(propName, v);
+    });
+    accessPoint.id = apKey;
+    accessPoint.title = accessPoint.title || apKey;
+    accessPoint.setProps = this.setAP.bind(this, apKey);
+
+    return AccessPoints.getPureProps(accessPoint);
+  }
+
+  setAP (apKey: string, apData: Record<string, any> | null): IAccessPoint | undefined {
+    if (!apData) {
+      return undefined;
+    }
+    // @ts-ignore
+    const accessPoint = this[apKey];
+    if (!accessPoint) {
+      return this.addAP(apKey, apData);
+    }
+    /* istanbul ignore if */
+    if (!accessPoint.isAP) {
+      addAdditionalAPProps(accessPoint);
+    }
+    const was: string[] = [];
+    const became: string[] = [];
+    const changes: any[] = [];
+
+    const msgVal = (propName: string, propValue: any, valueColor: string) => {
+      const ret = (v: any, color = blue) => `${cyan}${propName}${reset}: ${color}${v}${reset}`;
+      return (propValue == null || propValue === '') ? ret(`[${String(propValue)}]`) : ret(propValue, valueColor);
+    };
+
+    Object.entries(apData).forEach(([propName, newV]) => {
+      if (newV === undefined) {
+        return;
+      }
+      const oldV = accessPoint[propName];
+      newV = AccessPoints.normalizeValue(propName, newV);
+      if (oldV !== newV) {
+        was.push(msgVal(propName, oldV, magenta));
+        became.push(msgVal(propName, newV, green));
+        changes.push([propName, oldV, newV]);
+      }
+      accessPoint[propName] = newV;
+    });
+    if (was.length) {
+      this[_logger_].info(`${PREFIX}: Change AP ${green}${accessPoint.id}${reset}/${cyan}${accessPoint.consulServiceName}${reset} from ${was.join('; ')}  to  ${became.join('; ')}`);
+    }
+
+    accessPoint.idHostPortUpdated = accessPoint.idHostPortUpdated
+      || !!(accessPoint.host && accessPoint.port && (apData.host || apData.port));
+
+    const result = AccessPoints.getPureProps(accessPoint);
+    result.getChanges = () => (changes.length ? changes : undefined);
+    return result;
+  }
+
+  getAP (accessPointKey: string, andNotIsAP?: boolean): IAccessPoint | undefined {
+    if (accessPointKey) {
+      // @ts-ignore
+      const accessPoint = this[accessPointKey];
+      if (!andNotIsAP && !accessPoint?.isAP) {
+        return undefined;
+      }
+      return accessPoint;
+    }
+    return undefined;
+  }
+
+  /**
+   * Если передан accessPointKey, то возвращается этот AP, если есть.
+   * Если accessPointKey НЕ передан, то возвращаются ВСЕ AP
+   */
+  get (accessPointKey?: string, andNotIsAP?: boolean): IAccessPoints | IAccessPoint | undefined {
+    if (accessPointKey) {
+      // @ts-ignore
+      const accessPoint = this[accessPointKey];
+      if (!accessPoint || (!andNotIsAP && !accessPoint?.isAP)) {
+        return undefined;
+      }
+      return AccessPoints.getPureProps(accessPoint);
+    }
+    const accessPoints = Object.create(null) as IAccessPoints;
+    Object.values(this).filter((ap) => ap?.isAP).forEach((accessPoint) => {
+      accessPoints[accessPoint.id] = AccessPoints.getPureProps(accessPoint);
+    });
+    return accessPoints;
+  }
+}

package/src/constants.ts

@@ -0,0 +1,7 @@
+export const PREFIX = 'AF-CONSUL';
+export const MAX_API_CACHED = 3;
+
+export const CONSUL_AP_UPDATE_TIMEOUT_MILLIS = Number(process.env.CONSUL_AP_UPDATE_TIMEOUT_MILLIS) || 10_000;
+export const DEBUG = (String(process.env.DEBUG || '')).trim();
+export const CONSUL_DEBUG_ON = DEBUG.split(/[ ,]/).some((v) => /af-consul/i.test(v) || v === '*');
+export const FORCE_EVERY_REGISTER_ATTEMPT = !!process.env.FORCE_EVERY_REGISTER_ATTEMPT;

package/src/consul-client/endpoints/agent.ts

@@ -0,0 +1,91 @@
+import { ConsulHttpClient } from '../http-client';
+import { ServiceInfo, RegisterServiceOptions, AgentMember, RegisterCheck } from '../types';
+
+export class AgentAPI {
+  constructor (private client: ConsulHttpClient) {}
+
+  /**
+   * GET /v1/agent/services
+   * Returns all services registered with the local agent
+   */
+  async serviceList (): Promise<Record<string, ServiceInfo>> {
+    return this.client.get<Record<string, ServiceInfo>>('/agent/services');
+  }
+
+  /**
+   * PUT /v1/agent/service/register
+   * Registers a new service with the local agent
+   */
+  async serviceRegister (options: RegisterServiceOptions): Promise<void> {
+    // Convert to Consul API format (PascalCase)
+    const body: Record<string, unknown> = {
+      ID: options.id,
+      Name: options.name,
+      Tags: options.tags,
+      Address: options.address,
+      Port: options.port,
+      Meta: options.meta,
+      Check: options.check ? this.formatCheck(options.check) : undefined,
+      Checks: options.checks?.map((c) => this.formatCheck(c)),
+      Connect: options.connect,
+      Proxy: options.proxy,
+      TaggedAddresses: options.taggedAddresses,
+      Weights: options.weights,
+      EnableTagOverride: options.enableTagOverride,
+    };
+
+    // Remove undefined values
+    Object.keys(body).forEach((key) => {
+      if (body[key] === undefined) {
+        delete body[key];
+      }
+    });
+
+    await this.client.put<void>('/agent/service/register', body);
+  }
+
+  /**
+   * PUT /v1/agent/service/deregister/:service_id
+   * Deregisters a service from the local agent
+   */
+  async serviceDeregister (serviceId: string): Promise<void> {
+    await this.client.put<void>(`/agent/service/deregister/${encodeURIComponent(serviceId)}`);
+  }
+
+  /**
+   * GET /v1/agent/members
+   * Returns the members the agent sees in the cluster
+   */
+  async members (options?: { wan?: boolean; segment?: string }): Promise<AgentMember[]> {
+    const query: Record<string, string | boolean | undefined> = {};
+    if (options?.wan) {query.wan = options.wan;}
+    if (options?.segment) {query.segment = options.segment;}
+    return this.client.get<AgentMember[]>('/agent/members', Object.keys(query).length ? query : undefined);
+  }
+
+  private formatCheck (check: RegisterCheck): Record<string, unknown> {
+    const formatted: Record<string, unknown> = {
+      Name: check.name,
+      HTTP: check.http,
+      TCP: check.tcp,
+      Script: check.script,
+      Shell: check.shell,
+      DockerContainerID: check.dockercontainerid,
+      Interval: check.interval,
+      Timeout: check.timeout,
+      TTL: check.ttl,
+      Notes: check.notes,
+      Status: check.status,
+      DeregisterCriticalServiceAfter: check.deregistercriticalserviceafter,
+    };
+
+    // Remove undefined values
+    Object.keys(formatted).forEach((key) => {
+      if (formatted[key] === undefined) {
+        delete formatted[key];
+      }
+    });
+
+    return formatted;
+  }
+}

package/src/consul-client/endpoints/catalog.ts

@@ -0,0 +1,13 @@
+import { ConsulHttpClient } from '../http-client';
+
+export class CatalogAPI {
+  constructor (private client: ConsulHttpClient) {}
+
+  /**
+   * GET /v1/catalog/services
+   * Returns all services in a datacenter
+   */
+  async serviceList (dc?: string): Promise<Record<string, string[]>> {
+    return this.client.get<Record<string, string[]>>('/catalog/services', dc ? { dc } : undefined);
+  }
+}

package/src/consul-client/endpoints/health.ts

@@ -0,0 +1,31 @@
+import { ConsulHttpClient } from '../http-client';
+import { HealthServiceInfo } from '../types';
+
+export class HealthAPI {
+  constructor (private client: ConsulHttpClient) {}
+
+  /**
+   * GET /v1/health/service/:service
+   * Returns the nodes and health info of a service
+   */
+  async service (options: {
+    service: string;
+    dc?: string;
+    passing?: boolean;
+    tag?: string;
+    near?: string;
+  }): Promise<HealthServiceInfo[]> {
+    const { service, ...queryOptions } = options;
+    const query: Record<string, string | boolean | undefined> = {};
+
+    if (queryOptions.dc) {query.dc = queryOptions.dc;}
+    if (queryOptions.passing !== undefined) {query.passing = queryOptions.passing;}
+    if (queryOptions.tag) {query.tag = queryOptions.tag;}
+    if (queryOptions.near) {query.near = queryOptions.near;}
+
+    return this.client.get<HealthServiceInfo[]>(
+      `/health/service/${encodeURIComponent(service)}`,
+      Object.keys(query).length ? query : undefined,
+    );
+  }
+}

package/src/consul-client/http-client.ts

@@ -0,0 +1,166 @@
+import * as http from 'http';
+import * as https from 'https';
+
+import { ConsulClientOptions, RequestInfo, ResponseInfo, OnRequestHook, OnResponseHook } from './types';
+
+export class ConsulHttpClient {
+  private readonly baseUrl: string;
+  private readonly headers: Record<string, string>;
+  private readonly timeout: number;
+  private readonly httpModule: typeof http | typeof https;
+  private readonly host: string;
+  private readonly port: string | number;
+  private readonly protocol: string;
+
+  private requestCounter = 0;
+  private onRequestHooks: OnRequestHook[] = [];
+  private onResponseHooks: OnResponseHook[] = [];
+
+  constructor (options: ConsulClientOptions) {
+    const protocol = options.secure ? 'https' : 'http';
+    const port = options.port || (options.secure ? 443 : 8500);
+    this.host = options.host;
+    this.port = port;
+    this.protocol = `${protocol}:`;
+    this.baseUrl = `${protocol}://${options.host}:${port}/v1`;
+    this.httpModule = options.secure ? https : http;
+    this.timeout = options.timeout || 30000;
+
+    this.headers = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    };
+
+    // Support both direct token and defaults.token (for compatibility)
+    const token = options.token || options.defaults?.token;
+    if (token) {
+      this.headers['X-Consul-Token'] = token;
+    }
+  }
+
+  onRequest (hook: OnRequestHook): void {
+    this.onRequestHooks.push(hook);
+  }
+
+  onResponse (hook: OnResponseHook): void {
+    this.onResponseHooks.push(hook);
+  }
+
+  private buildQueryString (params?: Record<string, string | boolean | undefined>): string {
+    if (!params) {return '';}
+    const entries = Object.entries(params)
+      .filter(([, v]) => v !== undefined && v !== '')
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+    return entries.length ? `?${entries.join('&')}` : '';
+  }
+
+  async request<T> (
+    method: 'GET' | 'PUT' | 'POST' | 'DELETE',
+    path: string,
+    options?: {
+      query?: Record<string, string | boolean | undefined>;
+      body?: unknown;
+      skipCodes?: number[];
+    },
+  ): Promise<T> {
+    const requestId = ++this.requestCounter;
+    const queryString = this.buildQueryString(options?.query);
+    const url = `${this.baseUrl}${path}${queryString}`;
+    const body = options?.body ? JSON.stringify(options.body) : undefined;
+
+    const requestInfo: RequestInfo = {
+      id: requestId,
+      method,
+      url,
+      headers: { ...this.headers },
+      body,
+      timestamp: Date.now(),
+      // Properties for compatibility with debug utilities
+      path: `/v1${path}${queryString}`,
+      hostname: this.host,
+      port: this.port,
+      protocol: this.protocol,
+      query: options?.query,
+    };
+
+    // Emit onRequest hooks
+    this.onRequestHooks.forEach((hook) => hook(requestInfo));
+
+    return new Promise<T>((resolve, reject) => {
+      const urlObj = new URL(url);
+
+      const reqOptions: http.RequestOptions = {
+        hostname: urlObj.hostname,
+        port: urlObj.port,
+        path: urlObj.pathname + urlObj.search,
+        method,
+        headers: {
+          ...this.headers,
+          ...(body ? { 'Content-Length': Buffer.byteLength(body) } : {}),
+        },
+        timeout: this.timeout,
+      };
+
+      const req = this.httpModule.request(reqOptions, (res) => {
+        let data = '';
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          const statusCode = res.statusCode || 0;
+          let parsedBody: unknown;
+
+          try {
+            parsedBody = data ? JSON.parse(data) : null;
+          } catch {
+            parsedBody = data;
+          }
+
+          const responseInfo: ResponseInfo = {
+            requestId,
+            statusCode,
+            body: parsedBody,
+            timestamp: Date.now(),
+          };
+
+          // Emit onResponse hooks
+          this.onResponseHooks.forEach((hook) => hook(requestInfo, responseInfo));
+
+          if (statusCode >= 200 && statusCode < 300) {
+            resolve(parsedBody as T);
+          } else if (options?.skipCodes?.includes(statusCode)) {
+            resolve(parsedBody as T);
+          } else {
+            reject(new Error(`Consul API error: ${statusCode} - ${JSON.stringify(parsedBody)}`));
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.on('timeout', () => {
+        req.destroy();
+        reject(new Error(`Request timeout: ${url}`));
+      });
+
+      if (body) {
+        req.write(body);
+      }
+      req.end();
+    });
+  }
+
+  async get<T> (path: string, query?: Record<string, string | boolean | undefined>): Promise<T> {
+    return this.request<T>('GET', path, query ? { query } : undefined);
+  }
+
+  async put<T> (path: string, body?: unknown, query?: Record<string, string | boolean | undefined>): Promise<T> {
+    return this.request<T>('PUT', path, {
+      ...(query ? { query } : {}),
+      ...(body !== undefined ? { body } : {}),
+    });
+  }
+
+  getRequestCounter (): number {
+    return this.requestCounter;
+  }
+}