《互联网产品的客户端架构·规模化与架构演进》5.1 故障域与爆炸半径

// file: src/stability/fault-domain.ts
// tier: L1
// verify: node --test test/stability/fault-domain.test.ts

export type DependencyKind = "service" | "sdk" | "storage" | "config" | "thirdparty";

export type Dependency = {
  id: string;
  title: string;
  domain: string;
  kind: DependencyKind;
  redundant: boolean;
  dependsOn: string[];
};

export type Feature = { id: string; title: string; dependsOn: string[] };

export type BlastRadius = { dependencyId: string; dependencies: string[]; features: string[]; ratio: number };

export type FaultDomain = { id: string; title: string; dependencies: string[] };

const DOMAIN_TITLES: Record<string, string> = {
  network: "网络与分发",
  backend: "业务后端",
  storage: "数据存储",
  config: "配置与实验",
  thirdparty: "第三方 SDK",
};

export const DEPENDENCIES: Dependency[] = [
  { id: "dns", title: "域名解析", domain: "network", kind: "service", redundant: true, dependsOn: [] },
  { id: "cdn", title: "静态资源 CDN", domain: "network", kind: "service", redundant: true, dependsOn: ["dns"] },
  { id: "api-gateway", title: "API 网关", domain: "backend", kind: "service", redundant: false, dependsOn: ["dns"] },
  { id: "order-api", title: "订单服务", domain: "backend", kind: "service", redundant: false, dependsOn: ["api-gateway", "order-db"] },
  { id: "order-db", title: "订单主库", domain: "storage", kind: "storage", redundant: false, dependsOn: [] },
  { id: "remote-config", title: "远程配置", domain: "config", kind: "config", redundant: true, dependsOn: ["cdn"] },
  { id: "payment-sdk", title: "支付 SDK", domain: "thirdparty", kind: "thirdparty", redundant: false, dependsOn: [] },
  { id: "push-sdk", title: "推送 SDK", domain: "thirdparty", kind: "thirdparty", redundant: true, dependsOn: [] },
  { id: "analytics-sdk", title: "埋点 SDK", domain: "thirdparty", kind: "sdk", redundant: true, dependsOn: [] },
];

export const FEATURES: Feature[] = [
  { id: "browse", title: "浏览首页", dependsOn: ["cdn", "remote-config"] },
  { id: "checkout", title: "下单支付", dependsOn: ["api-gateway", "order-api", "payment-sdk"] },
  { id: "order-history", title: "订单记录", dependsOn: ["api-gateway", "order-api"] },
  { id: "notification", title: "消息通知", dependsOn: ["push-sdk", "remote-config"] },
  { id: "analytics", title: "行为埋点", dependsOn: ["analytics-sdk"] },
];

export function dependencyById(id: string, dependencies: Dependency[] = DEPENDENCIES): Dependency | undefined {
  return dependencies.find((dependency) => dependency.id === id);
}

export function featureById(id: string, features: Feature[] = FEATURES): Feature | undefined {
  return features.find((feature) => feature.id === id);
}

export function directDependents(depId: string, dependencies: Dependency[] = DEPENDENCIES): string[] {
  return dependencies.filter((dependency) => dependency.dependsOn.includes(depId)).map((dependency) => dependency.id);
}

export function affectedDependencies(depId: string, dependencies: Dependency[] = DEPENDENCIES): string[] {
  const affected = new Set<string>([depId]);
  const queue = [depId];
  while (queue.length > 0) {
    const current = queue.shift() as string;
    for (const dependency of dependencies) {
      if (!affected.has(dependency.id) && dependency.dependsOn.includes(current)) {
        affected.add(dependency.id);
        queue.push(dependency.id);
      }
    }
  }
  return dependencies.filter((dependency) => affected.has(dependency.id)).map((dependency) => dependency.id);
}

export function dependentsOf(
  depId: string,
  dependencies: Dependency[] = DEPENDENCIES,
  features: Feature[] = FEATURES,
): string[] {
  const affected = new Set(affectedDependencies(depId, dependencies));
  return features.filter((feature) => feature.dependsOn.some((id) => affected.has(id))).map((feature) => feature.id);
}

export function blastRadius(
  depId: string,
  dependencies: Dependency[] = DEPENDENCIES,
  features: Feature[] = FEATURES,
): BlastRadius | undefined {
  if (!dependencies.some((dependency) => dependency.id === depId)) {
    return undefined;
  }
  const affectedFeatures = dependentsOf(depId, dependencies, features);
  return {
    dependencyId: depId,
    dependencies: affectedDependencies(depId, dependencies),
    features: affectedFeatures,
    ratio: features.length === 0 ? 0 : affectedFeatures.length / features.length,
  };
}

export function faultDomains(dependencies: Dependency[] = DEPENDENCIES): FaultDomain[] {
  const ids: string[] = [];
  for (const dependency of dependencies) {
    if (!ids.includes(dependency.domain)) {
      ids.push(dependency.domain);
    }
  }
  return ids.map((id) => ({
    id,
    title: DOMAIN_TITLES[id] ?? id,
    dependencies: dependencies.filter((dependency) => dependency.domain === id).map((dependency) => dependency.id),
  }));
}

export function domainBlastRadius(
  domainId: string,
  dependencies: Dependency[] = DEPENDENCIES,
  features: Feature[] = FEATURES,
): BlastRadius | undefined {
  const domain = faultDomains(dependencies).find((item) => item.id === domainId);
  if (domain === undefined) {
    return undefined;
  }
  const affected = new Set<string>();
  for (const depId of domain.dependencies) {
    for (const id of affectedDependencies(depId, dependencies)) {
      affected.add(id);
    }
  }
  const affectedFeatures = features.filter((feature) => feature.dependsOn.some((id) => affected.has(id))).map((feature) => feature.id);
  return {
    dependencyId: `domain/${domainId}`,
    dependencies: dependencies.filter((dependency) => affected.has(dependency.id)).map((dependency) => dependency.id),
    features: affectedFeatures,
    ratio: features.length === 0 ? 0 : affectedFeatures.length / features.length,
  };
}

export function singlePoints(
  minFeatures = 2,
  dependencies: Dependency[] = DEPENDENCIES,
  features: Feature[] = FEATURES,
): string[] {
  return dependencies
    .filter((dependency) => !dependency.redundant)
    .map((dependency, index) => ({ dependency, index, radius: blastRadius(dependency.id, dependencies, features) as BlastRadius }))
    .filter((item) => item.radius.features.length >= minFeatures)
    .sort((a, b) => b.radius.ratio - a.radius.ratio || a.index - b.index)
    .map((item) => item.dependency.id);
}

export function riskiestDomain(dependencies: Dependency[] = DEPENDENCIES, features: Feature[] = FEATURES): string | undefined {
  let best: { id: string; ratio: number } | undefined;
  for (const domain of faultDomains(dependencies)) {
    const ratio = domainBlastRadius(domain.id, dependencies, features)?.ratio ?? 0;
    if (best === undefined || ratio > best.ratio) {
      best = { id: domain.id, ratio };
    }
  }
  return best?.id;
}

export function sharedDependencies(
  featureA: string,
  featureB: string,
  dependencies: Dependency[] = DEPENDENCIES,
  features: Feature[] = FEATURES,
): string[] {
  const first = featureById(featureA, features);
  const second = featureById(featureB, features);
  if (first === undefined || second === undefined) {
    return [];
  }
  const shared = new Set(first.dependsOn.filter((id) => second.dependsOn.includes(id)));
  return dependencies.filter((dependency) => shared.has(dependency.id)).map((dependency) => dependency.id);
}

export function hasCycle(dependencies: Dependency[] = DEPENDENCIES): boolean {
  const state = new Map<string, number>();
  const visit = (id: string): boolean => {
    const current = state.get(id) ?? 0;
    if (current === 1) return true;
    if (current === 2) return false;
    state.set(id, 1);
    for (const next of dependencyById(id, dependencies)?.dependsOn ?? []) {
      if (visit(next)) return true;
    }
    state.set(id, 2);
    return false;
  };
  return dependencies.some((dependency) => visit(dependency.id));
}

export function unknownReferences(dependencies: Dependency[] = DEPENDENCIES, features: Feature[] = FEATURES): string[] {
  const known = new Set(dependencies.map((dependency) => dependency.id));
  const missing: string[] = [];
  for (const dependency of dependencies) {
    for (const ref of dependency.dependsOn) {
      if (!known.has(ref)) missing.push(`${dependency.id}->${ref}`);
    }
  }
  for (const feature of features) {
    for (const ref of feature.dependsOn) {
      if (!known.has(ref)) missing.push(`${feature.id}->${ref}`);
    }
  }
  return missing;
}

ℹ tests 22
ℹ suites 0
ℹ pass 22
ℹ fail 0
ℹ cancelled 0
ℹ skipped 0
ℹ todo 0
ℹ duration_ms 120.647959