refactor: remove redundant code

Author: BioPhoton

packages/utils/src/lib/process-id.ts

@@ -47,10 +47,6 @@ export const ID_PATTERNS = Object.freeze({
    * Used by: getUniqueInstanceId()
    */
   INSTANCE_ID: new RegExp(`^${TIME_ID_BASE.source}\\.\\d+\\.\\d+\\.\\d+$`),
-  /** @deprecated Use INSTANCE_ID instead */
-  SHARD_ID: new RegExp(`^${TIME_ID_BASE.source}\\.\\d+\\.\\d+\\.\\d+$`),
-  /** @deprecated Use TIME_ID instead */
-  READABLE_DATE: new RegExp(`^${TIME_ID_BASE.source}$`),
 } as const);
 
 /**

packages/utils/src/lib/process-id.unit.test.ts

@@ -77,16 +77,16 @@ describe('ID_PATTERNS', () => {
   );
 
   it.each(['20231114-221320-000.12345.1.1'])(
-    'SHARD_ID should match valid shard ID (deprecated alias): %s',
-    shardId => {
-      expect(shardId).toMatch(ID_PATTERNS.SHARD_ID);
+    'INSTANCE_ID should match valid instance ID: %s',
+    instanceId => {
+      expect(instanceId).toMatch(ID_PATTERNS.INSTANCE_ID);
     },
   );
 
   it.each(['20231114-221320-000'])(
-    'READABLE_DATE should match valid readable date (deprecated alias): %s',
-    readableDate => {
-      expect(readableDate).toMatch(ID_PATTERNS.READABLE_DATE);
+    'TIME_ID should match valid time ID: %s',
+    timeId => {
+      expect(timeId).toMatch(ID_PATTERNS.TIME_ID);
     },
   );
 });

packages/utils/src/lib/profiler/profiler-node.int.test.ts

@@ -5,7 +5,7 @@ import {
   omitTraceJson,
 } from '@code-pushup/test-utils';
 import type { PerformanceEntryEncoder } from '../performance-observer.js';
-import { WAL_ID_PATTERNS } from '../wal.js';
+import { ID_PATTERNS } from '../process-id.js';
 import { NodejsProfiler } from './profiler-node.js';
 import { entryToTraceEvents } from './trace-file-utils.js';
 import type { TraceEvent } from './trace-file.type.js';
@@ -261,7 +261,7 @@ describe('NodeJS Profiler Integration', () => {
       const groupIdDir = pathParts.at(-2);
       const fileName = pathParts.at(-1);
 
-      expect(groupIdDir).toMatch(WAL_ID_PATTERNS.GROUP_ID);
+      expect(groupIdDir).toMatch(ID_PATTERNS.TIME_ID);
       expect(fileName).toMatch(/^trace\.\d{8}-\d{6}-\d{3}(?:\.\d+){3}\.jsonl$/);
 
       const groupIdDirPath = path.dirname(filePath);
@@ -283,7 +283,7 @@ describe('NodeJS Profiler Integration', () => {
       const dirPath = path.dirname(filePath);
       const groupId = path.basename(dirPath);
 
-      expect(groupId).toMatch(WAL_ID_PATTERNS.GROUP_ID);
+      expect(groupId).toMatch(ID_PATTERNS.TIME_ID);
       // eslint-disable-next-line n/no-sync
       expect(fs.existsSync(dirPath)).toBeTrue();
       // eslint-disable-next-line n/no-sync

packages/utils/src/lib/wal.ts

@@ -3,6 +3,11 @@ import * as fs from 'node:fs';
 import path from 'node:path';
 import process from 'node:process';
 import { threadId } from 'node:worker_threads';
+import {
+  type Counter,
+  getUniqueInstanceId,
+  getUniqueTimeId,
+} from './process-id.js';
 
 /**
  * Codec for encoding/decoding values to/from strings for WAL storage.
@@ -375,6 +380,13 @@ export function setCoordinatorProcess(
 // eslint-disable-next-line functional/no-let
 let shardCount = 0;
 
+/**
+ * Simple counter implementation for generating sequential IDs.
+ */
+const shardCounter: Counter = {
+  next: () => ++shardCount,
+};
+
 /**
  * Generates a unique sharded WAL ID based on performance time origin, process ID, thread ID, and instance count.
  */
@@ -383,60 +395,6 @@ function getShardedWalId() {
   return `${Math.round(performance.timeOrigin)}.${process.pid}.${threadId}.${++ShardedWal.instanceCount}`;
 }
 
-/**
- * Generates a human-readable shard ID.
- * This ID is unique per process/thread/shard combination and used in the file name.
- * Format: readable-timestamp.pid.threadId.shardCount
- * Example: "20240101-120000-000.12345.1.1"
- * Becomes file: trace.20240101-120000-000.12345.1.1.log
- */
-export function getShardId(): string {
-  const timestamp = Math.round(performance.timeOrigin + performance.now());
-  const readableTimestamp = sortableReadableDateString(`${timestamp}`);
-  return `${readableTimestamp}.${process.pid}.${threadId}.${++shardCount}`;
-}
-
-/**
- * Generates a human-readable sharded group ID.
- * This ID is a globally unique, sortable, human-readable date string per run.
- * Used directly as the folder name to group shards.
- * Format: yyyymmdd-hhmmss-ms
- * Example: "20240101-120000-000"
- */
-export function getShardedGroupId(): string {
-  return sortableReadableDateString(
-    `${Math.round(performance.timeOrigin + performance.now())}`,
-  );
-}
-
-/**
- * Regex patterns for validating WAL ID formats
- */
-export const WAL_ID_PATTERNS = {
-  /** Readable date format: yyyymmdd-hhmmss-ms */
-  READABLE_DATE: /^\d{8}-\d{6}-\d{3}$/,
-  /** Group ID format: yyyymmdd-hhmmss-ms */
-  GROUP_ID: /^\d{8}-\d{6}-\d{3}$/,
-  /** Shard ID format: readable-date.pid.threadId.count */
-  SHARD_ID: /^\d{8}-\d{6}-\d{3}(?:\.\d+){3}$/,
-} as const;
-
-export function sortableReadableDateString(timestampMs: string): string {
-  const timestamp = Number.parseInt(timestampMs, 10);
-  const date = new Date(timestamp);
-  const MILLISECONDS_PER_SECOND = 1000;
-  const yyyy = date.getFullYear();
-  const mm = String(date.getMonth() + 1).padStart(2, '0');
-  const dd = String(date.getDate()).padStart(2, '0');
-  const hh = String(date.getHours()).padStart(2, '0');
-  const min = String(date.getMinutes()).padStart(2, '0');
-  const ss = String(date.getSeconds()).padStart(2, '0');
-  // eslint-disable-next-line @typescript-eslint/no-magic-numbers
-  const ms = String(timestamp % MILLISECONDS_PER_SECOND).padStart(3, '0');
-
-  return `${yyyy}${mm}${dd}-${hh}${min}${ss}-${ms}`;
-}
-
 /**
  * Ensures a directory exists, creating it recursively if necessary using sync methods.
  * @param dirPath - The directory path to ensure exists
@@ -491,7 +449,7 @@ export function getShardedFinalPath<T extends object | string = object>(opt: {
 export class ShardedWal<T extends object | string = object> {
   static instanceCount = 0;
   readonly #id: string = getShardedWalId();
-  readonly groupId = getShardedGroupId();
+  readonly groupId = getUniqueTimeId();
   readonly #format: WalFormat<T>;
   readonly #dir: string = process.cwd();
   readonly #isCoordinator: boolean;
@@ -511,7 +469,7 @@ export class ShardedWal<T extends object | string = object> {
     coordinatorIdEnvVar: string;
   }) {
     const { dir, format, groupId, coordinatorIdEnvVar } = opt;
-    this.groupId = groupId ?? getShardedGroupId();
+    this.groupId = groupId ?? getUniqueTimeId();
     if (dir) {
       this.#dir = dir;
     }
@@ -531,7 +489,7 @@ export class ShardedWal<T extends object | string = object> {
     return this.#isCoordinator;
   }
 
-  shard(shardId: string = getShardId()) {
+  shard(shardId: string = getUniqueInstanceId(shardCounter)) {
     return new WriteAheadLogFile({
       file: getShardedPath({
         dir: this.#dir,

packages/utils/src/lib/wal.unit.test.ts

@@ -1,16 +1,18 @@
 import { vol } from 'memfs';
 import { MEMFS_VOLUME } from '@code-pushup/test-utils';
+import {
+  ID_PATTERNS,
+  getUniqueInstanceId,
+  getUniqueTimeId,
+} from './process-id.js';
 import { SHARDED_WAL_COORDINATOR_ID_ENV_VAR } from './profiler/constants.js';
 import {
   type Codec,
   type InvalidEntry,
   ShardedWal,
-  WAL_ID_PATTERNS,
   WriteAheadLogFile,
   createTolerantCodec,
   filterValidRecords,
-  getShardId,
-  getShardedGroupId,
   isCoordinatorProcess,
   parseWalFormat,
   recoverFromContent,
@@ -506,15 +508,18 @@ describe('stringCodec', () => {
 
 describe('getShardId', () => {
   it('should generate shard ID with readable timestamp', () => {
-    const result = getShardId();
+    const counter = { next: () => 1 };
+    const result = getUniqueInstanceId(counter);
 
-    expect(result).toMatch(WAL_ID_PATTERNS.SHARD_ID);
+    expect(result).toMatch(ID_PATTERNS.INSTANCE_ID);
     expect(result).toStartWith('20231114-221320-000.');
   });
 
   it('should generate different shard IDs for different calls', () => {
-    const result1 = getShardId();
-    const result2 = getShardId();
+    let count = 0;
+    const counter = { next: () => ++count };
+    const result1 = getUniqueInstanceId(counter);
+    const result2 = getUniqueInstanceId(counter);
 
     expect(result1).not.toBe(result2);
     expect(result1).toStartWith('20231114-221320-000.');
@@ -555,15 +560,15 @@ describe('getShardId', () => {
 
 describe('getShardedGroupId', () => {
   it('should work with mocked timeOrigin', () => {
-    const result = getShardedGroupId();
+    const result = getUniqueTimeId();
 
     expect(result).toBe('20231114-221320-000');
-    expect(result).toMatch(WAL_ID_PATTERNS.GROUP_ID);
+    expect(result).toMatch(ID_PATTERNS.TIME_ID);
   });
 
   it('should be idempotent within same process', () => {
-    const result1 = getShardedGroupId();
-    const result2 = getShardedGroupId();
+    const result1 = getUniqueTimeId();
+    const result2 = getUniqueTimeId();
 
     expect(result1).toBe(result2);
   });