chore: Enable "curly" rule to avoid single-statement if confusion/errors.

src/infra/net/ssrf.pinning.test.ts

@@ -15,8 +15,11 @@ describe("ssrf pinning", () => {
 
     const first = await new Promise<{ address: string; family?: number }>((resolve, reject) => {
       pinned.lookup("example.com", (err, address, family) => {
-        if (err) reject(err);
-        else resolve({ address: address, family });
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ address: address, family });
+        }
       });
     });
     expect(first.address).toBe("93.184.216.34");
@@ -24,8 +27,11 @@ describe("ssrf pinning", () => {
 
     const all = await new Promise<unknown>((resolve, reject) => {
       pinned.lookup("example.com", { all: true }, (err, addresses) => {
-        if (err) reject(err);
-        else resolve(addresses);
+        if (err) {
+          reject(err);
+        } else {
+          resolve(addresses);
+        }
       });
     });
     expect(Array.isArray(all)).toBe(true);
@@ -52,8 +58,11 @@ describe("ssrf pinning", () => {
 
     const result = await new Promise<{ address: string }>((resolve, reject) => {
       lookup("other.test", (err, address) => {
-        if (err) reject(err);
-        else resolve({ address: address });
+        if (err) {
+          reject(err);
+        } else {
+          resolve({ address: address });
+        }
       });
     });
 

src/infra/net/ssrf.ts

@@ -30,9 +30,13 @@ function normalizeHostname(hostname: string): string {
 
 function parseIpv4(address: string): number[] | null {
   const parts = address.split(".");
-  if (parts.length !== 4) return null;
+  if (parts.length !== 4) {
+    return null;
+  }
   const numbers = parts.map((part) => Number.parseInt(part, 10));
-  if (numbers.some((value) => Number.isNaN(value) || value < 0 || value > 255)) return null;
+  if (numbers.some((value) => Number.isNaN(value) || value < 0 || value > 255)) {
+    return null;
+  }
   return numbers;
 }
 
@@ -43,10 +47,14 @@ function parseIpv4FromMappedIpv6(mapped: string): number[] | null {
   const parts = mapped.split(":").filter(Boolean);
   if (parts.length === 1) {
     const value = Number.parseInt(parts[0], 16);
-    if (Number.isNaN(value) || value < 0 || value > 0xffff_ffff) return null;
+    if (Number.isNaN(value) || value < 0 || value > 0xffff_ffff) {
+      return null;
+    }
     return [(value >>> 24) & 0xff, (value >>> 16) & 0xff, (value >>> 8) & 0xff, value & 0xff];
   }
-  if (parts.length !== 2) return null;
+  if (parts.length !== 2) {
+    return null;
+  }
   const high = Number.parseInt(parts[0], 16);
   const low = Number.parseInt(parts[1], 16);
   if (
@@ -65,13 +73,27 @@ function parseIpv4FromMappedIpv6(mapped: string): number[] | null {
 
 function isPrivateIpv4(parts: number[]): boolean {
   const [octet1, octet2] = parts;
-  if (octet1 === 0) return true;
-  if (octet1 === 10) return true;
-  if (octet1 === 127) return true;
-  if (octet1 === 169 && octet2 === 254) return true;
-  if (octet1 === 172 && octet2 >= 16 && octet2 <= 31) return true;
-  if (octet1 === 192 && octet2 === 168) return true;
-  if (octet1 === 100 && octet2 >= 64 && octet2 <= 127) return true;
+  if (octet1 === 0) {
+    return true;
+  }
+  if (octet1 === 10) {
+    return true;
+  }
+  if (octet1 === 127) {
+    return true;
+  }
+  if (octet1 === 169 && octet2 === 254) {
+    return true;
+  }
+  if (octet1 === 172 && octet2 >= 16 && octet2 <= 31) {
+    return true;
+  }
+  if (octet1 === 192 && octet2 === 168) {
+    return true;
+  }
+  if (octet1 === 100 && octet2 >= 64 && octet2 <= 127) {
+    return true;
+  }
   return false;
 }
 
@@ -80,28 +102,40 @@ export function isPrivateIpAddress(address: string): boolean {
   if (normalized.startsWith("[") && normalized.endsWith("]")) {
     normalized = normalized.slice(1, -1);
   }
-  if (!normalized) return false;
+  if (!normalized) {
+    return false;
+  }
 
   if (normalized.startsWith("::ffff:")) {
     const mapped = normalized.slice("::ffff:".length);
     const ipv4 = parseIpv4FromMappedIpv6(mapped);
-    if (ipv4) return isPrivateIpv4(ipv4);
+    if (ipv4) {
+      return isPrivateIpv4(ipv4);
+    }
   }
 
   if (normalized.includes(":")) {
-    if (normalized === "::" || normalized === "::1") return true;
+    if (normalized === "::" || normalized === "::1") {
+      return true;
+    }
     return PRIVATE_IPV6_PREFIXES.some((prefix) => normalized.startsWith(prefix));
   }
 
   const ipv4 = parseIpv4(normalized);
-  if (!ipv4) return false;
+  if (!ipv4) {
+    return false;
+  }
   return isPrivateIpv4(ipv4);
 }
 
 export function isBlockedHostname(hostname: string): boolean {
   const normalized = normalizeHostname(hostname);
-  if (!normalized) return false;
-  if (BLOCKED_HOSTNAMES.has(normalized)) return true;
+  if (!normalized) {
+    return false;
+  }
+  if (BLOCKED_HOSTNAMES.has(normalized)) {
+    return true;
+  }
   return (
     normalized.endsWith(".localhost") ||
     normalized.endsWith(".local") ||
@@ -134,7 +168,9 @@ export function createPinnedLookup(params: {
   return ((host: string, options?: unknown, callback?: unknown) => {
     const cb: LookupCallback =
       typeof options === "function" ? (options as LookupCallback) : (callback as LookupCallback);
-    if (!cb) return;
+    if (!cb) {
+      return;
+    }
     const normalized = normalizeHostname(host);
     if (!normalized || normalized !== normalizedHost) {
       if (typeof options === "function" || options === undefined) {
@@ -219,7 +255,9 @@ export function createPinnedDispatcher(pinned: PinnedHostname): Dispatcher {
 }
 
 export async function closeDispatcher(dispatcher?: Dispatcher | null): Promise<void> {
-  if (!dispatcher) return;
+  if (!dispatcher) {
+    return;
+  }
   const candidate = dispatcher as { close?: () => Promise<void> | void; destroy?: () => void };
   try {
     if (typeof candidate.close === "function") {