feat: enable eraseable syntax (#31)

* Enable eraseable types

* Update the tests

* Fix the benchmark

* Fix the names for enum based on discussion ChainSafe/lodestar#7574

* Fix naming convention

* Fix naming convention

* Apply suggestions from code review

Co-authored-by: Matthew Keil <[email protected]>

* Rename all enums with Enum suffix

* Rename all enums with Enum suffix

* Rename all enums with Enum suffix

* Update the name for HistoryProvier

---------

Co-authored-by: Matthew Keil <[email protected]>

Author: nazarhussain

package.json

@@ -50,7 +50,7 @@
     "prettier": "^3.4.0",
     "rimraf": "^5.0.10",
     "ts-node": "^10.9.2",
-    "typescript": "^5.6.3",
+    "typescript": "^5.8.2",
     "typescript-eslint": "^8.16.0",
     "vitest": "^3.0.6",
     "vitest-in-process-pool": "^2.0.0"

src/benchmark/convergence/coefficientOfVariance.ts

@@ -1,6 +1,13 @@
 import Debug from "debug";
 import {BenchmarkOpts, ConvergenceCheckFn} from "../../types.js";
-import {calcMean, calcMedian, calcVariance, filterOutliers, OutlierSensitivity, sortData} from "../../utils/math.js";
+import {
+  calcMean,
+  calcMedian,
+  calcVariance,
+  filterOutliers,
+  OutlierSensitivityEnum,
+  sortData,
+} from "../../utils/math.js";
 
 const debug = Debug("@chainsafe/benchmark/convergence");
 
@@ -43,7 +50,7 @@ export function createCVConvergenceCriteria(
     if (timeSinceLastCheck < sampleEveryMs) return false;
     lastConvergenceSample = currentMs;
     // For all statistical calculations we don't want to loose the precision so have to convert to numbers first
-    const samples = filterOutliers(sortData(runsNs.map((n) => Number(n))), true, OutlierSensitivity.Mild);
+    const samples = filterOutliers(sortData(runsNs.map((n) => Number(n))), true, OutlierSensitivityEnum.Mild);
 
     // If CV does not stabilize we fallback to the median approach
     if (runsNs.length > maxSamplesForCV) {

src/benchmark/options.ts

@@ -1,4 +1,4 @@
-import {AverageCalculation, BenchmarkOpts, Convergence} from "../types.js";
+import {AverageCalculationEnum, BenchmarkOpts, ConvergenceEnum} from "../types.js";
 
 export const defaultBenchmarkOptions: Required<BenchmarkOpts> = {
   minRuns: 1,
@@ -17,8 +17,8 @@ export const defaultBenchmarkOptions: Required<BenchmarkOpts> = {
   skip: false,
   only: false,
   threshold: 2,
-  convergence: Convergence.Linear,
-  averageCalculation: AverageCalculation.Simple,
+  convergence: ConvergenceEnum.Linear,
+  averageCalculation: AverageCalculationEnum.Simple,
 };
 
 export function getBenchmarkOptionsWithDefaults(opts: BenchmarkOpts): Required<BenchmarkOpts> {

src/benchmark/runBenchmarkFn.ts

@@ -1,6 +1,6 @@
 import Debug from "debug";
-import {BenchmarkResult, BenchmarkOpts, Convergence, ConvergenceCheckFn} from "../types.js";
-import {calcSum, filterOutliers, OutlierSensitivity} from "../utils/math.js";
+import {BenchmarkResult, BenchmarkOpts, Convergence, ConvergenceCheckFn, ConvergenceEnum} from "../types.js";
+import {calcSum, filterOutliers, OutlierSensitivityEnum} from "../utils/math.js";
 import {getBenchmarkOptionsWithDefaults} from "./options.js";
 import {createLinearConvergenceCriteria} from "./convergence/linearAverage.js";
 import {createCVConvergenceCriteria} from "./convergence/coefficientOfVariance.js";
@@ -9,8 +9,8 @@ const debug = Debug("@chainsafe/benchmark/run");
 
 const convergenceCriteria: Record<Convergence, (startMs: number, opts: Required<BenchmarkOpts>) => ConvergenceCheckFn> =
   {
-    [Convergence.Linear]: createLinearConvergenceCriteria,
-    [Convergence.CV]: createCVConvergenceCriteria,
+    [ConvergenceEnum.Linear]: createLinearConvergenceCriteria,
+    [ConvergenceEnum.CV]: createCVConvergenceCriteria,
   };
 
 export type BenchmarkRunOpts = BenchmarkOpts & {
@@ -45,8 +45,8 @@ export async function runBenchFn<T, T2>(
     throw new Error(`Average calculation logic is not defined. ${averageCalculation}`);
   }
 
-  if (!Object.values(Convergence).includes(convergence)) {
-    throw new Error(`Unknown convergence value ${convergence}. Valid values are ${Object.values(Convergence)}`);
+  if (!Object.values(ConvergenceEnum).includes(convergence)) {
+    throw new Error(`Unknown convergence value ${convergence}. Valid values are ${Object.values(ConvergenceEnum)}`);
   }
 
   // Ratio of maxMs that the warmup is allow to take from elapsedMs
@@ -138,7 +138,7 @@ either the before(), beforeEach() or fn() functions are too slow.
   }
 
   if (averageCalculation === "clean-outliers") {
-    const cleanData = filterOutliers(runsNs, false, OutlierSensitivity.Mild);
+    const cleanData = filterOutliers(runsNs, false, OutlierSensitivityEnum.Mild);
     averageNs = Number(calcSum(cleanData) / BigInt(cleanData.length)) / runsFactor;
   }
 

src/cli/compare.ts

@@ -7,7 +7,7 @@ import {renderBenchmarkComparisonTable} from "../utils/render.js";
 import {isGaRun} from "../github/context.js";
 import {postGaComment} from "../github/comments/index.js";
 import {benchmarkComparisonComment} from "../github/comments/comparisonReportComment.js";
-import {GithubCommentTag} from "../github/octokit.js";
+import {GithubCommentTagEnum} from "../github/octokit.js";
 
 export async function compare({dirs}: {dirs: string[]}): Promise<void> {
   consoleLog("Comparing benchmarks:");
@@ -41,7 +41,7 @@ export async function compare({dirs}: {dirs: string[]}): Promise<void> {
   if (isGaRun()) {
     await postGaComment({
       commentBody: benchmarkComparisonComment(resultsComp),
-      tag: GithubCommentTag.ComparisonReport,
+      tag: GithubCommentTagEnum.ComparisonReport,
       commentOnPush: true,
     });
   }

src/cli/options.ts

@@ -1,5 +1,11 @@
 import {Options} from "yargs";
-import {StorageOptions, BenchmarkOpts, FileCollectionOptions, Convergence, AverageCalculation} from "../types.js";
+import {
+  StorageOptions,
+  BenchmarkOpts,
+  FileCollectionOptions,
+  AverageCalculationEnum,
+  ConvergenceEnum,
+} from "../types.js";
 import {defaultBenchmarkOptions} from "../benchmark/options.js";
 
 export const optionsDefault = {
@@ -209,14 +215,14 @@ export const benchmarkOptions: ICliCommandOptions<CLIBenchmarkOptions> = {
     type: "string",
     description: "The algorithm used to detect the convergence to stop benchmark runs",
     default: defaultBenchmarkOptions.convergence,
-    choices: Object.values(Convergence),
+    choices: Object.values(ConvergenceEnum),
     group: benchmarkGroup,
   },
   averageCalculation: {
     type: "string",
     description: "Use simple average of all runs or clean the outliers before calculating average",
     default: defaultBenchmarkOptions.averageCalculation,
-    choices: Object.values(AverageCalculation),
+    choices: Object.values(AverageCalculationEnum),
     group: benchmarkGroup,
   },
 };

src/cli/run.ts

@@ -19,9 +19,9 @@ import {isGaRun} from "../github/context.js";
 import {BenchmarkRunner} from "../benchmark/runner.js";
 import {optionsDefault} from "./options.js";
 import {consoleLog} from "../utils/output.js";
-import {HistoryProviderType} from "../history/provider.js";
+import {HistoryProviderEnum} from "../history/provider.js";
 import {performanceReportComment} from "../github/comments/performanceReportComment.js";
-import {GithubCommentTag} from "../github/octokit.js";
+import {GithubCommentTagEnum} from "../github/octokit.js";
 import {defaultBenchmarkOptions} from "../benchmark/options.js";
 
 const debug = Debug("@chainsafe/benchmark/cli");
@@ -81,7 +81,7 @@ export async function run(opts_: FileCollectionOptions & StorageOptions & Benchm
         currentCommit.branch ??
         parseBranchFromRef(
           github.context.ref ?? (await shell("git symbolic-ref HEAD")),
-          historyProvider.type === HistoryProviderType.Local
+          historyProvider.type === HistoryProviderEnum.Local
         );
       consoleLog(`Persisting new benchmark data for branch '${branch}' commit '${currBench.commitSha}'`);
       // TODO: prune and limit total entries
@@ -100,7 +100,7 @@ export async function run(opts_: FileCollectionOptions & StorageOptions & Benchm
     if (!opts.skipPostComment && isGaRun()) {
       await postGaComment({
         commentBody: performanceReportComment(resultsComp),
-        tag: GithubCommentTag.PerformanceReport,
+        tag: GithubCommentTagEnum.PerformanceReport,
         commentOnPush: resultsComp.someFailed,
       });
     }

src/compare/index.ts

@@ -5,14 +5,14 @@ import {isGaRun} from "../github/context.js";
 import {IHistoryProvider} from "../history/provider.js";
 import {validateBenchmark} from "../history/schema.js";
 
-enum CompareWithType {
-  latestCommitInBranch = "latestCommitInBranch",
-  exactCommit = "exactCommit",
-}
+const CompareWithTypeEnum = {
+  latestCommitInBranch: "latestCommitInBranch",
+  exactCommit: "exactCommit",
+} as const;
 
 export type CompareWith =
-  | {type: CompareWithType.latestCommitInBranch; branch: string; before?: string}
-  | {type: CompareWithType.exactCommit; commitSha: string};
+  | {type: typeof CompareWithTypeEnum.latestCommitInBranch; branch: string; before?: string}
+  | {type: typeof CompareWithTypeEnum.exactCommit; commitSha: string};
 
 export async function resolveCompare(provider: IHistoryProvider, opts: StorageOptions): Promise<Benchmark | null> {
   const compareWith = await resolveCompareWith(opts);
@@ -29,10 +29,10 @@ export async function resolvePrevBenchmark(
   provider: IHistoryProvider
 ): Promise<Benchmark | null> {
   switch (compareWith.type) {
-    case CompareWithType.exactCommit:
+    case CompareWithTypeEnum.exactCommit:
       return await provider.readHistoryCommit(compareWith.commitSha);
 
-    case CompareWithType.latestCommitInBranch: {
+    case CompareWithTypeEnum.latestCommitInBranch: {
       // Try first latest commit in branch
       return await provider.readLatestInBranch(compareWith.branch);
     }
@@ -41,10 +41,10 @@ export async function resolvePrevBenchmark(
 
 export function renderCompareWith(compareWith: CompareWith): string {
   switch (compareWith.type) {
-    case CompareWithType.exactCommit:
+    case CompareWithTypeEnum.exactCommit:
       return `exactCommit ${compareWith.commitSha}`;
 
-    case CompareWithType.latestCommitInBranch: {
+    case CompareWithTypeEnum.latestCommitInBranch: {
       if (compareWith.before) {
         return `latestCommitInBranch '${compareWith.branch}' before commit ${compareWith.before}`;
       } else {
@@ -57,11 +57,11 @@ export function renderCompareWith(compareWith: CompareWith): string {
 export async function resolveCompareWith(opts: StorageOptions): Promise<CompareWith> {
   // compare may be a branch or commit
   if (opts.compareBranch) {
-    return {type: CompareWithType.latestCommitInBranch, branch: opts.compareBranch};
+    return {type: CompareWithTypeEnum.latestCommitInBranch, branch: opts.compareBranch};
   }
 
   if (opts.compareCommit) {
-    return {type: CompareWithType.exactCommit, commitSha: opts.compareCommit};
+    return {type: CompareWithTypeEnum.exactCommit, commitSha: opts.compareCommit};
   }
 
   // In GA CI figure out what to compare against with github actions events
@@ -70,13 +70,13 @@ export async function resolveCompareWith(opts: StorageOptions): Promise<CompareW
       case "pull_request": {
         const eventData = getGithubEventData<GithubActionsEventData["pull_request"]>();
         const baseBranch = eventData.pull_request.base.ref; // base.ref is already parsed
-        return {type: CompareWithType.latestCommitInBranch, branch: baseBranch};
+        return {type: CompareWithTypeEnum.latestCommitInBranch, branch: baseBranch};
       }
 
       case "push": {
         const eventData = getGithubEventData<GithubActionsEventData["push"]>();
         const branch = parseBranchFromRef(github.context.ref);
-        return {type: CompareWithType.latestCommitInBranch, branch: branch, before: eventData.before};
+        return {type: CompareWithTypeEnum.latestCommitInBranch, branch: branch, before: eventData.before};
       }
 
       default:
@@ -86,5 +86,5 @@ export async function resolveCompareWith(opts: StorageOptions): Promise<CompareW
 
   // Otherwise compare against the default branch
   const defaultBranch = await getDefaultBranch(opts);
-  return {type: CompareWithType.latestCommitInBranch, branch: defaultBranch};
+  return {type: CompareWithTypeEnum.latestCommitInBranch, branch: defaultBranch};
 }

src/github/octokit.ts

@@ -1,9 +1,11 @@
+import {EnumLike} from "../types.js";
 import {getContext} from "./context.js";
 
-export enum GithubCommentTag {
-  PerformanceReport = "benchmarkbot/action",
-  ComparisonReport = "benchmarkbot/compare",
-}
+export const GithubCommentTagEnum = {
+  PerformanceReport: "benchmarkbot/action",
+  ComparisonReport: "benchmarkbot/compare",
+} as const;
+export type GithubCommentTag = EnumLike<typeof GithubCommentTagEnum>;
 
 export async function commentToPrUpdatable(prNumber: number, body: string, tag: GithubCommentTag): Promise<void> {
   const {repo, octokit} = getContext();

src/history/gaCache.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import * as cache from "@actions/cache";
 import {Benchmark} from "../types.js";
 import {LocalHistoryProvider} from "./local.js";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProviderEnum, HistoryProvider, IHistoryProvider} from "./provider.js";
 
 /**
  * Persist results in CSV, one benchmark result per file
@@ -23,14 +23,15 @@ export function getGaCacheHistoryProvider(cacheKey: string): IHistoryProvider {
 }
 
 class GaCacheHistoryProvider extends LocalHistoryProvider implements IHistoryProvider {
-  readonly type = HistoryProviderType.GaCache;
+  readonly type: HistoryProvider = HistoryProviderEnum.GaCache;
   private initializePromise: Promise<unknown> | null = null;
+  private readonly tmpDir: string;
+  private readonly cacheKey: string;
 
-  constructor(
-    private readonly tmpDir: string,
-    private readonly cacheKey: string
-  ) {
+  constructor(tmpDir: string, cacheKey: string) {
     super(tmpDir);
+    this.tmpDir = tmpDir;
+    this.cacheKey = cacheKey;
   }
 
   providerInfo(): string {

src/history/local.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProviderEnum, HistoryProvider, IHistoryProvider} from "./provider.js";
 import {Benchmark, BenchmarkResults} from "../types.js";
 import {fromCsv, toCsv} from "../utils/file.js";
 import {FsError} from "../utils/index.js";
@@ -33,8 +33,12 @@ interface CsvMeta {
  * ```
  */
 export class LocalHistoryProvider implements IHistoryProvider {
-  readonly type: HistoryProviderType = HistoryProviderType.Local;
-  constructor(private readonly dirpath: string) {}
+  readonly type: HistoryProvider = HistoryProviderEnum.Local;
+  private dirpath: string;
+
+  constructor(dirpath: string) {
+    this.dirpath = dirpath;
+  }
 
   providerInfo(): string {
     return `LocalHistoryProvider, dirpath ${this.dirpath}`;

src/history/provider.ts

@@ -1,10 +1,11 @@
-import {Benchmark} from "../types.js";
+import {Benchmark, EnumLike} from "../types.js";
 
-export enum HistoryProviderType {
-  Local = "Local",
-  GaCache = "GaCache",
-  S3 = "S3",
-}
+export const HistoryProviderEnum = {
+  Local: "Local",
+  GaCache: "GaCache",
+  S3: "S3",
+} as const;
+export type HistoryProvider = EnumLike<typeof HistoryProviderEnum>;
 
 /**
  * How to organize data?
@@ -29,7 +30,7 @@ export enum HistoryProviderType {
  * In history you can ONLY track a single branch, which should be the main branch.
  */
 export interface IHistoryProvider {
-  readonly type: HistoryProviderType;
+  readonly type: HistoryProvider;
   providerInfo(): string;
   readLatestInBranch(branch: string): Promise<Benchmark | null>;
   writeLatestInBranch(branch: string, benchmark: Benchmark): Promise<void>;

src/history/s3.ts

@@ -2,7 +2,7 @@ import path from "node:path";
 import S3 from "aws-sdk/clients/s3.js";
 import {Benchmark, BenchmarkResults} from "../types.js";
 import {fromCsv, toCsv, extendError, AwsError} from "../utils/index.js";
-import {HistoryProviderType, IHistoryProvider} from "./provider.js";
+import {HistoryProvider, HistoryProviderEnum, IHistoryProvider} from "./provider.js";
 
 export type S3Config = Pick<S3.Types.ClientConfiguration, "accessKeyId" | "secretAccessKey" | "region" | "endpoint"> & {
   Bucket: string;
@@ -19,10 +19,12 @@ interface CsvMeta {
 }
 
 export class S3HistoryProvider implements IHistoryProvider {
-  readonly type = HistoryProviderType.S3;
+  readonly type: HistoryProvider = HistoryProviderEnum.S3;
   private s3: S3;
+  private config: S3Config;
 
-  constructor(private readonly config: S3Config) {
+  constructor(config: S3Config) {
+    this.config = config;
     this.s3 = new S3(config);
   }