devflare 1.0.0-next.16 → 1.0.0-next.18

package/dist/index-vt4yxkmf.js

@@ -1,470 +0,0 @@
-import {
-  BinaryFlags,
-  BinaryKind,
-  base64Decode,
-  base64Encode,
-  decodeBinaryFrame,
-  deserializeValue,
-  encodeBinaryFrame,
-  parseJsonMsg,
-  serializeValue,
-  stringifyJsonMsg
-} from "./index-9ba1etyz.js";
-import {
-  normalizeSendEmailMessage
-} from "./index-h18pxvzs.js";
-
-// src/bridge/server.ts
-var server_default = {
-  async fetch(request, env, ctx) {
-    const url = new URL(request.url);
-    if (request.headers.get("Upgrade") === "websocket") {
-      return handleWebSocket(request, env, ctx);
-    }
-    if (url.pathname.startsWith("/_devflare/transfer/")) {
-      return handleHttpTransfer(request, env, url);
-    }
-    if (url.pathname === "/_devflare/health") {
-      return new Response(JSON.stringify({ ok: true, bindings: Object.keys(env) }), {
-        headers: { "Content-Type": "application/json" }
-      });
-    }
-    return new Response("Devflare Bridge Gateway", { status: 200 });
-  }
-};
-async function handleWebSocket(request, env, ctx) {
-  const { 0: client, 1: server } = new WebSocketPair;
-  const activeStreams = new Map;
-  const wsProxies = new Map;
-  const incomingStreams = new Map;
-  server.accept();
-  server.addEventListener("message", async (event) => {
-    try {
-      if (typeof event.data === "string") {
-        await handleJsonMessage(event.data, server, env, ctx, activeStreams, wsProxies, incomingStreams);
-      } else if (event.data instanceof ArrayBuffer) {
-        handleBinaryMessage(new Uint8Array(event.data), server, wsProxies, incomingStreams);
-      }
-    } catch {}
-  });
-  server.addEventListener("close", () => {
-    for (const [_sid, stream] of activeStreams) {
-      stream.reader.cancel();
-    }
-    activeStreams.clear();
-    for (const [_wid, proxy] of wsProxies) {
-      proxy.doWs.close();
-    }
-    wsProxies.clear();
-  });
-  return new Response(null, { status: 101, webSocket: client });
-}
-async function handleJsonMessage(data, ws, env, ctx, activeStreams, wsProxies, incomingStreams) {
-  const msg = parseJsonMsg(data);
-  switch (msg.t) {
-    case "rpc.call":
-      await handleRpcCall(msg, ws, env, ctx, activeStreams, incomingStreams);
-      break;
-    case "stream.pull":
-      await handleStreamPull(msg, ws, activeStreams);
-      break;
-    case "stream.open":
-      handleStreamOpen(msg, incomingStreams);
-      break;
-    case "stream.end":
-      handleStreamEnd(msg, incomingStreams);
-      break;
-    case "stream.abort":
-      handleStreamAbort(msg, incomingStreams);
-      break;
-    case "ws.open":
-      await handleWsOpen(msg, ws, env, wsProxies);
-      break;
-    case "ws.close":
-      handleWsClose(msg, wsProxies);
-      break;
-  }
-}
-async function handleRpcCall(msg, ws, env, ctx, activeStreams, incomingStreams) {
-  try {
-    const getStream = (sid) => incomingStreams.get(sid)?.stream ?? null;
-    const params = deserializeValue(msg.params, getStream);
-    const result = await executeRpcMethod(msg.method, params, env, ctx);
-    const { value: serializedResult, streams } = await serializeValue(result);
-    for (const streamRef of streams) {
-      activeStreams.set(streamRef.sid, {
-        reader: streamRef.stream.getReader(),
-        seq: 0
-      });
-    }
-    const response = {
-      t: "rpc.ok",
-      id: msg.id,
-      result: serializedResult
-    };
-    ws.send(stringifyJsonMsg(response));
-  } catch (error) {
-    const response = {
-      t: "rpc.err",
-      id: msg.id,
-      error: {
-        code: error.code ?? "INTERNAL_ERROR",
-        message: error instanceof Error ? error.message : String(error)
-      }
-    };
-    ws.send(stringifyJsonMsg(response));
-  }
-}
-async function executeRpcMethod(method, params, env, ctx) {
-  const parts = method.split(".");
-  if (parts.length < 2) {
-    throw new Error(`Invalid method format: ${method}`);
-  }
-  const bindingName = parts[0];
-  const operation = parts.slice(1).join(".");
-  const binding = env[bindingName];
-  if (!binding) {
-    throw new Error(`Binding not found: ${bindingName}`);
-  }
-  switch (operation) {
-    case "get":
-      return binding.get(params[0], params[1]);
-    case "put":
-      return binding.put(params[0], params[1], params[2]);
-    case "delete":
-      return binding.delete(params[0]);
-    case "list":
-      return binding.list(params[0]);
-    case "getWithMetadata":
-      return binding.getWithMetadata(params[0], params[1]);
-    case "head":
-      return serializeR2Object(await binding.head(params[0]));
-    case "r2.get":
-      return serializeR2ObjectBody(await binding.get(params[0], params[1]));
-    case "r2.put":
-      return binding.put(params[0], params[1], params[2]);
-    case "r2.delete":
-      return binding.delete(params[0]);
-    case "r2.list":
-      return binding.list(params[0]);
-    case "prepare":
-      return serializeD1Statement(binding.prepare(params[0]));
-    case "batch":
-      return binding.batch(params[0]);
-    case "exec":
-      return binding.exec(params[0]);
-    case "dump":
-      return binding.dump();
-    case "stmt.bind":
-      return { __type: "D1Statement", sql: params[0], bindings: params.slice(1) };
-    case "stmt.first":
-      return executeD1Statement(binding, params[0], params.slice(1), "first", params[params.length - 1]);
-    case "stmt.all":
-      return executeD1Statement(binding, params[0], params.slice(1), "all");
-    case "stmt.run":
-      return executeD1Statement(binding, params[0], params.slice(1), "run");
-    case "stmt.raw":
-      return executeD1Statement(binding, params[0], params.slice(1), "raw", params[params.length - 1]);
-    case "idFromName":
-      return serializeDOId(binding.idFromName(params[0]));
-    case "idFromString":
-      return serializeDOId(binding.idFromString(params[0]));
-    case "newUniqueId":
-      return serializeDOId(binding.newUniqueId(params[0]));
-    case "get":
-      const doId = deserializeDOId(params[0], binding);
-      const stub = binding.get(doId);
-      return { __type: "DOStub", binding: bindingName, id: params[0] };
-    case "stub.fetch":
-      return executeDoFetch(env, params[0], params[1], params[2]);
-    case "stub.rpc":
-      return executeDoRpc(env, params[0], params[1], params[2], params[3]);
-    case "email.send":
-      return executeSendEmail(binding, params[0]);
-    case "send":
-      return binding.send(params[0], params[1]);
-    case "sendBatch":
-      return binding.sendBatch(params[0], params[1]);
-    case "run":
-      if (typeof binding.run === "function") {
-        return binding.run(params[0], params[1]);
-      }
-      break;
-    default:
-      throw new Error(`Unknown operation: ${method}`);
-  }
-}
-async function executeSendEmail(binding, message) {
-  return binding.send(normalizeSendEmailMessage(message));
-}
-function serializeR2Object(obj) {
-  if (!obj)
-    return null;
-  return {
-    __type: "R2Object",
-    key: obj.key,
-    version: obj.version,
-    size: obj.size,
-    etag: obj.etag,
-    httpEtag: obj.httpEtag,
-    checksums: obj.checksums,
-    uploaded: obj.uploaded?.toISOString(),
-    httpMetadata: obj.httpMetadata,
-    customMetadata: obj.customMetadata,
-    range: obj.range,
-    storageClass: obj.storageClass
-  };
-}
-async function serializeR2ObjectBody(obj) {
-  if (!obj)
-    return null;
-  const hasBody = "body" in obj || "arrayBuffer" in obj;
-  if (!hasBody) {
-    return serializeR2Object(obj);
-  }
-  const body = obj;
-  const arrayBuffer = await body.arrayBuffer();
-  const bodyData = base64Encode(new Uint8Array(arrayBuffer));
-  return {
-    __type: "R2ObjectBody",
-    key: body.key,
-    version: body.version,
-    size: body.size,
-    etag: body.etag,
-    httpEtag: body.httpEtag,
-    checksums: body.checksums,
-    uploaded: body.uploaded?.toISOString(),
-    httpMetadata: body.httpMetadata,
-    customMetadata: body.customMetadata,
-    range: body.range,
-    storageClass: body.storageClass,
-    bodyData
-  };
-}
-function serializeD1Statement(stmt) {
-  return { __type: "D1Statement" };
-}
-async function executeD1Statement(db, sql, bindings, mode, extra) {
-  let stmt = db.prepare(sql);
-  if (bindings.length > 0) {
-    stmt = stmt.bind(...bindings);
-  }
-  switch (mode) {
-    case "first":
-      return typeof extra === "string" ? stmt.first(extra) : stmt.first();
-    case "all":
-      return stmt.all();
-    case "run":
-      return stmt.run();
-    case "raw":
-      return stmt.raw(extra);
-  }
-}
-function serializeDOId(id) {
-  return { __type: "DOId", hex: id.toString() };
-}
-function deserializeDOId(serialized, ns) {
-  if (serialized.__type === "DOId") {
-    return ns.idFromString(serialized.hex);
-  }
-  throw new Error("Invalid DOId format");
-}
-async function executeDoFetch(env, bindingName, idSerialized, requestSerialized) {
-  const binding = env[bindingName];
-  const id = deserializeDOId(idSerialized, binding);
-  const stub = binding.get(id);
-  const bodyBytes = requestSerialized.body?.type === "bytes" ? base64Decode(requestSerialized.body.data) : undefined;
-  const bodyBuffer = bodyBytes ? bodyBytes.buffer.slice(bodyBytes.byteOffset, bodyBytes.byteOffset + bodyBytes.byteLength) : undefined;
-  const request = new Request(requestSerialized.url, {
-    method: requestSerialized.method,
-    headers: requestSerialized.headers,
-    body: bodyBuffer
-  });
-  return stub.fetch(request);
-}
-async function executeDoRpc(env, bindingName, idSerialized, methodName, args) {
-  const binding = env[bindingName];
-  const id = deserializeDOId(idSerialized, binding);
-  const stub = binding.get(id);
-  const response = await stub.fetch(new Request("http://do/_rpc", {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ method: methodName, params: args })
-  }));
-  const result = await response.json();
-  if (!result.ok) {
-    throw new Error(result.error?.message ?? "DO RPC failed");
-  }
-  return result.result;
-}
-async function handleStreamPull(msg, ws, activeStreams) {
-  const stream = activeStreams.get(msg.sid);
-  if (!stream)
-    return;
-  let sent = 0;
-  const maxBytes = msg.creditBytes;
-  try {
-    while (sent < maxBytes) {
-      const { done, value } = await stream.reader.read();
-      if (done) {
-        ws.send(stringifyJsonMsg({ t: "stream.end", sid: msg.sid }));
-        activeStreams.delete(msg.sid);
-        break;
-      }
-      if (value) {
-        const frame = encodeBinaryFrame(BinaryKind.StreamChunk, msg.sid, stream.seq++, 0, value);
-        ws.send(frame);
-        sent += value.byteLength;
-      }
-    }
-  } catch (error) {
-    ws.send(stringifyJsonMsg({
-      t: "stream.abort",
-      sid: msg.sid,
-      error: String(error)
-    }));
-    activeStreams.delete(msg.sid);
-  }
-}
-function handleStreamOpen(msg, incomingStreams) {
-  let controller;
-  const stream = new ReadableStream({
-    start(c) {
-      controller = c;
-    }
-  });
-  incomingStreams.set(msg.sid, { controller, stream });
-}
-function handleStreamEnd(msg, incomingStreams) {
-  const stream = incomingStreams.get(msg.sid);
-  if (stream) {
-    stream.controller.close();
-    incomingStreams.delete(msg.sid);
-  }
-}
-function handleStreamAbort(msg, incomingStreams) {
-  const stream = incomingStreams.get(msg.sid);
-  if (stream) {
-    stream.controller.error(new Error(msg.error ?? "Stream aborted"));
-    incomingStreams.delete(msg.sid);
-  }
-}
-function handleBinaryMessage(frame, ws, wsProxies, incomingStreams) {
-  const decoded = decodeBinaryFrame(frame);
-  switch (decoded.kind) {
-    case BinaryKind.StreamChunk:
-      const stream = incomingStreams.get(decoded.id);
-      if (stream) {
-        stream.controller.enqueue(decoded.payload);
-      }
-      break;
-    case BinaryKind.WsData:
-      const proxy = wsProxies.get(decoded.id);
-      if (proxy) {
-        const isText = (decoded.flags & BinaryFlags.TEXT) !== 0;
-        if (isText) {
-          proxy.doWs.send(new TextDecoder().decode(decoded.payload));
-        } else {
-          proxy.doWs.send(decoded.payload);
-        }
-      }
-      break;
-  }
-}
-async function handleWsOpen(msg, ws, env, wsProxies) {
-  try {
-    const binding = env[msg.target.binding];
-    const id = binding.idFromString(msg.target.id);
-    const stub = binding.get(id);
-    const headers = new Headers(msg.target.headers ?? []);
-    headers.set("Upgrade", "websocket");
-    const request = new Request(msg.target.url, {
-      method: "GET",
-      headers
-    });
-    const response = await stub.fetch(request);
-    const doWs = response.webSocket;
-    if (!doWs) {
-      ws.send(stringifyJsonMsg({
-        t: "rpc.err",
-        id: `ws_${msg.wid}`,
-        error: { code: "WS_UPGRADE_FAILED", message: "DO did not return WebSocket" }
-      }));
-      return;
-    }
-    doWs.accept();
-    const proxy = {
-      doWs,
-      clientWid: msg.wid
-    };
-    wsProxies.set(msg.wid, proxy);
-    doWs.addEventListener("message", (event) => {
-      const isText = typeof event.data === "string";
-      const payload = isText ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
-      const flags = isText ? BinaryFlags.TEXT : 0;
-      const frame = encodeBinaryFrame(BinaryKind.WsData, msg.wid, 0, flags, payload);
-      ws.send(frame);
-    });
-    doWs.addEventListener("close", (event) => {
-      ws.send(stringifyJsonMsg({
-        t: "ws.close",
-        wid: msg.wid,
-        code: event.code,
-        reason: event.reason
-      }));
-      wsProxies.delete(msg.wid);
-    });
-    ws.send(stringifyJsonMsg({ t: "ws.opened", wid: msg.wid }));
-  } catch (error) {
-    ws.send(stringifyJsonMsg({
-      t: "rpc.err",
-      id: `ws_${msg.wid}`,
-      error: {
-        code: "WS_OPEN_FAILED",
-        message: error instanceof Error ? error.message : String(error)
-      }
-    }));
-  }
-}
-function handleWsClose(msg, wsProxies) {
-  const proxy = wsProxies.get(msg.wid);
-  if (proxy) {
-    proxy.doWs.close(msg.code, msg.reason);
-    wsProxies.delete(msg.wid);
-  }
-}
-async function handleHttpTransfer(request, env, url) {
-  const transferId = url.pathname.split("/").pop();
-  if (request.method === "PUT" || request.method === "POST") {
-    const [binding, ...keyParts] = (transferId ?? "").split(":");
-    const key = keyParts.join(":");
-    const bucket = env[binding];
-    if (!bucket) {
-      return new Response("Binding not found", { status: 404 });
-    }
-    const result = await bucket.put(key, request.body);
-    return new Response(JSON.stringify(result), {
-      headers: { "Content-Type": "application/json" }
-    });
-  }
-  if (request.method === "GET") {
-    const [binding, ...keyParts] = (transferId ?? "").split(":");
-    const key = keyParts.join(":");
-    const bucket = env[binding];
-    if (!bucket) {
-      return new Response("Binding not found", { status: 404 });
-    }
-    const object = await bucket.get(key);
-    if (!object) {
-      return new Response("Object not found", { status: 404 });
-    }
-    return new Response(object.body, {
-      headers: {
-        "Content-Type": object.httpMetadata?.contentType ?? "application/octet-stream",
-        "Content-Length": String(object.size)
-      }
-    });
-  }
-  return new Response("Method not allowed", { status: 405 });
-}
-export { server_default };