devflare 1.0.0-next.7 → 1.0.0-next.70

package/dist/_chunks/preview-resources-CQIu2-NY.js

@@ -0,0 +1,359 @@
+import { n as materializePreviewScopedConfig, r as materializePreviewScopedString, t as isPreviewScopedName } from "./preview-j9Kbx4-G.js";
+import { l as mergeConfigForEnvironment } from "./loader-BC0skbnH.js";
+import { g as normalizeR2Binding, h as normalizeQueueProducer } from "./schema-normalization-CTdiY17P.js";
+import { d as getPrimaryAccount, n as getEffectiveAccountId } from "./preferences-CbYERA_m.js";
+import { _ as listR2Buckets, a as createVectorizeIndex, c as deleteKVNamespace, d as deleteVectorizeIndex, g as listQueues, h as listKVNamespaces, i as createR2Bucket, l as deleteQueue, m as listHyperdrives, n as createKVNamespace, o as deleteD1Database, p as listD1Databases, r as createQueue, s as deleteHyperdrive, t as createD1Database, u as deleteR2Bucket, v as listVectorizeIndexes } from "./account-resources-BdKj8q1h.js";
+//#region src/config/preview-resources.ts
+const defaultPreviewScopedResourceLifecycleApi = {
+	getPrimaryAccount,
+	getEffectiveAccountId,
+	listKVNamespaces,
+	createKVNamespace,
+	deleteKVNamespace,
+	listD1Databases,
+	createD1Database,
+	deleteD1Database,
+	listR2Buckets,
+	createR2Bucket,
+	deleteR2Bucket,
+	listQueues,
+	createQueue,
+	deleteQueue,
+	listVectorizeIndexes,
+	createVectorizeIndex,
+	deleteVectorizeIndex,
+	listHyperdrives,
+	deleteHyperdrive
+};
+function resolvePreviewScopedResourceLifecycleApi(overrides) {
+	return {
+		...defaultPreviewScopedResourceLifecycleApi,
+		...overrides ?? {}
+	};
+}
+function createEmptyPreviewScopedResourceNames() {
+	return {
+		kv: [],
+		d1: [],
+		r2: [],
+		queues: [],
+		vectorize: [],
+		hyperdrive: [],
+		analyticsEngine: [],
+		browser: []
+	};
+}
+function createEmptyPreviewScopedResourcePlan() {
+	return {
+		kv: [],
+		d1: [],
+		r2: [],
+		queues: [],
+		vectorize: [],
+		hyperdrive: [],
+		analyticsEngine: [],
+		browser: []
+	};
+}
+function createPreviewScopedResourceRef(value, bindingName, options) {
+	if (!isPreviewScopedName(value)) return null;
+	const baseName = materializePreviewScopedString(value, { env: {} });
+	const previewName = materializePreviewScopedString(value, options);
+	if (!baseName || !previewName || baseName === previewName) return null;
+	return {
+		...bindingName ? { bindingName } : {},
+		baseName,
+		previewName
+	};
+}
+function upsertPreviewScopedQueueRef(queueRefs, value, options) {
+	const ref = createPreviewScopedResourceRef(value, void 0, options);
+	if (!ref) return;
+	if (!queueRefs.has(ref.previewName)) queueRefs.set(ref.previewName, ref);
+}
+function applyHyperdriveBindingFallbacks(config, hyperdriveBindingFallbacks) {
+	if (!config.bindings?.hyperdrive || Object.keys(hyperdriveBindingFallbacks).length === 0) return config;
+	return {
+		...config,
+		bindings: {
+			...config.bindings,
+			hyperdrive: Object.fromEntries(Object.entries(config.bindings.hyperdrive).map(([bindingName, bindingConfig]) => {
+				const fallbackName = hyperdriveBindingFallbacks[bindingName];
+				if (!fallbackName) return [bindingName, bindingConfig];
+				return [bindingName, fallbackName];
+			}))
+		}
+	};
+}
+function resolvePreviewScopedResourceLifecycleWarnings(plan) {
+	const warnings = [];
+	if (plan.analyticsEngine.length > 0) warnings.push("Workers Analytics Engine datasets are created automatically on first write, so Devflare does not provision or delete preview-scoped analytics datasets.");
+	if (plan.browser.length > 0) warnings.push("Browser Rendering bindings do not own account-scoped resources, so Devflare does not provision or delete preview-scoped browser bindings.");
+	return warnings;
+}
+function hasPreviewScopedLifecycleResources(plan) {
+	return plan.kv.length > 0 || plan.d1.length > 0 || plan.r2.length > 0 || plan.queues.length > 0 || plan.vectorize.length > 0 || plan.hyperdrive.length > 0;
+}
+async function resolveLifecycleAccountId(config, options, cloudflareApi) {
+	if (options.accountId?.trim()) return options.accountId.trim();
+	if (config.accountId?.trim()) return config.accountId.trim();
+	const primaryAccount = await cloudflareApi.getPrimaryAccount();
+	if (!primaryAccount) throw new Error("Could not resolve a Cloudflare account for preview-scoped resource lifecycle management. Set accountId in devflare.config.ts, pass --account, or authenticate with Wrangler.");
+	return (await cloudflareApi.getEffectiveAccountId(primaryAccount.id)).accountId;
+}
+async function loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi) {
+	const [namespaces, databases, buckets, queues, vectorizeIndexes, hyperdrives] = await Promise.all([
+		plan.kv.length > 0 ? cloudflareApi.listKVNamespaces(accountId) : Promise.resolve([]),
+		plan.d1.length > 0 ? cloudflareApi.listD1Databases(accountId) : Promise.resolve([]),
+		plan.r2.length > 0 ? cloudflareApi.listR2Buckets(accountId) : Promise.resolve([]),
+		plan.queues.length > 0 ? cloudflareApi.listQueues(accountId) : Promise.resolve([]),
+		plan.vectorize.length > 0 ? cloudflareApi.listVectorizeIndexes(accountId) : Promise.resolve([]),
+		plan.hyperdrive.length > 0 ? cloudflareApi.listHyperdrives(accountId) : Promise.resolve([])
+	]);
+	return {
+		namespaces,
+		databases,
+		buckets,
+		queues,
+		vectorizeIndexes,
+		hyperdrives
+	};
+}
+function createPreviewScopedResourceResolutionCloudflareApi(state) {
+	return {
+		listKVNamespaces: async () => state.namespaces,
+		listD1Databases: async () => state.databases,
+		listHyperdrives: async () => state.hyperdrives
+	};
+}
+function findVectorizeIndexByName(indexes, name) {
+	return indexes.find((index) => index.name === name);
+}
+function findKVNamespaceByName(namespaces, name) {
+	return namespaces.find((namespace) => namespace.name === name);
+}
+function findD1DatabaseByName(databases, name) {
+	return databases.find((database) => database.name === name);
+}
+function findR2BucketByName(buckets, name) {
+	return buckets.find((bucket) => bucket.name === name);
+}
+function findQueueByName(queues, name) {
+	return queues.find((queue) => queue.name === name);
+}
+function findHyperdriveByName(hyperdrives, name) {
+	return hyperdrives.find((hyperdrive) => hyperdrive.name === name);
+}
+function collectPreviewScopedResourcePlan(config, options = {}) {
+	const mergedConfig = mergeConfigForEnvironment(config, options.environment);
+	const plan = createEmptyPreviewScopedResourcePlan();
+	const bindings = mergedConfig.bindings;
+	if (!bindings) return plan;
+	if (bindings.kv) plan.kv = Object.entries(bindings.kv).map(([bindingName, bindingConfig]) => {
+		return typeof bindingConfig === "string" ? createPreviewScopedResourceRef(bindingConfig, bindingName, options) : null;
+	}).filter((ref) => ref !== null);
+	if (bindings.d1) plan.d1 = Object.entries(bindings.d1).map(([bindingName, bindingConfig]) => {
+		return typeof bindingConfig === "string" ? createPreviewScopedResourceRef(bindingConfig, bindingName, options) : null;
+	}).filter((ref) => ref !== null);
+	if (bindings.r2) plan.r2 = Object.entries(bindings.r2).map(([bindingName, bindingConfig]) => {
+		return createPreviewScopedResourceRef(normalizeR2Binding(bindingConfig).bucketName, bindingName, options);
+	}).filter((ref) => ref !== null);
+	if (bindings.queues) {
+		const queueRefs = /* @__PURE__ */ new Map();
+		for (const producer of Object.values(bindings.queues.producers ?? {})) upsertPreviewScopedQueueRef(queueRefs, normalizeQueueProducer(producer).queue, options);
+		for (const consumer of bindings.queues.consumers ?? []) {
+			upsertPreviewScopedQueueRef(queueRefs, consumer.queue, options);
+			if (consumer.deadLetterQueue) upsertPreviewScopedQueueRef(queueRefs, consumer.deadLetterQueue, options);
+		}
+		plan.queues = Array.from(queueRefs.values());
+	}
+	if (bindings.vectorize) plan.vectorize = Object.entries(bindings.vectorize).map(([bindingName, bindingConfig]) => {
+		return createPreviewScopedResourceRef(bindingConfig.indexName, bindingName, options);
+	}).filter((ref) => ref !== null);
+	if (bindings.hyperdrive) plan.hyperdrive = Object.entries(bindings.hyperdrive).map(([bindingName, bindingConfig]) => {
+		if (typeof bindingConfig === "string") return createPreviewScopedResourceRef(bindingConfig, bindingName, options);
+		if (bindingConfig && typeof bindingConfig === "object" && "name" in bindingConfig && typeof bindingConfig.name === "string") {
+			if ("previewId" in bindingConfig && typeof bindingConfig.previewId === "string" && bindingConfig.previewId.trim()) return null;
+			const ref = createPreviewScopedResourceRef(bindingConfig.name, bindingName, options);
+			if (ref && bindingConfig.previewFallback === "base") ref.allowBaseFallback = true;
+			return ref;
+		}
+		return null;
+	}).filter((ref) => ref !== null);
+	if (bindings.analyticsEngine) plan.analyticsEngine = Object.entries(bindings.analyticsEngine).map(([bindingName, bindingConfig]) => {
+		return createPreviewScopedResourceRef(bindingConfig.dataset, bindingName, options);
+	}).filter((ref) => ref !== null);
+	if (bindings.browser) plan.browser = Object.entries(bindings.browser).map(([bindingName, bindingConfig]) => {
+		if (typeof bindingConfig !== "string") return null;
+		return createPreviewScopedResourceRef(bindingConfig, bindingName, options);
+	}).filter((ref) => ref !== null);
+	return plan;
+}
+async function preparePreviewScopedResourcesForDeploy(config, options = {}) {
+	const mergedConfig = mergeConfigForEnvironment(config, options.environment);
+	const plan = collectPreviewScopedResourcePlan(config, options);
+	const created = createEmptyPreviewScopedResourceNames();
+	const existing = createEmptyPreviewScopedResourceNames();
+	const warnings = resolvePreviewScopedResourceLifecycleWarnings(plan);
+	if (!hasPreviewScopedLifecycleResources(plan)) return {
+		config: materializePreviewScopedConfig(mergedConfig, options),
+		plan,
+		created,
+		existing,
+		warnings
+	};
+	const cloudflareApi = resolvePreviewScopedResourceLifecycleApi(options.cloudflare);
+	const accountId = await resolveLifecycleAccountId(config, options, cloudflareApi);
+	const { namespaces, databases, buckets, queues, vectorizeIndexes, hyperdrives } = await loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi);
+	for (const ref of plan.kv) {
+		if (findKVNamespaceByName(namespaces, ref.previewName)) {
+			existing.kv.push(ref.previewName);
+			continue;
+		}
+		const namespace = await cloudflareApi.createKVNamespace(accountId, ref.previewName);
+		created.kv.push(ref.previewName);
+		namespaces.push(namespace);
+	}
+	for (const ref of plan.d1) {
+		if (findD1DatabaseByName(databases, ref.previewName)) {
+			existing.d1.push(ref.previewName);
+			continue;
+		}
+		const database = await cloudflareApi.createD1Database(accountId, ref.previewName);
+		created.d1.push(ref.previewName);
+		databases.push(database);
+	}
+	for (const ref of plan.r2) {
+		if (findR2BucketByName(buckets, ref.previewName)) {
+			existing.r2.push(ref.previewName);
+			continue;
+		}
+		const bucket = await cloudflareApi.createR2Bucket(accountId, ref.previewName);
+		created.r2.push(ref.previewName);
+		buckets.push(bucket);
+	}
+	for (const ref of plan.queues) {
+		if (findQueueByName(queues, ref.previewName)) {
+			existing.queues.push(ref.previewName);
+			continue;
+		}
+		const queue = await cloudflareApi.createQueue(accountId, ref.previewName);
+		created.queues.push(ref.previewName);
+		queues.push(queue);
+	}
+	for (const ref of plan.vectorize) {
+		if (findVectorizeIndexByName(vectorizeIndexes, ref.previewName)) {
+			existing.vectorize.push(ref.previewName);
+			continue;
+		}
+		const baseIndex = findVectorizeIndexByName(vectorizeIndexes, ref.baseName);
+		if (!baseIndex) throw new Error(`Could not provision preview Vectorize index "${ref.previewName}" because the base index "${ref.baseName}" was not found.`);
+		const createdIndex = await cloudflareApi.createVectorizeIndex(accountId, {
+			name: ref.previewName,
+			dimensions: baseIndex.dimensions,
+			metric: baseIndex.metric,
+			description: baseIndex.description
+		});
+		created.vectorize.push(ref.previewName);
+		vectorizeIndexes.push(createdIndex);
+	}
+	const hyperdriveBindingFallbacks = {};
+	for (const ref of plan.hyperdrive) {
+		if (findHyperdriveByName(hyperdrives, ref.previewName)) {
+			existing.hyperdrive.push(ref.previewName);
+			continue;
+		}
+		if (!findHyperdriveByName(hyperdrives, ref.baseName)) throw new Error(`Could not resolve preview Hyperdrive "${ref.previewName}" because neither the preview config nor the base config "${ref.baseName}" exists in this account.`);
+		if (!ref.allowBaseFallback) {
+			const bindingLabel = ref.bindingName ? `"${ref.bindingName}"` : `for preview name "${ref.previewName}"`;
+			throw new Error(`Preview Hyperdrive binding ${bindingLabel} has no dedicated preview Hyperdrive configuration "${ref.previewName}" in this account. Either provision a dedicated preview Hyperdrive (or set \`previewId\` on the binding), or opt in to reusing the base Hyperdrive by setting \`previewFallback: 'base'\` on the binding.`);
+		}
+		if (ref.bindingName) hyperdriveBindingFallbacks[ref.bindingName] = ref.baseName;
+		warnings.push(`Preview Hyperdrive "${ref.previewName}" is not auto-provisioned because Cloudflare does not expose stored Hyperdrive credentials for cloning. Devflare will reuse the base Hyperdrive "${ref.baseName}" for binding ${ref.bindingName ?? ref.previewName}.`);
+	}
+	return {
+		accountId,
+		config: materializePreviewScopedConfig(applyHyperdriveBindingFallbacks(mergedConfig, hyperdriveBindingFallbacks), options),
+		resourceResolutionCloudflare: createPreviewScopedResourceResolutionCloudflareApi({
+			namespaces,
+			databases,
+			hyperdrives
+		}),
+		plan,
+		created,
+		existing,
+		warnings
+	};
+}
+async function cleanupPreviewScopedResources(config, options = {}) {
+	const plan = collectPreviewScopedResourcePlan(config, options);
+	const candidates = createEmptyPreviewScopedResourceNames();
+	const deleted = createEmptyPreviewScopedResourceNames();
+	const warnings = resolvePreviewScopedResourceLifecycleWarnings(plan);
+	if (!hasPreviewScopedLifecycleResources(plan)) return {
+		plan,
+		candidates,
+		deleted,
+		warnings
+	};
+	const cloudflareApi = resolvePreviewScopedResourceLifecycleApi(options.cloudflare);
+	const accountId = await resolveLifecycleAccountId(config, options, cloudflareApi);
+	const apply = options.apply === true;
+	const { namespaces, databases, buckets, queues, vectorizeIndexes, hyperdrives } = await loadPreviewScopedResourceLifecycleState(accountId, plan, cloudflareApi);
+	const kvCandidates = plan.kv.map((ref) => findKVNamespaceByName(namespaces, ref.previewName)).filter((namespace) => namespace !== void 0);
+	for (const namespace of kvCandidates) {
+		candidates.kv.push(namespace.name);
+		if (!apply) continue;
+		await cloudflareApi.deleteKVNamespace(accountId, namespace.id);
+		deleted.kv.push(namespace.name);
+	}
+	const d1Candidates = plan.d1.map((ref) => findD1DatabaseByName(databases, ref.previewName)).filter((database) => database !== void 0);
+	for (const database of d1Candidates) {
+		candidates.d1.push(database.name);
+		if (!apply) continue;
+		await cloudflareApi.deleteD1Database(accountId, database.id);
+		deleted.d1.push(database.name);
+	}
+	const r2Candidates = plan.r2.map((ref) => findR2BucketByName(buckets, ref.previewName)).filter((bucket) => bucket !== void 0);
+	for (const bucket of r2Candidates) {
+		candidates.r2.push(bucket.name);
+		if (!apply) continue;
+		await cloudflareApi.deleteR2Bucket(accountId, bucket.name);
+		deleted.r2.push(bucket.name);
+	}
+	const queueCandidates = plan.queues.map((ref) => findQueueByName(queues, ref.previewName)).filter((queue) => queue !== void 0);
+	for (const queue of queueCandidates) {
+		candidates.queues.push(queue.name);
+		if (!apply) continue;
+		if (!queue.id) {
+			warnings.push(`Skipping queue deletion for "${queue.name}" because Cloudflare did not return a queue id.`);
+			continue;
+		}
+		await cloudflareApi.deleteQueue(accountId, queue.id);
+		deleted.queues.push(queue.name);
+	}
+	const vectorizeCandidates = plan.vectorize.map((ref) => findVectorizeIndexByName(vectorizeIndexes, ref.previewName)).filter((index) => index !== void 0);
+	for (const index of vectorizeCandidates) {
+		candidates.vectorize.push(index.name);
+		if (!apply) continue;
+		await cloudflareApi.deleteVectorizeIndex(accountId, index.name);
+		deleted.vectorize.push(index.name);
+	}
+	const hyperdriveCandidates = plan.hyperdrive.map((ref) => findHyperdriveByName(hyperdrives, ref.previewName)).filter((hyperdrive) => hyperdrive !== void 0);
+	for (const hyperdrive of hyperdriveCandidates) {
+		candidates.hyperdrive.push(hyperdrive.name);
+		if (!apply) continue;
+		await cloudflareApi.deleteHyperdrive(accountId, hyperdrive.id);
+		deleted.hyperdrive.push(hyperdrive.name);
+	}
+	if (plan.hyperdrive.length > 0) warnings.push("Preview-scoped Hyperdrive cleanup only deletes preview configs that already exist. Devflare does not auto-provision preview Hyperdrives because Cloudflare does not expose stored Hyperdrive credentials for cloning.");
+	return {
+		accountId,
+		plan,
+		candidates,
+		deleted,
+		warnings
+	};
+}
+//#endregion
+export { preparePreviewScopedResourcesForDeploy as n, cleanupPreviewScopedResources as t };