@podium/client 5.0.0-next.10 → 5.0.0-next.12

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [5.0.0-next.12](https://github.com/podium-lib/client/compare/v5.0.0-next.11...v5.0.0-next.12) (2022-09-20)
+
+
+### Features
+
+* replace request with undici for http requests ([31163db](https://github.com/podium-lib/client/commit/31163db538d87cb797135d7febcc6cc244eac17a))
+
+# [5.0.0-next.11](https://github.com/podium-lib/client/compare/v5.0.0-next.10...v5.0.0-next.11) (2022-09-08)
+
+
+### Bug Fixes
+
+* Fix inspect method on response object ([#294](https://github.com/podium-lib/client/issues/294)) ([94d1485](https://github.com/podium-lib/client/commit/94d14856ca2280888aa50e9cb7e7f782cd49666a))
+
 # [5.0.0-next.10](https://github.com/podium-lib/client/compare/v5.0.0-next.9...v5.0.0-next.10) (2022-09-07)
 
 

package/lib/http.js

@@ -0,0 +1,23 @@
+import { Client } from 'undici';
+
+export default class HTTP {
+    // #client;
+
+    // constructor() {
+    //     // this.#client = { request };
+    // }
+
+    async request(url, options) {
+        const u = new URL(url);
+        const client = new Client(u.origin, {
+            ...options,
+            connect: { rejectUnauthorized: options.rejectUnauthorized },
+        });
+
+        const { statusCode, headers, body } = await client.request({
+            ...options,
+            path: u.pathname,
+        });
+        return { statusCode, headers, body };
+    }
+}

package/lib/resolver.content.js

@@ -1,21 +1,22 @@
 /* eslint-disable no-param-reassign */
-
 import { pipeline } from 'stream';
 import Metrics from '@metrics/client';
-import request from 'request';
 import abslog from 'abslog';
 import * as putils from '@podium/utils';
 import { Boom, badGateway } from '@hapi/boom';
-
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
 import * as utils from './utils.js';
 import Response from './response.js';
+import HTTP from './http.js';
 
 const currentDirectory = dirname(fileURLToPath(import.meta.url));
 
-const pkgJson = fs.readFileSync(join(currentDirectory, '../package.json'), 'utf-8');
+const pkgJson = fs.readFileSync(
+    join(currentDirectory, '../package.json'),
+    'utf-8',
+);
 const pkg = JSON.parse(pkgJson);
 
 const UA_STRING = `${pkg.name} ${pkg.version}`;
@@ -24,13 +25,11 @@ export default class PodletClientContentResolver {
     #log;
     #metrics;
     #histogram;
-    #httpAgent;
-    #httpsAgent;
+    #http;
     constructor(options = {}) {
+        this.#http = options.http || new HTTP();
         const name = options.clientName;
         this.#log = abslog(options.logger);
-        this.#httpAgent = options.httpAgent;
-        this.#httpsAgent = options.httpsAgent;
         this.#metrics = new Metrics();
         this.#histogram = this.#metrics.histogram({
             name: 'podium_client_resolver_content_resolve',
@@ -43,7 +42,7 @@ export default class PodletClientContentResolver {
             buckets: [0.001, 0.01, 0.1, 0.5, 1, 2, 10],
         });
 
-        this.#metrics.on('error', error => {
+        this.#metrics.on('error', (error) => {
             this.#log.error(
                 'Error emitted by metric stream in @podium/client module',
                 error,
@@ -55,207 +54,177 @@ export default class PodletClientContentResolver {
         return this.#metrics;
     }
 
-    resolve(outgoing) {
-        return new Promise((resolve, reject) => {
-            if (outgoing.kill && outgoing.throwable) {
-                this.#log.warn(
-                    `recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times - throwing - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                );
-                reject(
-                    badGateway(
-                        `Recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times`,
-                    ),
-                );
-                return;
-            }
+    async resolve(outgoing) {
+        if (outgoing.kill && outgoing.throwable) {
+            this.#log.warn(
+                `recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times - throwing - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            throw badGateway(
+                `Recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times`,
+            );
+        }
 
-            if (outgoing.kill) {
-                this.#log.warn(
-                    `recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times - serving fallback - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                );
-                outgoing.success = true;
-                outgoing.pushFallback();
-                resolve(outgoing);
-                return;
-            }
+        if (outgoing.kill) {
+            this.#log.warn(
+                `recursion detected - failed to resolve fetching of podlet ${outgoing.recursions} times - serving fallback - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            outgoing.success = true;
+            outgoing.pushFallback();
+            return outgoing;
+        }
+
+        if (outgoing.status === 'empty' && outgoing.throwable) {
+            this.#log.warn(
+                `no manifest available - cannot read content - throwing - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            throw badGateway(`No manifest available - Cannot read content`);
+        }
 
-            if (outgoing.status === 'empty' && outgoing.throwable) {
-                this.#log.warn(
-                    `no manifest available - cannot read content - throwing - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                );
-                reject(
-                    badGateway(`No manifest available - Cannot read content`),
+        if (outgoing.status === 'empty') {
+            this.#log.warn(
+                `no manifest available - cannot read content - serving fallback - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            outgoing.success = true;
+            outgoing.pushFallback();
+            return outgoing;
+        }
+
+        const headers = {
+            ...outgoing.reqOptions.headers,
+            'User-Agent': UA_STRING,
+        };
+
+        putils.serializeContext(headers, outgoing.context, outgoing.name);
+
+        const uri = putils.uriBuilder(
+            outgoing.reqOptions.pathname,
+            outgoing.contentUri,
+        )
+
+        const reqOptions = {
+            rejectUnauthorized: outgoing.rejectUnauthorized,
+            bodyTimeout: outgoing.timeout,
+            method: 'GET',
+            query: outgoing.reqOptions.query,
+            headers,
+        };
+
+        if (outgoing.redirectable) {
+            reqOptions.follow = false;
+        }
+
+        const timer = this.#histogram.timer({
+            labels: {
+                podlet: outgoing.name,
+            },
+        });
+
+        this.#log.debug(
+            `start reading content from remote resource - manifest version is ${outgoing.manifest.version} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
+        );
+
+        try {
+            const {
+                statusCode,
+                headers: hdrs,
+                body,
+            } = await this.#http.request(uri, reqOptions);
+
+            // Remote responds but with an http error code
+            const resError = statusCode >= 400;
+            if (resError && outgoing.throwable) {
+                timer({
+                    labels: {
+                        status: 'failure',
+                    },
+                });
+
+                this.#log.debug(
+                    `remote resource responded with non 200 http status code for content - code: ${statusCode} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
                 );
-                return;
+
+                const errorMessage = `Could not read content. Resource responded with ${statusCode} on ${outgoing.contentUri}`;
+
+                const errorOptions = {
+                    statusCode,
+                    decorate: {
+                        statusCode,
+                    },
+                };
+
+                throw new Boom(errorMessage, errorOptions);
             }
+            if (resError) {
+                timer({
+                    labels: {
+                        status: 'failure',
+                    },
+                });
 
-            if (outgoing.status === 'empty') {
                 this.#log.warn(
-                    `no manifest available - cannot read content - serving fallback - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+                    `remote resource responded with non 200 http status code for content - code: ${statusCode} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
                 );
                 outgoing.success = true;
                 outgoing.pushFallback();
-                resolve(outgoing);
-                return;
-            }
-
-            const headers = {
-                ...outgoing.reqOptions.headers,
-                'User-Agent': UA_STRING,
-            };
-
-            putils.serializeContext(headers, outgoing.context, outgoing.name);
-
-            const reqOptions = {
-                rejectUnauthorized: outgoing.rejectUnauthorized,
-                timeout: outgoing.timeout,
-                method: 'GET',
-                agent: outgoing.contentUri.startsWith('https://')
-                ? this.#httpsAgent
-                : this.#httpAgent,
-                uri: putils.uriBuilder(
-                    outgoing.reqOptions.pathname,
-                    outgoing.contentUri,
-                ),
-                qs: outgoing.reqOptions.query,
-                headers,
-            };
-
-            if (outgoing.redirectable) {
-                reqOptions.followRedirect = false;
+                return outgoing;
             }
 
-            const timer = this.#histogram.timer({
-                labels: {
-                    podlet: outgoing.name,
-                },
-            });
+            const contentVersion = utils.isHeaderDefined(hdrs, 'podlet-version')
+                ? hdrs['podlet-version']
+                : undefined;
 
             this.#log.debug(
-                `start reading content from remote resource - manifest version is ${outgoing.manifest.version} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
+                `got head response from remote resource for content - header version is ${hdrs['podlet-version']} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
             );
 
-            const r = request(reqOptions);
-
-            r.on('response', response => {
-                // Remote responds but with an http error code
-                const resError = response.statusCode >= 400;
-                if (resError && outgoing.throwable) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.debug(
-                        `remote resource responded with non 200 http status code for content - code: ${response.statusCode} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
-                    );
-
-                    const errorMessage = `Could not read content. Resource responded with ${response.statusCode} on ${outgoing.contentUri}`;
-
-                    const errorOptions = {
-                        statusCode: response.statusCode,
-                        decorate: {
-                            statusCode: response.statusCode,
-                        },
-                    };
-
-                    reject(new Boom(errorMessage, errorOptions));
-                    return;
-                }
-                if (resError) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `remote resource responded with non 200 http status code for content - code: ${response.statusCode} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
-                    );
-                    outgoing.success = true;
-                    outgoing.pushFallback();
-                    resolve(outgoing);
-                    return;
-                }
-
-                const contentVersion = utils.isHeaderDefined(
-                    response.headers,
-                    'podlet-version',
-                )
-                    ? response.headers['podlet-version']
-                    : undefined;
+            if (
+                contentVersion !== outgoing.manifest.version &&
+                contentVersion !== undefined
+            ) {
+                timer({
+                    labels: {
+                        status: 'success',
+                    },
+                });
 
-                this.#log.debug(
-                    `got head response from remote resource for content - header version is ${response.headers['podlet-version']} - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
+                this.#log.info(
+                    `podlet version number in header differs from cached version number - aborting request to remote resource for content - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
                 );
+                // TODO r.abort();
+                outgoing.status = 'stale';
+                return outgoing;
+            }
 
-                if (
-                    contentVersion !== outgoing.manifest.version &&
-                    contentVersion !== undefined
-                ) {
-                    timer({
-                        labels: {
-                            status: 'success',
-                        },
-                    });
-
-                    this.#log.info(
-                        `podlet version number in header differs from cached version number - aborting request to remote resource for content - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
-                    );
-                    r.abort();
-                    outgoing.status = 'stale';
-                    return;
-                }
-
-                outgoing.success = true;
-                outgoing.headers = response.headers;
-
-                if (outgoing.redirectable && response.statusCode >= 300) {
-                    outgoing.redirect = {
-                        statusCode: response.statusCode,
-                        location: response.headers && response.headers.location,
-                    };
-                }
+            outgoing.success = true;
+            outgoing.headers = hdrs;
 
-                outgoing.emit(
-                    'beforeStream',
-                    new Response({
-                        headers: outgoing.headers,
-                        js: outgoing.manifest.js,
-                        css: outgoing.manifest.css,
-                        redirect: outgoing.redirect,
-                    }),
-                );
+            if (outgoing.redirectable && statusCode >= 300) {
+                outgoing.redirect = {
+                    statusCode,
+                    location: hdrs && hdrs.location,
+                };
+            }
 
-                pipeline([r, outgoing], (err) => {
-                    if (err) {
-                        this.#log.warn('error while piping content stream', err);
-                    }
-                });
-            });
+            outgoing.emit(
+                'beforeStream',
+                new Response({
+                    headers: outgoing.headers,
+                    js: outgoing.manifest.js,
+                    css: outgoing.manifest.css,
+                    redirect: outgoing.redirect,
+                }),
+            );
 
-            r.on('error', error => {
-                // Network error
-                if (outgoing.throwable) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `could not create network connection to remote resource when trying to request content - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
-                    );
-                    reject(
-                        badGateway(
-                            `Error reading content at ${outgoing.contentUri}`,
-                            error,
-                        ),
-                    );
-                    return;
+            pipeline([body, outgoing], (err) => {
+                if (err) {
+                    this.#log.warn('error while piping content stream', err);
                 }
+            });
+        } catch (error) {
+            if (error.isBoom) throw error;
 
+            // Network error
+            if (outgoing.throwable) {
                 timer({
                     labels: {
                         status: 'failure',
@@ -265,30 +234,43 @@ export default class PodletClientContentResolver {
                 this.#log.warn(
                     `could not create network connection to remote resource when trying to request content - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
                 );
+                throw badGateway(
+                    `Error reading content at ${outgoing.contentUri}`,
+                    error,
+                );
+            }
 
-                outgoing.success = true;
-
-                outgoing.pushFallback();
-                resolve(outgoing);
+            timer({
+                labels: {
+                    status: 'failure',
+                },
             });
 
-            r.on('end', () => {
-                timer({
-                    labels: {
-                        status: 'success',
-                    },
-                });
+            this.#log.warn(
+                `could not create network connection to remote resource when trying to request content - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
+            );
 
-                this.#log.debug(
-                    `successfully read content from remote resource - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
-                );
+            outgoing.success = true;
 
-                resolve(outgoing);
-            });
+            outgoing.pushFallback();
+
+            return outgoing;
+        }
+
+        timer({
+            labels: {
+                status: 'success',
+            },
         });
+
+        this.#log.debug(
+            `successfully read content from remote resource - resource: ${outgoing.name} - url: ${outgoing.contentUri}`,
+        );
+
+        return outgoing;
     }
 
     get [Symbol.toStringTag]() {
         return 'PodletClientContentResolver';
     }
-};
+}

package/lib/resolver.fallback.js

@@ -1,16 +1,18 @@
 /* eslint-disable no-param-reassign */
 
-import request from 'request';
 import abslog from 'abslog';
 import Metrics from '@metrics/client';
-
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import HTTP from './http.js';
 
 const currentDirectory = dirname(fileURLToPath(import.meta.url));
 
-const pkgJson = fs.readFileSync(join(currentDirectory, '../package.json'), 'utf-8');
+const pkgJson = fs.readFileSync(
+    join(currentDirectory, '../package.json'),
+    'utf-8',
+);
 const pkg = JSON.parse(pkgJson);
 
 const UA_STRING = `${pkg.name} ${pkg.version}`;
@@ -19,14 +21,12 @@ export default class PodletClientFallbackResolver {
     #log;
     #metrics;
     #histogram;
-    #httpAgent;
-    #httpsAgent;
+    #http;
     constructor(options = {}) {
+        this.#http = options.http || new HTTP();
         const name = options.clientName;
         this.#log = abslog(options.logger);
         this.#metrics = new Metrics();
-        this.#httpAgent = options.httpAgent;
-        this.#httpsAgent = options.httpsAgent;
         this.#histogram = this.#metrics.histogram({
             name: 'podium_client_resolver_fallback_resolve',
             description: 'Time taken for success/failure of fallback request',
@@ -38,7 +38,7 @@ export default class PodletClientFallbackResolver {
             buckets: [0.001, 0.01, 0.1, 0.5, 1, 2, 10],
         });
 
-        this.#metrics.on('error', error => {
+        this.#metrics.on('error', (error) => {
             this.#log.error(
                 'Error emitted by metric stream in @podium/client module',
                 error,
@@ -50,113 +50,103 @@ export default class PodletClientFallbackResolver {
         return this.#metrics;
     }
 
-    resolve(outgoing) {
-        return new Promise(resolve => {
-            if (outgoing.status === 'cached') {
-                resolve(outgoing);
-                return;
-            }
+    async resolve(outgoing) {
+        if (outgoing.status === 'cached') {
+            return outgoing;
+        }
+
+        // Manifest has no fallback, fetching of manifest likely failed.
+        // Its not possible to fetch anything
+        // Do not set fallback so we can serve any previous fallback we might have
+        if (outgoing.manifest.fallback === undefined) {
+            return outgoing;
+        }
+
+        // If manifest fallback is empty, there is no fallback content to fetch
+        // Set fallback to empty string
+        if (outgoing.manifest.fallback === '') {
+            this.#log.debug(
+                `no fallback defined in manifest - resource: ${outgoing.name}`,
+            );
+            outgoing.fallback = '';
+            return outgoing;
+        }
+
+        // The manifest fallback holds a URI, fetch its content
+        const headers = {
+            'User-Agent': UA_STRING,
+        };
+
+        const reqOptions = {
+            rejectUnauthorized: outgoing.rejectUnauthorized,
+            timeout: outgoing.timeout,
+            method: 'GET',
+            headers,
+        };
+
+        const timer = this.#histogram.timer({
+            labels: {
+                podlet: outgoing.name,
+            },
+        });
 
-            // Manifest has no fallback, fetching of manifest likely failed.
-            // Its not possible to fetch anything
-            // Do not set fallback so we can serve any previous fallback we might have
-            if (outgoing.manifest.fallback === undefined) {
-                resolve(outgoing);
-                return;
-            }
+        try {
+            this.#log.debug(
+                `start reading fallback content from remote resource - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
+            );
+            const { statusCode, body } = await this.#http.request(
+                outgoing.fallbackUri,
+                reqOptions,
+            );
+
+            // Remote responds but with an http error code
+            const resError = statusCode !== 200;
+            if (resError) {
+                timer({
+                    labels: {
+                        status: 'failure',
+                    },
+                });
 
-            // If manifest fallback is empty, there is no fallback content to fetch
-            // Set fallback to empty string
-            if (outgoing.manifest.fallback === '') {
-                this.#log.debug(
-                    `no fallback defined in manifest - resource: ${outgoing.name}`,
+                this.#log.warn(
+                    `remote resource responded with non 200 http status code for fallback content - code: ${statusCode} - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
                 );
+
                 outgoing.fallback = '';
-                resolve(outgoing);
-                return;
+                return outgoing;
             }
 
-            // The manifest fallback holds a URI, fetch its content
-            const headers = {
-                'User-Agent': UA_STRING,
-            };
-
-            const reqOptions = {
-                rejectUnauthorized: outgoing.rejectUnauthorized,
-                timeout: outgoing.timeout,
-                method: 'GET',
-                agent: outgoing.fallbackUri.startsWith('https://')
-                ? this.#httpsAgent
-                : this.#httpAgent,
-                uri: outgoing.fallbackUri,
-                headers,
-            };
-
-            const timer = this.#histogram.timer({
+            // Response is OK. Store response body as fallback html for caching
+            timer({
                 labels: {
-                    podlet: outgoing.name,
+                    status: 'success',
                 },
             });
 
-            request(reqOptions, (error, res, body) => {
-                this.#log.debug(
-                    `start reading fallback content from remote resource - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
-                );
+            // Set fallback to the fetched content
+            outgoing.fallback = await body.text();
 
-                // Network error
-                if (error) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `could not create network connection to remote resource for fallback content - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
-                    );
-
-                    outgoing.fallback = '';
-                    resolve(outgoing);
-                    return;
-                }
-
-                // Remote responds but with an http error code
-                const resError = res.statusCode !== 200;
-                if (resError) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `remote resource responded with non 200 http status code for fallback content - code: ${res.statusCode} - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
-                    );
-
-                    outgoing.fallback = '';
-                    resolve(outgoing);
-                    return;
-                }
-
-                // Response is OK. Store response body as fallback html for caching
-                timer({
-                    labels: {
-                        status: 'success',
-                    },
-                });
+            this.#log.debug(
+                `successfully read fallback from remote resource - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
+            );
+            return outgoing;
+        } catch (error) {
+            timer({
+                labels: {
+                    status: 'failure',
+                },
+            });
 
-                // Set fallback to the fetched content
-                outgoing.fallback = body;
+            this.#log.warn(
+                `could not create network connection to remote resource for fallback content - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
+            );
 
-                this.#log.debug(
-                    `successfully read fallback from remote resource - resource: ${outgoing.name} - url: ${outgoing.fallbackUri}`,
-                );
-                resolve(outgoing);
-            });
-        });
+            outgoing.fallback = '';
+            return outgoing;
+        }
     }
 
     get [Symbol.toStringTag]() {
         return 'PodletClientFallbackResolver';
     }
-};
+}

package/lib/resolver.js

@@ -1,6 +1,7 @@
 import Metrics from '@metrics/client';
 import abslog from 'abslog';
 import assert from 'assert';
+import HTTP from './http.js';
 import Manifest from './resolver.manifest.js';
 import Fallback from './resolver.fallback.js';
 import Content from './resolver.content.js';
@@ -19,10 +20,11 @@ export default class PodletClientResolver {
         );
 
         const log = abslog(options.logger);
+        const http = new HTTP();
         this.#cache = new Cache(registry, options);
-        this.#manifest = new Manifest(options);
-        this.#fallback = new Fallback(options);
-        this.#content = new Content(options);
+        this.#manifest = new Manifest({ ...options, http });
+        this.#fallback = new Fallback({ ...options, http });
+        this.#content = new Content({ ...options, http });
         this.#metrics = new Metrics();
 
         this.#metrics.on('error', error => {

package/lib/resolver.manifest.js

@@ -1,19 +1,21 @@
 /* eslint-disable no-param-reassign */
 
 import CachePolicy from 'http-cache-semantics';
-import {manifest as validateManifest } from'@podium/schemas';
-import request from 'request';
+import { manifest as validateManifest } from '@podium/schemas';
 import Metrics from '@metrics/client';
 import abslog from 'abslog';
 import * as utils from '@podium/utils';
-
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
 import fs from 'fs';
+import HTTP from './http.js';
 
 const currentDirectory = dirname(fileURLToPath(import.meta.url));
 
-const pkgJson = fs.readFileSync(join(currentDirectory, '../package.json'), 'utf-8');
+const pkgJson = fs.readFileSync(
+    join(currentDirectory, '../package.json'),
+    'utf-8',
+);
 const pkg = JSON.parse(pkgJson);
 
 const UA_STRING = `${pkg.name} ${pkg.version}`;
@@ -21,15 +23,13 @@ const UA_STRING = `${pkg.name} ${pkg.version}`;
 export default class PodletClientManifestResolver {
     #log;
     #metrics;
-    #httpAgent;
-    #httpsAgent;
     #histogram;
+    #http;
     constructor(options = {}) {
+        this.#http = options.http || new HTTP();
         const name = options.clientName;
         this.#log = abslog(options.logger);
         this.#metrics = new Metrics();
-        this.#httpAgent = options.httpAgent;
-        this.#httpsAgent = options.httpsAgent;
         this.#histogram = this.#metrics.histogram({
             name: 'podium_client_resolver_manifest_resolve',
             description: 'Time taken for success/failure of manifest request',
@@ -41,7 +41,7 @@ export default class PodletClientManifestResolver {
             buckets: [0.001, 0.01, 0.1, 0.5, 1, 2, 10],
         });
 
-        this.#metrics.on('error', error => {
+        this.#metrics.on('error', (error) => {
             this.#log.error(
                 'Error emitted by metric stream in @podium/client module',
                 error,
@@ -53,161 +53,154 @@ export default class PodletClientManifestResolver {
         return this.#metrics;
     }
 
-    resolve(outgoing) {
-        return new Promise(resolve => {
-            if (outgoing.status === 'cached') {
-                resolve(outgoing);
-                return;
-            }
+    async resolve(outgoing) {
+        if (outgoing.status === 'cached') {
+            return outgoing;
+        }
 
-            const headers = {
-                'User-Agent': UA_STRING,
-            };
+        const headers = {
+            'User-Agent': UA_STRING,
+        };
 
-            const reqOptions = {
-                rejectUnauthorized: outgoing.rejectUnauthorized,
-                timeout: outgoing.timeout,
-                method: 'GET',
-                agent: outgoing.manifestUri.startsWith('https://')
-                ? this.#httpsAgent
-                : this.#httpAgent,
-                json: true,
-                uri: outgoing.manifestUri,
-                headers,
-            };
+        const reqOptions = {
+            rejectUnauthorized: outgoing.rejectUnauthorized,
+            timeout: outgoing.timeout,
+            method: 'GET',
+            json: true,
+            headers,
+        };
 
-            const timer = this.#histogram.timer({
-                labels: {
-                    podlet: outgoing.name,
-                },
-            });
+        const timer = this.#histogram.timer({
+            labels: {
+                podlet: outgoing.name,
+            },
+        });
 
-            request(reqOptions, (error, res, body) => {
-                this.#log.debug(
-                    `start reading manifest from remote resource - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                );
+        this.#log.debug(
+            `start reading manifest from remote resource - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+        );
 
-                // Network error or JSON parsing error
-                if (error) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `could not create network connection to remote manifest - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                    );
-                    resolve(outgoing);
-                    return;
-                }
-
-                // Remote responds but with an http error code
-                const resError = res.statusCode !== 200;
-                if (resError) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `remote resource responded with non 200 http status code for manifest - code: ${res.statusCode} - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                    );
-                    resolve(outgoing);
-                    return;
-                }
-
-                const manifest = validateManifest(body);
-
-                // Manifest validation error
-                if (manifest.error) {
-                    timer({
-                        labels: {
-                            status: 'failure',
-                        },
-                    });
-
-                    this.#log.warn(
-                        `could not parse manifest - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                    );
-                    resolve(outgoing);
-                    return;
-                }
-
-                // Manifest is valid, calculate maxAge for caching and continue
+        try {
+            const {
+                statusCode,
+                headers: hdrs,
+                body,
+            } = await this.#http.request(outgoing.manifestUri, reqOptions);
+
+            // Remote responds but with an http error code
+            const resError = statusCode !== 200;
+            if (resError) {
                 timer({
                     labels: {
-                        status: 'success',
+                        status: 'failure',
                     },
                 });
 
-                const resValues = {
-                    status: res.statusCode,
-                    headers: res.headers,
-                };
-
-                const cachePolicy = new CachePolicy(reqOptions, resValues, {
-                    ignoreCargoCult: true,
-                });
-                const maxAge = cachePolicy.timeToLive();
-                if (maxAge !== 0) {
-                    this.#log.debug(
-                        `remote resource has cache header which yelds a max age of ${maxAge}ms, using this as cache ttl - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
-                    );
-                    outgoing.maxAge = maxAge;
-                }
-
-                // Build absolute content and fallback URIs
-                if (manifest.value.fallback !== '') {
-                    manifest.value.fallback = utils.uriRelativeToAbsolute(
-                        manifest.value.fallback,
-                        outgoing.manifestUri,
-                    );
-                }
-
-                manifest.value.content = utils.uriRelativeToAbsolute(
-                    manifest.value.content,
-                    outgoing.manifestUri,
+                this.#log.warn(
+                    `remote resource responded with non 200 http status code for manifest - code: ${statusCode} - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
                 );
+                return outgoing;
+            }
 
-                // Construct css and js objects with absolute URIs
-                manifest.value.css = manifest.value.css.map(obj => {
-                    obj.value = utils.uriRelativeToAbsolute(
-                        obj.value,
-                        outgoing.manifestUri,
-                    );
-                    return new utils.AssetCss(obj);
-                });
+            const manifest = validateManifest(await body.json());
 
-                manifest.value.js = manifest.value.js.map(obj => {
-                    obj.value = utils.uriRelativeToAbsolute(
-                        obj.value,
-                        outgoing.manifestUri,
-                    );
-                    return new utils.AssetJs(obj);
+            // Manifest validation error
+            if (manifest.error) {
+                timer({
+                    labels: {
+                        status: 'failure',
+                    },
                 });
 
-                // Build absolute proxy URIs
-                Object.keys(manifest.value.proxy).forEach(key => {
-                    manifest.value.proxy[key] = utils.uriRelativeToAbsolute(
-                        manifest.value.proxy[key],
-                        outgoing.manifestUri,
-                    );
-                });
+                this.#log.warn(
+                    `could not parse manifest - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+                );
+                return outgoing;
+            }
 
-                outgoing.manifest = manifest.value;
-                outgoing.status = 'fresh';
+            // Manifest is valid, calculate maxAge for caching and continue
+            timer({
+                labels: {
+                    status: 'success',
+                },
+            });
+
+            const resValues = {
+                status: statusCode,
+                headers: hdrs,
+            };
 
+            const cachePolicy = new CachePolicy(reqOptions, resValues, {
+                ignoreCargoCult: true,
+            });
+            const maxAge = cachePolicy.timeToLive();
+            if (maxAge !== 0) {
                 this.#log.debug(
-                    `successfully read manifest from remote resource - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+                    `remote resource has cache header which yelds a max age of ${maxAge}ms, using this as cache ttl - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+                );
+                outgoing.maxAge = maxAge;
+            }
+
+            // Build absolute content and fallback URIs
+            if (manifest.value.fallback !== '') {
+                manifest.value.fallback = utils.uriRelativeToAbsolute(
+                    manifest.value.fallback,
+                    outgoing.manifestUri,
+                );
+            }
+
+            manifest.value.content = utils.uriRelativeToAbsolute(
+                manifest.value.content,
+                outgoing.manifestUri,
+            );
+
+            // Construct css and js objects with absolute URIs
+            manifest.value.css = manifest.value.css.map((obj) => {
+                obj.value = utils.uriRelativeToAbsolute(
+                    obj.value,
+                    outgoing.manifestUri,
                 );
-                resolve(outgoing);
+                return new utils.AssetCss(obj);
             });
-        });
+
+            manifest.value.js = manifest.value.js.map((obj) => {
+                obj.value = utils.uriRelativeToAbsolute(
+                    obj.value,
+                    outgoing.manifestUri,
+                );
+                return new utils.AssetJs(obj);
+            });
+
+            // Build absolute proxy URIs
+            Object.keys(manifest.value.proxy).forEach((key) => {
+                manifest.value.proxy[key] = utils.uriRelativeToAbsolute(
+                    manifest.value.proxy[key],
+                    outgoing.manifestUri,
+                );
+            });
+
+            outgoing.manifest = manifest.value;
+            outgoing.status = 'fresh';
+
+            this.#log.debug(
+                `successfully read manifest from remote resource - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            return outgoing;
+        } catch (error) {
+            timer({
+                labels: {
+                    status: 'failure',
+                },
+            });
+
+            this.#log.warn(
+                `could not create network connection to remote manifest - resource: ${outgoing.name} - url: ${outgoing.manifestUri}`,
+            );
+            return outgoing;
+        }
     }
 
     get [Symbol.toStringTag]() {
         return 'PodletClientManifestResolver';
     }
-};
+}

package/lib/resource.js

@@ -1,7 +1,6 @@
 /* eslint-disable no-param-reassign */
 
 import Metrics from '@metrics/client';
-import stream from 'stream';
 import abslog from 'abslog';
 import assert from 'assert';
 
@@ -63,22 +62,16 @@ export default class PodiumClientResource {
 
         this.#state.setInitializingState();
 
-        const chunks = [];
-        const to = new stream.Writable({
-            write: (chunk, encoding, next) => {
-                chunks.push(chunk);
-                next();
-            },
-        });
-
-        stream.pipeline([outgoing, to], () => {
-            // noop
-        });
-
         const { manifest, headers, redirect } = await this.#resolver.resolve(
             outgoing,
         );
 
+        const chunks = [];
+        // eslint-disable-next-line no-restricted-syntax
+        for await (const chunk of outgoing) {
+            chunks.push(chunk)
+        }
+
         const content = !outgoing.redirect
             ? Buffer.concat(chunks).toString()
             : '';

package/lib/response.js

@@ -60,15 +60,11 @@ export default class PodiumClientResponse {
 
     [inspect]() {
         return {
-            referrerpolicy: this.referrerpolicy,
-            crossorigin: this.crossorigin,
-            integrity: this.integrity,
-            nomodule: this.nomodule,
-            value: this.value,
-            async: this.async,
-            defer: this.defer,
-            type: this.type,
-            data: this.data,
+            redirect: this.redirect,
+            content: this.content,
+            headers: this.headers,
+            css: this.css,
+            js: this.js,
         };
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podium/client",
-  "version": "5.0.0-next.10",
+  "version": "5.0.0-next.12",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -42,8 +42,8 @@
     "abslog": "2.4.0",
     "http-cache-semantics": "^4.0.3",
     "lodash.clonedeep": "^4.5.0",
-    "request": "^2.88.0",
-    "ttl-mem-cache": "4.1.0"
+    "ttl-mem-cache": "4.1.0",
+    "undici": "^5.10.0"
   },
   "devDependencies": {
     "@podium/test-utils": "2.5.2",