devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-15fpa5tx.js

@@ -0,0 +1,232 @@
+import {
+  DEVFLARE_KV_NAMESPACE_TITLE,
+  getEffectiveAccountId,
+  getOrCreateNamedKVNamespace,
+  getPrimaryAccount
+} from "./index-1d4jg11n.js";
+import {
+  isAuthenticated,
+  kvGet,
+  kvPut
+} from "./index-mg8vwqxf.js";
+
+// src/cloudflare/usage.ts
+var USAGE_KEY_PREFIX = "usage:";
+var LIMITS_KEY = "limits";
+var DEFAULT_LIMITS = {
+  aiTokensPerDay: 1e4,
+  aiRequestsPerDay: 100,
+  vectorizeOpsPerDay: 1000,
+  enabled: true
+};
+async function getOrCreateUsageNamespace(accountId) {
+  return getOrCreateNamedKVNamespace(accountId, DEVFLARE_KV_NAMESPACE_TITLE);
+}
+function getTodayDate() {
+  return new Date().toISOString().split("T")[0];
+}
+function buildUsageKey(service, date) {
+  return `${USAGE_KEY_PREFIX}${service}:${date}`;
+}
+async function getUsage(accountId, service, date) {
+  const targetDate = date ?? getTodayDate();
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const key = buildUsageKey(service, targetDate);
+  const value = await kvGet(accountId, namespaceId, key);
+  if (value === null) {
+    return null;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+var MAX_RECORD_USAGE_ATTEMPTS = 5;
+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 ?? (() => 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) {
+      const backoffMs = Math.min(25 * 2 ** attempt, 400);
+      await sleep(backoffMs);
+    }
+  }
+  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()
+  };
+}
+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: new Date().toISOString()
+  };
+  await kvPut(accountId, namespaceId, key, JSON.stringify(record));
+}
+async function getLimits(accountId) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const value = await kvGet(accountId, namespaceId, LIMITS_KEY);
+  if (value === null) {
+    return DEFAULT_LIMITS;
+  }
+  try {
+    return { ...DEFAULT_LIMITS, ...JSON.parse(value) };
+  } catch {
+    return DEFAULT_LIMITS;
+  }
+}
+async function setLimits(accountId, limits) {
+  const namespaceId = await getOrCreateUsageNamespace(accountId);
+  const current = await getLimits(accountId);
+  const updated = {
+    ...current,
+    ...limits
+  };
+  await kvPut(accountId, namespaceId, LIMITS_KEY, JSON.stringify(updated));
+  return updated;
+}
+async function setLimitsEnabled(accountId, enabled) {
+  return setLimits(accountId, { enabled });
+}
+async function isWithinLimits(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return true;
+  }
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.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;
+  }
+}
+async function getUsageSummary(accountId, service) {
+  const limits = await getLimits(accountId);
+  const usage = await getUsage(accountId, service);
+  const currentCount = usage?.count ?? 0;
+  let limit;
+  switch (service) {
+    case "ai":
+      limit = limits.aiRequestsPerDay;
+      break;
+    case "vectorize":
+      limit = limits.vectorizeOpsPerDay;
+      break;
+  }
+  const withinLimit = limit === undefined || currentCount < limit;
+  const percentUsed = limit ? currentCount / limit * 100 : undefined;
+  return {
+    service,
+    today: currentCount,
+    limit,
+    withinLimit,
+    percentUsed
+  };
+}
+async function getAllUsageSummaries(accountId) {
+  const trackedServices = ["ai", "vectorize"];
+  return Promise.all(trackedServices.map((s) => getUsageSummary(accountId, s)));
+}
+async function canProceedWithTest(accountId, service) {
+  const limits = await getLimits(accountId);
+  if (!limits.enabled) {
+    return { allowed: true };
+  }
+  const withinLimits = await isWithinLimits(accountId, service);
+  if (!withinLimits) {
+    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 };
+}
+async function recordTestUsage(accountId, service, count = 1) {
+  await recordUsage(accountId, service, count);
+}
+async function shouldSkip(service) {
+  try {
+    const isAuth = await isAuthenticated();
+    if (!isAuth) {
+      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;
+  }
+}
+
+export { getUsage, recordUsage, resetUsage, getLimits, setLimits, setLimitsEnabled, isWithinLimits, getUsageSummary, getAllUsageSummaries, canProceedWithTest, recordTestUsage, shouldSkip };