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

package/dist/index-tk6ej9dj.js

@@ -1,94 +0,0 @@
-import {
-  DEFAULT_ENTRYPOINT_PATTERN,
-  findFiles
-} from "./index-rbht7m9r.js";
-import {
-  __require
-} from "./index-37x76zdn.js";
-
-// src/utils/entrypoint-discovery.ts
-import { readdirSync, readFileSync } from "fs";
-import { join } from "path";
-var ENTRYPOINT_CLASS_PATTERN = /export\s+class\s+(\w+)\s+extends\s+WorkerEntrypoint/g;
-function findEntrypointClasses(code) {
-  const classes = [];
-  ENTRYPOINT_CLASS_PATTERN.lastIndex = 0;
-  let match;
-  while ((match = ENTRYPOINT_CLASS_PATTERN.exec(code)) !== null) {
-    classes.push(match[1]);
-  }
-  return classes;
-}
-var EP_FILE_PATTERN = /^ep\.[^.]+\.ts$/;
-function discoverEntrypointsSync(dir) {
-  const discovered = [];
-  try {
-    const files = readdirSync(dir, { withFileTypes: true });
-    for (const file of files) {
-      if (file.isFile() && EP_FILE_PATTERN.test(file.name)) {
-        const filePath = join(dir, file.name);
-        try {
-          const code = readFileSync(filePath, "utf-8");
-          const classNames = findEntrypointClasses(code);
-          for (const className of classNames) {
-            discovered.push({ className, filePath });
-          }
-        } catch {}
-      }
-    }
-  } catch {}
-  return discovered;
-}
-async function discoverEntrypointsAsync(cwd, pattern = DEFAULT_ENTRYPOINT_PATTERN) {
-  const fs = await import("node:fs/promises");
-  const discovered = [];
-  const files = await findFiles(pattern, { cwd });
-  for (const filePath of files) {
-    try {
-      const code = await fs.readFile(filePath, "utf-8");
-      const classNames = findEntrypointClasses(code);
-      for (const className of classNames) {
-        discovered.push({ className, filePath });
-      }
-    } catch {}
-  }
-  return discovered;
-}
-
-// src/utils/resolve-package.ts
-import { resolve, dirname } from "pathe";
-import { readFileSync as readFileSync2, existsSync } from "node:fs";
-function resolvePackageSpecifier(specifier, fromDir) {
-  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[A-Za-z]:/.test(specifier)) {
-    return resolve(fromDir, specifier);
-  }
-  try {
-    const parts = specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
-    const subpath = specifier.startsWith("@") ? specifier.split("/").slice(2).join("/") : specifier.split("/").slice(1).join("/");
-    const pkgJsonPath = __require.resolve(`${parts}/package.json`, { paths: [fromDir] });
-    const pkgDir = dirname(pkgJsonPath);
-    if (subpath) {
-      const pkgJson = JSON.parse(readFileSync2(pkgJsonPath, "utf-8"));
-      const exportPath = pkgJson.exports?.[`./${subpath}`];
-      if (exportPath) {
-        const targetPath = typeof exportPath === "string" ? exportPath : exportPath.default || exportPath.import;
-        return resolve(pkgDir, targetPath);
-      }
-      const directPath = resolve(pkgDir, `${subpath}.ts`);
-      if (existsSync(directPath))
-        return directPath;
-      const withExt = resolve(pkgDir, subpath);
-      if (existsSync(withExt))
-        return withExt;
-      if (existsSync(`${withExt}.ts`))
-        return `${withExt}.ts`;
-      if (existsSync(`${withExt}.js`))
-        return `${withExt}.js`;
-    }
-    return pkgDir;
-  } catch {
-    return resolve(fromDir, specifier);
-  }
-}
-
-export { discoverEntrypointsSync, discoverEntrypointsAsync, resolvePackageSpecifier };

package/dist/index-v8vvsn9x.js

@@ -1,169 +0,0 @@
-// src/config/define.ts
-function defineConfig(config) {
-  if (typeof config === "function") {
-    const result = config();
-    if (result instanceof Promise) {
-      return result;
-    }
-    return result;
-  }
-  return config;
-}
-
-// src/config/ref.ts
-var resolvedCache = new WeakMap;
-var pendingResolutions = new WeakMap;
-function ref(nameOrImport, maybeImport) {
-  const nameOverride = typeof nameOrImport === "string" ? nameOrImport : undefined;
-  const importFn = typeof nameOrImport === "function" ? nameOrImport : maybeImport;
-  if (!importFn) {
-    throw new Error("ref() requires an import function");
-  }
-  const fnSource = importFn.toString();
-  const importMatch = fnSource.match(/import\s*\(\s*['"]([^'"]+)['"]\s*\)/);
-  const configPath = importMatch?.[1] ?? "<pending>";
-  async function doResolve() {
-    const cached = resolvedCache.get(proxy);
-    if (cached)
-      return cached;
-    const pending = pendingResolutions.get(proxy);
-    if (pending)
-      return pending;
-    const promise = (async () => {
-      const module = await importFn();
-      const config = "default" in module ? module.default : module;
-      if (!config.name && !nameOverride) {
-        throw new Error('Referenced config must have a "name" property');
-      }
-      const resolved = {
-        name: nameOverride ?? config.name,
-        config,
-        configPath
-      };
-      resolvedCache.set(proxy, resolved);
-      return resolved;
-    })();
-    pendingResolutions.set(proxy, promise);
-    return promise;
-  }
-  function getResolved() {
-    const cached = resolvedCache.get(proxy);
-    if (cached)
-      return cached;
-    throw new Error("ref() not yet resolved. Call ref().resolve() first, or use top-level await " + "in your config file to resolve all refs before exporting.");
-  }
-  function createWorkerBinding(entrypoint) {
-    return {
-      get service() {
-        const cached = resolvedCache.get(proxy);
-        if (cached)
-          return cached.name;
-        if (nameOverride)
-          return nameOverride;
-        return "<pending>";
-      },
-      entrypoint,
-      __ref: proxy
-    };
-  }
-  const workerAccessor = new Proxy((entrypoint) => createWorkerBinding(entrypoint), {
-    get(target, prop) {
-      if (prop === "service") {
-        const cached = resolvedCache.get(proxy);
-        if (cached)
-          return cached.name;
-        if (nameOverride)
-          return nameOverride;
-        return "<pending>";
-      }
-      if (prop === "entrypoint")
-        return;
-      if (prop === "__ref")
-        return proxy;
-      return Reflect.get(target, prop);
-    }
-  });
-  function createDOBinding(bindingName) {
-    return {
-      get className() {
-        const cached = resolvedCache.get(proxy);
-        if (cached?.config.bindings?.durableObjects) {
-          const doBindings = cached.config.bindings.durableObjects;
-          const doConfig = doBindings[bindingName];
-          if (typeof doConfig === "string") {
-            return doConfig;
-          } else if (doConfig && typeof doConfig === "object" && "className" in doConfig) {
-            return doConfig.className;
-          }
-        }
-        return bindingName;
-      },
-      get scriptName() {
-        const cached = resolvedCache.get(proxy);
-        if (cached)
-          return cached.name;
-        if (nameOverride)
-          return nameOverride;
-        return "<pending>";
-      },
-      __ref: proxy
-    };
-  }
-  const knownProps = new Set(["name", "config", "configPath", "worker", "__import", "__nameOverride", "resolve", "then"]);
-  const proxyTarget = {
-    get name() {
-      return getResolved().name;
-    },
-    get config() {
-      return getResolved().config;
-    },
-    configPath,
-    worker: workerAccessor,
-    __import: importFn,
-    __nameOverride: nameOverride,
-    resolve: doResolve
-  };
-  const proxy = new Proxy(proxyTarget, {
-    get(target, prop) {
-      if (typeof prop === "string" && knownProps.has(prop)) {
-        return Reflect.get(target, prop);
-      }
-      if (typeof prop === "symbol") {
-        return Reflect.get(target, prop);
-      }
-      if (typeof prop === "string" && /^[A-Z][A-Z0-9_]*$/.test(prop)) {
-        return createDOBinding(prop);
-      }
-      return Reflect.get(target, prop);
-    },
-    has(target, prop) {
-      if (typeof prop === "string") {
-        if (knownProps.has(prop))
-          return true;
-        if (/^[A-Z][A-Z0-9_]*$/.test(prop))
-          return true;
-      }
-      return Reflect.has(target, prop);
-    }
-  });
-  return proxy;
-}
-async function resolveRef(configImport, options) {
-  const result = options?.workerName ? ref(options.workerName, configImport) : ref(configImport);
-  await result.resolve();
-  return result;
-}
-function serviceBinding(refOrLegacy, options) {
-  if ("worker" in refOrLegacy) {
-    const entrypoint2 = options?.entrypoint;
-    return entrypoint2 ? refOrLegacy.worker(entrypoint2) : refOrLegacy.worker;
-  }
-  const entrypoint = options?.entrypoint ?? refOrLegacy.entrypoint;
-  return {
-    service: refOrLegacy.name,
-    ...entrypoint && { entrypoint },
-    __ref: refOrLegacy
-  };
-}
-
-export { defineConfig, ref, resolveRef, serviceBinding };

package/dist/index-z14anrqp.js

@@ -1,226 +0,0 @@
-// src/transform/worker-entrypoint.ts
-import ts from "typescript";
-import MagicString from "magic-string";
-function findExportedFunctions(code) {
-  const functions = [];
-  const sourceFile = ts.createSourceFile("worker.ts", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const funcName = isDefault ? "fetch" : node.name.text;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: funcName,
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault
-        });
-      }
-    }
-    if (ts.isFunctionDeclaration(node) && !node.name) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
-      if (isExported && isDefault) {
-        const isAsync = modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-        const params = node.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-        const returnType = node.type ? code.substring(node.type.getStart(sourceFile), node.type.getEnd()) : undefined;
-        functions.push({
-          name: "fetch",
-          isAsync,
-          params,
-          returnType,
-          start: node.getStart(sourceFile),
-          end: node.getEnd(),
-          isDefault: true
-        });
-      }
-    }
-    if (ts.isVariableStatement(node)) {
-      const modifiers = ts.getModifiers(node);
-      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
-      if (isExported) {
-        for (const decl of node.declarationList.declarations) {
-          if (ts.isIdentifier(decl.name) && decl.initializer) {
-            let funcExpr;
-            if (ts.isFunctionExpression(decl.initializer)) {
-              funcExpr = decl.initializer;
-            } else if (ts.isArrowFunction(decl.initializer)) {
-              funcExpr = decl.initializer;
-            }
-            if (funcExpr) {
-              const modifiersArr = ts.getModifiers(funcExpr);
-              const isAsync = modifiersArr?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? (ts.isArrowFunction(funcExpr) && funcExpr.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)) ?? false;
-              const params = funcExpr.parameters.map((p) => code.substring(p.getStart(sourceFile), p.getEnd())).join(", ");
-              const returnType = funcExpr.type ? code.substring(funcExpr.type.getStart(sourceFile), funcExpr.type.getEnd()) : undefined;
-              functions.push({
-                name: decl.name.text,
-                isAsync,
-                params,
-                returnType,
-                start: node.getStart(sourceFile),
-                end: node.getEnd()
-              });
-            }
-          }
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return functions;
-}
-function shouldTransformWorker(code, filePath) {
-  if (!filePath.endsWith("worker.ts") && !filePath.endsWith("worker.js")) {
-    return false;
-  }
-  const functions = findExportedFunctions(code);
-  return functions.length > 0;
-}
-function transformWorkerEntrypoint(code, id, options = {}) {
-  const className = options.className ?? "Worker";
-  const injectContext = options.injectContext ?? true;
-  const functions = findExportedFunctions(code);
-  if (functions.length === 0) {
-    return null;
-  }
-  const fetchFn = functions.find((f) => f.name === "fetch");
-  const rpcMethods = functions.filter((f) => f.name !== "fetch");
-  const s = new MagicString(code);
-  const importStatement = `import { WorkerEntrypoint } from 'cloudflare:workers'
-`;
-  if (injectContext) {
-    s.prepend(`import { runWithContext } from 'devflare/runtime'
-`);
-  }
-  s.prepend(importStatement);
-  for (const fn of functions) {
-    const fnCode = code.substring(fn.start, fn.end);
-    const internalName = fn.name === "fetch" ? "__originalFetch" : `__original_${fn.name}`;
-    if (fn.isDefault) {
-      const replacement = fnCode.replace(/^export\s+default\s+(async\s+)?function\s*/, (_, asyncKw) => `const ${internalName} = ${asyncKw || ""}function `);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export function") || fnCode.startsWith("export async function")) {
-      const replacement = fnCode.replace(/^export\s+(async\s+)?function\s+\w+/, (_, asyncKw) => `${asyncKw || ""}function ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
-    } else if (fnCode.startsWith("export const")) {
-      const replacement = fnCode.replace(/^export\s+const\s+\w+/, () => `const ${internalName}`);
-      s.overwrite(fn.start, fn.end, replacement);
-    }
-  }
-  let classBody = `
-
-// ============ Devflare WorkerEntrypoint ============
-class ${className} extends WorkerEntrypoint {
-`;
-  if (fetchFn) {
-    if (injectContext) {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return runWithContext(
-`;
-      classBody += `			this.env,
-`;
-      classBody += `			this.ctx,
-`;
-      classBody += `			request,
-`;
-      classBody += `			() => __originalFetch(request, this.env, this.ctx),
-`;
-      classBody += `			'fetch'
-`;
-      classBody += `		)
-`;
-      classBody += `	}
-`;
-    } else {
-      classBody += `	async fetch(request: Request): Promise<Response> {
-`;
-      classBody += `		return __originalFetch(request, this.env, this.ctx)
-`;
-      classBody += `	}
-`;
-    }
-  }
-  for (const fn of rpcMethods) {
-    const asyncPrefix = fn.isAsync ? "async " : "";
-    const returnType = fn.returnType ? `: ${fn.returnType}` : "";
-    const paramNames = extractParamNames(fn.params);
-    classBody += `
-	${asyncPrefix}${fn.name}(${fn.params})${returnType} {
-`;
-    classBody += `		return __original_${fn.name}(${paramNames})
-`;
-    classBody += `	}
-`;
-  }
-  classBody += `}
-
-`;
-  classBody += `export { ${className} }
-`;
-  classBody += `export { ${className} as default }
-`;
-  classBody += `// ============ End Devflare WorkerEntrypoint ============
-`;
-  s.append(classBody);
-  return {
-    code: s.toString(),
-    map: s.generateMap({
-      source: id,
-      file: id + ".map",
-      includeContent: true
-    }),
-    rpcMethods: rpcMethods.map((fn) => fn.name),
-    className
-  };
-}
-function extractParamNames(params) {
-  if (!params.trim())
-    return "";
-  const tempCode = `function f(${params}) {}`;
-  const sourceFile = ts.createSourceFile("temp.ts", tempCode, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const names = [];
-  function visit(node) {
-    if (ts.isFunctionDeclaration(node)) {
-      for (const param of node.parameters) {
-        if (ts.isIdentifier(param.name)) {
-          names.push(param.name.text);
-        } else if (ts.isObjectBindingPattern(param.name) || ts.isArrayBindingPattern(param.name)) {
-          names.push(tempCode.substring(param.name.getStart(sourceFile), param.name.getEnd()));
-        }
-      }
-    }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  return names.join(", ");
-}
-function generateRpcInterface(functions, interfaceName) {
-  const rpcMethods = functions.filter((f) => f.name !== "fetch");
-  if (rpcMethods.length === 0) {
-    return "";
-  }
-  let output = `export interface ${interfaceName} {
-`;
-  for (const fn of rpcMethods) {
-    const returnType = fn.returnType ?? "unknown";
-    const promiseReturn = returnType.startsWith("Promise<") ? returnType : `Promise<${returnType}>`;
-    output += `	${fn.name}(${fn.params}): ${promiseReturn}
-`;
-  }
-  output += `}
-`;
-  return output;
-}
-
-export { findExportedFunctions, shouldTransformWorker, transformWorkerEntrypoint, generateRpcInterface };

package/dist/init-f9mgmew3.js

@@ -1,186 +0,0 @@
-import {
-  getDependencies
-} from "./index-1xpj0m4r.js";
-import"./index-37x76zdn.js";
-
-// src/cli/commands/init.ts
-import { resolve, join } from "pathe";
-var MINIMAL_TEMPLATE = {
-  name: "minimal",
-  description: "Minimal starter with single handler",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
-
-export default defineConfig({
-	name: '{{PROJECT_NAME}}',
-	compatibilityDate: '${new Date().toISOString().split("T")[0]}',
-})
-`,
-    "src/index.ts": `import { env, ctx, event, locals } from 'devflare/runtime'
-
-export default {
-	async fetch(request: Request): Promise<Response> {
-		return new Response('Hello from devflare!')
-	}
-}
-`,
-    "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": {
-		"devflare": "^0.1.0",
-		"typescript": "^5.7.0"
-	}
-}
-`,
-    "tsconfig.json": `{
-	"compilerOptions": {
-		"target": "ESNext",
-		"module": "ESNext",
-		"moduleResolution": "bundler",
-		"strict": true,
-		"skipLibCheck": true,
-		"types": ["@cloudflare/workers-types"]
-	},
-	"include": ["src/**/*", "devflare.config.ts"]
-}
-`
-  }
-};
-var API_TEMPLATE = {
-  name: "api",
-  description: "API starter with middleware and routing",
-  files: {
-    "devflare.config.ts": `import { defineConfig } from 'devflare'
-
-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' }],
-	}
-})
-`,
-    "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 })
-	)
-)
-
-export default {
-	async fetch(request: Request, env: unknown, ctx: ExecutionContext): Promise<Response> {
-		return handler()
-	}
-}
-`,
-    "src/middleware/cors.ts": `import type { Middleware } from 'devflare/runtime'
-import { event } from 'devflare/runtime'
-
-export const corsMiddleware: Middleware = async (next) => {
-	// 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 next()
-	const newResponse = new Response(response.body, response)
-	newResponse.headers.set('Access-Control-Allow-Origin', '*')
-	return newResponse
-}
-`,
-    "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)
-
-	if (url.pathname === '/api/health') {
-		return new Response(JSON.stringify({ status: 'ok' }), {
-			headers: { 'Content-Type': 'application/json' }
-		})
-	}
-
-	if (url.pathname.startsWith('/api/')) {
-		return new Response(JSON.stringify({ error: 'Not found' }), {
-			status: 404,
-			headers: { 'Content-Type': 'application/json' }
-		})
-	}
-
-	// Not an API route, pass through
-	return null
-}
-`,
-    "package.json": MINIMAL_TEMPLATE.files["package.json"],
-    "tsconfig.json": MINIMAL_TEMPLATE.files["tsconfig.json"]
-  }
-};
-var TEMPLATES = {
-  minimal: MINIMAL_TEMPLATE,
-  api: API_TEMPLATE
-};
-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 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 { 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);
-    await fs.writeFile(fullPath, processedContent, "utf-8");
-    logger.info(`  Created: ${filePath}`);
-  }
-  logger.success(`
-Project created successfully!`);
-  logger.info(`
-Next steps:`);
-  logger.info(`  cd ${projectName}`);
-  logger.info(`  bun install`);
-  logger.info(`  bun run dev`);
-  return { exitCode: 0 };
-}
-export {
-  runInitCommand
-};