refactor: update biome line width to 120

Evyweb · Evyweb · commit 4e15599bb68f · 2025-04-24T09:19:28.000+02:00
diff --git a/biome.json b/biome.json
@@ -14,7 +14,7 @@
     "formatWithErrors": false,
     "indentStyle": "space",
     "indentWidth": 4,
-    "lineWidth": 80
+    "lineWidth": 120
   },
   "javascript": {
     "formatter": {
diff --git a/specs/UUID/UUID.spec.ts b/specs/UUID/UUID.spec.ts
@@ -91,12 +91,8 @@ describe('UUID', () => {
 
         describe('When a UUID is created with a value', () => {
             it('should return false', () => {
-                expect(
-                    UuidFrom('123e4567-e89b-12d3-a456-426614174000').isNew()
-                ).toBe(false);
-                expect(
-                    Uuid('123e4567-e89b-12d3-a456-426614174000', false).isNew()
-                ).toBe(false);
+                expect(UuidFrom('123e4567-e89b-12d3-a456-426614174000').isNew()).toBe(false);
+                expect(Uuid('123e4567-e89b-12d3-a456-426614174000', false).isNew()).toBe(false);
             });
         });
     });
diff --git a/specs/aggregate/Aggregate.spec.ts b/specs/aggregate/Aggregate.spec.ts
@@ -28,26 +28,15 @@ describe('Aggregate', () => {
             let aggregate: FakeUserAggregate;
 
             beforeEach(() => {
-                commandBus.register(
-                    () => new LogUsernameChangedCommandHandler(logger)
-                );
-                eventBus.on(
-                    FakeUserEvents.USER_NAME_UPDATED,
-                    () => new UsernameChangedEventHandler(commandBus)
-                );
+                commandBus.register(() => new LogUsernameChangedCommandHandler(logger));
+                eventBus.on(FakeUserEvents.USER_NAME_UPDATED, () => new UsernameChangedEventHandler(commandBus));
 
                 aggregate = FakeUserAggregate.create({
                     id: UuidFrom('15e4c6b3-0b0a-4b1a-9b0a-9b0a9b0a9b0a'),
                     name: 'John Doe',
                 });
 
-                aggregate.addEvent(
-                    new UsernameUpdatedEvent(
-                        aggregate.id(),
-                        'John Doe',
-                        'Jane Doe'
-                    )
-                );
+                aggregate.addEvent(new UsernameUpdatedEvent(aggregate.id(), 'John Doe', 'Jane Doe'));
                 aggregate.addEvent(
                     new OtherEvent({
                         eventId: '266e27fe-1c3f-4be6-8646-358e830544d4',
@@ -138,13 +127,7 @@ describe('Aggregate', () => {
                     name: 'John Doe',
                 });
 
-                aggregate.addEvent(
-                    new UsernameUpdatedEvent(
-                        aggregate.id(),
-                        'John Doe',
-                        'Jane Doe'
-                    )
-                );
+                aggregate.addEvent(new UsernameUpdatedEvent(aggregate.id(), 'John Doe', 'Jane Doe'));
 
                 // Act
                 aggregate.dispatchEvents(eventBus);
diff --git a/specs/aggregate/LogUsernameChangedCommandHandler.ts b/specs/aggregate/LogUsernameChangedCommandHandler.ts
@@ -9,13 +9,7 @@ export class LogUsernameChangedCommandHandler extends CommandHandler<LogUsername
         super();
     }
 
-    async handle({
-        userId,
-        oldName,
-        newName,
-    }: LogUsernameChangedCommand): Promise<void> {
-        this.logger.log(
-            `User "${oldName}" with ID: "${userId}" has a new name: "${newName}"`
-        );
+    async handle({ userId, oldName, newName }: LogUsernameChangedCommand): Promise<void> {
+        this.logger.log(`User "${oldName}" with ID: "${userId}" has a new name: "${newName}"`);
     }
 }
diff --git a/specs/aggregate/UsernameChangedEventHandler.ts b/specs/aggregate/UsernameChangedEventHandler.ts
@@ -4,9 +4,7 @@ import type { IEventHandler } from '@/domainEvent/IEventHandler';
 import { LogUsernameChangedCommand } from './LogUsernameChangedCommand';
 import type { UsernameUpdatedEvent } from './UsernameUpdatedEvent';
 
-export class UsernameChangedEventHandler
-    implements IEventHandler<UsernameUpdatedEvent>
-{
+export class UsernameChangedEventHandler implements IEventHandler<UsernameUpdatedEvent> {
     public readonly __TAG = 'UsernameChangedEventHandler';
 
     constructor(private readonly commandBus: Bus<Command>) {}
diff --git a/specs/aggregate/UsernameUpdatedEvent.ts b/specs/aggregate/UsernameUpdatedEvent.ts
@@ -7,9 +7,7 @@ export class UsernameUpdatedEvent extends DomainEvent {
 
     constructor(userId: string, oldName: string, newName: string) {
         super({
-            eventId: UuidFrom('266e27fe-1c3f-4be6-8646-358e830544d4').get(
-                'value'
-            ),
+            eventId: UuidFrom('266e27fe-1c3f-4be6-8646-358e830544d4').get('value'),
             occurredOn: new Date(Date.UTC(2024, 0, 28, 1, 6, 59, 782)),
             payload: {
                 userId,
diff --git a/specs/bus/command/CommandHandler.spec.ts b/specs/bus/command/CommandHandler.spec.ts
@@ -24,9 +24,7 @@ describe('CommandHandler', () => {
             const commandHandler = new FakeCommandHandler(new FakeLogger());
 
             // Act
-            const result = await commandHandler.handle(
-                new FakeCommand('fakeName')
-            );
+            const result = await commandHandler.handle(new FakeCommand('fakeName'));
 
             // Assert
             expect(result).toBeUndefined();
@@ -36,14 +34,10 @@ describe('CommandHandler', () => {
     describe('When the command handler returns a value', () => {
         it('should correctly return the value', async () => {
             // Arrange
-            const commandHandler = new FakeCommandHandlerWithReturnedValue(
-                new FakeLogger()
-            );
+            const commandHandler = new FakeCommandHandlerWithReturnedValue(new FakeLogger());
 
             // Act
-            const result = await commandHandler.handle(
-                new FakeCommand('fakeName')
-            );
+            const result = await commandHandler.handle(new FakeCommand('fakeName'));
 
             // Assert
             expect(result).toBe(true);
diff --git a/specs/bus/command/FakeCommandHandlerWithReturnedValue.ts b/specs/bus/command/FakeCommandHandlerWithReturnedValue.ts
@@ -2,10 +2,7 @@ import { CommandHandler } from '@/bus/command/CommandHandler';
 import type { Logger } from '@/logger/Logger';
 import type { FakeCommand } from './FakeCommand';
 
-export class FakeCommandHandlerWithReturnedValue extends CommandHandler<
-    FakeCommand,
-    boolean
-> {
+export class FakeCommandHandlerWithReturnedValue extends CommandHandler<FakeCommand, boolean> {
     public readonly __TAG = 'FakeCommandHandlerWithReturnedValue';
 
     constructor(private readonly logger: Logger) {
diff --git a/specs/bus/commandBus/CommandBus.spec.ts b/specs/bus/commandBus/CommandBus.spec.ts
@@ -33,14 +33,10 @@ describe('[CommandBus]', () => {
                 // Arrange
                 const logger = new FakeLogger();
                 const commandBus = new Bus<Command>();
-                commandBus.register(
-                    () => new FakeUpdateNameCommandHandler(logger)
-                );
+                commandBus.register(() => new FakeUpdateNameCommandHandler(logger));
 
                 // Act
-                const result = await commandBus.execute(
-                    new FakeUpdateNameCommand('NEW NAME')
-                );
+                const result = await commandBus.execute(new FakeUpdateNameCommand('NEW NAME'));
 
                 // Assert
                 expect(result).toBeUndefined();
@@ -52,20 +48,11 @@ describe('[CommandBus]', () => {
                 // Arrange
                 const logger = new FakeLogger();
                 const commandBus = new Bus<Command>();
-                commandBus.use(
-                    new CommandLoggerMiddleware(logger, 'Middleware')
-                );
-                commandBus.register(
-                    () =>
-                        new FakeUpdateNameWithReturnedValueCommandHandler(
-                            logger
-                        )
-                );
+                commandBus.use(new CommandLoggerMiddleware(logger, 'Middleware'));
+                commandBus.register(() => new FakeUpdateNameWithReturnedValueCommandHandler(logger));
 
                 // Act
-                const result = await commandBus.execute<string>(
-                    new FakeUpdateNameWithReturnedValueCommand('NEW NAME')
-                );
+                const result = await commandBus.execute<string>(new FakeUpdateNameWithReturnedValueCommand('NEW NAME'));
 
                 // Assert
                 expect(result).toEqual<string>('NEW NAME');
@@ -78,13 +65,10 @@ describe('[CommandBus]', () => {
                 const commandBus = new Bus<Command>();
 
                 // Act
-                const registration = () =>
-                    commandBus.register(() => new FakeInvalidCommandHandler());
+                const registration = () => commandBus.register(() => new FakeInvalidCommandHandler());
 
                 // Assert
-                expect(registration).toThrowError(
-                    'The handler must have a __TAG property to be registered.'
-                );
+                expect(registration).toThrowError('The handler must have a __TAG property to be registered.');
             });
         });
     });
@@ -98,9 +82,7 @@ describe('[CommandBus]', () => {
             const errorMessage = `No handler registered for ${command.__TAG}. Please check the __TAG property of both command and handler.`;
 
             // Act & Assert
-            await expect(() => commandBus.execute(command)).rejects.toThrow(
-                errorMessage
-            );
+            await expect(() => commandBus.execute(command)).rejects.toThrow(errorMessage);
         });
     });
 
diff --git a/specs/bus/commandBus/FakeInvalidCommandHandler.ts b/specs/bus/commandBus/FakeInvalidCommandHandler.ts
@@ -10,9 +10,7 @@ export class FakeInvalidCommand extends Command {
     }
 }
 
-export class FakeInvalidCommandHandler
-    implements ICommandHandler<FakeUpdateNameCommand, string>
-{
+export class FakeInvalidCommandHandler implements ICommandHandler<FakeUpdateNameCommand, string> {
     readonly __TAG: string = '';
 
     handle(command: FakeInvalidCommand): Promise<string> {
diff --git a/specs/bus/commandBus/FakeUpdateNameWithReturnedValueCommandHandler.ts b/specs/bus/commandBus/FakeUpdateNameWithReturnedValueCommandHandler.ts
@@ -2,9 +2,7 @@ import type { ICommandHandler } from '@/bus/command/ICommandHandler';
 import type { FakeLogger } from '../../logger/FakeLogger';
 import type { FakeUpdateNameCommand } from './FakeUpdateNameCommand';
 
-export class FakeUpdateNameWithReturnedValueCommandHandler
-    implements ICommandHandler<FakeUpdateNameCommand, string>
-{
+export class FakeUpdateNameWithReturnedValueCommandHandler implements ICommandHandler<FakeUpdateNameCommand, string> {
     readonly __TAG = 'FakeUpdateNameWithReturnedValueCommandHandler';
 
     constructor(private readonly logger: FakeLogger) {}
diff --git a/specs/bus/query/FakeViewCurrentNameQueryHandler.ts b/specs/bus/query/FakeViewCurrentNameQueryHandler.ts
@@ -2,10 +2,7 @@ import { QueryHandler } from '@/bus/query/QueryHandler';
 import type { FakeResponse } from './FakeResponse';
 import type { FakeViewCurrentNameQuery } from './FakeViewCurrentNameQuery';
 
-export class FakeViewCurrentNameQueryHandler extends QueryHandler<
-    FakeViewCurrentNameQuery,
-    FakeResponse
-> {
+export class FakeViewCurrentNameQueryHandler extends QueryHandler<FakeViewCurrentNameQuery, FakeResponse> {
     public readonly __TAG = 'FakeViewCurrentNameQueryHandler';
 
     handle(query: FakeViewCurrentNameQuery): Promise<FakeResponse> {
diff --git a/specs/bus/queryBus/QueryBus.spec.ts b/specs/bus/queryBus/QueryBus.spec.ts
@@ -34,9 +34,7 @@ describe('[QueryBus]', () => {
             const query = new FakeViewCurrentNameQuery('Current name');
 
             // Act & Assert
-            await expect(queryBus.execute(query)).rejects.toThrow(
-                'No handler registered for FakeViewCurrentNameQuery'
-            );
+            await expect(queryBus.execute(query)).rejects.toThrow('No handler registered for FakeViewCurrentNameQuery');
         });
     });
 
diff --git a/specs/entity/Entity.spec.ts b/specs/entity/Entity.spec.ts
@@ -75,9 +75,7 @@ describe('Entity', () => {
             entity.set('name', 'newFakeName');
 
             // Assert
-            expect(entity.get('id').get('value')).toEqual(
-                '11111111-1111-1111-1111-111111111111'
-            );
+            expect(entity.get('id').get('value')).toEqual('11111111-1111-1111-1111-111111111111');
             expect(entity.get('name')).toEqual('newFakeName');
         });
     });
diff --git a/specs/valueObjects/ValueObject.spec.ts b/specs/valueObjects/ValueObject.spec.ts
@@ -188,9 +188,7 @@ describe('[ValueObject]', () => {
             const primitiveValue = 'fakeName1';
 
             // Act
-            const result = valueObject1.equals(
-                primitiveValue as unknown as SomeInformation
-            );
+            const result = valueObject1.equals(primitiveValue as unknown as SomeInformation);
 
             // Assert
             expect(result).toEqual(false);
diff --git a/src/aggregate/Aggregate.ts b/src/aggregate/Aggregate.ts
@@ -3,9 +3,7 @@ import { Entity } from '@/entity/Entity';
 import type { EventBusPort } from '@/eventBus/EventBusPort';
 import type { UUID } from '@/valueObject/uuid/UUID';
 
-export abstract class Aggregate<
-    EntityData extends { id: UUID },
-> extends Entity<EntityData> {
+export abstract class Aggregate<EntityData extends { id: UUID }> extends Entity<EntityData> {
     private domainEvents: DomainEvent[] = [];
 
     addEvent(domainEvent: DomainEvent): void {
diff --git a/src/bus/Bus.ts b/src/bus/Bus.ts
@@ -9,14 +9,9 @@ export class Bus<M extends Message> {
     register<R>(handlerFactory: () => IMessageHandler<M, R>): void {
         const handler = handlerFactory();
         if (!handler.__TAG) {
-            throw new Error(
-                'The handler must have a __TAG property to be registered.'
-            );
+            throw new Error('The handler must have a __TAG property to be registered.');
         }
-        this.handlers.set(
-            handler.__TAG,
-            handlerFactory as () => IMessageHandler<M>
-        );
+        this.handlers.set(handler.__TAG, handlerFactory as () => IMessageHandler<M>);
     }
 
     use(middleware: Middleware<M>): void {
@@ -39,9 +34,7 @@ export class Bus<M extends Message> {
             return handler.handle(finalMessage) as Promise<R>;
         };
 
-        const middlewareChain = this.middlewares.reduceRight<
-            (message: M) => Promise<R>
-        >(
+        const middlewareChain = this.middlewares.reduceRight<(message: M) => Promise<R>>(
             (next, middleware) => (msg) => middleware.execute(msg, next),
             executeHandler
         );
diff --git a/src/bus/command/CommandHandler.ts b/src/bus/command/CommandHandler.ts
@@ -1,9 +1,6 @@
 import type { Command } from '@/bus/command/Command';
 
-export abstract class CommandHandler<
-    TCommand extends Command,
-    TResponse = void,
-> {
+export abstract class CommandHandler<TCommand extends Command, TResponse = void> {
     public abstract readonly __TAG: string;
 
     public abstract handle(command: TCommand): Promise<TResponse>;
diff --git a/src/bus/middleware/CommandLoggerMiddleware.ts b/src/bus/middleware/CommandLoggerMiddleware.ts
@@ -8,14 +8,9 @@ export class CommandLoggerMiddleware implements Middleware<Command> {
         private readonly middlewareId: string
     ) {}
 
-    async execute<T>(
-        command: Command,
-        next: (command: Command) => Promise<T>
-    ): Promise<T> {
+    async execute<T>(command: Command, next: (command: Command) => Promise<T>): Promise<T> {
         const date = new Date().toISOString();
-        this.logger.log(
-            `[${date}][${this.middlewareId}][${command.__TAG}] - ${JSON.stringify(command)}`
-        );
+        this.logger.log(`[${date}][${this.middlewareId}][${command.__TAG}] - ${JSON.stringify(command)}`);
         return next(command);
     }
 }
diff --git a/src/bus/middleware/QueryLoggerMiddleware.ts b/src/bus/middleware/QueryLoggerMiddleware.ts
@@ -10,9 +10,7 @@ export class QueryLoggerMiddleware implements Middleware<Query> {
 
     execute<T>(query: Query, next: (query: Query) => Promise<T>): Promise<T> {
         const date = new Date().toISOString();
-        this.logger.log(
-            `[${date}][${this.middlewareId}][${query.__TAG}] - ${JSON.stringify(query)}`
-        );
+        this.logger.log(`[${date}][${this.middlewareId}][${query.__TAG}] - ${JSON.stringify(query)}`);
         return next(query);
     }
 }
diff --git a/src/eventBus/EventBus.ts b/src/eventBus/EventBus.ts
@@ -7,10 +7,7 @@ type ChainFunction = (event: DomainEvent) => Promise<void>;
 
 export class EventBus implements EventBusPort {
     private middlewares: IEventMiddleware[] = [];
-    private readonly handlers: Record<
-        string,
-        (() => IEventHandler<DomainEvent>)[]
-    > = {};
+    private readonly handlers: Record<string, (() => IEventHandler<DomainEvent>)[]> = {};
 
     use(middleware: IEventMiddleware): void {
         this.middlewares.push(middleware);
@@ -39,14 +36,11 @@ export class EventBus implements EventBusPort {
             return;
         }
 
-        const middlewareChain = this.middlewares.reduceRight<ChainFunction>(
-            (next, middleware) => {
-                return async (event: DomainEvent) => {
-                    await middleware.execute(event, next);
-                };
-            },
-            executeHandlers
-        );
+        const middlewareChain = this.middlewares.reduceRight<ChainFunction>((next, middleware) => {
+            return async (event: DomainEvent) => {
+                await middleware.execute(event, next);
+            };
+        }, executeHandlers);
 
         await middlewareChain(domainEvent);
     }
diff --git a/src/eventBus/EventLoggingMiddleware.ts b/src/eventBus/EventLoggingMiddleware.ts
diff --git a/src/eventBus/IEventMiddleware.ts b/src/eventBus/IEventMiddleware.ts
diff --git a/src/result/Result.ts b/src/result/Result.ts
diff --git a/src/valueObject/ValueObject.ts b/src/valueObject/ValueObject.ts
diff --git a/src/valueObject/uuid/UUID.ts b/src/valueObject/uuid/UUID.ts

Original file line number	Diff line number	Diff line change
`@@ -9,13 +9,7 @@ export class LogUsernameChangedCommandHandler extends CommandHandler<LogUsername`
`9`	`9`	`super();`
`10`	`10`	`}`
`11`	`11`
`12`		`- async handle({`
`13`		`- userId,`
`14`		`- oldName,`
`15`		`- newName,`
`16`		`- }: LogUsernameChangedCommand): Promise<void> {`
`17`		`- this.logger.log(`
`18`		- `User "${oldName}" with ID: "${userId}" has a new name: "${newName}"`
`19`		`- );`
	`12`	`+ async handle({ userId, oldName, newName }: LogUsernameChangedCommand): Promise<void> {`
	`13`	+ this.logger.log(`User "${oldName}" with ID: "${userId}" has a new name: "${newName}"`);
`20`	`14`	`}`
`21`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,9 +10,7 @@ export class FakeInvalidCommand extends Command {`
`10`	`10`	`}`
`11`	`11`	`}`
`12`	`12`
`13`		`-export class FakeInvalidCommandHandler`
`14`		`- implements ICommandHandler<FakeUpdateNameCommand, string>`
`15`		`-{`
	`13`	`+export class FakeInvalidCommandHandler implements ICommandHandler<FakeUpdateNameCommand, string> {`
`16`	`14`	`readonly __TAG: string = '';`
`17`	`15`
`18`	`16`	`handle(command: FakeInvalidCommand): Promise<string> {`