@tramvai/cli 3.26.2 → 3.27.0

package/lib/utils/getApplicationUrl.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApplicationUrl = void 0;
+const getApplicationUrl = ({ protocol, host, port, }) => {
+    return `${protocol}://${host}:${port}`;
+};
+exports.getApplicationUrl = getApplicationUrl;
+//# sourceMappingURL=getApplicationUrl.js.map

package/lib/utils/getApplicationUrl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getApplicationUrl.js","sourceRoot":"","sources":["../../src/utils/getApplicationUrl.ts"],"names":[],"mappings":";;;AAAO,MAAM,iBAAiB,GAAG,CAAC,EAChC,QAAQ,EACR,IAAI,EACJ,IAAI,GAKL,EAAE,EAAE;IACH,OAAO,GAAG,QAAQ,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;AACzC,CAAC,CAAC;AAVW,QAAA,iBAAiB,qBAU5B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/cli",
-  "version": "3.26.2",
+  "version": "3.27.0",
   "description": "Cli инструмент для сборки и запуска приложений",
   "files": [
     "src",
@@ -70,8 +70,8 @@
     "@tinkoff/request-plugin-protocol-http": "^0.11.8",
     "@tinkoff/utils": "^2.1.3",
     "@tinkoff/webpack-dedupe-plugin": "2.0.2",
-    "@tramvai/build": "4.1.0",
-    "@tramvai/react": "3.26.2",
+    "@tramvai/build": "4.1.1",
+    "@tramvai/react": "3.27.0",
     "@tramvai/tools-check-versions": "0.5.3",
     "@tramvai/tools-migrate": "0.7.3",
     "ajv": "^8.12.0",

package/schema.json

@@ -1166,23 +1166,23 @@
                               "dotAll": {
                                 "type": "boolean"
                               },
-                              "__@match@6849": {
+                              "__@match@6855": {
                                 "type": "object",
                                 "additionalProperties": false
                               },
-                              "__@replace@6851": {
+                              "__@replace@6857": {
                                 "type": "object",
                                 "additionalProperties": false
                               },
-                              "__@search@6854": {
+                              "__@search@6860": {
                                 "type": "object",
                                 "additionalProperties": false
                               },
-                              "__@split@6856": {
+                              "__@split@6862": {
                                 "type": "object",
                                 "additionalProperties": false
                               },
-                              "__@matchAll@6858": {
+                              "__@matchAll@6864": {
                                 "type": "object",
                                 "additionalProperties": false
                               }
@@ -1844,23 +1844,23 @@
                                 "dotAll": {
                                   "type": "boolean"
                                 },
-                                "__@match@6849": {
+                                "__@match@6855": {
                                   "type": "object",
                                   "additionalProperties": false
                                 },
-                                "__@replace@6851": {
+                                "__@replace@6857": {
                                   "type": "object",
                                   "additionalProperties": false
                                 },
-                                "__@search@6854": {
+                                "__@search@6860": {
                                   "type": "object",
                                   "additionalProperties": false
                                 },
-                                "__@split@6856": {
+                                "__@split@6862": {
                                   "type": "object",
                                   "additionalProperties": false
                                 },
-                                "__@matchAll@6858": {
+                                "__@matchAll@6864": {
                                   "type": "object",
                                   "additionalProperties": false
                                 }
@@ -2522,23 +2522,23 @@
                                   "dotAll": {
                                     "type": "boolean"
                                   },
-                                  "__@match@6849": {
+                                  "__@match@6855": {
                                     "type": "object",
                                     "additionalProperties": false
                                   },
-                                  "__@replace@6851": {
+                                  "__@replace@6857": {
                                     "type": "object",
                                     "additionalProperties": false
                                   },
-                                  "__@search@6854": {
+                                  "__@search@6860": {
                                     "type": "object",
                                     "additionalProperties": false
                                   },
-                                  "__@split@6856": {
+                                  "__@split@6862": {
                                     "type": "object",
                                     "additionalProperties": false
                                   },
-                                  "__@matchAll@6858": {
+                                  "__@matchAll@6864": {
                                     "type": "object",
                                     "additionalProperties": false
                                   }

package/src/api/shared/providers/selfSignedCertificateProvider.ts

@@ -0,0 +1,29 @@
+import type { Provider } from '@tinkoff/dippy';
+import { provide } from '@tinkoff/dippy';
+import {
+  COMMAND_PARAMETERS_TOKEN,
+  CONFIG_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
+} from '../../../di/tokens';
+import { createSelfSignedCertificate } from '../utils/selfSignedCertificate/createSelfSignedCertificate';
+
+export const selfSignedCertificateProvider: Provider[] = [
+  provide({
+    provide: SELF_SIGNED_CERTIFICATE_TOKEN,
+    useFactory: ({ configManager, parameters }) => {
+      const { host } = configManager;
+      if (configManager.httpProtocol === 'https') {
+        return createSelfSignedCertificate({
+          host,
+          certificatePath: parameters?.httpsCert,
+          keyPath: parameters?.httpsKey,
+        });
+      }
+      return null;
+    },
+    deps: {
+      configManager: CONFIG_MANAGER_TOKEN,
+      parameters: COMMAND_PARAMETERS_TOKEN,
+    },
+  }),
+];

package/src/api/shared/types/base.ts

@@ -2,3 +2,8 @@ export interface BaseParams {
   stdout?: NodeJS.WritableStream;
   stderr?: NodeJS.WritableStream;
 }
+
+export interface Certificate {
+  keyPath: string;
+  certificatePath: string;
+}

package/src/api/shared/utils/selfSignedCertificate/certificatedHostsList.ts

@@ -0,0 +1,22 @@
+import fs from 'fs';
+import path from 'path';
+import { certificateDirectoryPath } from './common';
+
+export const certificatedHostsListFilePath = path.resolve(
+  certificateDirectoryPath,
+  'certificatedHostsList'
+);
+const separator = ',';
+
+export const createCertificatedHostsListFile = (data: string[]) => {
+  fs.writeFileSync(certificatedHostsListFilePath, data.join(separator), 'utf-8');
+};
+
+export const readCertificatedHostsListFile = (): Set<string> | null => {
+  if (!fs.existsSync(certificatedHostsListFilePath)) {
+    return null;
+  }
+
+  const data = fs.readFileSync(certificatedHostsListFilePath, 'utf-8');
+  return new Set(data.split(separator));
+};

package/src/api/shared/utils/selfSignedCertificate/common.ts

@@ -0,0 +1,4 @@
+import path from 'path';
+
+export const certificateDirectory = 'certificates';
+export const certificateDirectoryPath = path.resolve(process.cwd(), certificateDirectory);

package/src/api/shared/utils/selfSignedCertificate/createSelfSignedCertificate.spec.ts

@@ -0,0 +1,154 @@
+import os from 'os';
+import fs from 'fs';
+import path from 'path';
+import child_process from 'child_process';
+
+import { createSelfSignedCertificate } from './createSelfSignedCertificate';
+import { certificatedHostsListFilePath } from './certificatedHostsList';
+import { certificateDirectoryPath } from './common';
+
+const defaultKeyPath = path.resolve(certificateDirectoryPath, 'localhost-key.pem');
+const defaultCertificatePath = path.resolve(certificateDirectoryPath, 'localhost.pem');
+const gitignorePath = path.resolve(process.cwd(), '.gitignore');
+const customHost = 'localhost.domain.com';
+
+jest.mock('os', () => {
+  return {
+    networkInterfaces: (param: string) => {
+      return [];
+    },
+  };
+});
+
+const existsSyncSpy = jest.spyOn(fs, 'existsSync');
+const mkdirSyncSpy = jest.spyOn(fs, 'mkdirSync');
+const writeFileSyncSpy = jest.spyOn(fs, 'writeFileSync');
+const readFileSyncSpy = jest.spyOn(fs, 'readFileSync');
+const execSyncSpy = jest.spyOn(child_process, 'execSync');
+const appendFileSyncSpy = jest.spyOn(fs, 'appendFileSync');
+
+describe('shared/utils/selfSignedCertificate', () => {
+  beforeEach(() => {
+    writeFileSyncSpy.mockImplementation(() => undefined);
+    mkdirSyncSpy.mockImplementation(() => {
+      return undefined;
+    });
+    execSyncSpy.mockImplementation((command) => {
+      if (command === 'mkcert -CAROOT') return '/location';
+      return '';
+    });
+
+    readFileSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) return '';
+      return `localhost,${customHost}`;
+    });
+  });
+  afterEach(() => {
+    jest.clearAllMocks();
+    existsSyncSpy.mockReset();
+    mkdirSyncSpy.mockReset();
+    writeFileSyncSpy.mockReset();
+    execSyncSpy.mockReset();
+  });
+  it('should generate certificate', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === certificatedHostsListFilePath || path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+
+    const result = createSelfSignedCertificate({});
+
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost`
+    );
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+  it('should generate certificate for provided host', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === certificatedHostsListFilePath || path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: customHost });
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost ${customHost}`
+    );
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+
+  it('should return already existed certificate if it was generated previously', async () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: customHost });
+    expect(execSyncSpy).toHaveBeenCalledTimes(0);
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+
+  it('should use custom certificate if provided', () => {
+    const customCertificate = {
+      certificatePath: path.resolve('path-to-custom-certificate/cert.pem'),
+      keyPath: path.resolve('path-to-custom-certificate/key.pem'),
+    };
+    const result = createSelfSignedCertificate({
+      host: customHost,
+      ...customCertificate,
+    });
+
+    expect(execSyncSpy).toHaveBeenCalledTimes(0);
+
+    expect(result).toEqual({
+      keyPath: customCertificate.keyPath,
+      certificatePath: customCertificate.certificatePath,
+    });
+  });
+  it('if a new host be provided, a new certificate should be generated even if a certificate already exists.', () => {
+    existsSyncSpy.mockImplementation((path) => {
+      if (path === gitignorePath) {
+        return false;
+      }
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: 'new.localhost.domain' });
+    expect(execSyncSpy).toHaveBeenNthCalledWith(
+      1,
+      `mkcert -install -key-file "${defaultKeyPath}" -cert-file "${defaultCertificatePath}" localhost new.localhost.domain`
+    );
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+  it('should add certificates folder to .gitignore if .gitignore file exist', () => {
+    existsSyncSpy.mockImplementation((path) => {
+      return true;
+    });
+    const result = createSelfSignedCertificate({ host: 'new.localhost.domain' });
+    expect(appendFileSyncSpy).toBeCalledTimes(1);
+
+    expect(result).toEqual({
+      keyPath: defaultKeyPath,
+      certificatePath: defaultCertificatePath,
+    });
+  });
+});

package/src/api/shared/utils/selfSignedCertificate/createSelfSignedCertificate.ts

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+import type { Certificate } from '../../types/base';
+import { getHosts } from './getHosts';
+import { certificateDirectoryPath, certificateDirectory } from './common';
+import {
+  createCertificatedHostsListFile,
+  readCertificatedHostsListFile,
+} from './certificatedHostsList';
+
+interface CreateSelfSignedCertificateOptions {
+  host?: string;
+  keyPath?: string;
+  certificatePath?: string;
+}
+
+// eslint-disable-next-line max-statements
+export const createSelfSignedCertificate = (
+  options: CreateSelfSignedCertificateOptions
+): Certificate => {
+  try {
+    const { host } = options;
+    const hosts = getHosts(host === '0.0.0.0' ? null : host);
+    const hostsFile = readCertificatedHostsListFile();
+
+    const defaultKeyPath = path.resolve(certificateDirectoryPath, 'localhost-key.pem');
+    const defaultCertificatePath = path.resolve(certificateDirectoryPath, 'localhost.pem');
+
+    const keyPath = options.keyPath ? path.resolve(options.keyPath) : defaultKeyPath;
+    const certificatePath = options.certificatePath
+      ? path.resolve(options.certificatePath)
+      : defaultCertificatePath;
+
+    // check if certificates are already generated, in this case we simply skip step
+
+    const isExternalCertificateProvided = options.certificatePath && options.keyPath;
+
+    const isCertificateAlreadyExist =
+      !isExternalCertificateProvided &&
+      fs.existsSync(keyPath) &&
+      fs.existsSync(certificatePath) &&
+      hostsFile &&
+      hosts.every((h) => hostsFile.has(h));
+
+    const gitignorePath = path.resolve(process.cwd(), '.gitignore');
+    if (
+      fs.existsSync(gitignorePath) &&
+      !fs.readFileSync(gitignorePath, 'utf-8').includes(certificateDirectory)
+    ) {
+      fs.appendFileSync(gitignorePath, `\n${certificateDirectory}`);
+    }
+
+    if (isExternalCertificateProvided || isCertificateAlreadyExist) {
+      console.log(
+        chalk.blue(
+          'Certificates for https environment are already exist, skipping step with certificate generation'
+        )
+      );
+
+      return {
+        keyPath,
+        certificatePath,
+      };
+    }
+
+    fs.mkdirSync(certificateDirectoryPath, { recursive: true });
+    createCertificatedHostsListFile(hosts);
+
+    // TODO: maybe it is better to install mkcert for users for better dx
+    // check https://github.com/liuweiGL/vite-plugin-mkcert/blob/main/plugin/index.ts and https://github.com/vercel/next.js/blob/28fdc367b1f6d41245ea036bc40d1035a8a4d0e4/packages/next/src/lib/mkcert.ts#L68
+    execSync(
+      `mkcert -install -key-file "${keyPath}" -cert-file "${certificatePath}" ${hosts.join(' ')}`
+    );
+
+    if (!fs.existsSync(keyPath) || !fs.existsSync(certificatePath)) {
+      throw new Error(
+        'Error occured while certificate creation. Generated certificate files not found'
+      );
+    }
+
+    const CAROOTFileLocation = execSync('mkcert -CAROOT').toString().trim();
+
+    console.log(chalk.green(`Root certificate located in ${chalk.blue(CAROOTFileLocation)}`));
+
+    return {
+      keyPath,
+      certificatePath,
+    };
+  } catch (error) {
+    console.error(
+      chalk.red(
+        `Error while generating the certificate. The mkcert tool may not be installed please check and install it if that is the case.`
+      )
+    );
+    throw new Error(error);
+  }
+};

package/src/api/shared/utils/selfSignedCertificate/getHosts.ts

@@ -0,0 +1,31 @@
+import os from 'os';
+
+export const getDefaultHosts = () => {
+  const defaultHosts = ['localhost'];
+  const networkInterfaces = os.networkInterfaces();
+
+  for (const networkInterfaceKey in networkInterfaces) {
+    const networkInterfacesInfo = networkInterfaces[networkInterfaceKey];
+
+    if (networkInterfacesInfo) {
+      for (const info of networkInterfacesInfo) {
+        // https://github.com/nodejs/node/issues/42787
+        //@ts-expect-error
+        if (info.family === 'IPv4' || info.family === '4') {
+          defaultHosts.push(info.address);
+        }
+      }
+    }
+  }
+
+  return defaultHosts;
+};
+
+export const getHosts = (host?: string) => {
+  const hosts = new Set([...getDefaultHosts()]);
+
+  if (host && !hosts.has(host)) {
+    hosts.add(host);
+  }
+  return Array.from(hosts);
+};

package/src/api/start/index.ts

@@ -11,6 +11,9 @@ import type { Builder } from '../../typings/build/Builder';
 
 export type Params = WithConfig<{
   buildType?: 'server' | 'client' | 'all';
+  https?: boolean;
+  httpsKey?: string;
+  httpsCert?: string;
   host?: string;
   port?: number;
   staticPort?: number;

package/src/api/start/providers/application/server.ts

@@ -1,8 +1,13 @@
 import type { Provider } from '@tinkoff/dippy';
 import { provide } from '@tinkoff/dippy';
-
+import { readFileSync } from 'fs';
+import { createProxyServer } from 'http-proxy';
 import { INIT_HANDLER_TOKEN, CLOSE_HANDLER_TOKEN } from '../../tokens';
-import { CONFIG_MANAGER_TOKEN, SERVER_TOKEN } from '../../../../di/tokens';
+import {
+  CONFIG_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
+  SERVER_TOKEN,
+} from '../../../../di/tokens';
 import { stopServer } from '../../utils/stopServer';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
@@ -10,14 +15,24 @@ import { listenServer } from '../../utils/listenServer';
 export const serverProviders: readonly Provider[] = [
   provide({
     provide: SERVER_TOKEN,
-    useFactory: createServer,
+    useFactory: ({ selfSignedCertificate }) => {
+      return createServer(selfSignedCertificate);
+    },
+    deps: {
+      selfSignedCertificate: {
+        token: SELF_SIGNED_CERTIFICATE_TOKEN,
+        optional: true,
+      },
+    },
   }),
   provide({
     provide: INIT_HANDLER_TOKEN,
     multi: true,
-    useFactory: ({ server, configManager }) => {
+    useFactory: ({ server, configManager, selfSignedCertificate }) => {
       return async function staticServerListen() {
-        const { host, port } = configManager;
+        const { https } = configManager;
+        const port = https && configManager.host !== '0.0.0.0' ? 443 : configManager.port;
+        const host = https ? '0.0.0.0' : configManager.host;
 
         await listenServer(server, host, port);
       };
@@ -25,6 +40,7 @@ export const serverProviders: readonly Provider[] = [
     deps: {
       server: SERVER_TOKEN,
       configManager: CONFIG_MANAGER_TOKEN,
+      selfSignedCertificate: SELF_SIGNED_CERTIFICATE_TOKEN,
     },
   }),
   provide({

package/src/api/start/providers/application/shared.ts

@@ -1,6 +1,5 @@
 import type { Provider } from '@tinkoff/dippy';
 import { provide } from '@tinkoff/dippy';
-
 import { CLOSE_HANDLER_TOKEN, INIT_HANDLER_TOKEN } from '../../tokens';
 import {
   CONFIG_MANAGER_TOKEN,
@@ -8,14 +7,17 @@ import {
   COMMAND_PARAMETERS_TOKEN,
   STATIC_SERVER_TOKEN,
   PORT_MANAGER_TOKEN,
+  SELF_SIGNED_CERTIFICATE_TOKEN,
 } from '../../../../di/tokens';
 import { stopServer } from '../../utils/stopServer';
 import type { ApplicationConfigEntry } from '../../../../typings/configEntry/application';
 import { createConfigManager } from '../../../../config/configManager';
 import { createServer } from '../../utils/createServer';
 import { listenServer } from '../../utils/listenServer';
+import { selfSignedCertificateProvider } from '../../../shared/providers/selfSignedCertificateProvider';
 
 export const sharedProviders: readonly Provider[] = [
+  ...selfSignedCertificateProvider,
   provide({
     provide: CONFIG_MANAGER_TOKEN,
     useFactory: ({ configEntry, parameters, portManager }) =>
@@ -34,7 +36,15 @@ export const sharedProviders: readonly Provider[] = [
   }),
   provide({
     provide: STATIC_SERVER_TOKEN,
-    useFactory: createServer,
+    useFactory: ({ selfSignedCertificate }) => {
+      return createServer(selfSignedCertificate);
+    },
+    deps: {
+      selfSignedCertificate: {
+        token: SELF_SIGNED_CERTIFICATE_TOKEN,
+        optional: true,
+      },
+    },
   }),
   provide({
     provide: INIT_HANDLER_TOKEN,

package/src/api/start/utils/banner.ts

@@ -8,6 +8,7 @@ import { isApplication } from '../../../config/validate';
 const label = (name) => chalk.bold.cyan(`▸ ${name}:`);
 const link = (url) => chalk.underline.blue(url);
 
+// eslint-disable-next-line max-statements
 export function showBanner(di: Container) {
   if (!di.get({ token: UI_SHOW_BANNER_TOKEN, optional: true })) {
     return;
@@ -31,14 +32,21 @@ export function showBanner(di: Container) {
     titleLines.push(`${label('FileSystemPages')}  true`);
   }
 
-  const server = `http://${config.host.replace('0.0.0.0', 'localhost')}:${config.port}`;
-  const staticServer = `http://${config.staticHost.replace('0.0.0.0', 'localhost')}:${
-    config.staticPort
-  }`;
+  // TODO: add information about hosted url !
+  const baseServerUrl = `${config.httpProtocol}://${config.host.replace('0.0.0.0', 'localhost')}`;
+  const server = `${baseServerUrl}:${config.port}`;
+
+  const staticServer = `${config.httpProtocol}://${config.staticHost.replace(
+    '0.0.0.0',
+    'localhost'
+  )}:${config.staticPort}`;
 
   if (config.type === 'application') {
     // Listeners
     messageLines.push(chalk.bold('Static: ') + link(staticServer));
+    if (config.host !== '0.0.0.0' && config.https) {
+      messageLines.push(chalk.bold('App:    ') + link(baseServerUrl));
+    }
     messageLines.push(chalk.bold('App:    ') + link(server));
   }
 

package/src/api/start/utils/createServer.ts

@@ -1,8 +1,26 @@
 import { createServer as httpCreateServer } from 'http';
+import { createServer as httpsCreateServer } from 'https';
+import { readFileSync } from 'fs';
 import stoppable from 'stoppable';
+import type { Certificate } from '../../shared/types/base';
 
-export const createServer = () => {
+const createHttpsServer = ({ keyPath, certificatePath }: Certificate) => {
+  const options = {
+    key: readFileSync(keyPath),
+    cert: readFileSync(certificatePath),
+  };
+  const httpsServer = httpsCreateServer(options);
+  return stoppable(httpsServer, 0);
+};
+
+const createHttpServer = () => {
   const server = httpCreateServer();
 
   return stoppable(server, 0);
 };
+
+export const createServer = (certificate?: Certificate) => {
+  return certificate && certificate?.certificatePath && certificate?.keyPath
+    ? createHttpsServer(certificate)
+    : createHttpServer();
+};