devflare 1.0.0-next.7 → 1.0.0-next.71

package/dist/_chunks/usage-rRusKejc.js

@@ -0,0 +1,272 @@
+import { d as kvGet, f as kvPut, g as isAuthenticated } from "./api-BKClUlUf.js";
+import { c as getOrCreateNamedKVNamespace, d as getPrimaryAccount, n as getEffectiveAccountId, s as DEVFLARE_KV_NAMESPACE_TITLE } from "./preferences-CbYERA_m.js";
+//#region src/cloudflare/usage.ts
+const USAGE_KEY_PREFIX = "usage:";
+const LIMITS_KEY = "limits";
+const DEFAULT_LIMITS = {
+	aiTokensPerDay: 1e4,
+	aiRequestsPerDay: 100,
+	vectorizeOpsPerDay: 1e3,
+	enabled: true
+};
+/**
+* Find or create the devflare-managed KV namespace
+*/
+async function getOrCreateUsageNamespace(accountId) {
+	return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+/**
+* Get today's date in ISO format (YYYY-MM-DD)
+*/
+function getTodayDate() {
+	return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+}
+/**
+* Build the usage key for a service and date
+*/
+function buildUsageKey(service, date) {
+	return `${USAGE_KEY_PREFIX}${service}:${date}`;
+}
+/**
+* Get usage for a specific service on a specific date
+*/
+async function getUsage(accountId, service, date) {
+	const targetDate = date ?? getTodayDate();
+	const value = await kvGet(accountId, await getOrCreateUsageNamespace(accountId), buildUsageKey(service, targetDate));
+	if (value === null) return null;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return null;
+	}
+}
+const MAX_RECORD_USAGE_ATTEMPTS = 5;
+/**
+* Record usage for a service.
+*
+* Usage counts are recorded via an optimistic read-modify-write loop against
+* a Devflare-managed KV namespace. After each write the value is re-read and
+* compared against the update we just issued; if another writer clobbered it
+* we back off and retry, capped at {@link MAX_RECORD_USAGE_ATTEMPTS} attempts.
+*
+* Because Cloudflare KV is eventually consistent and lacks conditional writes,
+* the counters are inherently best-effort — under heavy concurrency some
+* increments can still be lost. When the retry budget is exhausted we emit a
+* warning instead of silently dropping the update.
+*/
+async function recordUsage(accountId, service, count = 1, deps = {}) {
+	const kvGetFn = deps.kvGet ?? kvGet;
+	const kvPutFn = deps.kvPut ?? kvPut;
+	const getNamespaceId = deps.getNamespaceId ?? getOrCreateUsageNamespace;
+	const sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+	const maxAttempts = deps.maxAttempts ?? MAX_RECORD_USAGE_ATTEMPTS;
+	const warn = deps.warn ?? ((message) => console.warn(message));
+	const today = now().toISOString().split("T")[0];
+	const namespaceId = await getNamespaceId(accountId);
+	const key = buildUsageKey(service, today);
+	let lastWritten = null;
+	let lastObserved = null;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) {
+		const existingRaw = await kvGetFn(accountId, namespaceId, key);
+		let existing = null;
+		if (existingRaw !== null) try {
+			existing = JSON.parse(existingRaw);
+		} catch {
+			existing = null;
+		}
+		lastObserved = existing;
+		const record = {
+			service,
+			date: today,
+			count: (existing?.count ?? 0) + count,
+			updatedAt: now().toISOString()
+		};
+		await kvPutFn(accountId, namespaceId, key, JSON.stringify(record));
+		lastWritten = record;
+		const verifyRaw = await kvGetFn(accountId, namespaceId, key);
+		if (verifyRaw !== null) try {
+			const verify = JSON.parse(verifyRaw);
+			if (verify.updatedAt === record.updatedAt && verify.count === record.count) return record;
+		} catch {}
+		if (attempt < maxAttempts - 1) await sleep(Math.min(25 * 2 ** attempt, 400));
+	}
+	warn(`[devflare] recordUsage: could not confirm usage write for ${service} after ${maxAttempts} attempts due to concurrent writes; usage counts are best-effort under concurrency.`);
+	return lastWritten ?? {
+		service,
+		date: today,
+		count: (lastObserved?.count ?? 0) + count,
+		updatedAt: now().toISOString()
+	};
+}
+/**
+* Reset usage for a service (typically called when limits are adjusted)
+*/
+async function resetUsage(accountId, service) {
+	const today = getTodayDate();
+	const namespaceId = await getOrCreateUsageNamespace(accountId);
+	const key = buildUsageKey(service, today);
+	const record = {
+		service,
+		date: today,
+		count: 0,
+		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+}
+/**
+* Get the current usage limits
+*/
+async function getLimits(accountId) {
+	const value = await kvGet(accountId, await getOrCreateUsageNamespace(accountId), LIMITS_KEY);
+	if (value === null) return DEFAULT_LIMITS;
+	try {
+		return {
+			...DEFAULT_LIMITS,
+			...JSON.parse(value)
+		};
+	} catch {
+		return DEFAULT_LIMITS;
+	}
+}
+/**
+* Update usage limits
+*/
+async function setLimits(accountId, limits) {
+	const namespaceId = await getOrCreateUsageNamespace(accountId);
+	const updated = {
+		...await getLimits(accountId),
+		...limits
+	};
+	await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
+	return updated;
+}
+/**
+* Enable or disable limits enforcement
+*/
+async function setLimitsEnabled(accountId, enabled) {
+	return setLimits(accountId, { enabled });
+}
+/**
+* Check if usage is within limits for a service
+*/
+async function isWithinLimits(accountId, service) {
+	const limits = await getLimits(accountId);
+	if (!limits.enabled) return true;
+	const currentCount = (await getUsage(accountId, service))?.count ?? 0;
+	switch (service) {
+		case "ai":
+			if (limits.aiRequestsPerDay && currentCount >= limits.aiRequestsPerDay) return false;
+			return true;
+		case "vectorize":
+			if (limits.vectorizeOpsPerDay && currentCount >= limits.vectorizeOpsPerDay) return false;
+			return true;
+		default: return true;
+	}
+}
+/**
+* Get usage summary for a service
+*/
+async function getUsageSummary(accountId, service) {
+	const limits = await getLimits(accountId);
+	const currentCount = (await getUsage(accountId, service))?.count ?? 0;
+	let limit;
+	switch (service) {
+		case "ai":
+			limit = limits.aiRequestsPerDay;
+			break;
+		case "vectorize":
+			limit = limits.vectorizeOpsPerDay;
+			break;
+	}
+	const withinLimit = limit === void 0 || currentCount < limit;
+	const percentUsed = limit ? currentCount / limit * 100 : void 0;
+	return {
+		service,
+		today: currentCount,
+		limit,
+		withinLimit,
+		percentUsed
+	};
+}
+/**
+* Get usage summary for all tracked services
+*/
+async function getAllUsageSummaries(accountId) {
+	return Promise.all(["ai", "vectorize"].map((s) => getUsageSummary(accountId, s)));
+}
+/**
+* Check if we can proceed with testing for a specific service
+* Returns true if within limits, false if limits exceeded
+*
+* Use this before running tests that use remote bindings
+*/
+async function canProceedWithTest(accountId, service) {
+	if (!(await getLimits(accountId)).enabled) return { allowed: true };
+	if (!await isWithinLimits(accountId, service)) {
+		const summary = await getUsageSummary(accountId, service);
+		return {
+			allowed: false,
+			reason: `Daily limit exceeded for ${service}: ${summary.today}/${summary.limit} (${summary.percentUsed?.toFixed(1)}%)`
+		};
+	}
+	return { allowed: true };
+}
+/**
+* Record that a test used a remote service
+* Call this after successful test execution
+*/
+async function recordTestUsage(accountId, service, count = 1) {
+	await recordUsage(accountId, service, count);
+}
+/**
+* Check if tests for a service should be skipped
+*
+* Returns `true` if tests should be SKIPPED (service not available)
+* Returns `false` if tests can proceed
+*
+* Automatically logs the skip reason to console.
+*
+* NOTE: This function is read-only and catches all errors gracefully.
+* If Cloudflare is unreachable, auth fails, or limits can't be checked,
+* it will return true (skip) with an appropriate message.
+*
+* Usage:
+* ```ts
+* import { account } from 'devflare/cloudflare'
+*
+* const skipAI = await account.shouldSkip('ai')
+*
+* describe.skipIf(skipAI)('AI tests', () => {
+*   // ...
+* })
+* ```
+*/
+async function shouldSkip(service) {
+	try {
+		if (!await isAuthenticated()) {
+			console.log(`⏭️  ${service.toUpperCase()} tests skipped: Not authenticated. Run: bunx wrangler login`);
+			return true;
+		}
+		const primary = await getPrimaryAccount();
+		if (!primary) {
+			console.log(`⏭️  ${service.toUpperCase()} tests skipped: No Cloudflare account found`);
+			return true;
+		}
+		const { accountId } = await getEffectiveAccountId(primary.id);
+		try {
+			const { allowed, reason } = await canProceedWithTest(accountId, service);
+			if (!allowed) {
+				console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${reason}`);
+				return true;
+			}
+		} catch {}
+		return false;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		console.log(`⏭️  ${service.toUpperCase()} tests skipped: ${message}`);
+		return true;
+	}
+}
+//#endregion
+export { getUsageSummary as a, recordUsage as c, setLimitsEnabled as d, shouldSkip as f, getUsage as i, resetUsage as l, getAllUsageSummaries as n, isWithinLimits as o, getLimits as r, recordTestUsage as s, canProceedWithTest as t, setLimits as u };