devflare 1.0.0-next.3 → 1.0.0-next.31

package/dist/index-stgn34cr.js

@@ -0,0 +1,148 @@
+import {
+  BOLD,
+  CYAN,
+  CYAN_BOLD,
+  DIM,
+  GREEN,
+  RED,
+  RESET,
+  WHITE,
+  YELLOW
+} from "./index-3t6rypgc.js";
+
+// src/cli/ui.ts
+var ANSI_REGEX = /\x1b\[[0-9;]*m/g;
+function createCliTheme(options = {}) {
+  if (options["no-color"] === true) {
+    return { useColor: false };
+  }
+  if (process.env.NO_COLOR?.trim()) {
+    return { useColor: false };
+  }
+  if (process.env.TERM === "dumb") {
+    return { useColor: false };
+  }
+  return {
+    useColor: process.stdout?.isTTY === true
+  };
+}
+function paint(value, code, theme) {
+  return theme.useColor ? `${code}${value}${RESET}` : value;
+}
+function dim(value, theme) {
+  return paint(value, DIM, theme);
+}
+function bold(value, theme) {
+  return paint(value, BOLD, theme);
+}
+function cyan(value, theme) {
+  return paint(value, CYAN, theme);
+}
+function cyanBold(value, theme) {
+  return paint(value, CYAN_BOLD, theme);
+}
+function green(value, theme) {
+  return paint(value, GREEN, theme);
+}
+function yellow(value, theme) {
+  return paint(value, YELLOW, theme);
+}
+function yellowBold(value, theme) {
+  return paint(value, `${BOLD}${YELLOW}`, theme);
+}
+function red(value, theme) {
+  return paint(value, RED, theme);
+}
+function whiteDim(value, theme) {
+  return paint(value, `${DIM}${WHITE}`, theme);
+}
+function accent(value, theme, kind = "cyan") {
+  switch (kind) {
+    case "yellow":
+      return yellowBold(value, theme);
+    case "green":
+      return green(value, theme);
+    case "red":
+      return red(value, theme);
+    case "dim":
+      return dim(value, theme);
+    case "bold":
+      return bold(value, theme);
+    case "white-dim":
+      return whiteDim(value, theme);
+    case "cyan":
+    default:
+      return cyanBold(value, theme);
+  }
+}
+function logLine(logger, message = "") {
+  logger.log(message);
+}
+function stripAnsi(value) {
+  return value.replace(ANSI_REGEX, "");
+}
+function truncateCell(value, width) {
+  if (value.length <= width) {
+    return value;
+  }
+  if (width <= 1) {
+    return "…";
+  }
+  return `${value.slice(0, width - 1)}…`;
+}
+function truncateStyledCell(value, width) {
+  const plainValue = stripAnsi(value);
+  if (plainValue.length <= width) {
+    return value;
+  }
+  const truncatedPlainValue = truncateCell(plainValue, width);
+  const prefixMatch = value.match(/^((?:\x1b\[[0-9;]*m)+)/);
+  const suffixMatch = value.match(/((?:\x1b\[[0-9;]*m)+)$/);
+  const prefix = prefixMatch?.[1] ?? "";
+  const suffix = prefix ? RESET : suffixMatch?.[1] ?? "";
+  return `${prefix}${truncatedPlainValue}${suffix}`;
+}
+function padStyledCell(value, width) {
+  const truncatedValue = truncateStyledCell(value, width);
+  const visibleLength = stripAnsi(truncatedValue).length;
+  return `${truncatedValue}${" ".repeat(Math.max(width - visibleLength, 0))}`;
+}
+function formatTableLine(values, widths) {
+  return values.map((value, index) => {
+    const width = widths[index];
+    if (width === undefined || index === values.length - 1) {
+      return value;
+    }
+    return padStyledCell(value, width);
+  }).join("  ");
+}
+function renderTable(rows, columns, theme) {
+  if (rows.length === 0) {
+    return [];
+  }
+  const widths = columns.map((column) => column.width);
+  return [
+    formatTableLine(columns.map((column) => dim(column.label, theme)), widths),
+    ...rows.map((row) => formatTableLine(columns.map((column) => column.value(row)), widths))
+  ];
+}
+function logTable(logger, options) {
+  if (options.rows.length === 0) {
+    return;
+  }
+  logLine(logger, `${accent(options.title, options.theme, options.titleAccent)} ${dim(`(${options.rows.length})`, options.theme)}`);
+  for (const line of renderTable(options.rows, options.columns, options.theme)) {
+    logLine(logger, line);
+  }
+}
+function formatLabelValue(label, value, theme, labelWidth = 12) {
+  return `${dim(label.padEnd(labelWidth), theme)} ${value}`;
+}
+function formatCommand(command, description, theme) {
+  return `  ${cyan(command, theme)}${dim(" — ", theme)}${description}`;
+}
+function formatBullet(text, theme, bullet = "•") {
+  return `  ${dim(bullet, theme)} ${text}`;
+}
+
+export { createCliTheme, dim, bold, cyan, cyanBold, green, yellow, yellowBold, red, whiteDim, accent, logLine, formatTableLine, logTable, formatLabelValue, formatCommand, formatBullet };

package/dist/index-t9y0sve5.js

@@ -0,0 +1,155 @@
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// src/test/binding-hints.ts
+function extractBindingHints(config) {
+  const hints = {};
+  if (config.bindings?.kv) {
+    for (const name of Object.keys(config.bindings.kv)) {
+      hints[name] = "kv";
+    }
+  }
+  if (config.bindings?.r2) {
+    for (const name of Object.keys(config.bindings.r2)) {
+      hints[name] = "r2";
+    }
+  }
+  if (config.bindings?.d1) {
+    for (const name of Object.keys(config.bindings.d1)) {
+      hints[name] = "d1";
+    }
+  }
+  if (config.bindings?.durableObjects) {
+    for (const name of Object.keys(config.bindings.durableObjects)) {
+      hints[name] = "do";
+    }
+  }
+  if (config.bindings?.services) {
+    for (const name of Object.keys(config.bindings.services)) {
+      hints[name] = "service";
+    }
+  }
+  if (config.bindings?.queues?.consumers) {
+    for (const consumer of config.bindings.queues.consumers) {
+      hints[consumer.queue] = "queue";
+    }
+  }
+  if (config.bindings?.queues?.producers) {
+    for (const name of Object.keys(config.bindings.queues.producers)) {
+      hints[name] = "queue";
+    }
+  }
+  if (config.bindings?.ai) {
+    hints[config.bindings.ai.binding] = "ai";
+  }
+  if (config.bindings?.sendEmail) {
+    for (const name of Object.keys(config.bindings.sendEmail)) {
+      hints[name] = "sendEmail";
+    }
+  }
+  if (config.bindings?.workflows) {
+    for (const name of Object.keys(config.bindings.workflows)) {
+      hints[name] = "workflow";
+    }
+  }
+  return hints;
+}
+
+// src/shims/local-hyperdrive.ts
+var HYPERDRIVE_CONNECT_MESSAGE = "Local Hyperdrive does not implement the raw socket connect(). " + "Use the populated connection fields (connectionString, or host/port/user/password/database) " + "with your Node database driver, or run a createTestContext()/Miniflare-backed test " + "(Miniflare establishes real Hyperdrive socket connections) for socket-level behavior.";
+function defaultPortForDatabaseUrl(url) {
+  if (url.port) {
+    return Number(url.port);
+  }
+  return url.protocol === "mysql:" ? 3306 : 5432;
+}
+function createLocalHyperdrive(connectionString) {
+  const url = new URL(connectionString);
+  return {
+    connectionString,
+    host: url.hostname,
+    port: defaultPortForDatabaseUrl(url),
+    user: decodeURIComponent(url.username),
+    password: decodeURIComponent(url.password),
+    database: decodeURIComponent(url.pathname.replace(/^\//, "")),
+    connect() {
+      throw new Error(HYPERDRIVE_CONNECT_MESSAGE);
+    }
+  };
+}
+
+// src/shims/local-worker-loader.ts
+var activeWorkerLoaderRuntimes = new Set;
+function getModuleSource(module, mainModule) {
+  if (typeof module === "string") {
+    return module;
+  }
+  if (module && typeof module === "object" && typeof module.js === "string") {
+    return module.js;
+  }
+  throw new Error(`Worker Loader local shim only supports JavaScript main modules. Could not load "${mainModule}".`);
+}
+function createRequestInit(request) {
+  return {
+    method: request.method,
+    headers: request.headers,
+    body: request.body
+  };
+}
+async function createRuntime(code) {
+  const { Miniflare } = await import("miniflare");
+  const mainModule = code.mainModule;
+  const script = getModuleSource(code.modules[mainModule], mainModule);
+  const miniflare = new Miniflare({
+    modules: true,
+    compatibilityDate: code.compatibilityDate,
+    ...code.compatibilityFlags && { compatibilityFlags: code.compatibilityFlags },
+    ...code.env && { bindings: code.env },
+    script
+  });
+  await miniflare.ready;
+  activeWorkerLoaderRuntimes.add(miniflare);
+  return miniflare;
+}
+function createLocalWorkerStub(codeProvider) {
+  let runtimePromise = null;
+  const getRuntime = () => {
+    runtimePromise ??= Promise.resolve(codeProvider()).then(createRuntime);
+    return runtimePromise;
+  };
+  const fetcher = {
+    async fetch(input, init) {
+      const request = input instanceof Request ? input : new Request(input, init);
+      const runtime = await getRuntime();
+      return runtime.dispatchFetch(request.url, createRequestInit(request));
+    }
+  };
+  return {
+    getEntrypoint() {
+      return fetcher;
+    },
+    getDurableObjectClass() {
+      throw new Error("Worker Loader local shim cannot materialise a dynamic Durable Object class. getDurableObjectClass() returns an opaque facet-spawning reference that workerd only exposes inside the runtime. Use createTestContext() (a real Miniflare worker) for Durable Object behavior, or createMockWorkerLoader({ stub }) to inject a stub.");
+    }
+  };
+}
+function createLocalWorkerLoaderBinding() {
+  return {
+    get(_name, getCode) {
+      return createLocalWorkerStub(getCode);
+    },
+    load(code) {
+      return createLocalWorkerStub(() => code);
+    }
+  };
+}
+async function disposeLocalWorkerLoaderBindings() {
+  const runtimes = Array.from(activeWorkerLoaderRuntimes);
+  activeWorkerLoaderRuntimes.clear();
+  await Promise.all(runtimes.map(async (runtime) => {
+    await runtime.dispose();
+  }));
+}
+
+export { extractBindingHints, createLocalHyperdrive, createLocalWorkerLoaderBinding, disposeLocalWorkerLoaderBindings };

package/dist/index-vez803pp.js

@@ -0,0 +1,52 @@
+import {
+  findFiles
+} from "./index-qwgr4q7s.js";
+import {
+  resolveConfigPath
+} from "./index-dfcp9hsd.js";
+
+// src/cli/config-path.ts
+import { stat } from "node:fs/promises";
+var CONFIG_FILE_EXTENSIONS = [".ts", ".mts", ".js", ".mjs"];
+var SUPPORTED_CONFIG_FILENAMES = CONFIG_FILE_EXTENSIONS.map((extension) => `devflare.config${extension}`);
+function hasKnownConfigExtension(filePath) {
+  return CONFIG_FILE_EXTENSIONS.some((extension) => filePath.endsWith(extension));
+}
+async function getExistingFilePath(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    return fileStat.isFile() ? filePath : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveConfigCandidatePath(candidatePath) {
+  const candidates = [candidatePath];
+  if (!hasKnownConfigExtension(candidatePath)) {
+    for (const extension of CONFIG_FILE_EXTENSIONS) {
+      candidates.push(`${candidatePath}${extension}`);
+    }
+  }
+  for (const candidate of candidates) {
+    const existingFilePath = await getExistingFilePath(candidate);
+    if (existingFilePath) {
+      return existingFilePath;
+    }
+  }
+  return await resolveConfigPath(candidatePath) ?? null;
+}
+async function findConfigPathsUnderDirectory(rootDir) {
+  const matches = await findFiles([
+    ...SUPPORTED_CONFIG_FILENAMES,
+    ...SUPPORTED_CONFIG_FILENAMES.map((filename) => `**/${filename}`)
+  ], {
+    cwd: rootDir,
+    absolute: true
+  });
+  return [...new Set(matches)].sort((left, right) => left.localeCompare(right));
+}
+function formatSupportedConfigFilenames() {
+  return SUPPORTED_CONFIG_FILENAMES.join(", ");
+}
+
+export { resolveConfigCandidatePath, findConfigPathsUnderDirectory, formatSupportedConfigFilenames };

package/dist/index-vhqww6tt.js

@@ -0,0 +1,307 @@
+// src/transform/durable-object.ts
+import ts from "typescript";
+import MagicString from "magic-string";
+function getBaseIdentifierName(expr) {
+  if (ts.isIdentifier(expr)) {
+    return expr.text;
+  }
+  if (ts.isPropertyAccessExpression(expr)) {
+    return expr.name.text;
+  }
+  return;
+}
+function extendsDurableObject(node) {
+  const clauses = node.heritageClauses;
+  if (!clauses)
+    return false;
+  for (const clause of clauses) {
+    if (clause.token !== ts.SyntaxKind.ExtendsKeyword)
+      continue;
+    for (const type of clause.types) {
+      const name = getBaseIdentifierName(type.expression);
+      if (name === "DurableObject")
+        return true;
+    }
+  }
+  return false;
+}
+function getDurableObjectDecorator(node) {
+  const decorators = ts.canHaveDecorators(node) ? ts.getDecorators(node) : undefined;
+  if (!decorators)
+    return;
+  for (const decorator of decorators) {
+    const expr = decorator.expression;
+    if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression) && expr.expression.text === "durableObject") {
+      return decorator;
+    }
+    if (ts.isIdentifier(expr) && expr.text === "durableObject") {
+      return decorator;
+    }
+  }
+  return;
+}
+function parseDecoratorOptions(decorator) {
+  const expr = decorator.expression;
+  if (!ts.isCallExpression(expr))
+    return;
+  const arg = expr.arguments[0];
+  if (!arg || !ts.isObjectLiteralExpression(arg))
+    return;
+  const result = {};
+  for (const prop of arg.properties) {
+    if (!ts.isPropertyAssignment(prop))
+      continue;
+    let key;
+    if (ts.isIdentifier(prop.name))
+      key = prop.name.text;
+    else if (ts.isStringLiteral(prop.name))
+      key = prop.name.text;
+    if (!key)
+      continue;
+    const value = prop.initializer;
+    if (value.kind === ts.SyntaxKind.TrueKeyword) {
+      result[key] = true;
+    } else if (value.kind === ts.SyntaxKind.FalseKeyword) {
+      result[key] = false;
+    } else if (ts.isStringLiteralLike(value)) {
+      result[key] = value.text;
+    } else if (ts.isNumericLiteral(value)) {
+      result[key] = Number(value.text);
+    } else if (ts.isArrayLiteralExpression(value)) {
+      const items = [];
+      for (const el of value.elements) {
+        if (ts.isStringLiteralLike(el))
+          items.push(el.text);
+      }
+      result[key] = items;
+    }
+  }
+  return result;
+}
+function collectDurableObjectClasses(code) {
+  const sourceFile = ts.createSourceFile("durable-object.tsx", code, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+  const classMap = new Map;
+  const inspect = (node) => {
+    if (!node.name)
+      return;
+    const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
+    const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    if (!isExported)
+      return;
+    const name = node.name.text;
+    const extendsBase = extendsDurableObject(node);
+    const decorator = getDurableObjectDecorator(node);
+    const hasDecorator = decorator !== undefined;
+    if (!extendsBase && !hasDecorator)
+      return;
+    const existing = classMap.get(name);
+    const info = existing ?? { name, extendsBase: false, hasDecorator: false };
+    if (extendsBase)
+      info.extendsBase = true;
+    if (hasDecorator) {
+      info.hasDecorator = true;
+      const options = parseDecoratorOptions(decorator);
+      if (options)
+        info.decoratorOptions = options;
+    }
+    classMap.set(name, info);
+  };
+  for (const statement of sourceFile.statements) {
+    if (ts.isClassDeclaration(statement)) {
+      inspect(statement);
+    }
+  }
+  return Array.from(classMap.values());
+}
+function findDurableObjectClasses(code) {
+  return collectDurableObjectClasses(code).map((info) => info.name);
+}
+function findDurableObjectClassesDetailed(code) {
+  return collectDurableObjectClasses(code);
+}
+function generateWrapper(className, options = {}) {
+  const includeAlarms = options.alarms ?? false;
+  const includeWebsockets = options.websockets ?? false;
+  let wrapper = `
+// ============ Devflare DO Wrapper for ${className} ============
+import { createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, runWithEventContext } from 'devflare/runtime'
+
+const __Original${className} = ${className}
+
+class ${className}Wrapper extends __Original${className} {
+	async fetch(request: Request): Promise<Response> {
+		const __devflareEvent = createDurableObjectFetchEvent(request, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.fetch(__devflareEvent)
+		)
+	}
+`;
+  if (includeAlarms) {
+    wrapper += `
+	async alarm(): Promise<void> {
+		const __devflareEvent = createDurableObjectAlarmEvent(this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.alarm?.(__devflareEvent) ?? Promise.resolve()
+		)
+	}
+`;
+  }
+  if (includeWebsockets) {
+    wrapper += `
+	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketMessageEvent(ws, message, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketMessage?.(__devflareEvent, message) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketClose?.(__devflareEvent, code, reason, wasClean) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketErrorEvent(ws, error, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketError?.(__devflareEvent, error) ?? Promise.resolve()
+		)
+	}
+`;
+  }
+  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 { createDurableObjectAlarmEvent, createDurableObjectFetchEvent, createDurableObjectWebSocketCloseEvent, createDurableObjectWebSocketErrorEvent, createDurableObjectWebSocketMessageEvent, runWithEventContext } 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> {
+		const __devflareEvent = createDurableObjectFetchEvent(request, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.fetch(__devflareEvent)
+		)
+	}
+`;
+  if (options.alarms) {
+    wrapper += `
+	async alarm(): Promise<void> {
+		const __devflareEvent = createDurableObjectAlarmEvent(this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.alarm?.(__devflareEvent) ?? Promise.resolve()
+		)
+	}
+`;
+  }
+  if (options.websockets) {
+    wrapper += `
+	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketMessageEvent(ws, message, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketMessage?.(__devflareEvent, message) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketClose(ws: WebSocket, code: number, reason: string, wasClean: boolean): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketCloseEvent(ws, code, reason, wasClean, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketClose?.(__devflareEvent, code, reason, wasClean) ?? Promise.resolve()
+		)
+	}
+
+	async webSocketError(ws: WebSocket, error: unknown): Promise<void> {
+		const __devflareEvent = createDurableObjectWebSocketErrorEvent(ws, error, this.env, this.ctx)
+		return runWithEventContext(
+			__devflareEvent,
+			() => super.webSocketError?.(__devflareEvent, error) ?? Promise.resolve()
+		)
+	}
+`;
+  }
+  wrapper += `}
+
+export { ${className}Wrapper as ${className} }
+// ============ End Devflare DO Wrapper ============
+`;
+  return wrapper;
+}
+
+export { findDurableObjectClasses, findDurableObjectClassesDetailed, generateWrapper, transformDurableObject };