@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-KOZMM5PZ.js

@@ -0,0 +1,426 @@
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-J7A4CZDO.js";
+import {
+  fromReadable,
+  toReadable
+} from "./chunk-XH4U3JSV.js";
+import {
+  fromWritable
+} from "./chunk-OXNGN5H7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpClient.js
+var NodeHttpClient_exports = {};
+__export(NodeHttpClient_exports, {
+  Dispatcher: () => Dispatcher,
+  Fetch: () => Fetch,
+  HttpAgent: () => HttpAgent,
+  RequestInit: () => RequestInit,
+  UndiciOptions: () => UndiciOptions,
+  dispatcherLayerGlobal: () => dispatcherLayerGlobal,
+  layerAgent: () => layerAgent,
+  layerAgentOptions: () => layerAgentOptions,
+  layerDispatcher: () => layerDispatcher,
+  layerFetch: () => layer,
+  layerNodeHttp: () => layerNodeHttp,
+  layerNodeHttpNoAgent: () => layerNodeHttpNoAgent,
+  layerUndici: () => layerUndici,
+  layerUndiciNoDispatcher: () => layerUndiciNoDispatcher,
+  makeAgent: () => makeAgent,
+  makeDispatcher: () => makeDispatcher,
+  makeNodeHttp: () => makeNodeHttp,
+  makeUndici: () => makeUndici
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import { flow } from "effect/Function";
+import * as Inspectable from "effect/Inspectable";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { pipeArguments } from "effect/Pipeable";
+import * as Stream from "effect/Stream";
+import * as Cookies from "effect/unstable/http/Cookies";
+import * as Headers from "effect/unstable/http/Headers";
+import * as Client from "effect/unstable/http/HttpClient";
+import * as Error from "effect/unstable/http/HttpClientError";
+import * as Response from "effect/unstable/http/HttpClientResponse";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+import * as Http from "node:http";
+import * as Https from "node:https";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import {
+  Fetch,
+  layer,
+  RequestInit
+} from "effect/unstable/http/FetchHttpClient";
+var Dispatcher = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/Dispatcher")) {
+};
+var loadUndici = /* @__PURE__ */ Effect.promise(() => import("./node/Undici.js"));
+var makeDispatcher = /* @__PURE__ */ Effect.acquireRelease(/* @__PURE__ */ Effect.map(loadUndici, (_) => new _.Agent()), (dispatcher) => Effect.promise(() => dispatcher.destroy()));
+var layerDispatcher = /* @__PURE__ */ Layer.effect(Dispatcher)(makeDispatcher);
+var dispatcherLayerGlobal = /* @__PURE__ */ Layer.effect(Dispatcher)(/* @__PURE__ */ Effect.map(loadUndici, (_) => _.getGlobalDispatcher()));
+var UndiciOptions = /* @__PURE__ */ Context.Reference("@effect/platform-node/NodeHttpClient/UndiciOptions", {
+  defaultValue: () => ({})
+});
+var makeUndici = /* @__PURE__ */ Effect.gen(function* () {
+  const dispatcher = yield* Dispatcher;
+  return Client.make((request3, url, signal, fiber) => convertBody(request3.body).pipe(Effect.flatMap((body) => Effect.tryPromise({
+    try: () => dispatcher.request({
+      ...fiber.getRef(UndiciOptions),
+      signal,
+      method: request3.method,
+      headers: request3.headers,
+      origin: url.origin,
+      path: url.pathname + url.search,
+      body,
+      // leave timeouts to Effect.timeout etc
+      headersTimeout: 60 * 60 * 1e3,
+      bodyTimeout: 0
+    }),
+    catch: (cause) => new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })
+  })), Effect.map((response) => new UndiciResponse(request3, response, url.href.split("#")[0]))));
+});
+function convertBody(body) {
+  switch (body._tag) {
+    case "Empty": {
+      return Effect.succeed(null);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      return Effect.succeed(body.body);
+    }
+    case "FormData": {
+      return Effect.succeed(body.formData);
+    }
+    case "Stream": {
+      return toReadable(body.stream);
+    }
+  }
+}
+function noopErrorHandler(_) {
+}
+var UndiciResponse = class extends Inspectable.Class {
+  [IncomingMessage.TypeId];
+  [Response.TypeId];
+  request;
+  source;
+  url;
+  constructor(request3, source, url) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.source = source;
+    this.url = url;
+    source.body.on("error", noopErrorHandler);
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  get statusText() {
+    return void 0;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get remoteAddress() {
+    return Option.none();
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source.body,
+      onError: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    });
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  textBody;
+  get text() {
+    if (this.textBody) {
+      return this.textBody;
+    }
+    this.textBody = Effect.map(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+    return this.textBody;
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  formDataBody;
+  get formData() {
+    return this.formDataBody ??= Effect.flatMap(this.arrayBuffer, (body) => Effect.tryPromise({
+      try: () => new globalThis.Response(body, {
+        headers: this.headers
+      }).formData(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    })).pipe(Effect.cached, Effect.runSync);
+  }
+  arrayBufferBody;
+  get arrayBuffer() {
+    if (this.arrayBufferBody) {
+      return this.arrayBufferBody;
+    }
+    this.arrayBufferBody = Effect.tryPromise({
+      try: () => this.source.body.arrayBuffer(),
+      catch: (cause) => new Error.HttpClientError({
+        reason: new Error.DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(Effect.cached, Effect.runSync);
+    this.textBody = Effect.map(this.arrayBufferBody, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferBody;
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerUndiciNoDispatcher = /* @__PURE__ */ Client.layerMergedContext(makeUndici);
+var layerUndici = /* @__PURE__ */ Layer.provide(layerUndiciNoDispatcher, layerDispatcher);
+var HttpAgent = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeHttpClient/HttpAgent")) {
+};
+var makeAgent = (options) => Effect.zipWith(Effect.acquireRelease(Effect.sync(() => new Http.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), Effect.acquireRelease(Effect.sync(() => new Https.Agent(options)), (agent) => Effect.sync(() => agent.destroy())), (http, https) => ({
+  http,
+  https
+}));
+var layerAgentOptions = /* @__PURE__ */ flow(makeAgent, /* @__PURE__ */ Layer.effect(HttpAgent));
+var layerAgent = /* @__PURE__ */ layerAgentOptions();
+var makeNodeHttp = /* @__PURE__ */ Effect.gen(function* () {
+  const agent = yield* HttpAgent;
+  return Client.make((request3, url, signal) => {
+    const nodeRequest = url.protocol === "https:" ? Https.request(url, {
+      agent: agent.https,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    }) : Http.request(url, {
+      agent: agent.http,
+      method: request3.method,
+      headers: request3.headers,
+      signal
+    });
+    return Effect.raceFirst(waitForResponse(nodeRequest, request3), sendBody(nodeRequest, request3, request3.body).pipe(Effect.andThen(Effect.never))).pipe(Effect.onError(() => Effect.sync(() => nodeRequest.destroy())), Effect.map((_) => new NodeHttpResponse(request3, _, url.href.split("#")[0])));
+  });
+});
+var sendBody = (nodeRequest, request3, body) => Effect.suspend(() => {
+  switch (body._tag) {
+    case "Empty": {
+      nodeRequest.end();
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "Uint8Array":
+    case "Raw": {
+      nodeRequest.end(body.body);
+      return waitForFinish(nodeRequest, request3);
+    }
+    case "FormData": {
+      const response = new globalThis.Response(body.formData);
+      response.headers.forEach((value, key) => {
+        nodeRequest.setHeader(key, value);
+      });
+      return Effect.tryPromise({
+        try: () => pipeline(Readable.fromWeb(response.body), nodeRequest),
+        catch: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      });
+    }
+    case "Stream": {
+      return Stream.run(Stream.mapError(body.stream, (cause) => new Error.HttpClientError({
+        reason: new Error.EncodeError({
+          request: request3,
+          cause
+        })
+      })), fromWritable({
+        evaluate: () => nodeRequest,
+        onError: (cause) => new Error.HttpClientError({
+          reason: new Error.TransportError({
+            request: request3,
+            cause
+          })
+        })
+      }));
+    }
+  }
+});
+var waitForResponse = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.on("error", onError2);
+  function onResponse(response) {
+    nodeRequest.off("error", onError2);
+    resume(Effect.succeed(response));
+  }
+  nodeRequest.on("upgrade", onResponse);
+  nodeRequest.on("response", onResponse);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("upgrade", onResponse);
+    nodeRequest.off("response", onResponse);
+  });
+});
+var waitForFinish = (nodeRequest, request3) => Effect.callback((resume) => {
+  function onError2(cause) {
+    resume(Effect.fail(new Error.HttpClientError({
+      reason: new Error.TransportError({
+        request: request3,
+        cause
+      })
+    })));
+  }
+  nodeRequest.once("error", onError2);
+  function onFinish() {
+    nodeRequest.off("error", onError2);
+    resume(Effect.void);
+  }
+  nodeRequest.once("finish", onFinish);
+  return Effect.sync(() => {
+    nodeRequest.off("error", onError2);
+    nodeRequest.off("finish", onFinish);
+  });
+});
+var NodeHttpResponse = class extends NodeHttpIncomingMessage {
+  [Response.TypeId];
+  request;
+  url;
+  constructor(request3, source, url) {
+    super(source, (cause) => new Error.HttpClientError({
+      reason: new Error.DecodeError({
+        request: request3,
+        response: this,
+        cause
+      })
+    }));
+    this[Response.TypeId] = Response.TypeId;
+    this.request = request3;
+    this.url = url;
+  }
+  get status() {
+    return this.source.statusCode;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies !== void 0) {
+      return this.cachedCookies;
+    }
+    const header = this.source.headers["set-cookie"];
+    return this.cachedCookies = header ? Cookies.fromSetCookie(header) : Cookies.empty;
+  }
+  get formData() {
+    return Effect.tryPromise({
+      try: () => {
+        const init = {
+          headers: new globalThis.Headers(this.source.headers)
+        };
+        if (this.source.statusCode) {
+          init.status = this.source.statusCode;
+        }
+        if (this.source.statusMessage) {
+          init.statusText = this.source.statusMessage;
+        }
+        return new globalThis.Response(Readable.toWeb(this.source), init).formData();
+      },
+      catch: this.onError
+    });
+  }
+  toJSON() {
+    return IncomingMessage.inspect(this, {
+      _id: "effect/http/HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var layerNodeHttpNoAgent = /* @__PURE__ */ Client.layerMergedContext(makeNodeHttp);
+var layerNodeHttp = /* @__PURE__ */ Layer.provide(layerNodeHttpNoAgent, layerAgent);
+
+export {
+  Dispatcher,
+  makeDispatcher,
+  layerDispatcher,
+  dispatcherLayerGlobal,
+  UndiciOptions,
+  makeUndici,
+  layerUndiciNoDispatcher,
+  layerUndici,
+  HttpAgent,
+  makeAgent,
+  layerAgentOptions,
+  layerAgent,
+  makeNodeHttp,
+  layerNodeHttpNoAgent,
+  layerNodeHttp,
+  NodeHttpClient_exports,
+  Fetch,
+  layer,
+  RequestInit
+};

package/dist/vendor/chunk-KUUXSID7.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-B3FZ67QU.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeStdio.js
+var NodeStdio_exports = {};
+__export(NodeStdio_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeStdio_exports
+};

package/dist/vendor/chunk-LEUPYT3Q.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain
+});
+import * as Runtime from "effect/Runtime";
+var runMain = /* @__PURE__ */ Runtime.makeRunMain(({
+  fiber,
+  teardown
+}) => {
+  let receivedSignal = false;
+  fiber.addObserver((exit) => {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigint);
+    teardown(exit, (code) => {
+      if (receivedSignal || code !== 0) {
+        process.exit(code);
+      }
+    });
+  });
+  function onSigint() {
+    receivedSignal = true;
+    fiber.interruptUnsafe(fiber.id);
+  }
+  process.on("SIGINT", onSigint);
+  process.on("SIGTERM", onSigint);
+});
+
+export {
+  runMain,
+  NodeRuntime_exports
+};

package/dist/vendor/chunk-M32LDTW7.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-BKTBUBQY.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeFileSystem.js
+var NodeFileSystem_exports = {};
+__export(NodeFileSystem_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  NodeFileSystem_exports
+};

package/dist/vendor/chunk-MBSKBQ5D.js

@@ -0,0 +1,21 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpServerRequest.js
+var NodeHttpServerRequest_exports = {};
+__export(NodeHttpServerRequest_exports, {
+  toIncomingMessage: () => toIncomingMessage,
+  toServerResponse: () => toServerResponse
+});
+var toIncomingMessage = (self) => self.source;
+var toServerResponse = (self) => {
+  const res = self.response;
+  return typeof res === "function" ? res() : res;
+};
+
+export {
+  toIncomingMessage,
+  toServerResponse,
+  NodeHttpServerRequest_exports
+};

package/dist/vendor/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/vendor/chunk-NBVRTDTV.js

@@ -0,0 +1,129 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeRedis.js
+var NodeRedis_exports = {};
+__export(NodeRedis_exports, {
+  NodeRedis: () => NodeRedis,
+  layer: () => layer,
+  layerConfig: () => layerConfig
+});
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Fn from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Redis from "effect/unstable/persistence/Redis";
+import { createClient, SocketTimeoutError } from "redis";
+var NodeRedis = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeRedis")) {
+};
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  let ready = false;
+  const socket = options?.socket;
+  const client = yield* Effect.acquireRelease(Effect.sync(() => createClient({
+    ...options,
+    socket: socket?.reconnectStrategy === void 0 ? {
+      ...socket,
+      reconnectStrategy: (retries, cause) => {
+        if (!ready) return cause;
+        if (cause instanceof SocketTimeoutError) return false;
+        const jitter = Math.floor(Math.random() * 200);
+        const delay = Math.min(2 ** retries * 50, 2e3);
+        return delay + jitter;
+      }
+    } : socket
+  })), (client2) => Effect.ignoreCause(Effect.promise(() => client2.close())));
+  client.once("ready", () => {
+    ready = true;
+  });
+  const runSync = Effect.runSyncWith(yield* Effect.context());
+  client.on("error", (cause) => {
+    runSync(Effect.logWarning("NodeRedis client error", cause));
+  });
+  yield* Effect.tryPromise({
+    try: () => client.connect(),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const use = (f) => Effect.tryPromise({
+    try: () => f(client),
+    catch: (cause) => new Redis.RedisError({
+      cause
+    })
+  });
+  const redis = yield* Redis.make({
+    send: (command, ...args) => Effect.tryPromise({
+      try: () => client.sendCommand([command, ...args]),
+      catch: (cause) => new Redis.RedisError({
+        cause
+      })
+    }),
+    subscribe: (channel, onMessage) => Effect.gen(function* () {
+      const terminal = yield* Deferred.make();
+      yield* Effect.acquireRelease(Effect.tryPromise({
+        try: async () => {
+          let subscriberReady = false;
+          const subscriber = client.duplicate(socket?.reconnectStrategy === void 0 ? {
+            socket: {
+              ...socket,
+              reconnectStrategy: (retries, cause) => {
+                if (!subscriberReady) return cause;
+                if (cause instanceof SocketTimeoutError) return false;
+                const jitter = Math.floor(Math.random() * 200);
+                const delay = Math.min(2 ** retries * 50, 2e3);
+                return delay + jitter;
+              }
+            }
+          } : {});
+          subscriber.once("ready", () => {
+            subscriberReady = true;
+          });
+          subscriber.on("error", (cause) => {
+            runSync(Effect.logWarning("NodeRedis subscriber error", cause));
+            if (!subscriber.isOpen) {
+              runSync(Deferred.fail(terminal, new Redis.RedisError({
+                cause
+              })));
+            }
+          });
+          try {
+            await subscriber.connect();
+            await subscriber.subscribe(channel, (message, channel2) => {
+              onMessage({
+                channel: channel2,
+                message
+              });
+            });
+            return subscriber;
+          } catch (cause) {
+            if (subscriber.isOpen) subscriber.destroy();
+            throw cause;
+          }
+        },
+        catch: (cause) => new Redis.RedisError({
+          cause
+        })
+      }), (subscriber) => Effect.sync(() => {
+        if (subscriber.isOpen) subscriber.destroy();
+      }));
+      return Deferred.await(terminal);
+    })
+  });
+  const nodeRedis = Fn.identity({
+    client,
+    use
+  });
+  return Context.make(NodeRedis, nodeRedis).pipe(Context.add(Redis.Redis, redis));
+});
+var layer = (options) => Layer.effectContext(make4(options));
+var layerConfig = (options) => Layer.effectContext(Config.unwrap(options).pipe(Effect.flatMap(make4)));
+
+export {
+  NodeRedis,
+  layer,
+  layerConfig,
+  NodeRedis_exports
+};