@hg-ts/exception 0.0.15

package/src/exceptions/error.exception.ts

@@ -0,0 +1,16 @@
+import { BaseException } from './base.exception';
+
+export class ErrorException extends BaseException {
+	public constructor(error: Error) {
+		const { cause } = error as any;
+
+		super(error.message, {
+			cause: cause instanceof Error
+				? new ErrorException(cause)
+				// eslint-disable-next-line no-undefined
+				: undefined,
+		});
+
+		(this as any).stack = error.stack;
+	}
+}

package/src/exceptions/forbidden.exception.ts

@@ -0,0 +1,3 @@
+import { BaseException } from './base.exception';
+
+export class ForbiddenException extends BaseException {}

package/src/exceptions/index.ts

@@ -0,0 +1,11 @@
+// Error exceptions must be imported before base exceptions because of cyclical imports
+export * from './error.exception';
+export * from './aggregate-error.exception';
+
+export * from './base.exception';
+export * from './base.aggregate.exception';
+
+export * from './unknown.exception';
+export * from './not-implemented.exception';
+export * from './will-never-happened.exception';
+export * from './forbidden.exception';

package/src/exceptions/not-implemented.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from './base.exception';
+
+export class NotImplementedException extends BaseException {
+	public constructor() {
+		super('Not implemented');
+	}
+}

package/src/exceptions/unknown.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from './base.exception';
+
+export class UnknownException extends BaseException {
+	public constructor(message: string) {
+		super(message);
+	}
+}

package/src/exceptions/will-never-happened.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from './base.exception';
+
+export class WillNeverHappenedException extends BaseException {
+	public constructor(message: string) {
+		super(message);
+	}
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+import '@hg-ts/types';
+export * from './exceptions';

package/src/tests/serialization.test-suite.ts

@@ -0,0 +1,121 @@
+import '@hg-ts/types';
+import {
+	Test,
+	TestSuite,
+	Describe,
+	expect,
+} from '@hg-ts/tests';
+import {
+	BaseAggregateException,
+	BaseException,
+	ErrorException,
+} from '../exceptions';
+import { TestAggregateException } from './test.aggregate-exception';
+import { TestException } from './test.exception';
+
+@Describe()
+export class SerializationTestSuite extends TestSuite {
+	@Test()
+	public async commonTest(): Promise<void> {
+		const message = 'Test message';
+		const exception = new TestException(message);
+
+		expect(exception).toBeInstanceOf(Error);
+		expect(exception).toBeInstanceOf(BaseException);
+		expect(exception).toBeInstanceOf(TestException);
+		expect(exception.message).toEqual(message);
+		expect(exception.code).toBeNull();
+		expect(exception.toJSON().name).toEqual(TestException.name);
+		expect(exception.toJSON().stack).toBeInstanceOf(Array);
+		expect(exception.toJSON().stack).not.toEqual([]);
+	}
+
+	@Test()
+	public async baseExceptionFromError(): Promise<void> {
+		const message = 'Test message';
+		const error = new Error(message);
+		const exception = BaseException.fromError(error);
+
+		expect(exception).toBeInstanceOf(Error);
+		expect(exception).toBeInstanceOf(BaseException);
+		expect(exception).toBeInstanceOf(ErrorException);
+		expect(exception.message).toEqual(message);
+		expect(exception.code).toBeNull();
+		expect(exception.toJSON().stack).toBeInstanceOf(Array);
+		expect(exception.toJSON().stack).not.toEqual([]);
+	}
+
+	@Test()
+	public async aggregateExceptionTest(): Promise<void> {
+		const message = 'Test aggregate message';
+		const exception = new TestAggregateException(message);
+
+		expect(exception).toBeInstanceOf(Error);
+		expect(exception).toBeInstanceOf(BaseException);
+		expect(exception).toBeInstanceOf(BaseAggregateException);
+		expect(exception).toBeInstanceOf(TestAggregateException);
+
+		expect(exception.message).toEqual(message);
+		expect(exception.code).toBeNull();
+
+		expect(exception.exceptions).toBeInstanceOf(Array);
+		expect(exception.exceptions).toHaveLength(3);
+	}
+
+	@Test()
+	public async syncStackTest(): Promise<void> {
+		const { stack } = new TestException('Test message').toJSON();
+
+		expect(stack[0]!.startsWith('at SerializationTestSuite.syncStackTest')).toBeTruthy();
+	}
+
+	@Test()
+	public async isFromNextTickTest(): Promise<void> {
+		return new Promise<void>(resolve => {
+			process.nextTick(() => {
+				const exception = new TestException('Test message');
+
+				expect(exception.isFromNextTick()).toBeTruthy();
+				resolve();
+			});
+		});
+	}
+
+	@Test()
+	public async isFromImmediateTest(): Promise<void> {
+		return new Promise<void>(resolve => {
+			setImmediate(() => {
+				const exception = new TestException('Test message');
+
+				expect(exception.isFromImmediate()).toBeTruthy();
+				resolve();
+			});
+		});
+	}
+
+	@Test()
+	public async fromTimeoutTest(): Promise<void> {
+		return new Promise<void>(resolve => {
+			setTimeout(() => {
+				const exception = new TestException('Test message');
+
+				expect(exception.isFromTimer()).toBeTruthy();
+				resolve();
+			}, 0);
+		});
+	}
+
+	@Test()
+	public async fromIntervalTest(): Promise<void> {
+		let interval: NodeJS.Timeout;
+		return new Promise<void>(resolve => {
+			interval = setInterval(() => {
+				const exception = new TestException('Test message');
+
+				expect(exception.isFromTimer()).toBeTruthy();
+				clearInterval(interval);
+				resolve();
+			}, 0);
+		});
+	}
+}

package/src/tests/test.aggregate-exception.ts

@@ -0,0 +1,16 @@
+import { BaseAggregateException } from '../exceptions';
+import { TestException } from './test.exception';
+
+export class TestAggregateException extends BaseAggregateException {
+	public constructor(message: string, code?: number) {
+		super(
+			[
+				new TestException('First inner exception'),
+				new TestException('Second inner exception'),
+				new TestException('Third inner exception'),
+			],
+			message,
+			{ code },
+		);
+	}
+}

package/src/tests/test.exception.ts

@@ -0,0 +1,7 @@
+import { BaseException } from '../exceptions';
+
+export class TestException extends BaseException {
+	public constructor(message: string, code?: number) {
+		super(message, { code });
+	}
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './stack-trace.formatter';

package/src/utils/stack-trace.formatter.ts

@@ -0,0 +1,30 @@
+import os from 'os';
+import { SOURCE_MAP_ENABLED } from '../consts';
+
+export class StackTraceFormatter {
+	public static format(stack: string, exceptionName: string): string[] {
+		return StackTraceFormatter.getStackLines(stack, exceptionName);
+	}
+
+	protected static getStackLines(stack: string, exceptionName: string): string[] {
+		let lines = stack.split(os.EOL)
+			.splice(1)
+			.filter(stackLine => !StackTraceFormatter.isInternalStackLine(stackLine))
+			.map(line => line.trim());
+
+		if (SOURCE_MAP_ENABLED) {
+			lines = lines.slice(4);
+		}
+		const lineFromExceptionConstructor = lines.findIndex(line => line.startsWith(`at new ${exceptionName}`));
+
+		if (lineFromExceptionConstructor > -1) {
+			return lines.slice(lineFromExceptionConstructor + 1);
+		}
+
+		return lines;
+	}
+
+	protected static isInternalStackLine(line: string): boolean {
+		return line.includes('internal/') && !line.includes('processTicksAndRejections');
+	}
+}

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+	"extends": "@hg-ts-config/typescript",
+	"compilerOptions": {
+		"baseUrl": "src",
+		"rootDir": "src",
+		"outDir": "dist-esm"
+	},
+	"exclude": ["dist", "dist-esm"]
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+	"extends": "@hg-ts-config/typescript",
+	"compilerOptions": {
+		"module": "CommonJS",
+		"baseUrl": "src",
+		"rootDir": "src",
+		"outDir": "dist"
+	},
+	"exclude": ["dist", "dist-esm"]
+}