@rancher/shell 3.0.11 → 3.0.12-rc.2

package/utils/__tests__/object.test.ts

@@ -210,6 +210,83 @@ describe('fx: diff', () => {
 
     expect(result).toStrictEqual(expected);
   });
+  it('should preserve nested object values when transitioning from empty object to populated object', () => {
+    const from = { parent: { child: { config: {} } } };
+    const to = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+
+    const result = diff(from, to);
+    const expected = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should preserve explicit empty object when clearing nested object values', () => {
+    const from = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+    const to = { parent: { child: { config: {} } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: {} } } };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should not emit nested empty objects when there are no differences', () => {
+    const from = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = {};
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should correctly nullify nested keys when removed', () => {
+    const from = {
+      parent: {
+        child: {
+          config: {
+            annotations: { hello: 'world' },
+            labels:      { key: 'value' }
+          }
+        }
+      }
+    };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: { labels: { key: null } } } } };
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should not nullify child keys when parent object is updated', () => {
+    const from = { parent: { child: { config: {} } } };
+    const to = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    const result = diff(from, to);
+    const expected = { parent: { child: { config: { annotations: { hello: 'world' } } } } };
+
+    expect(result).toStrictEqual(expected);
+    expect(result.parent.child.config).not.toHaveProperty('annotations', null);
+  });
 });
 
 describe('fx: definedKeys', () => {

package/utils/__tests__/time.test.ts

@@ -1,6 +1,19 @@
 import { DATE_FORMAT, TIME_FORMAT } from '@shell/store/prefs';
-import { dateTimeFormat } from '@shell/utils/time';
+import { dateTimeFormat, isMissingDate } from '@shell/utils/time';
 import { type Store } from 'vuex';
+import { ZERO_TIME } from '@shell/config/types';
+
+describe('function: isMissingDate', () => {
+  it.each([
+    [undefined, true],
+    [null, true],
+    ['', true],
+    [ZERO_TIME, true],
+    ['2010-10-21T04:29:00Z', false],
+  ])('given %p, returns %p', (date, expected) => {
+    expect(isMissingDate(date)).toBe(expected);
+  });
+});
 
 describe('function: dateTimeFormat', () => {
   jest.useFakeTimers()

package/utils/__tests__/url.test.ts

@@ -0,0 +1,246 @@
+import {
+  addParam, addParams, removeParam, parseLinkHeader, isMaybeSecure, portMatch, parse, stringify
+} from '@shell/utils/url';
+
+describe('fx: addParam', () => {
+  it('should add a query parameter to a URL without existing params', () => {
+    expect(addParam('https://example.com/path', 'foo', 'bar')).toStrictEqual('https://example.com/path?foo=bar');
+  });
+
+  it('should append a query parameter to a URL with existing params', () => {
+    expect(addParam('https://example.com/path?a=1', 'b', '2')).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should encode special characters in key and value', () => {
+    expect(addParam('https://example.com', 'my key', 'hello world')).toStrictEqual('https://example.com?my%20key=hello%20world');
+  });
+
+  it('should add multiple values from an array', () => {
+    expect(addParam('https://example.com', 'tag', ['a', 'b'])).toStrictEqual('https://example.com?tag=a&tag=b');
+  });
+
+  it('should add a key-only param when value is null', () => {
+    expect(addParam('https://example.com', 'flag', null)).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should handle an array with a null value', () => {
+    expect(addParam('https://example.com', 'flag', [null])).toStrictEqual('https://example.com?flag');
+  });
+
+  it('should add a param with an empty string value', () => {
+    expect(addParam('https://example.com', 'key', '')).toStrictEqual('https://example.com?key=');
+  });
+
+  it('should add a duplicate key as an additional param', () => {
+    expect(addParam('https://example.com?a=1', 'a', '2')).toStrictEqual('https://example.com?a=1&a=2');
+  });
+});
+
+describe('fx: addParams', () => {
+  it('should add multiple parameters to a URL', () => {
+    expect(addParams('https://example.com', { a: '1', b: '2' })).toStrictEqual('https://example.com?a=1&b=2');
+  });
+
+  it('should return the URL unchanged if params is empty', () => {
+    expect(addParams('https://example.com', {})).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is null', () => {
+    expect(addParams('https://example.com', null)).toStrictEqual('https://example.com');
+  });
+
+  it('should return the URL unchanged if params is a non-object value', () => {
+    expect(addParams('https://example.com', 'not-an-object')).toStrictEqual('https://example.com');
+  });
+});
+
+describe('fx: removeParam', () => {
+  it('should remove a query parameter from a URL', () => {
+    expect(removeParam('https://example.com?foo=bar&baz=qux', 'foo')).toStrictEqual('https://example.com/?baz=qux');
+  });
+
+  it('should return a normalized URL if the param does not exist', () => {
+    expect(removeParam('https://example.com?a=1', 'nonexistent')).toStrictEqual('https://example.com/?a=1');
+  });
+
+  it('should remove the only query parameter', () => {
+    expect(removeParam('https://example.com?only=param', 'only')).toStrictEqual('https://example.com/');
+  });
+
+  it('should normalize a key-only query parameter to key= (parser treats it as empty value)', () => {
+    expect(removeParam('https://example.com?flag', 'flag')).toStrictEqual('https://example.com/?flag=');
+  });
+});
+
+describe('fx: parseLinkHeader', () => {
+  it('should parse a single link header entry', () => {
+    expect(parseLinkHeader('<https://example.com/page2>; rel="next"')).toStrictEqual({ next: 'https://example.com/page2' });
+  });
+
+  it('should parse multiple link header entries', () => {
+    const header = '<https://example.com/page2>; rel="next", <https://example.com/page1>; rel="prev"';
+
+    expect(parseLinkHeader(header)).toStrictEqual({
+      next: 'https://example.com/page2',
+      prev: 'https://example.com/page1',
+    });
+  });
+
+  it('should return an empty object for an empty string', () => {
+    expect(parseLinkHeader('')).toStrictEqual({});
+  });
+
+  it('should return an empty object for a malformed header', () => {
+    expect(parseLinkHeader('not a valid link header')).toStrictEqual({});
+  });
+
+  it('should lowercase the rel value', () => {
+    expect(parseLinkHeader('<https://example.com>; rel="Next"')).toStrictEqual({ next: 'https://example.com' });
+  });
+});
+
+describe('fx: portMatch', () => {
+  it.each([
+    {
+      ports: [443], equals: [443, 8443], endsWith: [], expected: true, desc: 'port is in the equals list'
+    },
+    {
+      ports: [8080], equals: [443, 8443], endsWith: ['443'], expected: false, desc: 'port is not in equals or endsWith lists'
+    },
+    {
+      ports: [8443], equals: [], endsWith: ['443'], expected: true, desc: 'port string ends with the given suffix'
+    },
+    {
+      ports: [443], equals: [], endsWith: ['443'], expected: false, desc: 'port equals the suffix exactly (endsWith excludes exact match)'
+    },
+    {
+      ports: [], equals: [443], endsWith: ['443'], expected: false, desc: 'ports array is empty'
+    },
+    {
+      ports: [80, 443], equals: [443], endsWith: [], expected: true, desc: 'any port in the array matches equals'
+    },
+    {
+      ports: [18443], equals: [], endsWith: ['443'], expected: true, desc: 'multi-digit port ending with suffix'
+    },
+  ])('should return $expected when $desc', ({
+    ports, equals, endsWith, expected
+  }) => {
+    expect(portMatch(ports, equals, endsWith)).toBe(expected);
+  });
+});
+
+describe('fx: isMaybeSecure', () => {
+  it.each([
+    {
+      port: 80, proto: 'https', expected: true, desc: 'https protocol'
+    },
+    {
+      port: 80, proto: 'HTTPS', expected: true, desc: 'HTTPS protocol (case-insensitive)'
+    },
+    {
+      port: 443, proto: 'http', expected: true, desc: 'port 443'
+    },
+    {
+      port: 8443, proto: 'http', expected: true, desc: 'port 8443'
+    },
+    {
+      port: 18443, proto: 'http', expected: true, desc: 'port 18443 (endsWith 443)'
+    },
+    {
+      port: 80, proto: 'http', expected: false, desc: 'http on non-secure port'
+    },
+  ])('should return $expected for $desc', ({ port, proto, expected }) => {
+    expect(isMaybeSecure(port, proto)).toBe(expected);
+  });
+});
+
+describe('fx: parse', () => {
+  it('should parse a simple URL', () => {
+    const result = parse('https://example.com/path?foo=bar');
+
+    expect(result.protocol).toStrictEqual('https');
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.path).toStrictEqual('/path');
+    expect(result.query).toStrictEqual({ foo: 'bar' });
+  });
+
+  it('should parse a URL with port', () => {
+    const result = parse('https://example.com:8080/');
+
+    expect(result.host).toStrictEqual('example.com');
+    expect(result.port).toStrictEqual('8080');
+  });
+
+  it('should parse a URL with user credentials', () => {
+    const result = parse('https://user:pass@example.com/');
+
+    expect(result.user).toStrictEqual('user');
+    expect(result.password).toStrictEqual('pass');
+  });
+
+  it('should parse a URL with anchor', () => {
+    const result = parse('https://example.com/page#section1');
+
+    expect(result.anchor).toStrictEqual('section1');
+  });
+
+  it('should parse a URL with multiple query params', () => {
+    expect(parse('https://example.com?a=1&b=2').query).toStrictEqual({ a: '1', b: '2' });
+  });
+
+  it('should parse a URL with user only (no password)', () => {
+    const result = parse('https://admin@example.com/');
+
+    expect(result.user).toStrictEqual('admin');
+    expect(result.password).toStrictEqual('');
+  });
+
+  it('should set empty strings for missing optional fields', () => {
+    const result = parse('https://example.com/path');
+
+    expect(result.port).toStrictEqual('');
+    expect(result.anchor).toStrictEqual('');
+    expect(result.user).toStrictEqual('');
+    expect(result.password).toStrictEqual('');
+  });
+});
+
+describe('fx: stringify', () => {
+  it('should reconstruct a simple URL', () => {
+    expect(stringify(parse('https://example.com/path'))).toStrictEqual('https://example.com/path');
+  });
+
+  it('should include user and password when both present', () => {
+    expect(stringify(parse('https://user:pass@example.com/'))).toStrictEqual('https://user:pass@example.com/');
+  });
+
+  it('should include user only when password is absent', () => {
+    expect(stringify(parse('https://admin@example.com/'))).toStrictEqual('https://admin@example.com/');
+  });
+
+  it('should include port when present', () => {
+    expect(stringify(parse('https://example.com:9090/'))).toStrictEqual('https://example.com:9090/');
+  });
+
+  it('should include anchor when present', () => {
+    expect(stringify(parse('https://example.com/page#section'))).toStrictEqual('https://example.com/page#section');
+  });
+
+  it('should default path to / when path is empty', () => {
+    const parsed = parse('https://example.com');
+
+    parsed.path = '';
+
+    expect(stringify(parsed)).toStrictEqual('https://example.com/');
+  });
+
+  it('should include query parameters', () => {
+    expect(stringify(parse('https://example.com/path?a=1&b=2'))).toStrictEqual('https://example.com/path?a=1&b=2');
+  });
+
+  it('should round-trip a complex URL', () => {
+    const url = 'https://user:pass@example.com:8080/some/path?key=value&other=test#anchor';
+
+    expect(stringify(parse(url))).toStrictEqual(url);
+  });
+});

package/utils/axios.js

@@ -1,5 +1,5 @@
 import Axios from 'axios';
-import defu from 'defu';
+
 import axiosRetry from 'axios-retry';
 
 // Axios.prototype cannot be modified
@@ -37,9 +37,6 @@ const axiosExtra = {
   onError(fn) {
     this.onRequestError(fn);
     this.onResponseError(fn);
-  },
-  create(options) {
-    return createAxiosInstance(defu(options, this.defaults));
   }
 };
 

package/utils/dynamic-importer.js

@@ -94,8 +94,9 @@ export function loadProduct(name) {
 }
 
 export function listProducts() {
-  const ctx = require.context('@shell/config/product', true, /.*/);
-  const products = ctx.keys().filter(path => !path.endsWith('.js') && path.startsWith('./')).map(path => path.substr(2));
+  // We just want the .js or .ts files
+  const ctx = require.context('@shell/config/product', true, /\.\/.*\.[js|ts]/);
+  const products = ctx.keys().map(path => path.substr(2)).map(path => path.slice(0, -3));
 
   return products;
 }

package/utils/object.js

@@ -220,8 +220,14 @@ export function diff(from, to, preventNull = false) {
     if ( Array.isArray(toVal) || Array.isArray(fromVal) ) {
       // Don't diff arrays, just use the whole value
       res[k] = toVal;
-    } else if ( isObject(toVal) && isObject(from[k]) ) {
-      res[k] = diff(fromVal, toVal);
+    } else if ( isObject(toVal) && isObject(fromVal) ) {
+      const nested = diff(fromVal, toVal, preventNull);
+
+      if (isEmpty(toVal) && !isEmpty(fromVal)) {
+        res[k] = {};
+      } else if (!isEmpty(nested)) {
+        res[k] = nested;
+      }
     } else {
       res[k] = toVal;
     }
@@ -235,6 +241,31 @@ export function diff(from, to, preventNull = false) {
 
   for ( const k of missing ) {
     // we need to gate this in order to prevent unforseen problems with addonConfig
+    const hasDescendant = toKeys.some(
+      (tk) => tk.startsWith(`${ k }.`)
+    );
+
+    if (hasDescendant) {
+      continue;
+    }
+
+    // If we already have a value in 'out' for any parent of this missing key, do NOT nullify the child.
+    const parts = splitObjectPath(k);
+    let hasUpdatedParent = false;
+
+    for (let i = 1; i < parts.length; i++) {
+      const parentPath = joinObjectPath(parts.slice(0, i));
+
+      if (get(out, parentPath) !== undefined) {
+        hasUpdatedParent = true;
+        break;
+      }
+    }
+
+    if (hasUpdatedParent) {
+      continue;
+    }
+
     if (preventNull) {
     // keys that come from "definedKeys" method are strings with "" chars inside... We need to clean them up
       // so that we can access the value of the obj property

package/utils/pagination-utils.ts

@@ -299,7 +299,7 @@ class PaginationUtils {
     return isEqual(aPrimitiveTypes, bPrimitiveTypes) &&
       this.paginationFiltersEqual(aFilter, bFilter) &&
       this.paginationFiltersEqual(aPN, bPN) &&
-      sameArrayObjects<PaginationSort>(aSort, bSort, true);
+      sameArrayObjects<PaginationSort>(aSort, bSort, false);
   }
 }
 

package/utils/time.ts

@@ -2,6 +2,11 @@ import day from 'dayjs';
 import { escapeHtml } from '@shell/utils/string';
 import { DATE_FORMAT, TIME_FORMAT } from '@shell/store/prefs';
 import { type Store } from 'vuex';
+import { ZERO_TIME } from '@shell/config/types';
+
+export function isMissingDate(date: string | undefined | null): boolean {
+  return !date || date === ZERO_TIME;
+}
 
 const FACTORS = [60, 60, 24];
 const LABELS = ['sec', 'min', 'hour', 'day'];

package/utils/uiplugins.ts

@@ -5,14 +5,15 @@ import { UI_PLUGIN_BASE_URL, isSupportedChartVersion, UI_PLUGIN_LABELS } from '@
 import { Plugin, Version } from '@shell/types/uiplugins';
 
 const MAX_RETRIES = 10;
-const RETRY_WAIT = 2500;
+const RETRY_WAIT = 2500; // 2.5 seconds
+const ACTIVE_STATUS_TIMEOUT = 200000; // 20 seconds
 
 type Action = 'install' | 'upgrade';
 export type HelmRepository = any;
 export type HelmChart = any;
 
 /**
- *
+ * Get the latest compatible version of a Helm Chart extension
  * @param store Vue store
  * @param chartName The chartName
  * @param rancherVersion Rancher version
@@ -68,8 +69,8 @@ export async function waitForUIExtension(store: any, name: string, maxRetries =
         return extension;
       }
     } catch (e) {
+      console.error('waiting for UI extension to be available: error =', e); // eslint-disable-line no-console
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -106,7 +107,6 @@ export async function waitForUIPackage(store: any, extension: any, maxRetries =
       return true;
     } catch (error) {
     }
-
     tries++;
 
     if (tries > maxRetries) {
@@ -199,7 +199,7 @@ export async function getHelmRepositoryMatch(store: any, urlRegexes: string[], c
 }
 
 /**
- *
+ * Get a Helm Repository matching the given criteria.
  * @param store Vue store
  * @param matchFn Match function for repository's urls
  * @returns HelmRepository
@@ -225,15 +225,15 @@ export async function refreshHelmRepository(store: any, url: string): Promise<vo
   const now = (new Date()).toISOString().replace(/\.\d+Z$/, 'Z');
 
   repository.spec.forceUpdate = now;
-
   await repository.save();
 
-  await repository.waitForState('active', 10000, 1000);
+  await repository.waitForState('active', ACTIVE_STATUS_TIMEOUT, RETRY_WAIT);
 
   await new Promise((resolve) => setTimeout(resolve, 2000));
 }
 
 /**
+ * Create a Helm Repository and wait for it to be downloaded
  *
  * @param store Vue store
  * @param name Repository name
@@ -260,7 +260,7 @@ export async function createHelmRepository(store: any, name: string, url: string
 
   const helmRepo = await repo.save();
 
-  // Poll the repository until it says it has been downloaded
+  // Poll the repository status MAX_RETRIES times until it has been downloaded
   let fetched = false;
   let tries = 0;
 
@@ -275,23 +275,19 @@ export async function createHelmRepository(store: any, name: string, url: string
 
     const downloaded = repo.status.conditions.find((s: any) => s.type === 'Downloaded');
 
-    if (downloaded) {
-      if (downloaded.status === 'True') {
-        fetched = true;
-      }
+    console.log(`Waiting for helm repository to be downloaded... try ${ tries } time(s).`); // eslint-disable-line no-console
+
+    if (downloaded && downloaded.status === 'True') {
+      fetched = true;
     }
 
     if (!fetched) {
-      tries++;
-
       if (tries > MAX_RETRIES) {
         throw new Error('Failed to add Helm Chart Repository');
       }
 
       await new Promise((resolve) => setTimeout(resolve, RETRY_WAIT));
     }
-
-    fetched = true;
   }
 
   // Return the Helm Repository

package/utils/validators/__tests__/private-registry.test.ts

@@ -0,0 +1,76 @@
+import { privateRegistryRequired } from '@shell/utils/validators/private-registry';
+
+const makeCtx = (overrides: any = {}) => ({
+  t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+  privateRegistryEnabled: false,
+  normanCluster:          { importedConfig: { privateRegistryURL: null } },
+  isImportedCluster:      true,
+  ...overrides,
+});
+
+describe('privateRegistryRequired', () => {
+  it('should return undefined when the cluster is not imported', () => {
+    const ctx = makeCtx({ isImportedCluster: false, privateRegistryEnabled: true });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+
+  it('should default isImportedCluster to true when the property is absent from the context', () => {
+    const ctx: any = {
+      t:                      jest.fn((key: string, params?: any) => (params ? `${ key }:${ JSON.stringify(params) }` : key)),
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: null } },
+    };
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return undefined when the registry toggle is off', () => {
+    const ctx = makeCtx({ privateRegistryEnabled: false });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+
+  it('should return a required error when enabled but the url is empty', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: '' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a required error when normanCluster.importedConfig is missing', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          {},
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('validation.required:{"key":"cluster.privateRegistry.label"}');
+  });
+
+  it('should return a format error when enabled and the url is malformed', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'goober' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toStrictEqual('cluster.privateRegistry.privateRegistryUrlError');
+  });
+
+  it('should return undefined when enabled and the url is valid', () => {
+    const ctx = makeCtx({
+      privateRegistryEnabled: true,
+      normanCluster:          { importedConfig: { privateRegistryURL: 'registry.io:5000' } },
+    });
+    const rule = privateRegistryRequired(ctx);
+
+    expect(rule()).toBeUndefined();
+  });
+});

package/utils/validators/private-registry.ts

@@ -0,0 +1,28 @@
+import { Translation } from '@shell/types/t';
+import formRulesGenerator from '@shell/utils/validators/formRules';
+
+interface PrivateRegistryRuleContext {
+  t: Translation;
+  privateRegistryEnabled: boolean;
+  normanCluster: { importedConfig?: { privateRegistryURL?: string | null } } | null;
+  isImportedCluster?: boolean;
+}
+
+export function privateRegistryRequired(ctx: PrivateRegistryRuleContext) {
+  return () => {
+    // Check existence using `in` rather than direct access to avoid Vue's render-time warning
+    const isImported = 'isImportedCluster' in ctx ? !!ctx.isImportedCluster : true;
+
+    if (!isImported || !ctx.privateRegistryEnabled) {
+      return undefined;
+    }
+    const url = ctx.normanCluster?.importedConfig?.privateRegistryURL;
+
+    if (!url) {
+      return ctx.t('validation.required', { key: ctx.t('cluster.privateRegistry.label') });
+    }
+    const { registryUrl } = formRulesGenerator(ctx.t, { key: ctx.t('cluster.privateRegistry.label') });
+
+    return (registryUrl as (val: string) => string | undefined)(url);
+  };
+}

package/vue.config.js

@@ -75,15 +75,6 @@ const getProxyConfig = (proxyConfig) => ({
   '/v1-*':           proxyOpts(api), // SAML, KDM, etc
   '/rancherversion': proxyPrimeOpts(api), // Rancher version endpoint
   '/version':        proxyPrimeOpts(api), // Rancher Kube version endpoint
-  // These are for Ember embedding
-  '/c/*/edit':       proxyOpts('https://127.0.0.1:8000'), // Can't proxy all of /c because that's used by Vue too
-  '/k/':             proxyOpts('https://127.0.0.1:8000'),
-  '/g/':             proxyOpts('https://127.0.0.1:8000'),
-  '/n/':             proxyOpts('https://127.0.0.1:8000'),
-  '/p/':             proxyOpts('https://127.0.0.1:8000'),
-  '/assets':         proxyOpts('https://127.0.0.1:8000'),
-  '/translations':   proxyOpts('https://127.0.0.1:8000'),
-  '/engines-dist':   proxyOpts('https://127.0.0.1:8000'),
 });
 
 /**