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

package/dist/_chunks/family-DHkROYgX.js

@@ -0,0 +1,143 @@
+import { u as resolveConfigForEnvironment } from "./loader-BC0skbnH.js";
+//#region src/cli/commands/previews-support/family.ts
+function compareConfiguredWorkerFamilies(left, right) {
+	if (left.role === "primary" && right.role !== "primary") return -1;
+	if (left.role !== "primary" && right.role === "primary") return 1;
+	return left.baseName.localeCompare(right.baseName);
+}
+function comparePreviewScopeRows(left, right) {
+	const leftTime = left.updatedAt?.getTime() ?? 0;
+	const rightTime = right.updatedAt?.getTime() ?? 0;
+	if (rightTime !== leftTime) return rightTime - leftTime;
+	return left.scope.localeCompare(right.scope);
+}
+function collectConfiguredWorkerFamilies(config, environment) {
+	const resolvedConfig = resolveConfigForEnvironment(config, environment);
+	const families = /* @__PURE__ */ new Map();
+	families.set(resolvedConfig.name, {
+		baseName: resolvedConfig.name,
+		roleLabel: "primary",
+		role: "primary"
+	});
+	for (const [bindingName, binding] of Object.entries(resolvedConfig.bindings?.services ?? {})) {
+		if (families.get(binding.service)) continue;
+		families.set(binding.service, {
+			baseName: binding.service,
+			roleLabel: bindingName,
+			role: "service"
+		});
+	}
+	return Array.from(families.values()).sort(compareConfiguredWorkerFamilies);
+}
+function getWorkerUrl(workerName, workersSubdomain) {
+	if (!workersSubdomain) return;
+	return `https://${workerName}.${workersSubdomain}.workers.dev`;
+}
+function getWorkerScopeSuffix(workerName, baseName) {
+	if (!workerName.startsWith(`${baseName}-`)) return;
+	return workerName.slice(baseName.length + 1).trim() || void 0;
+}
+function buildStableWorkerRowsFromLiveWorkers(families, workers, workersSubdomain) {
+	const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+	return families.map((family) => {
+		const worker = workersByName.get(family.baseName);
+		const status = worker ? "active" : "missing";
+		return {
+			workerName: family.baseName,
+			role: family.roleLabel,
+			status,
+			updatedAt: worker?.modifiedOn,
+			url: worker ? getWorkerUrl(family.baseName, workersSubdomain) : void 0
+		};
+	});
+}
+function getDedicatedPreviewFamilyNamesFromWorkers(families, workers) {
+	const familyNames = /* @__PURE__ */ new Set();
+	const workerNames = workers.map((worker) => worker.name);
+	for (const family of families) {
+		if (family.role === "primary") {
+			familyNames.add(family.baseName);
+			continue;
+		}
+		if (workerNames.some((workerName) => Boolean(getWorkerScopeSuffix(workerName, family.baseName)))) familyNames.add(family.baseName);
+	}
+	return familyNames;
+}
+function buildPreviewScopeRowsFromLiveWorkers(families, workers, workersSubdomain) {
+	const workersByName = new Map(workers.map((worker) => [worker.name, worker]));
+	const previewFamilyNames = getDedicatedPreviewFamilyNamesFromWorkers(families, workers);
+	const expectedFamilies = families.filter((family) => previewFamilyNames.has(family.baseName));
+	const workerCandidatesByScope = buildPreviewWorkerCandidatesByScope(families, workers);
+	return Array.from(workerCandidatesByScope.keys()).map((scope) => {
+		const resolvedFamilies = expectedFamilies.map((family) => ({
+			family,
+			worker: workersByName.get(`${family.baseName}-${scope}`)
+		}));
+		const presentFamilies = resolvedFamilies.filter((entry) => entry.worker);
+		const updatedAt = presentFamilies.reduce((latest, entry) => {
+			const currentDate = entry.worker?.modifiedOn;
+			if (!currentDate) return latest;
+			if (!latest || currentDate.getTime() > latest.getTime()) return currentDate;
+			return latest;
+		}, void 0);
+		const entryWorker = resolvedFamilies.find((entry) => entry.family.role === "primary")?.worker ?? presentFamilies[0]?.worker;
+		const missingLabels = resolvedFamilies.filter((entry) => !entry.worker).map((entry) => entry.family.role === "primary" ? "primary" : entry.family.roleLabel);
+		const notes = [];
+		if (missingLabels.length > 0) notes.push(`missing ${missingLabels.join(", ")}`);
+		const strategy = "dedicated workers";
+		const status = presentFamilies.length === resolvedFamilies.length ? "ready" : "partial";
+		return {
+			scope,
+			strategy,
+			workersLabel: `${presentFamilies.length}/${resolvedFamilies.length}`,
+			status,
+			updatedAt,
+			notes: notes.length > 0 ? notes.join(" · ") : void 0,
+			entryUrl: entryWorker ? getWorkerUrl(entryWorker.name, workersSubdomain) : void 0
+		};
+	}).sort(comparePreviewScopeRows);
+}
+function buildPreviewWorkerCandidatesByScope(families, workers) {
+	const candidates = /* @__PURE__ */ new Map();
+	for (const worker of workers) for (const family of families) {
+		const scope = getWorkerScopeSuffix(worker.name, family.baseName);
+		if (!scope) continue;
+		const names = candidates.get(scope) ?? /* @__PURE__ */ new Set();
+		names.add(worker.name);
+		candidates.set(scope, names);
+	}
+	return new Map(Array.from(candidates.entries()).map(([scope, workerNames]) => {
+		return [scope, Array.from(workerNames).sort((left, right) => left.localeCompare(right))];
+	}));
+}
+function orderPreviewWorkerNamesForDeletion(workerNames, scope, families) {
+	const familyPriority = /* @__PURE__ */ new Map();
+	for (const family of families) familyPriority.set(family.baseName, {
+		priority: family.role === "primary" ? 0 : 1,
+		roleLabel: family.roleLabel
+	});
+	const resolveFamilyForWorker = (workerName) => {
+		for (const family of families) if (getWorkerScopeSuffix(workerName, family.baseName) === scope) {
+			const resolved = familyPriority.get(family.baseName);
+			if (resolved) return {
+				priority: resolved.priority,
+				roleLabel: resolved.roleLabel,
+				baseName: family.baseName
+			};
+		}
+		return {
+			priority: 2,
+			roleLabel: workerName
+		};
+	};
+	return [...workerNames].sort((left, right) => {
+		const leftFamily = resolveFamilyForWorker(left);
+		const rightFamily = resolveFamilyForWorker(right);
+		if (leftFamily.priority !== rightFamily.priority) return leftFamily.priority - rightFamily.priority;
+		if (leftFamily.roleLabel !== rightFamily.roleLabel) return leftFamily.roleLabel.localeCompare(rightFamily.roleLabel);
+		if (leftFamily.baseName && rightFamily.baseName && leftFamily.baseName !== rightFamily.baseName) return leftFamily.baseName.localeCompare(rightFamily.baseName);
+		return left.localeCompare(right);
+	});
+}
+//#endregion
+export { orderPreviewWorkerNamesForDeletion as a, collectConfiguredWorkerFamilies as i, buildPreviewWorkerCandidatesByScope as n, buildStableWorkerRowsFromLiveWorkers as r, buildPreviewScopeRowsFromLiveWorkers as t };

package/dist/_chunks/generated-artifacts-D_VIzDOi.js

@@ -0,0 +1,31 @@
+import { t as generatedDir } from "./generated-dir-DC2kM-mt.js";
+import { resolve } from "pathe";
+//#region src/cli/generated-artifacts.ts
+const WRANGLER_DEPLOY_DIR = [".wrangler", "deploy"];
+function getGeneratedArtifactPaths(cwd) {
+	const devflareDir = generatedDir(cwd);
+	const buildDir = generatedDir(cwd, "build");
+	const deployDir = resolve(cwd, ...WRANGLER_DEPLOY_DIR);
+	return {
+		devflareDir,
+		devWranglerConfigPath: resolve(devflareDir, "wrangler.jsonc"),
+		buildDir,
+		buildWorkerPath: resolve(buildDir, "worker.js"),
+		buildWranglerConfigPath: resolve(buildDir, "wrangler.jsonc"),
+		deployDir,
+		deployRedirectPath: resolve(deployDir, "config.json")
+	};
+}
+async function ensureGeneratedDirectory(dirPath, writeGitignore = false) {
+	const fs = await import("node:fs/promises");
+	await fs.mkdir(dirPath, { recursive: true });
+	if (!writeGitignore) return;
+	const gitignorePath = resolve(dirPath, ".gitignore");
+	try {
+		await fs.access(gitignorePath);
+	} catch {
+		await fs.writeFile(gitignorePath, "*\n", "utf-8");
+	}
+}
+//#endregion
+export { getGeneratedArtifactPaths as n, ensureGeneratedDirectory as t };

package/dist/_chunks/generated-dir-DC2kM-mt.js

@@ -0,0 +1,33 @@
+import { resolve } from "pathe";
+//#region src/utils/generated-dir.ts
+/** The generated-state directory used when nothing overrides it. */
+const DEFAULT_GENERATED_DIR = ".devflare";
+/** The environment variable that overrides {@link DEFAULT_GENERATED_DIR}. */
+const GENERATED_DIR_ENV = "DEVFLARE_DIR";
+/**
+* The generated-state directory NAME for this process.
+*
+* @param env - The environment to read; injected so callers can test the
+*   resolution without mutating `process.env`.
+* @returns The override when set to a non-blank value, else `.devflare`. A path
+*   is accepted as given — relative names resolve against the app's cwd, and an
+*   absolute path is honoured, which is how an instance can put its state
+*   outside the project entirely.
+*/
+function generatedDirName(env = process.env) {
+	const override = env[GENERATED_DIR_ENV]?.trim();
+	return override ? override : DEFAULT_GENERATED_DIR;
+}
+/**
+* Resolve a path inside this process's generated-state directory.
+*
+* @param cwd - The app directory the state belongs to.
+* @param segments - Path segments below the generated root, e.g.
+*   `'worker-entrypoints', 'main.js'`.
+* @returns The absolute path.
+*/
+function generatedDir(cwd, ...segments) {
+	return resolve(cwd, generatedDirName(), ...segments);
+}
+//#endregion
+export { generatedDir as t };

package/dist/_chunks/glob-DRw9sbfF.js

@@ -0,0 +1,56 @@
+import { globby, globbySync } from "globby";
+//#region src/utils/glob.ts
+/** Default glob pattern for Durable Object discovery */
+const DEFAULT_DO_PATTERN = "**/do.*.{ts,js}";
+/** Default glob pattern for WorkerEntrypoint discovery */
+const DEFAULT_ENTRYPOINT_PATTERN = "**/ep.*.{ts,js}";
+/** Default glob pattern for Workflow discovery */
+const DEFAULT_WORKFLOW_PATTERN = "**/wf.*.{ts,js}";
+/**
+* Find files matching a glob pattern with .gitignore support.
+* This is the async version for use in CLI commands and bundlers.
+*
+* @param pattern - Glob pattern (e.g., '**​/do.*.{ts,js}')
+* @param options - Glob options
+* @returns Array of matching file paths
+*/
+async function findFiles(pattern, options) {
+	const { cwd, absolute = true, gitignore = true } = options;
+	return globby(pattern, {
+		cwd,
+		absolute,
+		gitignore,
+		ignore: [
+			"**/node_modules/**",
+			"**/.devflare/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.git/**"
+		]
+	});
+}
+/**
+* Find files matching a glob pattern synchronously.
+* Use sparingly — prefer async version for better performance.
+*
+* @param pattern - Glob pattern (e.g., '**​/do.*.{ts,js}')
+* @param options - Glob options
+* @returns Array of matching file paths
+*/
+function findFilesSync(pattern, options) {
+	const { cwd, absolute = true, gitignore = true } = options;
+	return globbySync(pattern, {
+		cwd,
+		absolute,
+		gitignore,
+		ignore: [
+			"**/node_modules/**",
+			"**/.devflare/**",
+			"**/dist/**",
+			"**/build/**",
+			"**/.git/**"
+		]
+	});
+}
+//#endregion
+export { findFilesSync as a, findFiles as i, DEFAULT_ENTRYPOINT_PATTERN as n, DEFAULT_WORKFLOW_PATTERN as r, DEFAULT_DO_PATTERN as t };

package/dist/_chunks/init-B9_QIZcO.js

@@ -0,0 +1,165 @@
+import { a as cyanBold, d as green, f as logLine, o as dim, r as createCliTheme } from "./ui-BhCdDC2N.js";
+import { t as getInitDependencyVersions } from "./package-metadata-CLI488gB.js";
+import { t as getDependencies } from "./dependencies-HLIhxbIe.js";
+import { join, resolve } from "pathe";
+//#region src/cli/commands/init.ts
+const MINIMAL_TEMPLATE = {
+	name: "minimal",
+	description: "Minimal starter with single handler",
+	files: {
+		"devflare.config.ts": `import { defineConfig } from 'devflare/config'
+
+export default defineConfig({
+	name: '{{PROJECT_NAME}}',
+	compatibilityDate: '${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}',
+	files: {
+		fetch: 'src/fetch.ts'
+	}
+})
+`,
+		"src/fetch.ts": `import type { FetchEvent } from 'devflare/runtime'
+
+export async function fetch({ url }: FetchEvent): Promise<Response> {
+	return new Response(
+		url.pathname === '/'
+			? 'Hello from Devflare'
+			: \`Hello from Devflare: \${url.pathname}\`
+	)
+}
+`,
+		"package.json": `{
+	"name": "{{PROJECT_NAME}}",
+	"version": "0.0.1",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"dev": "devflare dev",
+		"build": "devflare build",
+		"deploy": "devflare deploy",
+		"types": "devflare types"
+	},
+	"devDependencies": {
+		"@cloudflare/workers-types": "{{WORKERS_TYPES_VERSION}}",
+		"devflare": "{{DEVFLARE_VERSION}}",
+		"typescript": "{{TYPESCRIPT_VERSION}}",
+		"wrangler": "{{WRANGLER_VERSION}}"
+	}
+}
+`,
+		"tsconfig.json": `{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "bundler",
+		"strict": true,
+		"skipLibCheck": true,
+		"types": ["@cloudflare/workers-types"]
+	},
+	"include": ["src/**/*", "env.d.ts", "devflare.config.ts"]
+}
+`
+	}
+};
+const TEMPLATES = {
+	minimal: MINIMAL_TEMPLATE,
+	api: {
+		name: "api",
+		description: "API starter with request-wide middleware",
+		files: {
+			"devflare.config.ts": `import { defineConfig } from 'devflare/config'
+
+export default defineConfig({
+	name: '{{PROJECT_NAME}}',
+	compatibilityDate: '${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}',
+	files: {
+		fetch: 'src/fetch.ts'
+	}
+})
+`,
+			"src/fetch.ts": `import { sequence } from 'devflare/runtime'
+import { corsHandle } from './middleware/cors'
+import { appFetch } from './app'
+
+export const handle = sequence(corsHandle, appFetch)
+`,
+			"src/middleware/cors.ts": `import type { FetchEvent, ResolveFetch } from 'devflare/runtime'
+
+export async function corsHandle(event: FetchEvent, resolve: ResolveFetch): Promise<Response> {
+	// Handle preflight
+	if (event.request.method === 'OPTIONS') {
+		return new Response(null, {
+			headers: {
+				'Access-Control-Allow-Origin': '*',
+				'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+				'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+			}
+		})
+	}
+
+	const response = await resolve(event)
+	const next = new Response(response.body, response)
+	next.headers.set('Access-Control-Allow-Origin', '*')
+	return next
+}
+`,
+			"src/app.ts": `import type { FetchEvent } from 'devflare/runtime'
+
+export async function appFetch({ url }: FetchEvent): Promise<Response> {
+	if (url.pathname === '/api/health') {
+		return Response.json({ status: 'ok' })
+	}
+
+	if (url.pathname.startsWith('/api/')) {
+		return Response.json({ error: 'Not found' }, { status: 404 })
+	}
+
+	return new Response('Not Found', { status: 404 })
+}
+`,
+			"package.json": MINIMAL_TEMPLATE.files["package.json"],
+			"tsconfig.json": MINIMAL_TEMPLATE.files["tsconfig.json"]
+		}
+	}
+};
+async function runInitCommand(parsed, logger, options) {
+	const projectName = parsed.args[0] || "my-devflare-app";
+	const templateName = parsed.options.template || "minimal";
+	const cwd = options.cwd || process.cwd();
+	const theme = createCliTheme(parsed.options);
+	logLine(logger);
+	logLine(logger, `${cyanBold("init", theme)} ${dim("Creating a new Devflare project", theme)}`);
+	logLine(logger, `${dim("project", theme)} ${green(projectName, theme)}`);
+	const template = TEMPLATES[templateName];
+	if (!template) {
+		logger.error(`Unknown template: ${templateName}`);
+		logger.info(`Available templates: ${Object.keys(TEMPLATES).join(", ")}`);
+		return { exitCode: 1 };
+	}
+	const projectDir = resolve(cwd, projectName);
+	const dependencyVersions = await getInitDependencyVersions();
+	const { fs } = await getDependencies();
+	try {
+		await fs.access(projectDir);
+		logger.error(`Directory already exists: ${projectDir}`);
+		return { exitCode: 1 };
+	} catch {}
+	await fs.mkdir(projectDir, { recursive: true });
+	for (const [filePath, content] of Object.entries(template.files)) {
+		const fullPath = join(projectDir, filePath);
+		const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+		await fs.mkdir(dir, { recursive: true }).catch(() => {});
+		const processedContent = content.replace(/\{\{PROJECT_NAME\}\}/g, projectName).replace(/\{\{DEVFLARE_VERSION\}\}/g, dependencyVersions.devflare).replace(/\{\{TYPESCRIPT_VERSION\}\}/g, dependencyVersions.typescript).replace(/\{\{WRANGLER_VERSION\}\}/g, dependencyVersions.wrangler).replace(/\{\{WORKERS_TYPES_VERSION\}\}/g, dependencyVersions.workersTypes);
+		await fs.writeFile(fullPath, processedContent, "utf-8");
+		logLine(logger, `  ${dim("created", theme)} ${filePath}`);
+	}
+	logger.success("Project created successfully!");
+	logLine(logger);
+	logLine(logger, dim("next steps", theme));
+	logLine(logger, `  cd ${projectName}`);
+	logLine(logger, "  bun install");
+	logLine(logger, "  bun run types");
+	logLine(logger, "  bun run dev");
+	return { exitCode: 0 };
+}
+//#endregion
+export { runInitCommand };