the-moby-effect/dist/cjs/internal/platforms/agnostic.js

Moby/Docker API client built using effect-ts

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.websocketRequest = exports.makeAgnosticWebsocketLayer = exports.makeAgnosticLayer = exports.makeAgnosticHttpClientLayer = void 0;
var HttpClient = _interopRequireWildcard(require("@effect/platform/HttpClient"));
var HttpClientRequest = _interopRequireWildcard(require("@effect/platform/HttpClientRequest"));
var Socket = _interopRequireWildcard(require("@effect/platform/Socket"));
var UrlParams = _interopRequireWildcard(require("@effect/platform/UrlParams"));
var Context = _interopRequireWildcard(require("effect/Context"));
var Effect = _interopRequireWildcard(require("effect/Effect"));
var Function = _interopRequireWildcard(require("effect/Function"));
var Layer = _interopRequireWildcard(require("effect/Layer"));
var Predicate = _interopRequireWildcard(require("effect/Predicate"));
var internalConnection = _interopRequireWildcard(require("./connection.js"));
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/** @internal */
const makeVersionPath = connectionOptions => Predicate.isNotUndefined(connectionOptions.version) ? `/v${connectionOptions.version}` : "";
/** @internal */
const makeHttpRequestUrl = /*#__PURE__*/internalConnection.MobyConnectionOptions.$match({
  ssh: options => `http://0.0.0.0${makeVersionPath(options)}`,
  socket: options => `http://0.0.0.0${makeVersionPath(options)}`,
  http: options => `http://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`,
  https: options => `https://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`
});
/** @internal */
const makeWebsocketRequestUrl = /*#__PURE__*/internalConnection.MobyConnectionOptions.$match({
  ssh: options => `ws://0.0.0.0${makeVersionPath(options)}`,
  socket: options => `ws+unix://${options.socketPath}${makeVersionPath(options)}:`,
  http: options => `ws://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`,
  https: options => `wss://${options.host}:${options.port}${options.path ?? ""}${makeVersionPath(options)}`
});
/** @internal */
const HttpClientMobyConnectionOptions = /*#__PURE__*/Symbol.for("@the-moby-effect/platforms/Agnostic/HttpClientMobyConnectionOptions");
/** @internal */
const websocketRequest = request => Effect.gen(function* () {
  const client = yield* HttpClient.HttpClient;
  const {
    hash,
    url,
    urlParams
  } = request;
  const {
    [HttpClientMobyConnectionOptions]: connectionOptions
  } = client;
  if (Predicate.isUndefined(connectionOptions)) {
    return yield* Effect.dieMessage("What happened to the connection options?");
  }
  const websocketUrl = yield* UrlParams.makeUrl(`${makeWebsocketRequestUrl(connectionOptions)}${url}`, urlParams, hash);
  return yield* Socket.makeWebSocket(websocketUrl.toString());
});
/** @internal */
exports.websocketRequest = websocketRequest;
const makeAgnosticHttpClientLayer = connectionOptions => Function.pipe(Layer.function(HttpClient.HttpClient, HttpClient.HttpClient, HttpClient.mapRequest(request => {
  const httpUrl = makeHttpRequestUrl(connectionOptions);
  const urlPrepended = HttpClientRequest.prependUrl(request, httpUrl);
  return urlPrepended;
})), Layer.map(context => {
  const tag = HttpClient.HttpClient;
  const oldClient = Context.get(context, tag);
  oldClient[HttpClientMobyConnectionOptions] = connectionOptions;
  return Context.make(tag, oldClient);
}));
/** @internal */
exports.makeAgnosticHttpClientLayer = makeAgnosticHttpClientLayer;
const makeAgnosticWebsocketLayer = connectionOptions => Layer.effect(Socket.WebSocketConstructor, Effect.gen(function* () {
  // Only the ws package supports unix socket connection options
  if (internalConnection.MobyConnectionOptions.$is("socket")(connectionOptions)) {
    const ws = yield* Effect.promise(() => import("ws"));
    return (url, protocols) => new ws.WebSocket(url, protocols);
  }
  return (url, protocols) => new WebSocket(url, protocols);
}));
/** @internal */
exports.makeAgnosticWebsocketLayer = makeAgnosticWebsocketLayer;
const makeAgnosticLayer = connectionOptions => {
  const httpClientLayer = makeAgnosticHttpClientLayer(connectionOptions);
  const websocketLayer = makeAgnosticWebsocketLayer(connectionOptions);
  return Layer.merge(websocketLayer, httpClientLayer);
};
exports.makeAgnosticLayer = makeAgnosticLayer;
//# sourceMappingURL=agnostic.js.map