lopata 0.0.1

package/runtime/bindings/crypto-extras.ts

@@ -0,0 +1,89 @@
+/**
+ * Cloudflare-specific crypto APIs: crypto.subtle.timingSafeEqual and crypto.DigestStream.
+ */
+
+import { timingSafeEqual } from "node:crypto";
+
+/**
+ * Constant-time comparison of two buffers.
+ * Non-standard extension to Web Crypto matching Cloudflare's API.
+ */
+export function cfTimingSafeEqual(a: ArrayBuffer | ArrayBufferView, b: ArrayBuffer | ArrayBufferView): boolean {
+  const bufA = ArrayBuffer.isView(a) ? Buffer.from(a.buffer, a.byteOffset, a.byteLength) : Buffer.from(a);
+  const bufB = ArrayBuffer.isView(b) ? Buffer.from(b.buffer, b.byteOffset, b.byteLength) : Buffer.from(b);
+
+  if (bufA.byteLength !== bufB.byteLength) {
+    throw new TypeError("Input buffers must have the same byte length");
+  }
+
+  return timingSafeEqual(bufA, bufB);
+}
+
+/**
+ * DigestStream — a WritableStream that computes a cryptographic hash of all written data.
+ * `digest` property is a Promise<ArrayBuffer> that resolves when the stream closes.
+ */
+export class DigestStream extends WritableStream<ArrayBuffer | ArrayBufferView> {
+  readonly digest: Promise<ArrayBuffer>;
+
+  constructor(algorithm: AlgorithmIdentifier) {
+    const algo = typeof algorithm === "string" ? algorithm : algorithm.name;
+
+    // Map CF algorithm names to Bun.CryptoHasher names
+    const algoMap: Record<string, string> = {
+      "SHA-1": "sha1",
+      "SHA-256": "sha256",
+      "SHA-384": "sha384",
+      "SHA-512": "sha512",
+      "MD5": "md5",
+    };
+
+    const hashName = algoMap[algo.toUpperCase()];
+    if (!hashName) {
+      throw new TypeError(`Unsupported algorithm: ${algo}`);
+    }
+
+    const hasher = new Bun.CryptoHasher(hashName as "sha1" | "sha256" | "sha384" | "sha512" | "md5");
+    let resolveDigest: (value: ArrayBuffer) => void;
+
+    const digestPromise = new Promise<ArrayBuffer>((resolve) => {
+      resolveDigest = resolve;
+    });
+
+    super({
+      write(chunk) {
+        if (ArrayBuffer.isView(chunk)) {
+          hasher.update(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        } else {
+          hasher.update(new Uint8Array(chunk));
+        }
+      },
+      close() {
+        const result = hasher.digest();
+        resolveDigest(result.buffer as ArrayBuffer);
+      },
+    });
+
+    this.digest = digestPromise;
+  }
+}
+
+/**
+ * Patches the global `crypto` object with CF-specific extensions.
+ */
+export function patchGlobalCrypto(): void {
+  // Add timingSafeEqual to crypto.subtle
+  const subtle = crypto.subtle;
+  Object.defineProperty(subtle, "timingSafeEqual", {
+    value: cfTimingSafeEqual,
+    writable: false,
+    configurable: true,
+  });
+
+  // Add DigestStream to crypto
+  Object.defineProperty(crypto, "DigestStream", {
+    value: DigestStream,
+    writable: false,
+    configurable: true,
+  });
+}

package/runtime/bindings/d1.ts

@@ -0,0 +1,315 @@
+import { Database, type SQLQueryBindings } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+
+interface D1Meta {
+  duration: number;
+  changes: number;
+  last_row_id: number;
+  served_by: string;
+  rows_read: number;
+  rows_written: number;
+  size_after: number;
+  changed_db: boolean;
+}
+
+interface D1Result<T = Record<string, unknown>> {
+  results: T[];
+  success: boolean;
+  meta: D1Meta;
+}
+
+interface D1ExecResult {
+  count: number;
+  duration: number;
+}
+
+function buildMeta(db: Database, durationMs: number, rowsRead: number, rowsWritten: number): D1Meta {
+  const changes = db.query<{ c: number }, []>("SELECT changes() as c").get()!.c;
+  const { page_count } = db.query<{ page_count: number }, []>("PRAGMA page_count").get()!;
+  const { page_size } = db.query<{ page_size: number }, []>("PRAGMA page_size").get()!;
+  return {
+    duration: durationMs,
+    changes,
+    last_row_id: db.query<{ id: number }, []>("SELECT last_insert_rowid() as id").get()!.id,
+    served_by: "bunflare-d1",
+    rows_read: rowsRead,
+    rows_written: rowsWritten,
+    size_after: page_count * page_size,
+    changed_db: changes > 0,
+  };
+}
+
+/**
+ * Split SQL text into individual statements, respecting string literals
+ * (single-quoted, double-quoted), line comments (--), and block comments.
+ */
+function splitStatements(sql: string): string[] {
+  const statements: string[] = [];
+  let current = "";
+  let i = 0;
+  const len = sql.length;
+
+  while (i < len) {
+    const ch = sql[i]!;
+
+    // Single-quoted string literal
+    if (ch === "'") {
+      current += ch;
+      i++;
+      while (i < len) {
+        const c = sql[i]!;
+        current += c;
+        i++;
+        if (c === "'" && i < len && sql[i] === "'") {
+          // escaped quote ''
+          current += sql[i]!;
+          i++;
+        } else if (c === "'") {
+          break;
+        }
+      }
+      continue;
+    }
+
+    // Double-quoted identifier
+    if (ch === '"') {
+      current += ch;
+      i++;
+      while (i < len) {
+        const c = sql[i]!;
+        current += c;
+        i++;
+        if (c === '"' && i < len && sql[i] === '"') {
+          current += sql[i]!;
+          i++;
+        } else if (c === '"') {
+          break;
+        }
+      }
+      continue;
+    }
+
+    // Line comment --
+    if (ch === "-" && i + 1 < len && sql[i + 1] === "-") {
+      i += 2;
+      while (i < len && sql[i] !== "\n") {
+        i++;
+      }
+      if (i < len) i++; // skip \n
+      current += " ";
+      continue;
+    }
+
+    // Block comment /* ... */
+    if (ch === "/" && i + 1 < len && sql[i + 1] === "*") {
+      i += 2;
+      while (i + 1 < len && !(sql[i] === "*" && sql[i + 1] === "/")) {
+        i++;
+      }
+      if (i + 1 < len) i += 2; // skip */
+      current += " ";
+      continue;
+    }
+
+    // Statement separator
+    if (ch === ";") {
+      const trimmed = current.trim();
+      if (trimmed.length > 0) {
+        statements.push(trimmed);
+      }
+      current = "";
+      i++;
+      continue;
+    }
+
+    current += ch;
+    i++;
+  }
+
+  const trimmed = current.trim();
+  if (trimmed.length > 0) {
+    statements.push(trimmed);
+  }
+
+  return statements;
+}
+
+/** Convert bind parameters: boolean→int, undefined→error, ArrayBuffer→Uint8Array */
+function convertBindParams(params: unknown[]): SQLQueryBindings[] {
+  return params.map((v, idx) => {
+    if (v === undefined) {
+      throw new Error(`D1_TYPE_ERROR: Cannot bind undefined value at index ${idx}. Use null instead.`);
+    }
+    if (typeof v === "boolean") {
+      return v ? 1 : 0;
+    }
+    if (v instanceof ArrayBuffer) {
+      return new Uint8Array(v);
+    }
+    return v as SQLQueryBindings;
+  });
+}
+
+/** Check if a SQL statement is a read query (returns rows) */
+function isReadStatement(sql: string): boolean {
+  const upper = sql.trimStart().toUpperCase();
+  return upper.startsWith("SELECT") || upper.startsWith("WITH") || upper.startsWith("PRAGMA");
+}
+
+export class LocalD1Database {
+  private db: Database;
+
+  constructor(db: Database) {
+    this.db = db;
+  }
+
+  prepare(sql: string): LocalD1PreparedStatement {
+    return new LocalD1PreparedStatement(this.db, sql);
+  }
+
+  async batch<T = Record<string, unknown>>(statements: LocalD1PreparedStatement[]): Promise<D1Result<T>[]> {
+    const results: D1Result<T>[] = [];
+    this.db.run("BEGIN");
+    try {
+      for (const stmt of statements) {
+        results.push(await stmt.all<T>());
+      }
+      this.db.run("COMMIT");
+    } catch (e) {
+      this.db.run("ROLLBACK");
+      throw e;
+    }
+    return results;
+  }
+
+  async exec(sql: string): Promise<D1ExecResult> {
+    const start = performance.now();
+    let count = 0;
+    const statements = splitStatements(sql);
+    for (const stmt of statements) {
+      try {
+        this.db.run(stmt);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`D1_EXEC_ERROR: Error in SQL statement [${stmt}]: ${msg}`);
+      }
+      count++;
+    }
+    return { count, duration: performance.now() - start };
+  }
+
+  async dump(): Promise<ArrayBuffer> {
+    return this.db.serialize().buffer as ArrayBuffer;
+  }
+
+  withSession(_bookmark?: string): LocalD1DatabaseSession {
+    return new LocalD1DatabaseSession(this.db);
+  }
+}
+
+export class LocalD1DatabaseSession {
+  private db: Database;
+
+  constructor(db: Database) {
+    this.db = db;
+  }
+
+  prepare(sql: string): LocalD1PreparedStatement {
+    return new LocalD1PreparedStatement(this.db, sql);
+  }
+
+  async batch<T = Record<string, unknown>>(statements: LocalD1PreparedStatement[]): Promise<D1Result<T>[]> {
+    const results: D1Result<T>[] = [];
+    this.db.run("BEGIN");
+    try {
+      for (const stmt of statements) {
+        results.push(await stmt.all<T>());
+      }
+      this.db.run("COMMIT");
+    } catch (e) {
+      this.db.run("ROLLBACK");
+      throw e;
+    }
+    return results;
+  }
+
+  getBookmark(): string | null {
+    return null;
+  }
+}
+
+export class LocalD1PreparedStatement {
+  private db: Database;
+  private sql: string;
+  private params: SQLQueryBindings[];
+
+  constructor(db: Database, sql: string) {
+    this.db = db;
+    this.sql = sql;
+    this.params = [];
+  }
+
+  bind(...values: unknown[]): LocalD1PreparedStatement {
+    const stmt = new LocalD1PreparedStatement(this.db, this.sql);
+    stmt.params = convertBindParams(values);
+    return stmt;
+  }
+
+  async first<T = Record<string, unknown>>(column?: string): Promise<T | null> {
+    const start = performance.now();
+    const row = this.db.query(this.sql).get(...this.params) as Record<string, unknown> | null;
+    if (!row) return null;
+    if (column) {
+      if (!(column in row)) {
+        throw new Error(`D1_ERROR: Column '${column}' does not exist in the result set.`);
+      }
+      return (row[column] as T) ?? null;
+    }
+    return row as T;
+  }
+
+  async run(): Promise<D1Result> {
+    const start = performance.now();
+    this.db.query(this.sql).run(...this.params);
+    const duration = performance.now() - start;
+    const changes = this.db.query<{ c: number }, []>("SELECT changes() as c").get()!.c;
+    return {
+      results: [],
+      success: true,
+      meta: buildMeta(this.db, duration, 0, changes),
+    };
+  }
+
+  async all<T = Record<string, unknown>>(): Promise<D1Result<T>> {
+    const start = performance.now();
+    const results = this.db.query(this.sql).all(...this.params) as T[];
+    const duration = performance.now() - start;
+    const isRead = isReadStatement(this.sql);
+    const changes = this.db.query<{ c: number }, []>("SELECT changes() as c").get()!.c;
+    return {
+      results,
+      success: true,
+      meta: buildMeta(this.db, duration, isRead ? results.length : 0, isRead ? 0 : changes),
+    };
+  }
+
+  async raw<T extends unknown[] = unknown[]>(options?: { columnNames?: boolean }): Promise<T[]> {
+    const query = this.db.query(this.sql);
+    const columns = query.columnNames;
+    const rows = query.values(...this.params) as T[];
+    if (options?.columnNames) {
+      return [columns as unknown as T, ...rows];
+    }
+    return rows;
+  }
+}
+
+export function openD1Database(dataDir: string, databaseName: string): LocalD1Database {
+  const d1Dir = join(dataDir, "d1");
+  mkdirSync(d1Dir, { recursive: true });
+  const dbPath = join(d1Dir, `${databaseName}.sqlite`);
+  const db = new Database(dbPath, { create: true });
+  db.run("PRAGMA journal_mode=WAL");
+  return new LocalD1Database(db);
+}

package/runtime/bindings/do-executor-inprocess.ts

@@ -0,0 +1,140 @@
+import type { DOExecutor, DOExecutorFactory, ExecutorConfig } from "./do-executor";
+import { DurableObjectStateImpl, type DurableObjectBase } from "./durable-object";
+import { warnInvalidRpcArgs } from "../rpc-validate";
+import { wrapRpcReturnValue, createRpcFunctionStub } from "./rpc-stub";
+
+export class InProcessExecutor implements DOExecutor {
+  private _state: DurableObjectStateImpl;
+  private _instance: DurableObjectBase;
+  private _containerRuntime?: import("./container").ContainerRuntime;
+
+  constructor(config: ExecutorConfig) {
+    const { id, db, namespaceName, cls, env, dataDir, limits, containerConfig, onAlarmSet } = config;
+
+    this._state = new DurableObjectStateImpl(id, db, namespaceName, dataDir, limits);
+
+    // Wire container runtime if configured
+    if (containerConfig) {
+      const { ContainerRuntime, ContainerContext } = require("./container") as typeof import("./container");
+      this._containerRuntime = new ContainerRuntime(
+        containerConfig.className,
+        id.toString(),
+        containerConfig.image,
+        containerConfig.dockerManager,
+      );
+      this._state.container = new ContainerContext(this._containerRuntime);
+    }
+
+    this._instance = new cls(this._state, env);
+
+    // Wire container runtime to ContainerBase instance
+    if (this._containerRuntime) {
+      const { ContainerBase } = require("./container") as typeof import("./container");
+      if (this._instance instanceof ContainerBase) {
+        this._instance._wireRuntime(this._containerRuntime);
+      }
+    }
+
+    // Wire instance resolver for WebSocket handler delegation
+    this._state._setInstanceResolver(() => this._instance);
+
+    // Wire alarm callback
+    if (onAlarmSet) {
+      this._state.storage._setAlarmCallback(onAlarmSet);
+    }
+  }
+
+  async executeFetch(request: Request): Promise<Response> {
+    const unlock = await this._state._lock();
+    try {
+      await this._state._waitForReady();
+      const fetchFn = (this._instance as unknown as Record<string, unknown>).fetch;
+      if (typeof fetchFn !== "function") {
+        throw new Error("Durable Object does not implement fetch()");
+      }
+      return await (fetchFn as (req: Request) => Promise<Response>).call(this._instance, request);
+    } finally {
+      unlock();
+    }
+  }
+
+  async executeRpc(method: string, args: unknown[]): Promise<unknown> {
+    warnInvalidRpcArgs(args, method);
+    const unlock = await this._state._lock();
+    try {
+      await this._state._waitForReady();
+      const val = (this._instance as unknown as Record<string, unknown>)[method];
+      if (typeof val === "function") {
+        const result = await (val as (...a: unknown[]) => unknown).call(this._instance, ...args);
+        return wrapRpcReturnValue(result, method);
+      }
+      throw new Error(`"${method}" is not a method on the Durable Object`);
+    } finally {
+      unlock();
+    }
+  }
+
+  async executeRpcGet(prop: string): Promise<unknown> {
+    const unlock = await this._state._lock();
+    try {
+      await this._state._waitForReady();
+      const val = (this._instance as unknown as Record<string, unknown>)[prop];
+      if (typeof val === "function") {
+        return createRpcFunctionStub(val as Function, this._instance);
+      }
+      return wrapRpcReturnValue(val, prop);
+    } finally {
+      unlock();
+    }
+  }
+
+  async executeAlarm(retryCount: number): Promise<void> {
+    const unlock = await this._state._lock();
+    try {
+      await this._state._waitForReady();
+      const alarmFn = (this._instance as unknown as Record<string, unknown>).alarm;
+      if (typeof alarmFn === "function") {
+        await alarmFn.call(this._instance, {
+          retryCount,
+          isRetry: retryCount > 0,
+        });
+      }
+    } finally {
+      unlock();
+    }
+  }
+
+  isActive(): boolean {
+    return this._state._hasActiveRequests();
+  }
+
+  isBlocked(): boolean {
+    return this._state._isBlocked();
+  }
+
+  activeWebSocketCount(): number {
+    return this._state.getWebSockets().length;
+  }
+
+  async dispose(): Promise<void> {
+    if (this._containerRuntime) {
+      await this._containerRuntime.cleanup();
+    }
+  }
+
+  /** @internal Get the raw DO instance (for testing/dashboard) */
+  get _rawInstance(): DurableObjectBase {
+    return this._instance;
+  }
+
+  /** @internal Get the state (for testing/alarm access) */
+  get _rawState(): DurableObjectStateImpl {
+    return this._state;
+  }
+}
+
+export class InProcessExecutorFactory implements DOExecutorFactory {
+  create(config: ExecutorConfig): DOExecutor {
+    return new InProcessExecutor(config);
+  }
+}