《独立开发者的商业指南·合同、应收与风险》11.1 DPA、SCC 与跨境传输

// file: src/contract/privacy.ts
// tier: L1
// verify: node --test test/contract/privacy.test.ts

import { type Cents } from "../core/money.ts";
import { type Result, fail, ok } from "../core/result.ts";

export type CrossBorderMechanism = "none" | "scc" | "bcr";

export type DpaTerms = {
  subprocessorNoticeDays: number;
  deletionDeadlineDays: number;
  auditRightsPerYear: number;
  crossBorder: CrossBorderMechanism;
};

export type DpaObligation = {
  subprocessorNoticeRequired: boolean;
  deletionDeadlineDays: number;
  auditRightsPerYear: number;
  crossBorderPaperwork: boolean;
};

export type DpaCostInput = {
  terms: DpaTerms;
  legalHoursPerYear: number;
  auditPrepHoursPerAudit: number;
  crossBorderSetupHours: number;
  hourlyRateCents: Cents;
};

export type DpaCost = {
  legalCostCents: Cents;
  auditCostCents: Cents;
  crossBorderSetupCents: Cents;
  annualRunCostCents: Cents;
  firstYearCostCents: Cents;
  laterYearCostCents: Cents;
};

export type DpaDealInput = {
  dealsLostWithoutDpa: number;
  annualValueCents: Cents;
};

function validHours(value: number): boolean {
  return Number.isFinite(value) && value >= 0;
}

function validCount(value: number): boolean {
  return Number.isInteger(value) && value >= 0;
}

function validAmount(value: Cents): boolean {
  return Number.isInteger(value) && value >= 0;
}

/**
 * A DPA is not one signature but five recurring obligations. This function
 * normalises the terms into the parts that create work: notice duties, a
 * deletion clock, audit rights and a cross-border paper trail.
 */
export function summarizeDpa(terms: DpaTerms): Result<DpaObligation> {
  if (!validCount(terms.subprocessorNoticeDays)) {
    return fail("subprocessor notice must be a non-negative integer of days");
  }
  if (!validCount(terms.deletionDeadlineDays)) {
    return fail("deletion deadline must be a non-negative integer of days");
  }
  if (!validCount(terms.auditRightsPerYear)) {
    return fail("audit rights must be a non-negative integer per year");
  }

  return ok({
    subprocessorNoticeRequired: terms.subprocessorNoticeDays > 0,
    deletionDeadlineDays: terms.deletionDeadlineDays,
    auditRightsPerYear: terms.auditRightsPerYear,
    crossBorderPaperwork: terms.crossBorder !== "none",
  });
}

/**
 * Maintenance cost is legal hours plus audit preparation. Cross-border setup
 * is a first-year cost: the mechanism adds documents, not a permanent fee.
 * Audit preparation is multiplied by the audit rights in the terms, because
 * two audit rights per year mean two preparation cycles, not one.
 */
export function annualDpaCost(input: DpaCostInput): Result<DpaCost> {
  if (
    !validHours(input.legalHoursPerYear) ||
    !validHours(input.auditPrepHoursPerAudit) ||
    !validHours(input.crossBorderSetupHours)
  ) {
    return fail("hours must be non-negative");
  }
  if (!validAmount(input.hourlyRateCents)) {
    return fail("hourly rate must be a non-negative integer amount");
  }
  const obligation = summarizeDpa(input.terms);
  if (!obligation.ok) {
    return fail(obligation.error);
  }

  const legalCostCents = Math.round(
    input.legalHoursPerYear * input.hourlyRateCents,
  );
  const auditCostCents = Math.round(
    input.auditPrepHoursPerAudit *
      obligation.value.auditRightsPerYear *
      input.hourlyRateCents,
  );
  const crossBorderSetupCents = obligation.value.crossBorderPaperwork
    ? Math.round(input.crossBorderSetupHours * input.hourlyRateCents)
    : 0;
  const annualRunCostCents = legalCostCents + auditCostCents;

  return ok({
    legalCostCents,
    auditCostCents,
    crossBorderSetupCents,
    annualRunCostCents,
    firstYearCostCents: annualRunCostCents + crossBorderSetupCents,
    laterYearCostCents: annualRunCostCents,
  });
}

/**
 * The other side of the DPA is revenue that never arrives. Lost deals times
 * annual contract value is the annual revenue at risk; net benefit subtracts
 * the maintenance cost from that number.
 */
export function dpaRevenueAtRisk(input: DpaDealInput): Result<Cents> {
  if (!validCount(input.dealsLostWithoutDpa)) {
    return fail("lost deals must be a non-negative integer");
  }
  if (!validAmount(input.annualValueCents)) {
    return fail("annual value must be a non-negative integer amount");
  }
  return ok(input.dealsLostWithoutDpa * input.annualValueCents);
}

export function dpaNetBenefit(
  revenueAtRiskCents: Cents,
  costCents: Cents,
): Cents {
  return revenueAtRiskCents - costCents;
}