the-moby-effect
Version:
Moby/Docker API client built using effect-ts
170 lines (169 loc) • 8.2 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.responseIsRawResponse = exports.rawToStream = exports.rawToSink = exports.rawFromStreamWith = exports.rawFromStream = exports.rawFromSink = exports.mergeRawToTaggedStream = exports.makeRawSocket = exports.makeRawChannel = exports.isRawSocket = exports.isRawChannel = exports.interleaveRaw = exports.demuxStdioRawTupled = exports.demuxStdioRawToSingleSink = exports.demuxStdioRawToSeparateSinks = exports.demuxRawToSingleSink = exports.asRawChannel = exports.RawSocketTypeId = exports.RawContentType = exports.RawChannelTypeId = void 0;
var Socket = _interopRequireWildcard(require("@effect/platform/Socket"));
var Channel = _interopRequireWildcard(require("effect/Channel"));
var Effect = _interopRequireWildcard(require("effect/Effect"));
var Function = _interopRequireWildcard(require("effect/Function"));
var Pipeable = _interopRequireWildcard(require("effect/Pipeable"));
var Predicate = _interopRequireWildcard(require("effect/Predicate"));
var Sink = _interopRequireWildcard(require("effect/Sink"));
var Stream = _interopRequireWildcard(require("effect/Stream"));
var Tuple = _interopRequireWildcard(require("effect/Tuple"));
var internalCompressed = _interopRequireWildcard(require("./compressed.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 RawContentType = exports.RawContentType = "application/vnd.docker.raw-stream";
/** @internal */
const RawSocketTypeId = exports.RawSocketTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/RawSocket");
/** @internal */
const RawChannelTypeId = exports.RawChannelTypeId = /*#__PURE__*/Symbol.for("the-moby-effect/demux/RawChannel");
/** @internal */
const makeRawSocket = underlying => ({
underlying,
"content-type": RawContentType,
[RawSocketTypeId]: RawSocketTypeId,
pipe() {
return Pipeable.pipeArguments(this, arguments);
}
});
/** @internal */
exports.makeRawSocket = makeRawSocket;
const makeRawChannel = underlying => ({
underlying,
"content-type": RawContentType,
[RawChannelTypeId]: RawChannelTypeId,
pipe() {
return Pipeable.pipeArguments(this, arguments);
}
});
/** @internal */
exports.makeRawChannel = makeRawChannel;
const isRawSocket = u => Predicate.hasProperty(u, RawSocketTypeId);
/** @internal */
exports.isRawSocket = isRawSocket;
const isRawChannel = u => Predicate.hasProperty(u, RawChannelTypeId);
/** @internal */
exports.isRawChannel = isRawChannel;
const responseIsRawResponse = response => response.headers["content-type"] === RawContentType;
/** @internal */
exports.responseIsRawResponse = responseIsRawResponse;
const asRawChannel = input => isRawSocket(input) ? makeRawChannel(Socket.toChannel(input.underlying)) : input;
/** @internal */
exports.asRawChannel = asRawChannel;
const rawToStream = input => Channel.toStream(asRawChannel(input).underlying);
/** @internal */
exports.rawToStream = rawToStream;
const rawToSink = input => Channel.toSink(asRawChannel(input).underlying);
/** @internal */
exports.rawToSink = rawToSink;
const rawFromStreamWith = () => input => makeRawChannel(Stream.toChannel(input));
/** @internal */
exports.rawFromStreamWith = rawFromStreamWith;
const rawFromStream = input => rawFromStreamWith()(input);
/** @internal */
exports.rawFromStream = rawFromStream;
const rawFromSink = input => makeRawChannel(Sink.toChannel(input));
/** @internal */
exports.rawFromSink = rawFromSink;
const interleaveRaw = (stdout, stderr) => {
return Stream.interleave(rawToStream(stdout), rawToStream(stderr));
};
/** @internal */
exports.interleaveRaw = interleaveRaw;
const mergeRawToTaggedStream = (stdout, stderr, options) => Stream.mergeWithTag({
stdout: rawToStream(asRawChannel(stdout)),
stderr: rawToStream(asRawChannel(stderr))
}, {
concurrency: "unbounded",
bufferSize: options?.bufferSize
});
/** @internal */
exports.mergeRawToTaggedStream = mergeRawToTaggedStream;
const demuxRawToSingleSink = exports.demuxRawToSingleSink = /*#__PURE__*/Function.dual(arguments_ => isRawSocket(arguments_[0]) || isRawChannel(arguments_[0]), (socket, source, sink, options) => Function.pipe(source, Stream.pipeThroughChannelOrFail(asRawChannel(socket).underlying), Stream.decodeText(options?.encoding), Stream.run(sink)));
/** @internal */
const demuxStdioRawTupled = exports.demuxStdioRawTupled = /*#__PURE__*/Effect.fnUntraced(function* (sockets, options) {
const {
stderr,
stdin,
stdout
} = sockets;
const stdinSocketObject = Predicate.isNotUndefined(stdin) ? {
stdin: stdin?.[1]
} : {};
const stdoutSocketObject = Predicate.isNotUndefined(stdout) ? {
stdout: stdout?.[0]
} : {};
const stderrSocketObject = Predicate.isNotUndefined(stderr) ? {
stderr: stderr?.[0]
} : {};
const stdinIoObject = Predicate.isNotUndefined(stdin) ? {
stdin: stdin?.[0]
} : {
stdin: Stream.empty
};
const stdoutIoObject = Predicate.isNotUndefined(stdout) ? {
stdout: stdout?.[1]
} : {
stdout: Sink.succeed(void 0)
};
const stderrIoObject = Predicate.isNotUndefined(stderr) ? {
stderr: stderr?.[1]
} : {
stderr: Sink.succeed(void 0)
};
return yield* demuxStdioRawToSeparateSinks({
...stdinSocketObject,
...stdoutSocketObject,
...stderrSocketObject
}, {
...stdinIoObject,
...stdoutIoObject,
...stderrIoObject
}, options);
});
/** @internal */
const demuxStdioRawToSingleSink = exports.demuxStdioRawToSingleSink = /*#__PURE__*/Function.dual(arguments_ => "stdin" in arguments_[0] || "stdout" in arguments_[0] || "stderr" in arguments_[0], /*#__PURE__*/Effect.fnUntraced(function* (sockets, source, sink, options) {
const {
stderr,
stdin,
stdout
} = sockets;
const stdoutStream = Predicate.isUndefined(stdout) ? Stream.empty : rawToStream(stdout);
const stderrStream = Predicate.isUndefined(stderr) ? Stream.empty : rawToStream(stderr);
const runInput = Predicate.isNotUndefined(stdin) ? demuxRawToSingleSink(stdin, source, Sink.drain, options) : Stream.run(source, Sink.drain);
const runOutput = Stream.interleave(stdoutStream, stderrStream).pipe(Stream.decodeText(options?.encoding)).pipe(Stream.run(sink));
return yield* Effect.map(Effect.all({
ranStdin: runInput,
ranOutput: runOutput
}, {
concurrency: 2
}), ({
ranOutput
}) => ranOutput);
}));
/** @internal */
const demuxStdioRawToSeparateSinks = exports.demuxStdioRawToSeparateSinks = /*#__PURE__*/Function.dual(arguments_ => !("stdin" in arguments_[0] && Predicate.hasProperty(arguments_[0]["stdin"], Stream.StreamTypeId)), /*#__PURE__*/Effect.fnUntraced(function* (sockets, io, options) {
const {
stderr,
stdin,
stdout
} = sockets;
const runStdin = Predicate.isNotUndefined(stdin) ? demuxRawToSingleSink(stdin, io.stdin, Sink.drain, options) : Stream.run(io.stdin, Sink.succeed(void 0));
const runStdout = Predicate.isNotUndefined(stdout) ? demuxRawToSingleSink(stdout, Stream.never, io.stdout, options) : Stream.run(Stream.empty, io.stdout);
const runStderr = Predicate.isNotUndefined(stderr) ? demuxRawToSingleSink(stderr, Stream.never, io.stderr, options) : Stream.run(Stream.empty, io.stderr);
return yield* Effect.map(Effect.all({
ranStdin: runStdin,
ranStdout: runStdout,
ranStderr: runStderr
}, {
concurrency: 3
}), ({
ranStderr,
ranStdout
}) => internalCompressed.compressDemuxOutput(Tuple.make(ranStdout, ranStderr)));
}));
//# sourceMappingURL=raw.js.map