feat: add url component for URL specific functions

.bitmap

@@ -161,5 +161,19 @@
  }
  }
  },
+ "url": {
+ "name": "url",
+ "scope": "",
+ "version": "",
+ "defaultScope": "pnpm.network",
+ "mainFile": "index.ts",
+ "rootDir": "network/url",
+ "config": {
+ "pnpm.env/envs/pnpm-env": {},
+ "teambit.envs/envs": {
+ "env": "pnpm.env/envs/pnpm-env"
+ }
+ }
+ },
  "$schema-version": "17.0.0"
 }

network/agent/agent.spec.ts

@@ -184,7 +184,30 @@ test('select correct client certificates when host has a port', () => {
 test('select correct client certificates when host has a path', () => {
  const agent = getAgent('https://foo.com/bar/baz', {
  clientCertificates: {
- '//foo.com/bar/': {
+ '//foo.com/': {
+ ca: 'ca',
+ cert: 'cert',
+ key: 'key',
+ },
+ },
+ })
+
+ expect(agent).toEqual({
+ ca: 'ca',
+ cert: 'cert',
+ key: 'key',
+ localAddress: undefined,
+ maxSockets: 50,
+ rejectUnauthorized: undefined,
+ timeout: 0,
+ __type: 'https',
+ })
+})
+
+test('select correct client certificates when host has a path and the cert contains a path', () => {
+ const agent = getAgent('https://foo.com/bar/baz', {
+ clientCertificates: {
+ '//foo.com/bar': {
  ca: 'ca',
  cert: 'cert',
  key: 'key',

network/agent/agent.ts

@@ -1,8 +1,8 @@
 import { URL } from 'url'
 import HttpAgent from 'agentkeepalive'
 import LRU from 'lru-cache'
-import nerfDart from 'nerf-dart'
 import { getProxyAgent, ProxyAgentOptions } from '@pnpm/network.proxy-agent'
+import { parseUri } from '@pnpm/network.url';
 
 const HttpsAgent = HttpAgent.HttpsAgent
 
@@ -22,14 +22,24 @@ export function getAgent (uri: string, opts: AgentOptions) {
  return getNonProxyAgent(uri, opts)
 }
 
+function getClientCertificates(uri: string, opts: AgentOptions) {
+ const { host, hostOnlyDomain, pathname } = parseUri(uri)
+
+ if (host.endsWith(pathname)) {
+ return opts.clientCertificates?.[host];
+ }
+
+ const fullPath = `${host}${pathname !== '/' ? pathname : ''}`;
+ return opts.clientCertificates?.[fullPath] ?? opts.clientCertificates?.[host] ?? opts.clientCertificates?.[hostOnlyDomain];
+}
+
 function getNonProxyAgent (uri: string, opts: AgentOptions) {
  const parsedUri = new URL(uri)
- const host = nerfDart(uri)
  const isHttps = parsedUri.protocol === 'https:'
 
  const { ca, cert, key: certKey } = {
  ...opts,
- ...opts.clientCertificates?.[host],
+ ...getClientCertificates(uri, opts),
  }
 
  /* eslint-disable @typescript-eslint/prefer-nullish-coalescing */

network/url/index.ts

@@ -0,0 +1,2 @@
+export { parseUri } from './url';
+export type { ParsedUri } from './url';

network/url/url.docs.mdx

@@ -0,0 +1,10 @@
+---
+labels: ['Url', 'module']
+description: 'A Url module.'
+---
+
+A url module.
+
+```ts
+url();
+```

network/url/url.spec.ts

@@ -0,0 +1,173 @@
+import { parseUri } from './url';
+
+describe('parseUri', () => {
+ it('should parse a simple URL', () => {
+ const uri = 'https://example.com';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a port', () => {
+ const uri = 'https://example.com:8080';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com:8080/',
+ hostOnlyDomain: '//example.com:8080/',
+ host: 'example.com',
+ port: '8080',
+ pathname: '/',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a search', () => {
+ const uri = 'https://example.com?foo=bar';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '?foo=bar',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a hash', () => {
+ const uri = 'https://example.com#foo';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: '#foo',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a path', () => {
+ const uri = 'https://example.com/path/to/file';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/path/to/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/path/to/file',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a query string', () => {
+ const uri = 'https://example.com?foo=bar&baz=qux';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '?foo=bar&baz=qux',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a fragment identifier', () => {
+ const uri = 'https://example.com#foo';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: '#foo',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with a username and password', () => {
+ const uri = 'https://username:[email protected]';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com/',
+ port: '',
+ pathname: '/',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL that its an IP with port', () => {
+ const uri = 'https://192.168.1.1:8080';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//192.168.1.1:8080/',
+ hostOnlyDomain: '//192.168.1.1:8080/',
+ host: '192.168.1.1',
+ port: '8080',
+ pathname: '/',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+
+ it('should parse a URL with port and subpaths ', () => {
+ const uri = 'https://example.com:8080/path/to/file';
+ const expected = {
+ raw: uri,
+ protocol: 'https:',
+ nerf: '//example.com:8080/path/to/',
+ host: 'example.com',
+ hostOnlyDomain: '//example.com:8080/',
+ port: '8080',
+ pathname: '/path/to/file',
+ search: '',
+ hash: '',
+ };
+ const actual = parseUri(uri);
+ expect(actual).toEqual(expected);
+ });
+});

network/url/url.ts

@@ -0,0 +1,71 @@
+import nerfDart from 'nerf-dart';
+
+export interface ParsedUri {
+ /**
+ * The url as string
+ */
+ raw: string;
+ /**
+ * The protocol of the url
+ */
+ protocol: string;
+ /**
+ * The nerf dart of the url
+ * @example https://example.com -> //example.com/
+ * @example https://example.com:8080/path/to/file -> //example.com:8080/path/to/
+ */
+ nerf: string;
+ /**
+ * The host of the url
+ * @example https://example.com -> example.com
+ */
+ host: string;
+ /**
+ * The host of the url with port
+ * @example https://example.com:8080 -> //example.com:8080/
+ */
+ hostOnlyDomain: string;
+ /**
+ * The port of the url
+ * @example https://example.com:8080 -> 8080
+ */
+ port: string;
+ /**
+ * The pathname of the url
+ * @example https://example.com/path/to/file -> /path/to/file
+ */
+ pathname: string;
+ /**
+ * The search of the url
+ * @example https://example.com/path/to/file?search=query -> ?search=query
+ */
+ search: string;
+ /**
+ * The hash of the url
+ * @example https://example.com/path/to/file#hash -> #hash
+ */
+ hash: string;
+}
+
+export function parseUri(uri: string): ParsedUri {
+ const parsed = new URL(uri);
+ return {
+ raw: uri,
+ protocol: parsed.protocol,
+ nerf: nerfDart(uri),
+ host: parsed.hostname,
+ hostOnlyDomain: convertToDomain(parsed),
+ port: parsed.port,
+ pathname: parsed.pathname,
+ search: parsed.search,
+ hash: parsed.hash,
+ };
+}
+
+function convertToDomain(url: URL): string {
+ let result = `//${url.hostname}`;
+ if (url.port) {
+ result += `:${url.port}`;
+ }
+ return `${result}/`;
+}