refactor(balances): limit_reached cap selection in its own files

Author: charlietlamb

server/src/internal/balances/trackWebhooks/checkLimitReached.ts

@@ -6,101 +6,12 @@ import {
 	type FullCustomer,
 	type FullSubject,
 	fullCustomerToTags,
-	fullSubjectToUsageWindowLimits,
-	getCurrentUsageWindowUsage,
-	orgToInStatuses,
-	type UsageLimitFilter,
-	type UsageLimitWebhookBlock,
-	usageLimitFilterMatchesProperties,
 	WebhookEventType,
 } from "@autumn/shared";
 import { sendSvixEvent } from "@/external/svix/svixHelpers.js";
 import type { AutumnContext } from "@/honoUtils/HonoEnv.js";
-import { usageWindowLimitToWebhookBlock } from "@/internal/balances/utils/usageWindows/usageWindowLimitToWebhookBlock.js";
-
-type BlockingUsageLimit = {
-	block: UsageLimitWebhookBlock;
-	filter: UsageLimitFilter | undefined;
-};
-
-/**
- * The cap that blocked this event. Enforcement stops at the cap with the least
- * headroom, so the webhook reports that one, filter included, from one source.
- */
-const findBlockingUsageLimit = ({
-	ctx,
-	fullSubject,
-	feature,
-	eventProperties,
-	now,
-}: {
-	ctx: AutumnContext;
-	fullSubject: FullSubject;
-	feature: Feature;
-	eventProperties?: Record<string, unknown> | null;
-	now: number;
-}): BlockingUsageLimit | undefined => {
-	const usageWindows = fullSubject.usage_windows ?? [];
-	const measured = fullSubjectToUsageWindowLimits({
-		fullSubject,
-		featureIds: [feature.id],
-		features: ctx.features,
-		now,
-		inStatuses: orgToInStatuses({ org: ctx.org }),
-	})
-		.filter((limit) =>
-			usageLimitFilterMatchesProperties({
-				filterProperties: limit.filter_properties,
-				eventProperties,
-			}),
-		)
-		.map((limit) => ({
-			limit,
-			usage: getCurrentUsageWindowUsage({ usageWindows, limit, now }),
-		}))
-		.sort(
-			(left, right) =>
-				left.limit.limit - left.usage - (right.limit.limit - right.usage),
-		);
-
-	const tightest = measured[0];
-	if (!tightest || tightest.usage < tightest.limit.limit) return undefined;
-
-	const block = usageWindowLimitToWebhookBlock({
-		limit: tightest.limit,
-		usage: tightest.usage,
-	});
-	if (!block) return undefined;
-
-	return {
-		block,
-		filter: tightest.limit.filter_properties
-			? { properties: tightest.limit.filter_properties }
-			: undefined,
-	};
-};
-
-/** Legacy deductions carry no FullSubject; read the exhausted filtered cap off the evaluated subject. */
-const findBlockedFilterOnSubject = ({
-	subject,
-	feature,
-	eventProperties,
-}: {
-	subject: ApiCustomerV5 | ApiEntityV2;
-	feature: Feature;
-	eventProperties?: Record<string, unknown> | null;
-}): UsageLimitFilter | undefined =>
-	subject.billing_controls?.usage_limits?.find(
-		(usageLimit) =>
-			usageLimit.feature_id === feature.id &&
-			usageLimit.enabled !== false &&
-			usageLimit.filter != null &&
-			usageLimitFilterMatchesProperties({
-				filterProperties: usageLimit.filter.properties,
-				eventProperties,
-			}) &&
-			(usageLimit.usage ?? 0) >= usageLimit.limit,
-	)?.filter;
+import { findBlockedFilterOnSubject } from "./limitReached/findBlockedFilterOnSubject.js";
+import { findBlockingUsageLimit } from "./limitReached/findBlockingUsageLimit.js";
 
 // Subjects must be built via buildEvaluationSubject, or plan-level / percentage
 // caps are invisible here and the allowed -> blocked transition never fires.

server/src/internal/balances/trackWebhooks/limitReached/findBlockedFilterOnSubject.ts

@@ -0,0 +1,29 @@
+import {
+	type ApiCustomerV5,
+	type ApiEntityV2,
+	type Feature,
+	type UsageLimitFilter,
+	usageLimitFilterMatchesProperties,
+} from "@autumn/shared";
+
+/** Legacy deductions carry no FullSubject; read the exhausted filtered cap off the evaluated subject. */
+export const findBlockedFilterOnSubject = ({
+	subject,
+	feature,
+	eventProperties,
+}: {
+	subject: ApiCustomerV5 | ApiEntityV2;
+	feature: Feature;
+	eventProperties?: Record<string, unknown> | null;
+}): UsageLimitFilter | undefined =>
+	subject.billing_controls?.usage_limits?.find(
+		(usageLimit) =>
+			usageLimit.feature_id === feature.id &&
+			usageLimit.enabled !== false &&
+			usageLimit.filter != null &&
+			usageLimitFilterMatchesProperties({
+				filterProperties: usageLimit.filter.properties,
+				eventProperties,
+			}) &&
+			(usageLimit.usage ?? 0) >= usageLimit.limit,
+	)?.filter;

server/src/internal/balances/trackWebhooks/limitReached/findBlockingUsageLimit.ts

@@ -0,0 +1,66 @@
+import {
+	type Feature,
+	type FullSubject,
+	fullSubjectToUsageWindowLimits,
+	getCurrentUsageWindowUsage,
+	orgToInStatuses,
+	usageLimitFilterMatchesProperties,
+} from "@autumn/shared";
+import type { AutumnContext } from "@/honoUtils/HonoEnv.js";
+import { usageWindowLimitToWebhookBlock } from "@/internal/balances/utils/usageWindows/usageWindowLimitToWebhookBlock.js";
+import type { BlockingUsageLimit } from "./types/blockingUsageLimit.js";
+
+/**
+ * The cap that blocked this event. Enforcement stops at the cap with the least
+ * headroom, so the webhook reports that one, filter included, from one source.
+ */
+export const findBlockingUsageLimit = ({
+	ctx,
+	fullSubject,
+	feature,
+	eventProperties,
+	now,
+}: {
+	ctx: AutumnContext;
+	fullSubject: FullSubject;
+	feature: Feature;
+	eventProperties?: Record<string, unknown> | null;
+	now: number;
+}): BlockingUsageLimit | undefined => {
+	const usageWindows = fullSubject.usage_windows ?? [];
+	const measured = fullSubjectToUsageWindowLimits({
+		fullSubject,
+		featureIds: [feature.id],
+		features: ctx.features,
+		now,
+		inStatuses: orgToInStatuses({ org: ctx.org }),
+	})
+		.filter((limit) =>
+			usageLimitFilterMatchesProperties({
+				filterProperties: limit.filter_properties,
+				eventProperties,
+			}),
+		)
+		.map((limit) => ({
+			limit,
+			headroom:
+				limit.limit - getCurrentUsageWindowUsage({ usageWindows, limit, now }),
+		}))
+		.sort((left, right) => left.headroom - right.headroom);
+
+	const tightest = measured[0];
+	if (!tightest || tightest.headroom > 0) return undefined;
+
+	const block = usageWindowLimitToWebhookBlock({
+		limit: tightest.limit,
+		usage: tightest.limit.limit - tightest.headroom,
+	});
+	if (!block) return undefined;
+
+	return {
+		block,
+		filter: tightest.limit.filter_properties
+			? { properties: tightest.limit.filter_properties }
+			: undefined,
+	};
+};

server/src/internal/balances/trackWebhooks/limitReached/types/blockingUsageLimit.ts

@@ -0,0 +1,6 @@
+import type { UsageLimitFilter, UsageLimitWebhookBlock } from "@autumn/shared";
+
+export type BlockingUsageLimit = {
+	block: UsageLimitWebhookBlock;
+	filter: UsageLimitFilter | undefined;
+};