perf(web): cut Cap Infra billing reads on the console, usage API, ledger and storage cron

apps/web/__tests__/unit/developer-api-contract.test.ts

@@ -115,6 +115,7 @@ import {
 	INFRA_RESOLUTION_TIERS,
 	INFRA_STORAGE_DOLLARS_PER_1000_MINUTES_PER_MONTH,
 } from "@/lib/infra-pricing";
+import { getAppStorage } from "@/lib/infra-storage";
 
 type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS";
 
@@ -157,6 +158,11 @@ const rateLimit = (response: Response) => ({
 	retryAfter: response.headers.get("Retry-After"),
 });
 
+const billingOf = async (billing: Record<string, unknown>) => ({
+	...billing,
+	stored: (await getAppStorage("app-1")).stored,
+});
+
 beforeEach(() => {
 	vi.clearAllMocks();
 	mocks.keyRows = [{ appId: "app-1", environment: "development" }];
@@ -183,7 +189,9 @@ beforeEach(() => {
 		},
 	];
 	mocks.selected = [];
-	mocks.billing.mockResolvedValue({ standing: { state: "active" } });
+	mocks.billing.mockImplementation(() =>
+		billingOf({ standing: { state: "active" } }),
+	);
 	mocks.createVideo.mockResolvedValue({
 		status: 200,
 		body: { videoId: "video-1" },
@@ -898,7 +906,9 @@ describe("usage", () => {
 	});
 
 	it("returns the fields the OpenAPI description requires", async () => {
-		mocks.billing.mockResolvedValue({ standing: {}, upload: {}, storage: {} });
+		mocks.billing.mockImplementation(() =>
+			billingOf({ standing: {}, upload: {}, storage: {} }),
+		);
 		const schema = developerOpenApiSpec(ORIGIN).components.schemas.Usage;
 
 		const data = await usage();

apps/web/__tests__/unit/developer-cron-storage.test.ts

@@ -2,49 +2,96 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 const mocks = vi.hoisted(() => ({
 	selects: [] as Record<string, unknown>[][],
+	page: [] as Record<string, unknown>[],
+	accountsTable: { id: "id", appId: "appId" },
+	appsTable: { id: "id", deletedAt: "deletedAt" },
+	ledgerTable: {
+		accountId: "accountId",
+		referenceId: "referenceId",
+		referenceType: "referenceType",
+	},
+	snapshotsTable: { appId: "appId", snapshotDate: "snapshotDate" },
+	yesterdayBilled: null as Record<string, unknown>[] | null,
+	markers: [] as unknown[],
 	getStorageUsageByApp: vi.fn(),
 	chargeStorageDay: vi.fn(),
-	latestStorageCharge: vi.fn(),
+	latestStorageCharges: vi.fn(),
 	runDueAutoTopUps: vi.fn(),
 	sendInfraOutOfCreditEmail: vi.fn(),
 }));
 
 vi.mock("@cap/database", () => ({
 	db: () => {
+		let table: unknown;
+		const dateOf = (condition: unknown) => {
+			const match = JSON.stringify(condition).match(
+				/\{"eq":\["referenceId","(\d{4}-\d{2}-\d{2})"\]\}/,
+			);
+			return match?.[1] ?? null;
+		};
+		const read = (condition: unknown) => {
+			if (table === mocks.appsTable) {
+				return mocks.page.map((account) => ({ id: account.appId }));
+			}
+			if (table === mocks.accountsTable) {
+				mocks.page = mocks.selects[0] ?? [];
+				return mocks.page;
+			}
+			if (table === mocks.ledgerTable) {
+				if (dateOf(condition) === new Date().toISOString().slice(0, 10)) {
+					return mocks.selects[1] ?? [];
+				}
+				return (
+					mocks.yesterdayBilled ??
+					mocks.page.map((account) => ({ accountId: account.id }))
+				);
+			}
+			return [];
+		};
 		const chain = {
 			select: () => chain,
-			from: () => chain,
-			innerJoin: () => chain,
-			where: async () => mocks.selects.shift() ?? [],
+			from: (next: unknown) => {
+				table = next;
+				return chain;
+			},
+			where: (condition: unknown) => {
+				const rows = Promise.resolve(read(condition));
+				return Object.assign(rows, {
+					orderBy: () => ({ limit: () => rows }),
+				});
+			},
 		};
 		return chain;
 	},
 }));
 vi.mock("@cap/database/schema", () => ({
-	developerApps: { id: "id", deletedAt: "deletedAt" },
-	developerCreditAccounts: { id: "id", appId: "appId" },
-	developerCreditTransactions: {
-		accountId: "accountId",
-		referenceId: "referenceId",
-		referenceType: "referenceType",
-	},
+	developerApps: mocks.appsTable,
+	developerCreditAccounts: mocks.accountsTable,
+	developerCreditTransactions: mocks.ledgerTable,
+	developerDailyStorageSnapshots: mocks.snapshotsTable,
 }));
 vi.mock("drizzle-orm", () => ({
 	and: (...args: unknown[]) => args,
+	asc: (a: unknown) => ({ asc: a }),
+	gt: (a: unknown, b: unknown) => ({ gt: [a, b] }),
 	eq: (a: unknown, b: unknown) => ({ eq: [a, b] }),
 	inArray: (a: unknown, b: unknown) => ({ inArray: [a, b] }),
 	isNull: (a: unknown) => ({ isNull: a }),
+	isNotNull: (a: unknown) => ({ isNotNull: a }),
 }));
 vi.mock("@/lib/infra-storage", () => ({
 	getStorageUsageByApp: mocks.getStorageUsageByApp,
 }));
 vi.mock("@/lib/infra-storage-billing", () => ({
 	chargeStorageDay: mocks.chargeStorageDay,
+	recordStorageDayVisits: async ({ appIds }: { appIds: string[] }) => {
+		mocks.markers.push(...appIds);
+	},
 }));
 vi.mock("@/lib/infra-standing", () => ({
 	INFRA_GRACE_DAYS: 7,
 	STORAGE_DAY_REFERENCE_TYPE: "storage_day",
-	latestStorageCharge: mocks.latestStorageCharge,
+	latestStorageCharges: mocks.latestStorageCharges,
 }));
 vi.mock("@/lib/infra-auto-top-up", () => ({
 	runDueAutoTopUps: mocks.runDueAutoTopUps,
@@ -90,17 +137,20 @@ const authorized = () => run(`Bearer ${CRON_SECRET}`);
 beforeEach(() => {
 	process.env.CRON_SECRET = CRON_SECRET;
 	mocks.selects = [];
+	mocks.page = [];
+	mocks.yesterdayBilled = null;
+	mocks.markers = [];
 	for (const mock of [
 		mocks.getStorageUsageByApp,
 		mocks.chargeStorageDay,
-		mocks.latestStorageCharge,
+		mocks.latestStorageCharges,
 		mocks.runDueAutoTopUps,
 		mocks.sendInfraOutOfCreditEmail,
 	]) {
 		mock.mockReset();
 	}
 	mocks.runDueAutoTopUps.mockResolvedValue(NO_TOP_UPS);
-	mocks.latestStorageCharge.mockResolvedValue(null);
+	mocks.latestStorageCharges.mockResolvedValue(new Map());
 	mocks.chargeStorageDay.mockResolvedValue(billed());
 });
 
@@ -191,21 +241,59 @@ describe("developer-storage cron job", () => {
 
 		expect(body.appsProcessed).toBe(0);
 		expect(mocks.chargeStorageDay).not.toHaveBeenCalled();
+		expect(mocks.markers).toEqual(["app-1"]);
+	});
+
+	it("looks up the last charge of every idle account in one read", async () => {
+		mocks.selects = [
+			[
+				{ id: "account-1", appId: "app-1" },
+				{ id: "account-2", appId: "app-2" },
+				{ id: "account-3", appId: "app-3" },
+			],
+			[],
+		];
+		mocks.getStorageUsageByApp.mockResolvedValue(
+			new Map([
+				["app-1", usage(0)],
+				["app-2", usage(28)],
+				["app-3", usage(0)],
+			]),
+		);
+
+		const { body } = await authorized();
+
+		expect(body).toMatchObject({ complete: true, appsProcessed: 1 });
+		expect(mocks.latestStorageCharges).toHaveBeenCalledTimes(1);
+		expect(mocks.latestStorageCharges).toHaveBeenCalledWith(expect.anything(), [
+			"account-1",
+			"account-3",
+		]);
 	});
 
 	it("still settles an app that stores nothing now but is short from before", async () => {
 		mocks.selects = [[{ id: "account-1", appId: "app-1" }], []];
 		mocks.getStorageUsageByApp.mockResolvedValue(
 			new Map([["app-1", usage(0)]]),
 		);
-		mocks.latestStorageCharge.mockResolvedValue({
-			createdAt: new Date(),
-			owedMicroCredits: 28,
-			shortSince: new Date(),
-		});
+		mocks.latestStorageCharges.mockResolvedValue(
+			new Map([
+				[
+					"account-1",
+					{
+						createdAt: new Date(),
+						owedMicroCredits: 28,
+						shortSince: new Date(),
+					},
+				],
+			]),
+		);
 
 		await authorized();
 
+		expect(mocks.latestStorageCharges).toHaveBeenCalledWith(expect.anything(), [
+			"account-1",
+		]);
 		expect(mocks.chargeStorageDay).toHaveBeenCalledTimes(1);
 	});
 

apps/web/__tests__/unit/developer-usage-counts.test.ts

@@ -87,6 +87,7 @@ vi.mock("@/lib/infra-standing", async (original) => ({
 
 import { app } from "@/app/api/developer/v1/[...route]/usage";
 import { storageUsage } from "@/lib/developer-pricing";
+import { getAppStorage } from "@/lib/infra-storage";
 
 const usage = async () => {
 	const response = await app.request("/", {
@@ -99,17 +100,18 @@ const usage = async () => {
 beforeEach(() => {
 	mocks.balanceMicroCredits = 2_999_901;
 	mocks.videos = [];
-	mocks.billing.mockResolvedValue({
+	mocks.billing.mockImplementation(async (appId: string) => ({
 		standing: { state: "active", pausesAt: null },
 		usage: storageUsage([]),
+		stored: (await getAppStorage(appId)).stored,
 		admission: {
 			allowed: true,
 			reason: null,
 			requiredMicroCredits: 1,
 			shortfallMicroCredits: 0,
 			message: null,
 		},
-	});
+	}));
 });
 
 describe("GET /usage totals", () => {

apps/web/__tests__/unit/developer-usage-route.test.ts

@@ -33,16 +33,15 @@ vi.mock("@/lib/developer-key-hash", () => ({
 	hashKey: async (key: string) => `hash:${key}`,
 }));
 vi.mock("@/lib/infra-standing", () => ({
-	getInfraBilling: async () => ({}),
+	getInfraBilling: async () => ({
+		stored: { videoCount: 2, totalMinutes: 12.5 },
+	}),
 	infraBillingJson: () => ({
 		standing: { state: "active", pausesAt: null },
 		upload: { allowed: true },
 	}),
 	infraStorageJson: () => ({ dailyMicroCredits: 0 }),
 }));
-vi.mock("@/lib/infra-storage", () => ({
-	getAppStorageUsage: async () => ({ videoCount: 2, totalMinutes: 12.5 }),
-}));
 vi.mock("@/lib/developer-transcript-usage", () => ({
 	getSpeechUsage: mocks.speech,
 }));

apps/web/__tests__/unit/developer-video-upload.test.ts

@@ -99,7 +99,7 @@ vi.mock("@/lib/infra-storage", async () => {
 	const { billableVideo, storageUsage } = await import(
 		"@/lib/developer-pricing"
 	);
-	return {
+	const storage = {
 		getAppStorageUsage: async (
 			appId: string,
 			newVideo?: Parameters<typeof storageUsage>[0][number]["video"],
@@ -129,6 +129,25 @@ vi.mock("@/lib/infra-storage", async () => {
 			return storageUsage(entries);
 		},
 	};
+	return {
+		...storage,
+		getAppStorage: async (
+			...[appId, newVideo, executor, options]: Parameters<
+				typeof storage.getAppStorageUsage
+			>
+		) => ({
+			stored: await storage.getAppStorageUsage(
+				appId,
+				newVideo,
+				executor,
+				options,
+			),
+			counted: await storage.getAppStorageUsage(appId, newVideo, executor, {
+				...options,
+				includeProcessing: true,
+			}),
+		}),
+	};
 });
 
 vi.mock("@/lib/developer-transcript-storage", () => ({