vovk-cli 0.0.1-beta.0

package/src/types.ts

@@ -0,0 +1,58 @@
+import { LogLevelNames } from 'loglevel';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type KnownAny = any;
+
+/*
+export type VovkEnv = {
+  PORT?: string;
+  VOVK_ROUTE?: string;
+  VOVK_FETCHER?: string;
+  VOVK_PREFIX?: string;
+  VOVK_VALIDATE_ON_CLIENT?: string;
+  VOVK_PORT?: string;
+  VOVK_CLIENT_OUT?: string;
+  VOVK_METADATA_OUT?: string;
+  VOVK_MODULES_DIR?: string;
+  __VOVK_START_SERVER__?: string;
+};
+*/
+export type VovkEnv = {
+  PORT?: string;
+  VOVK_CLIENT_OUT_DIR?: string;
+  VOVK_METADATA_OUT_DIR?: string;
+  VOVK_FETCHER?: string;
+  VOVK_VALIDATE_ON_CLIENT?: string;
+  VOVK_PORT?: string;
+  VOVK_MODULES_DIR?: string;
+  VOVK_VALIDATION_LIBRARY?: string;
+  VOVK_ORIGIN?: string;
+  VOVK_ROOT_ENTRY?: string;
+  VOVK_API_ENTRY_POINT?: string;
+  VOVK_ROOT_SEGMENT_MODULES_DIR_NAME?: string;
+  VOVK_LOG_LEVEL?: LogLevelNames;
+  __VOVK_START_SERVER_IN_STANDALONE_MODE__?: 'true';
+};
+/*
+export type VovkConfig = {
+  clientOut?: string;
+  metadataOut?: string;
+  route?: string;
+  fetcher?: string;
+  prefix?: string;
+  validateOnClient?: string | null;
+  modulesDir?: string;
+};
+*/
+export type VovkConfig = {
+  clientOutDir?: string;
+  metadataOutDir?: string;
+  fetcher?: string;
+  validateOnClient?: string | null;
+  modulesDir?: string;
+  validationLibrary?: string | null;
+  rootEntry?: string;
+  origin?: string;
+  rootSegmentModulesDirName?: string;
+  logLevel?: LogLevelNames;
+};

package/src/utils/debounceWithArgs.ts

@@ -0,0 +1,22 @@
+import debounce from 'lodash/debounce';
+import { KnownAny } from '../types';
+
+export default function debounceWithArgs<T extends (...args: KnownAny[]) => KnownAny>(
+  fn: T,
+  wait: number
+): (...args: Parameters<T>) => void | Promise<void> {
+  const debouncedFunctions = new Map<string, ReturnType<typeof debounce>>();
+
+  return (...args: Parameters<T>) => {
+    const key = JSON.stringify(args);
+
+    if (!debouncedFunctions.has(key)) {
+      debouncedFunctions.set(key, debounce(fn, wait));
+    }
+
+    const debouncedFn = debouncedFunctions.get(key);
+    if (debouncedFn) {
+      debouncedFn(...args);
+    }
+  };
+}

package/src/utils/fileExists.ts

@@ -0,0 +1,10 @@
+import fs from 'fs/promises';
+
+export default async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/getAvailablePort.ts

@@ -0,0 +1,50 @@
+import net from 'net';
+
+/**
+ * Checks if a port is available.
+ * @param {number} port - The port to check.
+ * @param {(isAvailable: boolean) => void} callback - The callback function.
+ */
+function checkPort(port: number, callback: (isAvailable: boolean) => void): void {
+  const server = net.createServer();
+
+  server.listen(port, () => {
+    server.close(() => {
+      callback(true); // Port is available
+    });
+  });
+
+  server.on('error', () => {
+    callback(false);
+  });
+}
+
+/**
+ * Finds an available port starting from a given port.
+ * @param {number} startPort - The port to start checking from.
+ * @param {number} maxAttempts - The maximum number of attempts to find an available port.
+ * @param {number} attempt - The current attempt number.
+ * @param {(failedPort: number, tryingPort: number) => void} onWarning - The callback function for warnings.
+ * @returns {Promise<string>}
+ */
+function getAvailablePort(
+  startPort: number,
+  maxAttempts: number,
+  attempt: number,
+  onWarning: (failedPort: number, tryingPort: number) => void
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    checkPort(startPort, (isAvailable) => {
+      if (isAvailable) {
+        resolve(startPort.toString()); // Found an available port
+      } else if (attempt < maxAttempts) {
+        onWarning(startPort, startPort + 1);
+        getAvailablePort(startPort + 1, maxAttempts, attempt + 1, onWarning).then(resolve, reject);
+      } else {
+        reject('No available ports found');
+      }
+    });
+  });
+}
+
+export default getAvailablePort;

package/test/index.ts

@@ -0,0 +1,3 @@
+import './utils.test';
+import './metadata-write.test';
+import './metadata-diff.test';

package/test/metadata-diff.test.ts

@@ -0,0 +1,300 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert';
+import diffMetadata from '../src/server/diffMetadata';
+import { HttpMethod, type VovkMetadata } from 'vovk';
+
+void describe('diffJson', async () => {
+  await test('Test case 1: No changes', () => {
+    const oldJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: { handlerA: {} },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerB: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const newJson: VovkMetadata = { ...oldJson };
+
+    const diff = diffMetadata(oldJson, newJson);
+
+    assert.deepStrictEqual(diff, {
+      workers: {
+        added: [],
+        removed: [],
+        handlers: [],
+      },
+      controllers: {
+        added: [],
+        removed: [],
+        handlers: [],
+      },
+    });
+  });
+
+  await test('Test case 2: Workers and Controllers added and removed', () => {
+    const oldJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: { handlerA: {} },
+        },
+        WorkerB: {
+          _workerName: 'WorkerB',
+          _handlers: { handlerB: {} },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerC: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const newJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerB: {
+          _workerName: 'WorkerB',
+          _handlers: { handlerB: {} },
+        },
+        WorkerC: { _workerName: 'WorkerC', _handlers: { handlerD: {} } },
+      },
+      controllers: {
+        ControllerB: {
+          _controllerName: 'ControllerB',
+          _handlers: {
+            handlerE: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const diff = diffMetadata(oldJson, newJson);
+
+    assert.deepStrictEqual(diff, {
+      workers: {
+        added: ['WorkerC'],
+        removed: ['WorkerA'],
+        handlers: [],
+      },
+      controllers: {
+        added: ['ControllerB'],
+        removed: ['ControllerA'],
+        handlers: [],
+      },
+    });
+  });
+
+  await test('Test case 3: Handlers added, removed, and changed', () => {
+    const oldJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: { handlerA: {}, handlerB: {} },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerC: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+            handlerD: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const newJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: {
+            handlerB: {}, // Unchanged
+            handlerE: {}, // Added
+            handlerA: { isGenerator: true }, // Changed
+          },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerD: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+            handlerF: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+            handlerC: {
+              path: 'newPath', // Changed
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const diff = diffMetadata(oldJson, newJson);
+
+    assert.deepStrictEqual(diff, {
+      workers: {
+        added: [],
+        removed: [],
+        handlers: [
+          {
+            nameOfClass: 'WorkerA',
+            added: ['handlerE'],
+            removed: [],
+            changed: ['handlerA'],
+          },
+        ],
+      },
+      controllers: {
+        added: [],
+        removed: [],
+        handlers: [
+          {
+            nameOfClass: 'ControllerA',
+            added: ['handlerF'],
+            removed: [],
+            changed: ['handlerC'],
+          },
+        ],
+      },
+    });
+  });
+
+  await test('Test case 4: Complex changes', () => {
+    const oldJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: { handlerA: {}, handlerB: {} },
+        },
+        WorkerB: {
+          _workerName: 'WorkerB',
+          _handlers: { handlerC: {} },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerD: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const newJson: VovkMetadata = {
+      emitMetadata: true,
+      segmentName: '',
+      workers: {
+        WorkerA: {
+          _workerName: 'WorkerA',
+          _handlers: { handlerB: {}, handlerE: {} },
+        },
+        WorkerC: {
+          _workerName: 'WorkerC',
+          _handlers: { handlerF: {} },
+        },
+      },
+      controllers: {
+        ControllerA: {
+          _controllerName: 'ControllerA',
+          _handlers: {
+            handlerD: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+            handlerG: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+        ControllerB: {
+          _controllerName: 'ControllerB',
+          _handlers: {
+            handlerH: {
+              path: 'path',
+              httpMethod: HttpMethod.GET,
+            },
+          },
+        },
+      },
+    };
+
+    const diff = diffMetadata(oldJson, newJson);
+
+    assert.deepStrictEqual(diff, {
+      workers: {
+        added: ['WorkerC'],
+        removed: ['WorkerB'],
+        handlers: [
+          {
+            nameOfClass: 'WorkerA',
+            added: ['handlerE'],
+            removed: ['handlerA'],
+            changed: [],
+          },
+        ],
+      },
+      controllers: {
+        added: ['ControllerB'],
+        removed: [],
+        handlers: [
+          {
+            nameOfClass: 'ControllerA',
+            added: ['handlerG'],
+            removed: [],
+            changed: [],
+          },
+        ],
+      },
+    });
+  });
+});

package/test/metadata-write.test.ts

@@ -0,0 +1,82 @@
+import assert from 'node:assert';
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import fs from 'fs/promises';
+import path from 'path';
+import * as glob from 'glob';
+import ensureMetadataFiles from '../src/server/ensureMetadataFiles';
+
+const tmpDir = path.join(process.cwd(), 'tmp');
+
+// Helper function to clear and create a temporary directory
+async function setupTmpDir() {
+  await cleanupTmpDir();
+  await fs.mkdir(tmpDir, { recursive: true });
+}
+
+async function cleanupTmpDir() {
+  await fs.rm(tmpDir, { recursive: true, force: true });
+}
+
+beforeEach(async () => {
+  await setupTmpDir();
+});
+
+afterEach(async () => {
+  await cleanupTmpDir();
+});
+
+void describe('Check if metadata files are created and removed correctly', async () => {
+  await test('ensureMetadataFiles creates and removes files correctly with nested segments', async () => {
+    const initialSegments = ['segment1', 'segment2', 'folder1/segment3', 'folder2/segment4'];
+
+    // Run the function with the initial segments
+    await ensureMetadataFiles(tmpDir, initialSegments, null);
+
+    // Check if files are created
+    let files = glob.sync('**/*.json', { cwd: tmpDir });
+    assert.deepStrictEqual(
+      files.sort(),
+      ['segment1.json', 'segment2.json', 'folder1/segment3.json', 'folder2/segment4.json'].sort()
+    );
+
+    // Check if index.js is created and has the correct content
+    const indexPath = path.join(tmpDir, 'index.js');
+    const expectedIndexContent = `module.exports['segment1'] = require('./segment1');
+module.exports['segment2'] = require('./segment2');
+module.exports['folder1/segment3'] = require('./folder1/segment3');
+module.exports['folder2/segment4'] = require('./folder2/segment4');`;
+
+    const indexContent = await fs.readFile(indexPath, 'utf-8');
+    assert.strictEqual(indexContent.trim(), expectedIndexContent.trim());
+
+    // Update the segments list (segment2 and segment3 remain, segment1 and segment4 are removed, segment5 is added)
+    const updatedSegments = ['segment2', 'folder1/segment3', 'segment5'];
+
+    // Run the function with the updated segments
+    await ensureMetadataFiles(tmpDir, updatedSegments, null);
+
+    // Check if files are updated correctly
+    files = glob.sync('**/*.json', { cwd: tmpDir });
+    assert.deepStrictEqual(files.sort(), ['segment2.json', 'folder1/segment3.json', 'segment5.json'].sort());
+
+    // Check if old files are removed
+    const removedFiles = ['segment1.json', 'folder2/segment4.json'];
+    for (const file of removedFiles) {
+      try {
+        await fs.stat(path.join(tmpDir, file));
+        assert.fail(`${file} should have been deleted`);
+      } catch (error) {
+        // eslint-disable-next-line no-undef
+        assert.strictEqual((error as NodeJS.ErrnoException).code, 'ENOENT');
+      }
+    }
+
+    // Check if the updated index.js file is correct
+    const updatedExpectedIndexContent = `module.exports['segment2'] = require('./segment2');
+module.exports['folder1/segment3'] = require('./folder1/segment3');
+module.exports['segment5'] = require('./segment5');`;
+
+    const updatedIndexContent = await fs.readFile(indexPath, 'utf-8');
+    assert.strictEqual(updatedIndexContent.trim(), updatedExpectedIndexContent.trim());
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,49 @@
+import assert from 'node:assert';
+import test, { describe } from 'node:test';
+import locateSegments from '../src/locateSegments';
+import path from 'node:path';
+
+void describe('Bug-sensitive utils', async () => {
+  await test('locateSegment', async () => {
+    const rootDirectory = path.join(__dirname, 'data/segments');
+    const results = await locateSegments(rootDirectory);
+
+    const expectedResults = [
+      {
+        routeFilePath: path.join(__dirname, 'data/segments/[[...vovk]]/route.ts'),
+        segmentName: '',
+      },
+      {
+        routeFilePath: path.join(__dirname, 'data/segments/bar/[[...custom]]/route.ts'),
+        segmentName: 'bar',
+      },
+      {
+        routeFilePath: path.join(__dirname, 'data/segments/foo/[[...vovk]]/route.ts'),
+        segmentName: 'foo',
+      },
+      {
+        routeFilePath: path.join(__dirname, 'data/segments/quux/corge/[[...vovk]]/route.ts'),
+        segmentName: 'quux/corge',
+      },
+    ];
+
+    assert.strictEqual(
+      results.length,
+      expectedResults.length,
+      'The number of located segments should match the expected count.'
+    );
+
+    for (let i = 0; i < results.length; i++) {
+      assert.strictEqual(
+        results[i].routeFilePath,
+        expectedResults[i].routeFilePath,
+        `The routeFilePath at index ${i} should match.`
+      );
+      assert.strictEqual(
+        results[i].segmentName,
+        expectedResults[i].segmentName,
+        `The segmentName at index ${i} should match.`
+      );
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.test.json

@@ -0,0 +1,4 @@
+{
+    "extends": "./tsconfig.json",
+    "include": ["src/**/*", "test/**/*", ".eslintrc.js"],
+}