@aigne/afs-cloudflare-cost 1.11.0-beta.12

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/adapter.cjs

@@ -0,0 +1,668 @@
+const require_pricing = require('./pricing.cjs');
+
+//#region src/adapter.ts
+const GRAPHQL_ENDPOINT = "https://api.cloudflare.com/client/v4/graphql";
+function buildWorkersQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      workersInvocationsAdaptive(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime scriptName }
+        sum { requests errors subrequests cpuTimeUs }
+      }
+    }
+  }
+}`;
+}
+function buildPagesFunctionsQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      pagesFunctionsInvocationsAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime scriptName }
+        sum { requests errors }
+      }
+    }
+  }
+}`;
+}
+function buildR2StorageQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      r2StorageAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime }
+        max { payloadSize }
+      }
+    }
+  }
+}`;
+}
+function buildR2OpsQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      r2OperationsAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime actionType }
+        sum { requests }
+      }
+    }
+  }
+}`;
+}
+function buildD1AnalyticsQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      d1AnalyticsAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime }
+        sum { readQueries writeQueries }
+      }
+    }
+  }
+}`;
+}
+function buildD1StorageQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      d1StorageAdaptiveGroups(
+        filter: {date_geq: "${startDate}", date_leq: "${endDate}"}
+        limit: 10000
+      ) {
+        dimensions { date }
+        max { databaseSizeBytes }
+      }
+    }
+  }
+}`;
+}
+function buildKVOpsQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      kvOperationsAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime actionType }
+        sum { requests }
+      }
+    }
+  }
+}`;
+}
+function buildKVStorageQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      kvStorageAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime }
+        max { byteCount }
+      }
+    }
+  }
+}`;
+}
+function buildDOInvocationsQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      durableObjectsInvocationsAdaptiveGroups(
+        filter: {datetime_geq: "${startDate}T00:00:00Z", datetime_leq: "${endDate}T23:59:59Z"}
+        limit: 10000
+      ) {
+        dimensions { datetime }
+        sum { requests wallTime }
+      }
+    }
+  }
+}`;
+}
+function buildDOStorageQuery(accountTag, startDate, endDate) {
+	return `{
+  viewer {
+    accounts(filter: {accountTag: "${accountTag}"}) {
+      durableObjectsStorageGroups(
+        filter: {date_geq: "${startDate}", date_leq: "${endDate}"}
+        limit: 10000
+      ) {
+        dimensions { date }
+        max { storedBytes }
+      }
+    }
+  }
+}`;
+}
+/** Extract date (YYYY-MM-DD) from a datetime string that may be ISO 8601 or just a date */
+function extractDate(datetime) {
+	return datetime ? datetime.slice(0, 10) : "";
+}
+/** Helper to traverse viewer.accounts[0].{datasetName} */
+function getDatasetItems(data, datasetName) {
+	const accounts = data.viewer?.accounts ?? [];
+	for (const account of accounts) {
+		const items = account[datasetName];
+		if (items) return items;
+	}
+	return [];
+}
+function extractWorkersUsage(data) {
+	const entries = [];
+	for (const item of getDatasetItems(data, "workersInvocationsAdaptive")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		const scriptName = dims?.scriptName ?? "workers";
+		entries.push({
+			date,
+			service: `workers:${scriptName}`,
+			usage: {
+				value: sum?.requests ?? 0,
+				unit: "requests"
+			},
+			metrics: {
+				requests: sum?.requests ?? 0,
+				cpuTimeUs: sum?.cpuTimeUs ?? 0
+			}
+		});
+	}
+	return entries;
+}
+function extractPagesFunctionsUsage(data) {
+	const entries = [];
+	for (const item of getDatasetItems(data, "pagesFunctionsInvocationsAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		const scriptName = dims?.scriptName ?? "pages";
+		entries.push({
+			date,
+			service: `workers:${scriptName}`,
+			usage: {
+				value: sum?.requests ?? 0,
+				unit: "requests"
+			},
+			metrics: {
+				requests: sum?.requests ?? 0,
+				cpuTimeUs: 0
+			}
+		});
+	}
+	return entries;
+}
+function extractR2StorageUsage(data) {
+	const entries = [];
+	for (const item of getDatasetItems(data, "r2StorageAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const max = item.max;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		const bytes = max?.payloadSize ?? 0;
+		entries.push({
+			date,
+			service: "r2",
+			usage: {
+				value: bytes,
+				unit: "bytes"
+			},
+			metrics: { storageBytes: bytes }
+		});
+	}
+	return entries;
+}
+const R2_CLASS_A_ACTIONS = new Set([
+	"PutObject",
+	"CopyObject",
+	"CreateMultipartUpload",
+	"CompleteMultipartUpload",
+	"UploadPart",
+	"ListParts",
+	"CreateBucket",
+	"ListMultipartUploads",
+	"UploadPartCopy",
+	"AbortMultipartUpload",
+	"DeleteObject",
+	"DeleteBucket"
+]);
+function extractR2OpsUsage(data) {
+	let classAOps = 0;
+	let classBOps = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "r2OperationsAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		const reqs = sum?.requests ?? 0;
+		if (R2_CLASS_A_ACTIONS.has(dims?.actionType ?? "")) classAOps += reqs;
+		else classBOps += reqs;
+	}
+	if (classAOps === 0 && classBOps === 0) return [];
+	return [{
+		date: latestDate,
+		service: "r2",
+		usage: {
+			value: classAOps + classBOps,
+			unit: "operations"
+		},
+		metrics: {
+			classAOps,
+			classBOps
+		}
+	}];
+}
+function extractD1AnalyticsUsage(data) {
+	const entries = [];
+	for (const item of getDatasetItems(data, "d1AnalyticsAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		const reads = sum?.readQueries ?? 0;
+		const writes = sum?.writeQueries ?? 0;
+		entries.push({
+			date,
+			service: "d1",
+			usage: {
+				value: reads + writes,
+				unit: "rows"
+			},
+			metrics: {
+				rowsRead: reads,
+				rowsWritten: writes
+			}
+		});
+	}
+	return entries;
+}
+function extractD1StorageUsage(data) {
+	let maxBytes = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "d1StorageAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const max = item.max;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		const bytes = max?.databaseSizeBytes ?? 0;
+		if (bytes > maxBytes) maxBytes = bytes;
+	}
+	if (maxBytes === 0 && !latestDate) return [];
+	return [{
+		date: latestDate,
+		service: "d1",
+		usage: {
+			value: maxBytes,
+			unit: "storage-bytes"
+		},
+		metrics: { storageBytes: maxBytes }
+	}];
+}
+function extractKVOpsUsage(data) {
+	let reads = 0;
+	let writes = 0;
+	let deletes = 0;
+	let lists = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "kvOperationsAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		const reqs = sum?.requests ?? 0;
+		const action = dims?.actionType ?? "read";
+		if (action === "write") writes += reqs;
+		else if (action === "delete") deletes += reqs;
+		else if (action === "list") lists += reqs;
+		else reads += reqs;
+	}
+	const total = reads + writes + deletes + lists;
+	if (total === 0) return [];
+	return [{
+		date: latestDate,
+		service: "kv",
+		usage: {
+			value: total,
+			unit: "operations"
+		},
+		metrics: {
+			reads,
+			writes,
+			deletes,
+			lists
+		}
+	}];
+}
+function extractKVStorageUsage(data) {
+	let maxBytes = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "kvStorageAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const max = item.max;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		const bytes = max?.byteCount ?? 0;
+		if (bytes > maxBytes) maxBytes = bytes;
+	}
+	if (maxBytes === 0 && !latestDate) return [];
+	return [{
+		date: latestDate,
+		service: "kv",
+		usage: {
+			value: maxBytes,
+			unit: "storage-bytes"
+		},
+		metrics: { storageBytes: maxBytes }
+	}];
+}
+function extractDOInvocationsUsage(data) {
+	let totalRequests = 0;
+	let totalWallTime = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "durableObjectsInvocationsAdaptiveGroups")) {
+		const dims = item.dimensions;
+		const sum = item.sum;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		totalRequests += sum?.requests ?? 0;
+		totalWallTime += sum?.wallTime ?? 0;
+	}
+	if (totalRequests === 0 && totalWallTime === 0) return [];
+	return [{
+		date: latestDate,
+		service: "durable-objects",
+		usage: {
+			value: totalRequests,
+			unit: "requests"
+		},
+		metrics: {
+			requests: totalRequests,
+			wallTimeUs: totalWallTime
+		}
+	}];
+}
+function extractDOStorageUsage(data) {
+	let maxBytes = 0;
+	let latestDate = "";
+	for (const item of getDatasetItems(data, "durableObjectsStorageGroups")) {
+		const dims = item.dimensions;
+		const max = item.max;
+		const date = extractDate(dims?.datetime ?? dims?.date ?? "");
+		if (date > latestDate) latestDate = date;
+		const bytes = max?.storedBytes ?? 0;
+		if (bytes > maxBytes) maxBytes = bytes;
+	}
+	if (maxBytes === 0 && !latestDate) return [];
+	return [{
+		date: latestDate,
+		service: "durable-objects",
+		usage: {
+			value: maxBytes,
+			unit: "storage-bytes"
+		},
+		metrics: { storageBytes: maxBytes }
+	}];
+}
+function getProductQueries(accountTag, startDate, endDate) {
+	return [
+		{
+			product: "workers",
+			query: buildWorkersQuery(accountTag, startDate, endDate),
+			extractUsage: extractWorkersUsage
+		},
+		{
+			product: "pages",
+			query: buildPagesFunctionsQuery(accountTag, startDate, endDate),
+			extractUsage: extractPagesFunctionsUsage
+		},
+		{
+			product: "r2-storage",
+			query: buildR2StorageQuery(accountTag, startDate, endDate),
+			extractUsage: extractR2StorageUsage
+		},
+		{
+			product: "r2-ops",
+			query: buildR2OpsQuery(accountTag, startDate, endDate),
+			extractUsage: extractR2OpsUsage
+		},
+		{
+			product: "d1-analytics",
+			query: buildD1AnalyticsQuery(accountTag, startDate, endDate),
+			extractUsage: extractD1AnalyticsUsage
+		},
+		{
+			product: "d1-storage",
+			query: buildD1StorageQuery(accountTag, startDate, endDate),
+			extractUsage: extractD1StorageUsage
+		},
+		{
+			product: "kv-ops",
+			query: buildKVOpsQuery(accountTag, startDate, endDate),
+			extractUsage: extractKVOpsUsage
+		},
+		{
+			product: "kv-storage",
+			query: buildKVStorageQuery(accountTag, startDate, endDate),
+			extractUsage: extractKVStorageUsage
+		},
+		{
+			product: "do-invocations",
+			query: buildDOInvocationsQuery(accountTag, startDate, endDate),
+			extractUsage: extractDOInvocationsUsage
+		},
+		{
+			product: "do-storage",
+			query: buildDOStorageQuery(accountTag, startDate, endDate),
+			extractUsage: extractDOStorageUsage
+		}
+	];
+}
+function aggregateMetrics(entries) {
+	const m = {
+		workers: {
+			requests: 0,
+			cpuTimeUs: 0
+		},
+		r2: {
+			storageBytes: 0,
+			classAOps: 0,
+			classBOps: 0
+		},
+		d1: {
+			rowsRead: 0,
+			rowsWritten: 0,
+			storageBytes: 0
+		},
+		kv: {
+			reads: 0,
+			writes: 0,
+			deletes: 0,
+			lists: 0,
+			storageBytes: 0
+		},
+		do: {
+			requests: 0,
+			wallTimeUs: 0,
+			storageBytes: 0
+		}
+	};
+	for (const e of entries) if (e.service.startsWith("workers:")) {
+		m.workers.requests += e.metrics.requests ?? 0;
+		m.workers.cpuTimeUs += e.metrics.cpuTimeUs ?? 0;
+	} else if (e.service === "r2") {
+		if (e.metrics.storageBytes !== void 0) m.r2.storageBytes = Math.max(m.r2.storageBytes, e.metrics.storageBytes);
+		m.r2.classAOps += e.metrics.classAOps ?? 0;
+		m.r2.classBOps += e.metrics.classBOps ?? 0;
+	} else if (e.service === "d1") {
+		m.d1.rowsRead += e.metrics.rowsRead ?? 0;
+		m.d1.rowsWritten += e.metrics.rowsWritten ?? 0;
+		if (e.metrics.storageBytes !== void 0) m.d1.storageBytes = Math.max(m.d1.storageBytes, e.metrics.storageBytes);
+	} else if (e.service === "kv") {
+		m.kv.reads += e.metrics.reads ?? 0;
+		m.kv.writes += e.metrics.writes ?? 0;
+		m.kv.deletes += e.metrics.deletes ?? 0;
+		m.kv.lists += e.metrics.lists ?? 0;
+		if (e.metrics.storageBytes !== void 0) m.kv.storageBytes = Math.max(m.kv.storageBytes, e.metrics.storageBytes);
+	} else if (e.service === "durable-objects") {
+		m.do.requests += e.metrics.requests ?? 0;
+		m.do.wallTimeUs += e.metrics.wallTimeUs ?? 0;
+		if (e.metrics.storageBytes !== void 0) m.do.storageBytes = Math.max(m.do.storageBytes, e.metrics.storageBytes);
+	}
+	return m;
+}
+function estimateTotalCost(metrics) {
+	return {
+		workers: require_pricing.estimateWorkersCost(metrics.workers.requests, metrics.workers.cpuTimeUs),
+		r2: require_pricing.estimateR2Cost(metrics.r2.storageBytes, metrics.r2.classAOps, metrics.r2.classBOps),
+		d1: require_pricing.estimateD1Cost(metrics.d1.rowsRead, metrics.d1.rowsWritten, metrics.d1.storageBytes),
+		kv: require_pricing.estimateKVCost(metrics.kv.reads, metrics.kv.writes, metrics.kv.deletes, metrics.kv.lists, metrics.kv.storageBytes),
+		"durable-objects": require_pricing.estimateDOCost(metrics.do.requests, metrics.do.wallTimeUs, metrics.do.storageBytes)
+	};
+}
+/** Map a service name to its product cost key */
+function serviceToProduct(service) {
+	if (service.startsWith("workers:")) return "workers";
+	return service;
+}
+/**
+* Distribute monthly product costs proportionally across daily usage entries.
+* Each entry gets: monthlyCost × (entryUsage / totalUsage) for its product.
+*/
+function distributeEstimates(entries, productCosts) {
+	const estimates = /* @__PURE__ */ new Map();
+	const productTotals = /* @__PURE__ */ new Map();
+	for (const e of entries) {
+		const product = serviceToProduct(e.service);
+		productTotals.set(product, (productTotals.get(product) ?? 0) + e.usage.value);
+	}
+	for (const e of entries) {
+		const product = serviceToProduct(e.service);
+		const monthlyCost = productCosts[product] ?? 0;
+		const totalUsage = productTotals.get(product) ?? 0;
+		if (monthlyCost === 0 || totalUsage === 0) estimates.set(e, 0);
+		else {
+			const share = Math.round(monthlyCost * (e.usage.value / totalUsage) * 100) / 100;
+			estimates.set(e, share);
+		}
+	}
+	return estimates;
+}
+var CloudflareCostAdapter = class {
+	cloud = "cloudflare";
+	config;
+	client;
+	cachedServices = null;
+	constructor(config = {}, client) {
+		this.config = config;
+		this.client = client;
+	}
+	async isAvailable() {
+		if (!this.config.apiToken || !this.config.accountId) return false;
+		try {
+			const client = this.getClient();
+			if (!client) return false;
+			const response = await client.post(GRAPHQL_ENDPOINT, {
+				headers: this.buildHeaders(),
+				body: JSON.stringify({ query: "{ viewer { accounts { accountTag } } }" })
+			});
+			return response.status === 200 && !response.data.errors;
+		} catch {
+			return false;
+		}
+	}
+	async fetchCosts(options) {
+		const client = this.getClient();
+		if (!client) throw new Error("Cloudflare HTTP client not available");
+		const accountId = this.config.accountId;
+		if (!accountId) throw new Error("Missing accountId in Cloudflare config");
+		const productQueries = getProductQueries(accountId, options.startDate, options.endDate);
+		const allEntries = [];
+		const headers = this.buildHeaders();
+		for (const pq of productQueries) try {
+			const response = await client.post(GRAPHQL_ENDPOINT, {
+				headers,
+				body: JSON.stringify({ query: pq.query })
+			});
+			if (response.status === 429) throw new Error("Cloudflare API rate limit exceeded");
+			if (response.data.errors && response.data.errors.length > 0) continue;
+			const data = response.data.data;
+			if (!data) continue;
+			const usageEntries = pq.extractUsage(data);
+			allEntries.push(...usageEntries);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("rate limit")) throw error;
+		}
+		const estimates = distributeEstimates(allEntries, estimateTotalCost(aggregateMetrics(allEntries)));
+		const records = [];
+		for (const entry of allEntries) {
+			if (entry.usage.unit === "storage-bytes") continue;
+			const amount = estimates.get(entry) ?? 0;
+			records.push({
+				cloud: "cloudflare",
+				service: entry.service,
+				date: entry.date,
+				amount: Math.round(amount * 100) / 100,
+				currency: "USD",
+				usage: entry.usage,
+				isEstimate: true
+			});
+		}
+		this.cachedServices = [...new Set(records.map((r) => r.service))];
+		return records;
+	}
+	async listServices() {
+		if (this.cachedServices) return this.cachedServices;
+		return [];
+	}
+	capabilities() {
+		return {
+			supportsAmount: true,
+			supportsUsage: true,
+			supportsTags: false,
+			supportsRegion: false,
+			supportsAccount: false,
+			supportsForecast: false
+		};
+	}
+	getClient() {
+		if (this.client) return this.client;
+		this.client = { async post(url, options) {
+			const resp = await fetch(url, {
+				method: "POST",
+				headers: options.headers,
+				body: options.body
+			});
+			const data = await resp.json();
+			return {
+				status: resp.status,
+				data
+			};
+		} };
+		return this.client;
+	}
+	buildHeaders() {
+		return {
+			Authorization: `Bearer ${this.config.apiToken}`,
+			"Content-Type": "application/json"
+		};
+	}
+};
+
+//#endregion
+exports.CloudflareCostAdapter = CloudflareCostAdapter;