devflare 1.0.0-next.3 → 1.0.0-next.30

package/dist/{init-f9mgmew3.js → init-cwpergap.js}

@@ -1,6 +1,17 @@
 import {
   getDependencies
-} from "./index-1xpj0m4r.js";
+} from "./index-z9gy8w6b.js";
+import {
+  getInitDependencyVersions
+} from "./index-627srx16.js";
+import {
+  createCliTheme,
+  cyanBold,
+  dim,
+  green,
+  logLine
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
 import"./index-37x76zdn.js";
 
 // src/cli/commands/init.ts
@@ -9,19 +20,24 @@ var MINIMAL_TEMPLATE = {
   name: "minimal",
   description: "Minimal starter with single handler",
   files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
+    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
 
 export default defineConfig({
 	name: '{{PROJECT_NAME}}',
 	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
+	files: {
+		fetch: 'src/fetch.ts'
+	}
 })
 `,
-    "src/index.ts": `import { env, ctx, event, locals } from 'devflare/runtime'
+    "src/fetch.ts": `import type { FetchEvent } from 'devflare/runtime'
 
-export default {
-	async fetch(request: Request): Promise<Response> {
-		return new Response('Hello from devflare!')
-	}
+export async function fetch({ url }: FetchEvent): Promise<Response> {
+	return new Response(
+		url.pathname === '/'
+			? 'Hello from Devflare'
+			: \`Hello from Devflare: \${url.pathname}\`
+	)
 }
 `,
     "package.json": `{
@@ -36,8 +52,10 @@ export default {
 		"types": "devflare types"
 	},
 	"devDependencies": {
-		"devflare": "^0.1.0",
-		"typescript": "^5.7.0"
+		"@cloudflare/workers-types": "{{WORKERS_TYPES_VERSION}}",
+		"devflare": "{{DEVFLARE_VERSION}}",
+		"typescript": "{{TYPESCRIPT_VERSION}}",
+		"wrangler": "{{WRANGLER_VERSION}}"
 	}
 }
 `,
@@ -50,91 +68,63 @@ export default {
 		"skipLibCheck": true,
 		"types": ["@cloudflare/workers-types"]
 	},
-	"include": ["src/**/*", "devflare.config.ts"]
+	"include": ["src/**/*", "env.d.ts", "devflare.config.ts"]
 }
 `
   }
 };
 var API_TEMPLATE = {
   name: "api",
-  description: "API starter with middleware and routing",
+  description: "API starter with request-wide middleware",
   files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
+    "devflare.config.ts": `import { defineConfig } from 'devflare/config'
 
 export default defineConfig({
 	name: '{{PROJECT_NAME}}',
 	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-	bindings: {
-		// Add your bindings here
-		// kv: [{ binding: 'CACHE' }],
-		// d1: [{ binding: 'DB', database_name: 'my-db' }],
+	files: {
+		fetch: 'src/fetch.ts'
 	}
 })
 `,
-    "src/index.ts": `import { sequence, resolve } from 'devflare/runtime'
-import { corsMiddleware } from './middleware/cors'
-import { apiRouter } from './routes/api'
-
-const handler = sequence(
-	corsMiddleware
-)(
-	resolve(
-		apiRouter,
-		async () => new Response('Not Found', { status: 404 })
-	)
-)
+    "src/fetch.ts": `import { sequence } from 'devflare/runtime'
+import { corsHandle } from './middleware/cors'
+import { appFetch } from './app'
 
-export default {
-	async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
-		return handler()
-	}
-}
+export const handle = sequence(corsHandle, appFetch)
 `,
-    "src/middleware/cors.ts": `import type { Middleware } from 'devflare/runtime'
-import { event } from 'devflare/runtime'
+    "src/middleware/cors.ts": `import type { FetchEvent, ResolveFetch } from 'devflare/runtime'
 
-export const corsMiddleware: Middleware = async (next) => {
+export async function corsHandle(event: FetchEvent, resolve: ResolveFetch): Promise<Response> {
 	// Handle preflight
-	if (event.request?.method === 'OPTIONS') {
+	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',
+				'Access-Control-Allow-Headers': 'Content-Type, Authorization'
 			}
 		})
 	}
 
-	const response = await next()
-	const newResponse = new Response(response.body, response)
-	newResponse.headers.set('Access-Control-Allow-Origin', '*')
-	return newResponse
+	const response = await resolve(event)
+	const next = new Response(response.body, response)
+	next.headers.set('Access-Control-Allow-Origin', '*')
+	return next
 }
 `,
-    "src/routes/api.ts": `import type { Handler } from 'devflare/runtime'
-import { event, env, locals } from 'devflare/runtime'
-
-export const apiRouter: Handler = async () => {
-	const request = event.request
-	if (!request) return null
-
-	const url = new URL(request.url)
+    "src/app.ts": `import type { FetchEvent } from 'devflare/runtime'
 
+export async function appFetch({ url }: FetchEvent): Promise<Response> {
 	if (url.pathname === '/api/health') {
-		return new Response(JSON.stringify({ status: 'ok' }), {
-			headers: { 'Content-Type': 'application/json' }
-		})
+		return Response.json({ status: 'ok' })
 	}
 
 	if (url.pathname.startsWith('/api/')) {
-		return new Response(JSON.stringify({ error: 'Not found' }), {
-			status: 404,
-			headers: { 'Content-Type': 'application/json' }
-		})
+		return Response.json({ error: 'Not found' }, { status: 404 })
 	}
 
-	// Not an API route, pass through
-	return null
+	return new Response('Not Found', { status: 404 })
 }
 `,
     "package.json": MINIMAL_TEMPLATE.files["package.json"],
@@ -149,7 +139,10 @@ 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();
-  logger.info(`Creating new devflare project: ${projectName}`);
+  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}`);
@@ -157,6 +150,7 @@ async function runInitCommand(parsed, logger, options) {
     return { exitCode: 1 };
   }
   const projectDir = resolve(cwd, projectName);
+  const dependencyVersions = await getInitDependencyVersions();
   const { fs } = await getDependencies();
   try {
     await fs.access(projectDir);
@@ -168,17 +162,17 @@ async function runInitCommand(parsed, logger, options) {
     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);
+    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");
-    logger.info(`  Created: ${filePath}`);
+    logLine(logger, `  ${dim("created", theme)} ${filePath}`);
   }
-  logger.success(`
-Project created successfully!`);
-  logger.info(`
-Next steps:`);
-  logger.info(`  cd ${projectName}`);
-  logger.info(`  bun install`);
-  logger.info(`  bun run dev`);
+  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 };
 }
 export {

package/dist/login-fthspvbx.js

@@ -0,0 +1,77 @@
+import {
+  getConfiguredAccountId
+} from "./index-thwacc28.js";
+import {
+  account
+} from "./index-qmmqww7h.js";
+import"./index-11p28kxx.js";
+import"./index-3jme4hgw.js";
+import {
+  getDependencies
+} from "./index-z9gy8w6b.js";
+import {
+  createCliTheme,
+  dim,
+  green,
+  logLine,
+  whiteDim,
+  yellow
+} from "./index-stgn34cr.js";
+import"./index-3t6rypgc.js";
+import"./index-15fpa5tx.js";
+import"./index-2sc756r1.js";
+import"./index-1d4jg11n.js";
+import"./index-mg8vwqxf.js";
+import"./index-c8p4njqy.js";
+import"./index-37x76zdn.js";
+
+// src/cli/commands/login.ts
+async function logResolvedAccount(cwd, logger, theme) {
+  try {
+    const primaryAccount = await account.getPrimaryAccount();
+    if (primaryAccount) {
+      logLine(logger, `${dim("Primary account:", theme)} ${green(primaryAccount.name, theme)} ${whiteDim(`(${primaryAccount.id})`, theme)}`);
+      return;
+    }
+  } catch {}
+  const configuredAccountId = await getConfiguredAccountId(cwd);
+  if (!configuredAccountId) {
+    logLine(logger, dim("Run `devflare account` to inspect available accounts.", theme));
+    return;
+  }
+  const configuredAccount = await account.getAccountById(configuredAccountId);
+  if (configuredAccount) {
+    logLine(logger, `${dim("Configured account:", theme)} ${green(configuredAccount.name, theme)} ${whiteDim(`(${configuredAccount.id})`, theme)}`);
+    return;
+  }
+  logLine(logger, `${dim("Configured account ID:", theme)} ${whiteDim(configuredAccountId, theme)}`);
+  logLine(logger, dim("Run `devflare account --account <id>` to inspect the configured account.", theme));
+}
+async function runLoginCommand(parsed, logger, options) {
+  const force = parsed.options.force === true;
+  const cwd = options.cwd ?? process.cwd();
+  const theme = createCliTheme(parsed.options);
+  if (!force && await account.isAuthenticated()) {
+    logger.success("Already authenticated with Cloudflare");
+    await logResolvedAccount(cwd, logger, theme);
+    logLine(logger, dim("Use `devflare login --force` to open Wrangler login again.", theme));
+    return { exitCode: 0 };
+  }
+  logLine(logger);
+  logLine(logger, `${yellow("login", theme)} ${dim("Opening Wrangler login…", theme)}`);
+  const deps = await getDependencies();
+  const result = await deps.exec.exec("bunx", ["wrangler", "login"], {
+    cwd,
+    stdio: "inherit"
+  });
+  if (result.exitCode !== 0) {
+    logger.error("Wrangler login failed");
+    return { exitCode: 1 };
+  }
+  logger.success("Authenticated with Cloudflare");
+  await logResolvedAccount(cwd, logger, theme);
+  return { exitCode: 0 };
+}
+export {
+  runLoginCommand
+};