devflare 0.0.0 → 1.0.0-next.0

package/dist/index-gz1gndna.js

@@ -0,0 +1,307 @@
+// src/transform/durable-object.ts
+import MagicString from "magic-string";
+var DO_CLASS_REGEX = /export\s+class\s+(\w+)\s+extends\s+DurableObject(?:<[^>]+>)?(?:\s+implements\s+[\w,\s]+)?\s*\{/g;
+var DECORATOR_CLASS_REGEX = /@durableObject\s*\([^)]*\)\s*\n?\s*export\s+class\s+(\w+)/g;
+function findDurableObjectClasses(code) {
+  const classes = new Set;
+  DO_CLASS_REGEX.lastIndex = 0;
+  DECORATOR_CLASS_REGEX.lastIndex = 0;
+  let match;
+  while ((match = DO_CLASS_REGEX.exec(code)) !== null) {
+    classes.add(match[1]);
+  }
+  while ((match = DECORATOR_CLASS_REGEX.exec(code)) !== null) {
+    classes.add(match[1]);
+  }
+  return Array.from(classes);
+}
+function findDurableObjectClassesDetailed(code) {
+  const classMap = new Map;
+  DO_CLASS_REGEX.lastIndex = 0;
+  DECORATOR_CLASS_REGEX.lastIndex = 0;
+  let match;
+  while ((match = DO_CLASS_REGEX.exec(code)) !== null) {
+    const name = match[1];
+    classMap.set(name, {
+      name,
+      extendsBase: true,
+      hasDecorator: false
+    });
+  }
+  const decoratorWithOptionsRegex = /@durableObject\s*\((\{[^}]*\})?\)\s*\n?\s*export\s+class\s+(\w+)/g;
+  while ((match = decoratorWithOptionsRegex.exec(code)) !== null) {
+    const optionsStr = match[1];
+    const name = match[2];
+    const existing = classMap.get(name);
+    if (existing) {
+      existing.hasDecorator = true;
+      if (optionsStr) {
+        try {
+          existing.decoratorOptions = parseSimpleObject(optionsStr);
+        } catch {}
+      }
+    } else {
+      const info = {
+        name,
+        extendsBase: false,
+        hasDecorator: true
+      };
+      if (optionsStr) {
+        try {
+          info.decoratorOptions = parseSimpleObject(optionsStr);
+        } catch {}
+      }
+      classMap.set(name, info);
+    }
+  }
+  return Array.from(classMap.values());
+}
+function parseSimpleObject(str) {
+  const result = {};
+  const inner = str.trim().slice(1, -1);
+  let depth = 0;
+  let current = "";
+  const pairs = [];
+  for (const char of inner) {
+    if (char === "[")
+      depth++;
+    else if (char === "]")
+      depth--;
+    else if (char === "," && depth === 0) {
+      pairs.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim())
+    pairs.push(current.trim());
+  for (const pair of pairs) {
+    const colonIndex = pair.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = pair.slice(0, colonIndex).trim();
+    const valueStr = pair.slice(colonIndex + 1).trim();
+    if (valueStr === "true") {
+      result[key] = true;
+    } else if (valueStr === "false") {
+      result[key] = false;
+    } else if (valueStr.startsWith("[")) {
+      const arrayContent = valueStr.slice(1, -1);
+      result[key] = arrayContent.split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, ""));
+    } else if (valueStr.startsWith("'") || valueStr.startsWith('"')) {
+      result[key] = valueStr.slice(1, -1);
+    } else if (!isNaN(Number(valueStr))) {
+      result[key] = Number(valueStr);
+    } else {
+      result[key] = valueStr;
+    }
+  }
+  return result;
+}
+function generateWrapper(className, options = {}) {
+  const includeAlarms = options.alarms ?? false;
+  const includeWebsockets = options.websockets ?? false;
+  let wrapper = `
+// ============ Devflare DO Wrapper for ${className} ============
+import { runWithContext } from 'devflare/runtime'
+
+const __Original${className} = ${className}
+
+class ${className}Wrapper extends __Original${className} {
+	async fetch(request: Request): Promise<Response> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			request,
+			() => super.fetch(request),
+			'fetch'
+		)
+	}
+`;
+  if (includeAlarms) {
+    wrapper += `
+	async alarm(): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.alarm?.() ?? Promise.resolve(),
+			'scheduled'
+		)
+	}
+`;
+  }
+  if (includeWebsockets) {
+    wrapper += `
+	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketMessage?.(ws, message) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketClose?.(ws, code, reason, wasClean) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+
+	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketError?.(ws, error) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+`;
+  }
+  wrapper += `}
+
+export { ${className}Wrapper as ${className} }
+// ============ End Devflare DO Wrapper ============
+`;
+  return wrapper;
+}
+async function transformDurableObject(code, id) {
+  const doClasses = findDurableObjectClassesDetailed(code);
+  if (doClasses.length === 0) {
+    return null;
+  }
+  const s = new MagicString(code);
+  for (const classInfo of doClasses) {
+    const className = classInfo.name;
+    if (classInfo.extendsBase) {
+      const exportPattern = new RegExp(`export\\s+class\\s+${className}\\s+extends\\s+DurableObject`, "g");
+      let match;
+      while ((match = exportPattern.exec(code)) !== null) {
+        const start = match.index;
+        const exportKeywordEnd = start + "export ".length;
+        s.overwrite(start, exportKeywordEnd, "");
+        const classNameStart = start + match[0].indexOf(className);
+        const classNameEnd = classNameStart + className.length;
+        s.overwrite(classNameStart, classNameEnd, `__Original${className}`);
+      }
+    } else if (classInfo.hasDecorator) {
+      const decoratorPattern = new RegExp(`@durableObject\\s*\\([^)]*\\)\\s*\\n?\\s*export\\s+class\\s+${className}(?:\\s+extends\\s+(\\w+))?`, "g");
+      let match;
+      while ((match = decoratorPattern.exec(code)) !== null) {
+        const start = match.index;
+        const existingBaseClass = match[1];
+        const decoratorEnd = code.indexOf(")", start) + 1;
+        const exportStart = code.indexOf("export", decoratorEnd);
+        const classDefEnd = start + match[0].length;
+        s.overwrite(start, exportStart, "");
+        const classNameStart = code.indexOf(className, exportStart);
+        const classNameEnd = classNameStart + className.length;
+        if (existingBaseClass) {
+          s.overwrite(classNameStart, classNameEnd, `__Original${className}`);
+        } else {
+          s.overwrite(classNameStart, classDefEnd, `__Original${className} extends DurableObject`);
+        }
+      }
+    }
+  }
+  const imports = `
+import { runWithContext } from 'devflare/runtime'
+`;
+  s.prepend(imports);
+  for (const classInfo of doClasses) {
+    const className = classInfo.name;
+    const options = classInfo.decoratorOptions || {};
+    const includeAlarms = options.alarms === true;
+    const includeWebsockets = options.websockets === true;
+    const wrapper = generateWrapperCodeInternal(className, {
+      alarms: includeAlarms,
+      websockets: includeWebsockets
+    });
+    s.append(wrapper);
+  }
+  return {
+    code: s.toString(),
+    map: s.generateMap({
+      source: id,
+      file: id + ".map",
+      includeContent: true
+    })
+  };
+}
+function generateWrapperCodeInternal(className, options) {
+  let wrapper = `
+
+// ============ Devflare DO Wrapper for ${className} ============
+class ${className}Wrapper extends __Original${className} {
+	async fetch(request: Request): Promise<Response> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			request,
+			() => super.fetch(request),
+			'fetch'
+		)
+	}
+`;
+  if (options.alarms) {
+    wrapper += `
+	async alarm(): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.alarm?.() ?? Promise.resolve(),
+			'scheduled'
+		)
+	}
+`;
+  }
+  if (options.websockets) {
+    wrapper += `
+	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketMessage?.(ws, message) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketClose?.(ws, code, reason, wasClean) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+
+	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+		return runWithContext(
+			this.env,
+			this.ctx,
+			null,
+			() => super.webSocketError?.(ws, error) ?? Promise.resolve(),
+			'fetch'
+		)
+	}
+`;
+  }
+  wrapper += `}
+
+export { ${className}Wrapper as ${className} }
+// ============ End Devflare DO Wrapper ============
+`;
+  return wrapper;
+}
+
+export { findDurableObjectClasses, findDurableObjectClassesDetailed, generateWrapper, transformDurableObject };

package/dist/index-hcex3rgh.js

@@ -0,0 +1,266 @@
+// src/config/schema.ts
+import { z } from "zod";
+var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
+var compatibilityDateSchema = z.string().regex(dateRegex, {
+  message: "Compatibility date must be in YYYY-MM-DD format"
+});
+var routesConfigSchema = z.object({
+  dir: z.string(),
+  prefix: z.string().optional()
+});
+var filesSchema = z.object({
+  fetch: z.union([z.string(), z.literal(false)]).optional(),
+  queue: z.union([z.string(), z.literal(false)]).optional(),
+  scheduled: z.union([z.string(), z.literal(false)]).optional(),
+  email: z.union([z.string(), z.literal(false)]).optional(),
+  durableObjects: z.union([z.string(), z.literal(false)]).optional(),
+  entrypoints: z.union([z.string(), z.literal(false)]).optional(),
+  workflows: z.union([z.string(), z.literal(false)]).optional(),
+  routes: z.union([routesConfigSchema, z.literal(false)]).optional(),
+  transport: z.string().optional()
+}).optional();
+var durableObjectBindingSchema = z.custom((val) => {
+  if (typeof val === "string")
+    return true;
+  if (val && typeof val === "object" && "className" in val) {
+    const obj = val;
+    return typeof obj.className === "string";
+  }
+  return false;
+}, {
+  message: "Expected string or { className: string, scriptName?: string }"
+});
+var queueConsumerSchema = z.object({
+  queue: z.string(),
+  maxBatchSize: z.number().optional(),
+  maxBatchTimeout: z.number().optional(),
+  maxRetries: z.number().optional(),
+  deadLetterQueue: z.string().optional(),
+  maxConcurrency: z.number().optional(),
+  retryDelay: z.number().optional()
+});
+var queuesConfigSchema = z.object({
+  producers: z.record(z.string(), z.string()).optional(),
+  consumers: z.array(queueConsumerSchema).optional()
+});
+var serviceBindingSchema = z.custom((val) => {
+  if (typeof val !== "object" && typeof val !== "function")
+    return false;
+  const obj = val;
+  const service = obj.service;
+  if (typeof service !== "string")
+    return false;
+  return true;
+}, {
+  message: "Expected service binding object with { service: string } or ref().worker"
+});
+var aiBindingSchema = z.object({
+  binding: z.string()
+});
+var vectorizeBindingSchema = z.object({
+  indexName: z.string()
+});
+var hyperdriveBindingSchema = z.object({
+  id: z.string()
+});
+var browserBindingSchema = z.object({
+  binding: z.string()
+});
+var analyticsBindingSchema = z.object({
+  dataset: z.string()
+});
+var sendEmailBindingSchema = z.object({
+  destinationAddress: z.string().optional()
+});
+var bindingsSchema = z.object({
+  kv: z.record(z.string(), z.string()).optional(),
+  d1: z.record(z.string(), z.string()).optional(),
+  r2: z.record(z.string(), z.string()).optional(),
+  durableObjects: z.record(z.string(), durableObjectBindingSchema).optional(),
+  queues: queuesConfigSchema.optional(),
+  services: z.record(z.string(), serviceBindingSchema).optional(),
+  ai: aiBindingSchema.optional(),
+  vectorize: z.record(z.string(), vectorizeBindingSchema).optional(),
+  hyperdrive: z.record(z.string(), hyperdriveBindingSchema).optional(),
+  browser: browserBindingSchema.optional(),
+  analyticsEngine: z.record(z.string(), analyticsBindingSchema).optional(),
+  sendEmail: z.record(z.string(), sendEmailBindingSchema).optional()
+}).optional();
+var triggersSchema = z.object({
+  crons: z.array(z.string()).optional()
+}).optional();
+var secretConfigSchema = z.object({
+  required: z.boolean().optional().default(true)
+});
+var routeConfigSchema = z.object({
+  pattern: z.string(),
+  zone_name: z.string().optional(),
+  zone_id: z.string().optional(),
+  custom_domain: z.boolean().optional()
+});
+var wsRouteConfigSchema = z.object({
+  pattern: z.string(),
+  doNamespace: z.string(),
+  idParam: z.string().default("id"),
+  forwardPath: z.string().default("/websocket")
+});
+var assetsConfigSchema = z.object({
+  directory: z.string(),
+  binding: z.string().optional()
+}).optional();
+var observabilitySchema = z.object({
+  enabled: z.boolean().optional(),
+  head_sampling_rate: z.number().min(0).max(1).optional()
+}).optional();
+var limitsSchema = z.object({
+  cpu_ms: z.number().optional()
+}).optional();
+var buildConfigSchema = z.object({
+  target: z.string().optional(),
+  minify: z.boolean().optional(),
+  sourcemap: z.boolean().optional(),
+  rolldownOptions: z.record(z.string(), z.unknown()).optional()
+}).optional();
+var migrationSchema = z.object({
+  tag: z.string(),
+  new_classes: z.array(z.string()).optional(),
+  renamed_classes: z.array(z.object({
+    from: z.string(),
+    to: z.string()
+  })).optional(),
+  deleted_classes: z.array(z.string()).optional(),
+  new_sqlite_classes: z.array(z.string()).optional()
+});
+var wranglerConfigSchema = z.object({
+  passthrough: z.record(z.string(), z.unknown()).optional()
+}).optional();
+var envConfigSchemaInner = z.object({
+  name: z.string().optional(),
+  compatibilityDate: compatibilityDateSchema.optional(),
+  compatibilityFlags: z.array(z.string()).optional(),
+  files: filesSchema,
+  bindings: bindingsSchema,
+  triggers: triggersSchema,
+  vars: z.record(z.string(), z.string()).optional(),
+  secrets: z.record(z.string(), secretConfigSchema).optional(),
+  routes: z.array(routeConfigSchema).optional(),
+  assets: assetsConfigSchema,
+  limits: limitsSchema,
+  observability: observabilitySchema,
+  migrations: z.array(migrationSchema).optional(),
+  build: buildConfigSchema,
+  wrangler: wranglerConfigSchema
+}).partial();
+function getCurrentDate() {
+  const now = new Date;
+  return now.toISOString().split("T")[0];
+}
+var FORCED_COMPATIBILITY_FLAGS = ["nodejs_compat", "nodejs_als"];
+var configSchema = z.object({
+  name: z.string({
+    required_error: "Worker name is required"
+  }),
+  accountId: z.string().optional(),
+  compatibilityDate: compatibilityDateSchema.optional().default(getCurrentDate),
+  compatibilityFlags: z.array(z.string()).optional().transform((flags = []) => {
+    const merged = new Set([...FORCED_COMPATIBILITY_FLAGS, ...flags]);
+    return [...merged];
+  }),
+  files: filesSchema,
+  bindings: bindingsSchema,
+  triggers: triggersSchema,
+  vars: z.record(z.string(), z.string()).optional(),
+  secrets: z.record(z.string(), secretConfigSchema).optional(),
+  routes: z.array(routeConfigSchema).optional(),
+  wsRoutes: z.array(wsRouteConfigSchema).optional(),
+  assets: assetsConfigSchema,
+  limits: limitsSchema,
+  observability: observabilitySchema,
+  migrations: z.array(migrationSchema).optional(),
+  build: buildConfigSchema,
+  plugins: z.array(z.unknown()).optional(),
+  env: z.record(z.string(), envConfigSchemaInner).optional(),
+  wrangler: wranglerConfigSchema
+});
+function normalizeDOBinding(config) {
+  if (typeof config === "string") {
+    return { className: config };
+  }
+  return {
+    className: config.className,
+    scriptName: config.scriptName,
+    __ref: config.__ref
+  };
+}
+
+// src/config/loader.ts
+import { loadConfig as c12LoadConfig } from "c12";
+import { existsSync } from "node:fs";
+import { join } from "pathe";
+var CONFIG_FILES = [
+  "devflare.config.ts",
+  "devflare.config.mts",
+  "devflare.config.js",
+  "devflare.config.mjs"
+];
+async function resolveConfigPath(cwd) {
+  for (const file of CONFIG_FILES) {
+    const path = join(cwd, file);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return;
+}
+async function loadConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const configFile = options.configFile ?? "devflare.config";
+  const { config, configFile: loadedFile } = await c12LoadConfig({
+    name: "devflare",
+    cwd,
+    configFile,
+    defaultConfig: undefined,
+    rcFile: false,
+    globalRc: false,
+    dotenv: false
+  });
+  if (!config || !loadedFile) {
+    throw new ConfigNotFoundError(cwd, configFile);
+  }
+  const result = configSchema.safeParse(config);
+  if (!result.success) {
+    throw new ConfigValidationError(result.error.issues, loadedFile);
+  }
+  return result.data;
+}
+
+class ConfigNotFoundError extends Error {
+  cwd;
+  configFile;
+  code = "CONFIG_NOT_FOUND";
+  constructor(cwd, configFile) {
+    super(`Config file not found in ${cwd}.
+` + `Expected one of: ${CONFIG_FILES.join(", ")}
+` + `Run 'devflare init' to create a new config.`);
+    this.cwd = cwd;
+    this.configFile = configFile;
+    this.name = "ConfigNotFoundError";
+  }
+}
+
+class ConfigValidationError extends Error {
+  issues;
+  configFile;
+  code = "CONFIG_VALIDATION_ERROR";
+  constructor(issues, configFile) {
+    const issueMessages = issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join(`
+`);
+    super(`Invalid config in ${configFile}:
+${issueMessages}`);
+    this.issues = issues;
+    this.configFile = configFile;
+    this.name = "ConfigValidationError";
+  }
+}
+
+export { configSchema, normalizeDOBinding, resolveConfigPath, loadConfig, ConfigNotFoundError, ConfigValidationError };