@tramvai/cli 3.12.0 → 3.14.0

package/src/models/port-manager.ts

@@ -1,29 +1,43 @@
+import { access, outputFile, appendFile, readFile } from 'fs-extra';
+import { join } from 'path';
+import findCacheDir from 'find-cache-dir';
 import detectPort from 'detect-port';
+import { lock } from 'proper-lockfile';
 
 import type { ConfigEntry } from '../typings/configEntry/common';
 import type { Params as StartParams } from '../api/start';
 import type { Params as StartProdParams } from '../api/start-prod';
+import type { Logger } from './logger';
 
 interface NetworkConstructorPayload {
   configEntry: ConfigEntry;
   commandParams: StartParams | StartProdParams;
+  logger: Logger;
 }
 
 export class PortManager {
-  static DEFAULT_PORT = 3000;
-  static DEFAULT_MODULE_PORT = 4040;
-  static DEFAULT_STATIC_PORT = 4000;
-  static DEFAULT_MODULE_STATIC_PORT = 4040;
+  static readonly DEFAULT_PORT = 3000;
+  static readonly DEFAULT_MODULE_PORT = 3040;
+  static readonly DEFAULT_STATIC_PORT = 4000;
+  static readonly DEFAULT_MODULE_STATIC_PORT = 4040;
 
-  private configEntry: ConfigEntry;
-  private commandParams: StartParams | StartProdParams;
+  private readonly configEntry: ConfigEntry;
+  private readonly commandParams: StartParams | StartProdParams;
+  private readonly cachePath: string;
+  private readonly logger: Logger;
 
   public port: number | null = null;
   public staticPort: number | null = null;
 
-  constructor({ configEntry, commandParams }: NetworkConstructorPayload) {
+  constructor({ configEntry, commandParams, logger }: NetworkConstructorPayload) {
     this.configEntry = configEntry;
     this.commandParams = commandParams;
+    this.logger = logger;
+
+    this.cachePath = join(
+      findCacheDir({ cwd: __dirname, create: true, name: 'tramvai' }),
+      'used-ports'
+    );
   }
 
   /**
@@ -33,47 +47,152 @@ export class PortManager {
    * Also, handle zero port (it means any random port) as the edge case,
    * because we must pass a final number to the config manager.
    */
-  public async computeAvailablePorts(): Promise<void> {
-    if (this.commandParams.port !== undefined && this.commandParams.port !== 0) {
-      // @ts-expect-error There is a string actually
-      this.port = parseInt(this.commandParams.port, 10);
+  public async computeAvailablePorts() {
+    await this.createCacheFile();
+    const release = await this.lockCacheFile();
+
+    try {
+      if (this.commandParams.port !== undefined && this.commandParams.port !== 0) {
+        // @ts-expect-error There is a string actually
+        this.port = parseInt(this.commandParams.port, 10);
+      }
+
+      if (this.commandParams.staticPort !== undefined && this.commandParams.staticPort !== 0) {
+        // @ts-expect-error There is a string actually
+        this.staticPort = parseInt(this.commandParams.staticPort, 10);
+      }
+
+      switch (this.configEntry.type) {
+        case 'child-app':
+          await this.forChildApp();
+          break;
+
+        case 'module':
+          await this.forModule();
+          break;
+
+        case 'application':
+          await this.forApplication();
+          break;
+
+        default:
+          break;
+      }
+
+      await this.appendCacheFile([this.port, this.staticPort].join(','));
+    } catch (error) {
+      this.logger.event({
+        type: 'warning',
+        event: 'PORT_MANAGER:GET_AVAILABLE_PORTS',
+        message: `Can't get free ports for ${this.configEntry.type}:`,
+        payload: error.message ?? '',
+      });
+    } finally {
+      await release();
     }
+  }
+
+  /**
+   * Cleanup a cache file by removing ports were written previously.
+   */
+  public async cleanup() {
+    const release = await this.lockCacheFile();
 
-    if (this.commandParams.staticPort !== undefined && this.commandParams.staticPort !== 0) {
-      // @ts-expect-error There is a string actually
-      this.staticPort = parseInt(this.commandParams.staticPort, 10);
+    try {
+      const cache = await this.readCacheFile();
+
+      await this.writeCacheFile(
+        cache
+          .filter(Boolean)
+          .filter((port) => port !== this.port.toString() && port !== this.staticPort.toString())
+          .join(',')
+      );
+    } catch (error) {
+      this.logger.event({
+        type: 'warning',
+        event: 'PORT_MANAGER:CLEANUP',
+        message: "Can't perform a cleanup of previously used ports:",
+        payload: error.message ?? '',
+      });
+    } finally {
+      await release();
     }
+  }
 
-    switch (this.configEntry.type) {
-      case 'child-app':
-        await this.forChildApp();
-        break;
+  private async forApplication() {
+    this.port = this.port ?? (await this.resolveFreePort(PortManager.DEFAULT_PORT));
+    this.staticPort =
+      this.staticPort ?? (await this.resolveFreePort(PortManager.DEFAULT_STATIC_PORT));
+  }
 
-      case 'module':
-        await this.forModule();
-        break;
+  private async forModule() {
+    this.port = this.port ?? (await this.resolveFreePort(PortManager.DEFAULT_MODULE_PORT));
+    this.staticPort =
+      this.staticPort ?? (await this.resolveFreePort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  }
+
+  private async forChildApp() {
+    this.port = this.port ?? (await this.resolveFreePort(PortManager.DEFAULT_MODULE_PORT));
+    this.staticPort =
+      this.staticPort ?? (await this.resolveFreePort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  }
+
+  private lockCacheFile() {
+    return lock(this.cachePath, { retries: 10 });
+  }
+
+  private async createCacheFile() {
+    try {
+      await access(this.cachePath);
+    } catch (error) {
+      await outputFile(this.cachePath, '');
+    }
+  }
 
-      case 'application':
-        await this.forApplication();
-        break;
+  private async readCacheFile() {
+    try {
+      const content = await readFile(this.cachePath, { encoding: 'utf-8' });
 
-      default:
-        break;
+      return content.split(',');
+    } catch (error) {
+      return [];
     }
   }
 
-  private async forApplication(): Promise<void> {
-    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_PORT));
-    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_STATIC_PORT));
+  private async writeCacheFile(content: string) {
+    await outputFile(this.cachePath, content);
   }
 
-  private async forModule(): Promise<void> {
-    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_MODULE_PORT));
-    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  private async appendCacheFile(content: string) {
+    await appendFile(this.cachePath, `,${content}`);
   }
 
-  private async forChildApp(): Promise<void> {
-    this.port = this.port ?? (await detectPort(PortManager.DEFAULT_MODULE_PORT));
-    this.staticPort = this.staticPort ?? (await detectPort(PortManager.DEFAULT_MODULE_STATIC_PORT));
+  private async resolveFreePort(initial: number) {
+    try {
+      const cache = await this.readCacheFile();
+      let port = await detectPort(initial);
+      let attempts = 1;
+
+      while (cache.includes(port.toString())) {
+        if (attempts >= 3) {
+          throw new Error(`Max attempts exceeded (${attempts})`);
+        }
+
+        port = await detectPort(0);
+
+        attempts++;
+      }
+
+      return port;
+    } catch (error) {
+      this.logger.event({
+        type: 'info',
+        event: 'PORT_MANAGER:RESOLVE_FREE_PORT',
+        message: "Can't resolve a free port, fallback to an initial one:",
+        payload: error.message ?? '',
+      });
+
+      return initial;
+    }
   }
 }

package/src/schema/autogeneratedSchema.json

@@ -1144,23 +1144,23 @@
                         "dotAll": {
                           "type": "boolean"
                         },
-                        "__@match@6838": {
+                        "__@match@6850": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@replace@6840": {
+                        "__@replace@6852": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@search@6843": {
+                        "__@search@6855": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@split@6845": {
+                        "__@split@6857": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@matchAll@6847": {
+                        "__@matchAll@6859": {
                           "type": "object",
                           "additionalProperties": false
                         }
@@ -1814,23 +1814,23 @@
                         "dotAll": {
                           "type": "boolean"
                         },
-                        "__@match@6838": {
+                        "__@match@6850": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@replace@6840": {
+                        "__@replace@6852": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@search@6843": {
+                        "__@search@6855": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@split@6845": {
+                        "__@split@6857": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@matchAll@6847": {
+                        "__@matchAll@6859": {
                           "type": "object",
                           "additionalProperties": false
                         }
@@ -2484,23 +2484,23 @@
                         "dotAll": {
                           "type": "boolean"
                         },
-                        "__@match@6838": {
+                        "__@match@6850": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@replace@6840": {
+                        "__@replace@6852": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@search@6843": {
+                        "__@search@6855": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@split@6845": {
+                        "__@split@6857": {
                           "type": "object",
                           "additionalProperties": false
                         },
-                        "__@matchAll@6847": {
+                        "__@matchAll@6859": {
                           "type": "object",
                           "additionalProperties": false
                         }

package/src/validators/commands/checkSwcDependencies.spec.ts

@@ -0,0 +1,117 @@
+import { sync as mockResolve } from 'resolve';
+import type { Context } from '../../models/context';
+import { checkSwcDependencies } from './checkSwcDependencies';
+
+const mockSwcIntegration = (version, mockCliVersion, mockRootVersion) => {
+  jest.mock(
+    `/app/basedir/@tramvai/swc-integration/package.json`,
+    () => {
+      return { dependencies: { '@swc/core': version } };
+    },
+    { virtual: true }
+  );
+
+  jest.mock(
+    `/app/@swc/core/package.json`,
+    () => {
+      return { version: mockCliVersion };
+    },
+    { virtual: true }
+  );
+
+  jest.mock(
+    `/app/basedir/@swc/core/package.json`,
+    () => {
+      return { version: mockRootVersion };
+    },
+    { virtual: true }
+  );
+};
+
+jest.mock('resolve', () => ({
+  sync: jest
+    .fn((name) => require.resolve(name))
+    .mockImplementation((name, { basedir = '' } = {}) => {
+      if (basedir) {
+        return `/app/basedir/${name}`;
+      }
+
+      return `/app/${name}`;
+    }),
+}));
+
+describe('validators/checkSwcDependencies', () => {
+  const mockLog = jest.fn();
+  const context = {} as Context;
+
+  beforeEach(() => {
+    mockLog.mockClear();
+    jest.resetModules();
+    (mockResolve as jest.Mock).mockClear();
+  });
+
+  it('returns ok if there is no @tramvai/swc-integration', async () => {
+    expect(await checkSwcDependencies(context, {})).toMatchInlineSnapshot(`
+      {
+        "name": "checkSwcDependencies",
+        "status": "ok",
+      }
+    `);
+  });
+
+  it('returns ok if there is @tramvai/swc-integration with correct version from root & cli', async () => {
+    mockSwcIntegration('1.0.0', '1.0.0', '1.0.0');
+
+    expect(await checkSwcDependencies(context, {})).toMatchInlineSnapshot(`
+      {
+        "name": "checkSwcDependencies",
+        "status": "ok",
+      }
+    `);
+  });
+
+  it('returns error if there is @tramvai/swc-integration with different version from root & cli', async () => {
+    mockSwcIntegration('1.0.1', '1.0.0', '1.0.0');
+
+    expect(await checkSwcDependencies(context, {})).toMatchInlineSnapshot(`
+      {
+        "message": "Version of @swc/core mismatch between
+      @tramvai/swc-integration (version: 1.0.1),
+      @tramvai/cli (version: 1.0.0) and
+      process.cwd() (version: 1.0.0)",
+        "name": "checkSwcDependencies",
+        "status": "error",
+      }
+    `);
+  });
+
+  it('returns error if there is correct version between @tramvai/swc-integration and root but different in cli', async () => {
+    mockSwcIntegration('1.0.0', '1.0.1', '1.0.0');
+
+    expect(await checkSwcDependencies(context, {})).toMatchInlineSnapshot(`
+      {
+        "message": "Version of @swc/core mismatch between
+      @tramvai/swc-integration (version: 1.0.0),
+      @tramvai/cli (version: 1.0.1) and
+      process.cwd() (version: 1.0.0)",
+        "name": "checkSwcDependencies",
+        "status": "error",
+      }
+    `);
+  });
+
+  it('returns error if there is correct version between @tramvai/swc-integration and cli but different in root', async () => {
+    mockSwcIntegration('1.0.0', '1.0.0', '1.0.1');
+
+    expect(await checkSwcDependencies(context, {})).toMatchInlineSnapshot(`
+      {
+        "message": "Version of @swc/core mismatch between
+      @tramvai/swc-integration (version: 1.0.0),
+      @tramvai/cli (version: 1.0.0) and
+      process.cwd() (version: 1.0.1)",
+        "name": "checkSwcDependencies",
+        "status": "error",
+      }
+    `);
+  });
+});

package/src/validators/commands/checkSwcDependencies.ts

@@ -0,0 +1,40 @@
+import { sync as resolve } from 'resolve';
+import type { Validator } from './validator.h';
+
+export const checkSwcDependencies: Validator = async () => {
+  const rootDir = process.cwd();
+  const packagePath = `@swc/core/package.json`;
+  const pathFromCli = resolve(packagePath);
+  const pathFromRoot = resolve(packagePath, { basedir: rootDir });
+  const pathFromRootToIntegration = resolve(`@tramvai/swc-integration/package.json`, {
+    basedir: rootDir,
+  });
+
+  let versionFromIntegration = '';
+  let versionFromRoot = '_from_root_version_';
+  let versionFromCli = '_from_cli_version_';
+  try {
+    versionFromIntegration = require(pathFromRootToIntegration).dependencies['@swc/core'];
+    versionFromRoot = require(pathFromRoot).version;
+    versionFromCli = require(pathFromCli).version;
+  } catch (e) {}
+
+  const allVersionsAreCorrect =
+    versionFromRoot === versionFromCli && versionFromCli === versionFromIntegration;
+
+  if (!versionFromIntegration || allVersionsAreCorrect) {
+    return {
+      name: 'checkSwcDependencies',
+      status: 'ok',
+    };
+  }
+
+  return {
+    name: 'checkSwcDependencies',
+    status: 'error',
+    message: `Version of @swc/core mismatch between
+@tramvai/swc-integration (version: ${versionFromIntegration}),
+@tramvai/cli (version: ${versionFromCli}) and
+process.cwd() (version: ${versionFromRoot})`,
+  };
+};