@git-stunts/git-warp 10.1.1

package/src/infrastructure/adapters/GlobalClockAdapter.js

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use ClockAdapter instead. This file is a backward-compatibility
+ * re-export and will be removed in a future version.
+ */
+export { default } from './ClockAdapter.js';

package/src/infrastructure/adapters/NoOpLogger.js

@@ -0,0 +1,62 @@
+import LoggerPort from '../../ports/LoggerPort.js';
+
+/**
+ * No-operation logger adapter.
+ *
+ * Provides a zero-overhead implementation of LoggerPort that discards
+ * all log messages. Useful as the default logger when logging is not
+ * needed, or for testing scenarios where log output is not relevant.
+ *
+ * All methods are no-ops that return immediately without side effects.
+ */
+export default class NoOpLogger extends LoggerPort {
+  /**
+   * No-op debug log.
+   * @param {string} _message - Ignored
+   * @param {Record<string, unknown>} [_context] - Ignored
+   * @returns {void}
+   */
+  debug(_message, _context) {
+    // Intentionally empty
+  }
+
+  /**
+   * No-op info log.
+   * @param {string} _message - Ignored
+   * @param {Record<string, unknown>} [_context] - Ignored
+   * @returns {void}
+   */
+  info(_message, _context) {
+    // Intentionally empty
+  }
+
+  /**
+   * No-op warning log.
+   * @param {string} _message - Ignored
+   * @param {Record<string, unknown>} [_context] - Ignored
+   * @returns {void}
+   */
+  warn(_message, _context) {
+    // Intentionally empty
+  }
+
+  /**
+   * No-op error log.
+   * @param {string} _message - Ignored
+   * @param {Record<string, unknown>} [_context] - Ignored
+   * @returns {void}
+   */
+  error(_message, _context) {
+    // Intentionally empty
+  }
+
+  /**
+   * Returns a new NoOpLogger instance.
+   * Context is ignored since no logging occurs.
+   * @param {Record<string, unknown>} [_context] - Ignored
+   * @returns {NoOpLogger} A new NoOpLogger instance
+   */
+  child(_context) {
+    return new NoOpLogger();
+  }
+}

package/src/infrastructure/adapters/NodeCryptoAdapter.js

@@ -0,0 +1,32 @@
+import CryptoPort from '../../ports/CryptoPort.js';
+import {
+  createHash,
+  createHmac,
+  timingSafeEqual as nodeTimingSafeEqual,
+} from 'node:crypto';
+
+/**
+ * Node.js crypto adapter implementing CryptoPort.
+ *
+ * This is the only file that imports node:crypto.
+ *
+ * @extends CryptoPort
+ */
+export default class NodeCryptoAdapter extends CryptoPort {
+  /** @inheritdoc */
+  // eslint-disable-next-line @typescript-eslint/require-await -- async ensures sync throws become rejected promises
+  async hash(algorithm, data) {
+    return createHash(algorithm).update(data).digest('hex');
+  }
+
+  /** @inheritdoc */
+  // eslint-disable-next-line @typescript-eslint/require-await -- async ensures sync throws become rejected promises
+  async hmac(algorithm, key, data) {
+    return createHmac(algorithm, key).update(data).digest();
+  }
+
+  /** @inheritdoc */
+  timingSafeEqual(a, b) {
+    return nodeTimingSafeEqual(a, b);
+  }
+}

package/src/infrastructure/adapters/NodeHttpAdapter.js

@@ -0,0 +1,98 @@
+import HttpServerPort from '../../ports/HttpServerPort.js';
+import { createServer } from 'node:http';
+
+/** Absolute streaming body limit (10 MB). */
+const MAX_BODY_BYTES = 10 * 1024 * 1024;
+
+/**
+ * Collects the request body and dispatches to the handler, returning
+ * a 500 response if the handler throws.
+ */
+async function dispatch(req, res, { handler, logger }) {
+  try {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of req) {
+      totalBytes += chunk.length;
+      if (totalBytes > MAX_BODY_BYTES) {
+        res.writeHead(413, { 'Content-Type': 'text/plain' });
+        res.end('Payload Too Large');
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks);
+
+    const response = await handler({
+      method: req.method,
+      url: req.url,
+      headers: req.headers,
+      body: body.length > 0 ? body : undefined,
+    });
+
+    res.writeHead(response.status || 200, response.headers || {});
+    res.end(response.body);
+  } catch (err) {
+    logger.error('[NodeHttpAdapter] dispatch error:', err);
+    if (!res.headersSent) {
+      res.writeHead(500, { 'Content-Type': 'text/plain' });
+    }
+    res.end('Internal Server Error');
+  }
+}
+
+const noopLogger = { error() {} };
+
+/**
+ * Node.js HTTP adapter implementing HttpServerPort.
+ *
+ * This is the only file that imports node:http for server creation.
+ *
+ * @extends HttpServerPort
+ */
+export default class NodeHttpAdapter extends HttpServerPort {
+  /**
+   * @param {{ logger?: { error: Function } }} [options]
+   */
+  constructor({ logger } = {}) {
+    super();
+    this._logger = logger || noopLogger;
+  }
+
+  /** @inheritdoc */
+  createServer(requestHandler) {
+    const logger = this._logger;
+    const server = createServer((req, res) => {
+      dispatch(req, res, { handler: requestHandler, logger }).catch((err) => {
+        logger.error('[NodeHttpAdapter] unhandled dispatch error:', err);
+      });
+    });
+
+    return {
+      listen(port, host, callback) {
+        const cb = typeof host === 'function' ? host : callback;
+        const bindHost = typeof host === 'string' ? host : undefined;
+        const onError = (err) => {
+          if (cb) {
+            cb(err);
+          }
+        };
+        server.once('error', onError);
+        const args = bindHost !== undefined ? [port, bindHost] : [port];
+        server.listen(...args, () => {
+          server.removeListener('error', onError);
+          if (cb) {
+            cb(null);
+          }
+        });
+      },
+      close(callback) {
+        server.close(callback);
+      },
+      address() {
+        return server.address();
+      },
+    };
+  }
+}

package/src/infrastructure/adapters/PerformanceClockAdapter.js

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use ClockAdapter instead. This file is a backward-compatibility
+ * re-export and will be removed in a future version.
+ */
+export { default } from './ClockAdapter.js';

package/src/infrastructure/adapters/WebCryptoAdapter.js

@@ -0,0 +1,121 @@
+import CryptoPort from '../../ports/CryptoPort.js';
+
+/**
+ * Map of common algorithm names to Web Crypto API algorithm identifiers.
+ * @const {Object<string, string>}
+ */
+const ALGO_MAP = {
+  'sha-1': 'SHA-1',
+  'sha1': 'SHA-1',
+  'sha-256': 'SHA-256',
+  'sha256': 'SHA-256',
+  'sha-384': 'SHA-384',
+  'sha384': 'SHA-384',
+  'sha-512': 'SHA-512',
+  'sha512': 'SHA-512',
+};
+
+/**
+ * Converts a common algorithm name to the Web Crypto API identifier.
+ * @param {string} algorithm - Algorithm name (e.g. 'sha256', 'sha-256')
+ * @returns {string} Web Crypto API algorithm identifier (e.g. 'SHA-256')
+ * @throws {Error} If the algorithm is not supported
+ */
+function toWebCryptoAlgo(algorithm) {
+  const mapped = ALGO_MAP[algorithm.toLowerCase()];
+  if (!mapped) {
+    throw new Error(`WebCryptoAdapter: unsupported algorithm "${algorithm}"`);
+  }
+  return mapped;
+}
+
+/**
+ * Converts input data to a Uint8Array for Web Crypto API consumption.
+ * @param {string|Buffer|Uint8Array} data - Input data
+ * @returns {Uint8Array} Data as Uint8Array
+ * @throws {Error} If data type is not supported
+ */
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) { return data; }
+  if (typeof data === 'string') { return new TextEncoder().encode(data); }
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) {
+    return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+  }
+  throw new Error('WebCryptoAdapter: data must be string, Buffer, or Uint8Array');
+}
+
+/**
+ * Converts an ArrayBuffer to a hex string.
+ * @param {ArrayBuffer} buf - ArrayBuffer to convert
+ * @returns {string} Hex-encoded string
+ */
+function bufToHex(buf) {
+  return Array.from(new Uint8Array(buf))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+/**
+ * Web Crypto API adapter implementing CryptoPort.
+ *
+ * Uses the standard Web Crypto API (globalThis.crypto.subtle) which is
+ * available in browsers, Deno, Bun, and Node.js 20+.
+ *
+ * All hash and HMAC operations are async because the Web Crypto API
+ * is inherently promise-based.
+ *
+ * @extends CryptoPort
+ */
+export default class WebCryptoAdapter extends CryptoPort {
+  /**
+   * Creates a new WebCryptoAdapter.
+   * @param {Object} [options] - Configuration options
+   * @param {SubtleCrypto} [options.subtle] - SubtleCrypto instance (defaults to globalThis.crypto.subtle)
+   */
+  constructor({ subtle } = {}) {
+    super();
+    this._subtle = subtle || globalThis.crypto.subtle;
+  }
+
+  /** @inheritdoc */
+  async hash(algorithm, data) {
+    const digest = await this._subtle.digest(
+      toWebCryptoAlgo(algorithm),
+      toUint8Array(data),
+    );
+    return bufToHex(digest);
+  }
+
+  /** @inheritdoc */
+  async hmac(algorithm, key, data) {
+    const keyBytes = toUint8Array(key);
+    const cryptoKey = await this._subtle.importKey(
+      'raw',
+      keyBytes,
+      { name: 'HMAC', hash: toWebCryptoAlgo(algorithm) },
+      false,
+      ['sign'],
+    );
+    const signature = await this._subtle.sign('HMAC', cryptoKey, toUint8Array(data));
+    return new Uint8Array(signature);
+  }
+
+  /**
+   * Constant-time comparison of two buffers.
+   *
+   * Uses XOR accumulation with no early exit to prevent timing attacks.
+   * This is the standard approach when crypto.timingSafeEqual is unavailable.
+   *
+   * @param {Buffer|Uint8Array} a - First buffer
+   * @param {Buffer|Uint8Array} b - Second buffer
+   * @returns {boolean} True if buffers are equal
+   */
+  timingSafeEqual(a, b) {
+    if (a.length !== b.length) { return false; }
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+      result |= a[i] ^ b[i];
+    }
+    return result === 0;
+  }
+}