@smthrs/gateway 0.35.0 → 1.0.0-rc.4

package/dist/vendor/chunk-Z6C7SO5Z.js

@@ -0,0 +1,507 @@
+import {
+  persisted,
+  stream
+} from "./chunk-IFTTT6D5.js";
+import {
+  fromReadableStream
+} from "./chunk-H2Z2Y4QH.js";
+import {
+  layer as layer2
+} from "./chunk-UHIDPUFF.js";
+import {
+  layer
+} from "./chunk-OBWXQKVP.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunHttpServer.js
+var BunHttpServer_exports = {};
+__export(BunHttpServer_exports, {
+  layer: () => layer4,
+  layerConfig: () => layerConfig,
+  layerHttpServices: () => layerHttpServices,
+  layerServer: () => layerServer,
+  layerTest: () => layerTest,
+  make: () => make3
+});
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { constVoid, flow } from "effect/Function";
+import * as Inspectable from "effect/Inspectable";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Result from "effect/Result";
+import * as Scheduler from "effect/Scheduler";
+import * as Scope from "effect/Scope";
+import * as Semaphore from "effect/Semaphore";
+import * as Stream from "effect/Stream";
+import * as Cookies from "effect/unstable/http/Cookies";
+import * as Etag from "effect/unstable/http/Etag";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as Headers from "effect/unstable/http/Headers";
+import * as HttpEffect from "effect/unstable/http/HttpEffect";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as Server from "effect/unstable/http/HttpServer";
+import * as Error from "effect/unstable/http/HttpServerError";
+import * as ServerRequest from "effect/unstable/http/HttpServerRequest";
+import * as ServerResponse from "effect/unstable/http/HttpServerResponse";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Socket from "effect/unstable/socket/Socket";
+var make3 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const scope2 = yield* Effect.scope;
+  let listenOptions = options;
+  if (!("unix" in options) || options.unix === void 0) {
+    const internetOptions = options;
+    let hostname = internetOptions.hostname ?? "::";
+    if (Result.isFailure(NetAddress.ipFromString(hostname))) {
+      hostname = yield* Effect.tryPromise({
+        try: async () => {
+          const result = await Bun.dns.lookup(hostname, {
+            socketType: "tcp"
+          });
+          if (result.length === 0) throw new globalThis.Error(`Could not resolve hostname: ${hostname}`);
+          return result[0].address;
+        },
+        catch: (cause) => new Error.ServeError({
+          cause
+        })
+      });
+    }
+    listenOptions = {
+      ...options,
+      hostname
+    };
+  }
+  const {
+    compressionThreshold = MIN_COMPRESSIBLE_SIZE,
+    ...websocket
+  } = options.websocket ?? {};
+  const handlerStack = [function(_request, _server) {
+    return new Response("not found", {
+      status: 404
+    });
+  }];
+  const server = Bun.serve({
+    ...listenOptions,
+    fetch: handlerStack[0],
+    websocket: {
+      ...websocket,
+      open(ws) {
+        Deferred.doneUnsafe(ws.data.deferred, Exit.succeed(ws));
+      },
+      message(ws, message) {
+        ws.data.run(message);
+      },
+      close(ws, code, closeReason) {
+        code = typeof code === "number" ? code : 1001;
+        const error = new Socket.SocketError({
+          reason: new Socket.SocketCloseError({
+            code,
+            closeReason
+          })
+        });
+        ws.data.closeError = error;
+        ws.data.onClose(error);
+      }
+    }
+  });
+  const shutdown = yield* Effect.promise(() => server.stop()).pipe(Effect.cached);
+  const preemptiveShutdown = options.disablePreemptiveShutdown ? Effect.void : Effect.timeoutOrElse(shutdown, {
+    duration: options.gracefulShutdownTimeout ?? Duration.seconds(20),
+    orElse: () => Effect.void
+  });
+  yield* Scope.addFinalizer(scope2, shutdown);
+  const address = "unix" in options && options.unix !== void 0 ? NetAddress.unixPathAddress(options.unix) : yield* Effect.fromResult(NetAddress.inetAddressFromIpString(server.hostname, server.port)).pipe(Effect.mapError((cause) => new Error.ServeError({
+    cause
+  })));
+  return Server.make({
+    address,
+    serve: Effect.fnUntraced(function* (httpApp, middleware) {
+      const parent = yield* Effect.fiber;
+      const services = parent.context;
+      const serveScope = Context.getUnsafe(services, Scope.Scope);
+      const scope3 = Scope.forkUnsafe(serveScope, "parallel");
+      const httpEffect = HttpEffect.toHandled(httpApp, (request, response) => Effect.sync(() => {
+        ;
+        request.resolve(makeResponse(request, response, services, scope3));
+      }), middleware);
+      function handler(request, server2) {
+        return new Promise((resolve, _reject) => {
+          const context = Context.add(services, ServerRequest.HttpServerRequest, new BunServerRequest(request, resolve, removeHost(request.url), server2, compressionThreshold));
+          const fiber2 = Fiber.runIn(Effect.runForkWith(context)(httpEffect), scope3);
+          request.signal.addEventListener("abort", () => {
+            fiber2.interruptUnsafe(parent.id, Error.ClientAbort.annotation);
+          }, {
+            once: true
+          });
+        });
+      }
+      yield* Scope.addFinalizerExit(serveScope, () => {
+        const index = handlerStack.indexOf(handler);
+        if (index !== -1) handlerStack.splice(index, 1);
+        server.reload({
+          fetch: handlerStack[handlerStack.length - 1],
+          ...options.routes === void 0 ? void 0 : {
+            routes: options.routes
+          }
+        });
+        return handlerStack.length === 1 ? preemptiveShutdown : Effect.void;
+      });
+      handlerStack.push(handler);
+      server.reload({
+        fetch: handler,
+        ...options.routes === void 0 ? void 0 : {
+          routes: options.routes
+        }
+      });
+    })
+  });
+});
+var MIN_COMPRESSIBLE_SIZE = 1024;
+var makeResponse = (request, response, context, scope2) => {
+  if (ServerResponse.omitsBody(response, request.method === "HEAD")) {
+    return ServerResponse.toWeb(response, {
+      withoutBody: true
+    });
+  }
+  const fields = {
+    headers: new globalThis.Headers(response.headers),
+    status: response.status
+  };
+  if (!Cookies.isEmpty(response.cookies)) {
+    for (const header of Cookies.toSetCookieHeaders(response.cookies)) {
+      fields.headers.append("set-cookie", header);
+    }
+  }
+  if (response.statusText !== void 0) {
+    fields.statusText = response.statusText;
+  }
+  response = HttpEffect.scopeTransferToStream(response);
+  const body = response.body;
+  switch (body._tag) {
+    case "Empty": {
+      return new Response(void 0, fields);
+    }
+    case "Uint8Array": {
+      return new Response(body.text ?? body.body, fields);
+    }
+    case "Raw": {
+      if (body.body instanceof Response) {
+        for (const [key, value] of fields.headers.entries()) {
+          body.body.headers.set(key, value);
+        }
+        return body.body;
+      }
+      return new Response(body.body, fields);
+    }
+    case "FormData": {
+      return new Response(body.formData, fields);
+    }
+    case "Stream": {
+      return new Response(Stream.toReadableStreamWith(Stream.unwrap(Effect.withFiber((fiber2) => {
+        Fiber.runIn(fiber2, scope2);
+        return Effect.succeed(body.stream);
+      })), context), fields);
+    }
+  }
+};
+var layerServer = /* @__PURE__ */ flow(make3, /* @__PURE__ */ Layer.effect(Server.HttpServer));
+var layerHttpServices = /* @__PURE__ */ Layer.mergeAll(layer, Etag.layerWeak, layer2);
+var layer4 = (options) => Layer.mergeAll(layerServer(options), layerHttpServices);
+var layerTest = /* @__PURE__ */ Server.layerTestClient.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ FetchHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.succeed(FetchHttpClient.RequestInit)({
+  keepalive: false
+})))), /* @__PURE__ */ Layer.provideMerge(/* @__PURE__ */ Layer.orDie(/* @__PURE__ */ layer4({
+  hostname: "127.0.0.1",
+  port: 0
+}))));
+var layerConfig = (options) => Layer.mergeAll(Layer.effect(Server.HttpServer)(Effect.flatMap(Config.unwrap(options), make3)), layerHttpServices);
+function wsDefaultRun(_) {
+  this.buffer.push(_);
+}
+var BunServerRequest = class _BunServerRequest extends Inspectable.Class {
+  [ServerRequest.TypeId];
+  [IncomingMessage.TypeId];
+  source;
+  resolve;
+  url;
+  bunServer;
+  compressionThreshold;
+  headersOverride;
+  remoteAddressOverride;
+  constructor(source, resolve, url, bunServer, compressionThreshold, headersOverride, remoteAddressOverride) {
+    super();
+    this[ServerRequest.TypeId] = ServerRequest.TypeId;
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this.source = source;
+    this.resolve = resolve;
+    this.url = url;
+    this.bunServer = bunServer;
+    this.compressionThreshold = compressionThreshold;
+    this.headersOverride = headersOverride;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: this.originalUrl
+    });
+  }
+  modify(options) {
+    return new _BunServerRequest(this.source, this.resolve, options.url ?? this.url, this.bunServer, this.compressionThreshold, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+  }
+  get method() {
+    return this.source.method.toUpperCase();
+  }
+  get originalUrl() {
+    return this.source.url;
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? Option.fromNullishOr(this.bunServer.requestIP(this.source)?.address);
+  }
+  get headers() {
+    this.headersOverride ??= Headers.fromInput(this.source.headers);
+    return this.headersOverride;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "");
+  }
+  get stream() {
+    return this.source.body ? fromReadableStream({
+      evaluate: () => this.source.body ?? emptyReadbleStream,
+      onError: (cause) => new Error.HttpServerError({
+        reason: new Error.RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }) : Stream.fail(new Error.HttpServerError({
+      reason: new Error.RequestParseError({
+        request: this,
+        description: "can not create stream from empty body"
+      })
+    }));
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
+      try: () => this.source.text(),
+      catch: (cause) => new Error.HttpServerError({
+        reason: new Error.RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    })));
+    return this.textEffect;
+  }
+  get json() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => JSON.parse(_),
+      catch: (cause) => new Error.HttpServerError({
+        reason: new Error.RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }));
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: (cause) => new Error.HttpServerError({
+        reason: new Error.RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    }));
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(persisted(this.source)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    return stream(this.source);
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = Effect.runSync(Effect.cached(Effect.tryPromise({
+      try: () => this.source.arrayBuffer(),
+      catch: (cause) => new Error.HttpServerError({
+        reason: new Error.RequestParseError({
+          request: this,
+          cause
+        })
+      })
+    })));
+    this.textEffect = Effect.map(this.arrayBufferEffect, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferEffect;
+  }
+  get upgrade() {
+    return Effect.callback((resume) => {
+      const deferred = Deferred.makeUnsafe();
+      const semaphore = Semaphore.makeUnsafe(1);
+      const success = this.bunServer.upgrade(this.source, {
+        data: {
+          deferred,
+          buffer: [],
+          closeError: void 0,
+          run: wsDefaultRun,
+          onClose: constVoid
+        }
+      });
+      if (!success) {
+        resume(Effect.fail(new Error.HttpServerError({
+          reason: new Error.RequestParseError({
+            request: this,
+            description: "Not an upgradeable ServerRequest"
+          })
+        })));
+        return;
+      }
+      const compressionThreshold = this.compressionThreshold;
+      resume(Effect.map(Deferred.await(deferred), (ws) => {
+        const write = (chunk) => Effect.sync(() => {
+          if (typeof chunk === "string") {
+            ws.sendText(chunk, chunk.length >= compressionThreshold);
+          } else if (Socket.isCloseEvent(chunk)) {
+            ws.close(chunk.code, chunk.reason);
+          } else {
+            ws.sendBinary(chunk, chunk.byteLength >= compressionThreshold);
+          }
+        });
+        const writeAll = (chunks) => Effect.sync(() => {
+          for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i];
+            if (typeof chunk === "string") {
+              ws.sendText(chunk, chunk.length >= compressionThreshold);
+            } else {
+              ws.sendBinary(chunk, chunk.byteLength >= compressionThreshold);
+            }
+          }
+        });
+        const writer = Effect.succeed({
+          write,
+          writeAll
+        });
+        const reader = Effect.gen(function* () {
+          const dispatcher = (yield* Scheduler.Scheduler).makeDispatcher();
+          yield* Effect.acquireRelease(semaphore.take(1), () => semaphore.release(1));
+          const closeError = ws.data.closeError ?? (ws.readyState >= 2 ? new Socket.SocketError({
+            reason: new Socket.SocketCloseError({
+              code: 1006
+            })
+          }) : void 0);
+          if (closeError !== void 0 && ws.data.buffer.length === 0) {
+            return yield* closeError;
+          }
+          const scope2 = yield* Effect.scope;
+          let buffer = ws.data.buffer.splice(0);
+          let error = closeError;
+          let waiter;
+          let flushScheduled = false;
+          function takeBuffer() {
+            const chunk = buffer;
+            buffer = [];
+            return chunk;
+          }
+          function deliver() {
+            flushScheduled = false;
+            if (waiter === void 0 || buffer.length === 0) return;
+            const resumeRead = waiter;
+            waiter = void 0;
+            resumeRead(Effect.succeed(takeBuffer()));
+          }
+          function push(data) {
+            buffer.push(data);
+            if (waiter !== void 0 && !flushScheduled) {
+              flushScheduled = true;
+              dispatcher.scheduleTask(deliver, 0);
+            }
+          }
+          function fail3(err) {
+            if (error === void 0) error = err;
+            if (waiter !== void 0) {
+              const resumeRead = waiter;
+              waiter = void 0;
+              resumeRead(buffer.length > 0 ? Effect.succeed(takeBuffer()) : Effect.fail(error));
+            }
+          }
+          ws.data.run = push;
+          ws.data.onClose = fail3;
+          yield* Scope.addFinalizer(scope2, Effect.suspend(() => {
+            fail3(new Socket.SocketError({
+              reason: new Socket.SocketCloseError({
+                code: 1006
+              })
+            }));
+            ws.data.run = wsDefaultRun;
+            ws.data.onClose = constVoid;
+            ws.close(1e3);
+            return Effect.void;
+          }));
+          return {
+            pull: Effect.callback((resumeRead) => {
+              if (buffer.length > 0) return resumeRead(Effect.succeed(takeBuffer()));
+              if (error !== void 0) return resumeRead(Effect.fail(error));
+              waiter = resumeRead;
+              return Effect.sync(() => {
+                if (waiter === resumeRead) waiter = void 0;
+              });
+            }),
+            upgrade: Socket.SocketUpgradeError.unsupported
+          };
+        });
+        return Socket.make({
+          reader,
+          writer
+        });
+      }));
+    });
+  }
+};
+var emptyReadbleStream = /* @__PURE__ */ new ReadableStream({
+  start(controller) {
+    controller.enqueue(new Uint8Array());
+    controller.close();
+  }
+});
+var removeHost = (url) => {
+  if (url[0] === "/") {
+    return url;
+  }
+  const index = url.indexOf("/", url.indexOf("//") + 2);
+  return index === -1 ? "/" : url.slice(index);
+};
+
+export {
+  make3 as make,
+  layerServer,
+  layerHttpServices,
+  layer4 as layer,
+  layerTest,
+  layerConfig,
+  BunHttpServer_exports
+};