feat: use map object instead of enum; use getter for map utils with lazy init

Author: dmltdev

__tests__/get-error-code.spec.ts

@@ -1,30 +1,30 @@
-import { describe, it, expect } from "vitest";
-import { getErrorCode } from "../src/helpers";
+import { describe, expect, it } from 'vitest';
+import { getErrorCode } from '../src/helpers';
 
-describe("getErrorCode", () => {
-  it("returns the error code for valid error names", () => {
-    expect(getErrorCode("InternalError")).toBe(1);
-    expect(getErrorCode("BadValue")).toBe(2);
-    expect(getErrorCode("DuplicateKey")).toBe(11000);
-    expect(getErrorCode("Unauthorized")).toBe(13);
-    expect(getErrorCode("AuthenticationFailed")).toBe(18);
+describe('getErrorCode', () => {
+  it('returns the error code for valid error names', () => {
+    expect(getErrorCode('InternalError')).toBe(1);
+    expect(getErrorCode('BadValue')).toBe(2);
+    expect(getErrorCode('DuplicateKey')).toBe(11000);
+    expect(getErrorCode('Unauthorized')).toBe(13);
+    expect(getErrorCode('AuthenticationFailed')).toBe(18);
   });
 
-  it("returns undefined for unknown error names", () => {
-    expect(getErrorCode("NonExistentError")).toBeUndefined();
-    expect(getErrorCode("")).toBeUndefined();
-    expect(getErrorCode("invalidname")).toBeUndefined();
+  it('returns undefined for unknown error names', () => {
+    expect(getErrorCode('NonExistentError')).toBeUndefined();
+    expect(getErrorCode('')).toBeUndefined();
+    expect(getErrorCode('invalidname')).toBeUndefined();
   });
 
-  it("handles case sensitivity", () => {
-    expect(getErrorCode("internalerror")).toBeUndefined();
-    expect(getErrorCode("INTERNALERROR")).toBeUndefined();
-    expect(getErrorCode("InternalError")).toBe(1);
+  it('handles case sensitivity', () => {
+    expect(getErrorCode('internalerror')).toBeUndefined();
+    expect(getErrorCode('INTERNALERROR')).toBeUndefined();
+    expect(getErrorCode('InternalError')).toBe(1);
   });
 
-  it("returns number type for valid names", () => {
-    const result = getErrorCode("InternalError");
-    expect(typeof result).toBe("number");
+  it('returns number type for valid names', () => {
+    const result = getErrorCode('InternalError');
+    expect(typeof result).toBe('number');
     expect(result).toBe(1);
   });
 });

__tests__/get-error-description.spec.ts

@@ -1,32 +1,34 @@
-import { describe, it, expect } from "vitest";
-import { getErrorDescription } from "../src/helpers";
+import { describe, expect, it } from 'vitest';
+import { getErrorDescription } from '../src/helpers';
 
-describe("getErrorDescription", () => {
-  it("returns the description for error codes with descriptions", () => {
-    expect(getErrorDescription(1)).toBe("An unspecified internal error occurred.");
-    expect(getErrorDescription(2)).toBe("The value provided is invalid.");
-    expect(getErrorDescription(6)).toBe("The host is unreachable.");
+describe('getErrorDescription', () => {
+  it('returns the description for error codes with descriptions', () => {
+    expect(getErrorDescription(1)).toBe(
+      'An unspecified internal error occurred.',
+    );
+    expect(getErrorDescription(2)).toBe('The value provided is invalid.');
+    expect(getErrorDescription(6)).toBe('The host is unreachable.');
   });
 
-  it("returns undefined for error codes without descriptions", () => {
+  it('returns undefined for error codes without descriptions', () => {
     expect(getErrorDescription(10)).toBeUndefined();
   });
 
-  it("returns undefined for unknown error codes", () => {
+  it('returns undefined for unknown error codes', () => {
     expect(getErrorDescription(99999)).toBeUndefined();
     expect(getErrorDescription(-1)).toBeUndefined();
     expect(getErrorDescription(0)).toBeUndefined();
   });
 
-  it("handles NaN, Infinity/-Infinity", () => {
+  it('handles NaN, Infinity/-Infinity', () => {
     expect(getErrorDescription(NaN)).toBeUndefined();
     expect(getErrorDescription(Infinity)).toBeUndefined();
     expect(getErrorDescription(-Infinity)).toBeUndefined();
   });
 
-  it("returns string type for codes with descriptions", () => {
+  it('returns string type for codes with descriptions', () => {
     const result = getErrorDescription(1);
-    expect(typeof result).toBe("string");
-    expect(result).toBe("An unspecified internal error occurred.");
+    expect(typeof result).toBe('string');
+    expect(result).toBe('An unspecified internal error occurred.');
   });
 });

__tests__/get-error-details.spec.ts

@@ -1,58 +1,58 @@
-import { describe, it, expect } from "vitest";
-import { getErrorDetails } from "../src/helpers";
+import { describe, expect, it } from 'vitest';
+import { getErrorDetails } from '../src/helpers';
 
-describe("getErrorDetails", () => {
-  it("returns full error object for valid error codes", () => {
+describe('getErrorDetails', () => {
+  it('returns full error object for valid error codes', () => {
     const result = getErrorDetails(1);
     expect(result).toEqual({
       code: 1,
-      name: "InternalError",
-      description: "An unspecified internal error occurred."
+      name: 'InternalError',
+      description: 'An unspecified internal error occurred.',
     });
 
     const duplicateKeyResult = getErrorDetails(11000);
     expect(duplicateKeyResult).toEqual({
       code: 11000,
-      name: "DuplicateKey"
+      name: 'DuplicateKey',
     });
   });
 
-  it("returns full error object for valid error names", () => {
-    const result = getErrorDetails("InternalError");
+  it('returns full error object for valid error names', () => {
+    const result = getErrorDetails('InternalError');
     expect(result).toEqual({
       code: 1,
-      name: "InternalError",
-      description: "An unspecified internal error occurred."
+      name: 'InternalError',
+      description: 'An unspecified internal error occurred.',
     });
 
-    const duplicateKeyResult = getErrorDetails("DuplicateKey");
+    const duplicateKeyResult = getErrorDetails('DuplicateKey');
     expect(duplicateKeyResult).toEqual({
       code: 11000,
-      name: "DuplicateKey"
+      name: 'DuplicateKey',
     });
   });
 
-  it("returns undefined for unknown error codes", () => {
+  it('returns undefined for unknown error codes', () => {
     expect(getErrorDetails(99999)).toBeUndefined();
     expect(getErrorDetails(-1)).toBeUndefined();
     expect(getErrorDetails(0)).toBeUndefined();
   });
 
-  it("returns undefined for unknown error names", () => {
-    expect(getErrorDetails("NonExistentError")).toBeUndefined();
-    expect(getErrorDetails("")).toBeUndefined();
-    expect(getErrorDetails("invalidname")).toBeUndefined();
+  it('returns undefined for unknown error names', () => {
+    expect(getErrorDetails('NonExistentError')).toBeUndefined();
+    expect(getErrorDetails('')).toBeUndefined();
+    expect(getErrorDetails('invalidname')).toBeUndefined();
   });
 
-  it("handles NaN, Infinity/-Infinity for numeric input", () => {
+  it('handles NaN, Infinity/-Infinity for numeric input', () => {
     expect(getErrorDetails(NaN)).toBeUndefined();
     expect(getErrorDetails(Infinity)).toBeUndefined();
     expect(getErrorDetails(-Infinity)).toBeUndefined();
   });
 
-  it("handles case sensitivity for string input", () => {
-    expect(getErrorDetails("internalerror")).toBeUndefined();
-    expect(getErrorDetails("INTERNALERROR")).toBeUndefined();
-    expect(getErrorDetails("InternalError")).toBeDefined();
+  it('handles case sensitivity for string input', () => {
+    expect(getErrorDetails('internalerror')).toBeUndefined();
+    expect(getErrorDetails('INTERNALERROR')).toBeUndefined();
+    expect(getErrorDetails('InternalError')).toBeDefined();
   });
 });

__tests__/get-error-name.spec.ts

@@ -1,30 +1,30 @@
-import { describe, it, expect } from "vitest";
-import { getErrorName } from "../src/helpers";
+import { describe, expect, it } from 'vitest';
+import { getErrorName } from '../src/helpers';
 
-describe("getErrorName", () => {
-  it("returns the error name for valid error codes", () => {
-    expect(getErrorName(1)).toBe("InternalError");
-    expect(getErrorName(2)).toBe("BadValue");
-    expect(getErrorName(11000)).toBe("DuplicateKey");
-    expect(getErrorName(13)).toBe("Unauthorized");
-    expect(getErrorName(18)).toBe("AuthenticationFailed");
+describe('getErrorName', () => {
+  it('returns the error name for valid error codes', () => {
+    expect(getErrorName(1)).toBe('InternalError');
+    expect(getErrorName(2)).toBe('BadValue');
+    expect(getErrorName(11000)).toBe('DuplicateKey');
+    expect(getErrorName(13)).toBe('Unauthorized');
+    expect(getErrorName(18)).toBe('AuthenticationFailed');
   });
 
-  it("returns undefined for unknown error codes", () => {
+  it('returns undefined for unknown error codes', () => {
     expect(getErrorName(99999)).toBeUndefined();
     expect(getErrorName(-1)).toBeUndefined();
     expect(getErrorName(0)).toBeUndefined();
   });
 
-  it("returns undefined for NaN, Infinity/-Infinity", () => {
+  it('returns undefined for NaN, Infinity/-Infinity', () => {
     expect(getErrorName(NaN)).toBeUndefined();
     expect(getErrorName(Infinity)).toBeUndefined();
     expect(getErrorName(-Infinity)).toBeUndefined();
   });
 
-  it("returns string type for valid codes", () => {
+  it('returns string type for valid codes', () => {
     const result = getErrorName(1);
-    expect(typeof result).toBe("string");
-    expect(result).toBe("InternalError");
+    expect(typeof result).toBe('string');
+    expect(result).toBe('InternalError');
   });
 });

__tests__/is-known-error-code.spec.ts

@@ -1,29 +1,29 @@
-import { describe, it, expect } from "vitest";
-import { isKnownErrorCode } from "../src/helpers";
+import { describe, expect, it } from 'vitest';
+import { isKnownErrorCode } from '../src/helpers';
 
-describe("isKnownErrorCode", () => {
-  it("returns true for valid error codes", () => {
+describe('isKnownErrorCode', () => {
+  it('returns true for valid error codes', () => {
     expect(isKnownErrorCode(1)).toBe(true);
     expect(isKnownErrorCode(2)).toBe(true);
     expect(isKnownErrorCode(11000)).toBe(true);
     expect(isKnownErrorCode(13)).toBe(true);
     expect(isKnownErrorCode(18)).toBe(true);
   });
 
-  it("returns false for unknown error codes", () => {
+  it('returns false for unknown error codes', () => {
     expect(isKnownErrorCode(99999)).toBe(false);
     expect(isKnownErrorCode(-1)).toBe(false);
     expect(isKnownErrorCode(0)).toBe(false);
   });
 
-  it("handles NaN, Infinity/-Infinity", () => {
+  it('handles NaN, Infinity/-Infinity', () => {
     expect(isKnownErrorCode(NaN)).toBe(false);
     expect(isKnownErrorCode(Infinity)).toBe(false);
     expect(isKnownErrorCode(-Infinity)).toBe(false);
   });
 
-  it("returns boolean type", () => {
-    expect(typeof isKnownErrorCode(1)).toBe("boolean");
-    expect(typeof isKnownErrorCode(99999)).toBe("boolean");
+  it('returns boolean type', () => {
+    expect(typeof isKnownErrorCode(1)).toBe('boolean');
+    expect(typeof isKnownErrorCode(99999)).toBe('boolean');
   });
 });