feat: use full name

Author: adbayb

README.md

@@ -8,12 +8,13 @@
 
 ## ✨ Features
 
-A TypeScript implementation of [the Clean Architecture specified by Robert C. Martin (Uncle Bob)](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html).
+A TypeScript implementation of [the Clean Architecture specified by Robert C. Martin (Uncle Bob)](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html).  
+The Clean Architecture is an architectural pattern that enables the creation of loosely coupled and testable systems by enforcing a clear separation of concerns. This separation isolates the business rules from the details (such as frameworks and external dependencies like databases), making the system more maintainable and evolutive.
 
-The Clean Architecture is an architectural pattern (a layered architecture) that enables the creation of loosely coupled and testable systems by enforcing a clear separation of concerns. This separation isolates the business rules from the details (such as frameworks and external dependencies like databases), making the system more maintainable and evolutive.
+Following the ["decompose by subdomain" pattern](https://microservices.io/patterns/decomposition/decompose-by-subdomain.html), a **modular architecture** has also been implemented to encapsulate and group all concerns from presentation to data per bounded context[^1]. This modular monolith approach enables decision autonomy within a module boundary[^2] and the creation of [self-contained systems](https://scs-architecture.org/) centered around business capabilities[^3].
 
-Following the ["decompose by subdomain" pattern](https://microservices.io/patterns/decomposition/decompose-by-subdomain.html), a **modular architecture** has also been implemented to encapsulate and group all concerns from presentation to data per bounded context[^1]. This modular monolith approach enables decision autonomy within a module boundary[^2] and the creation of [self-contained systems](https://scs-architecture.org/) centered around business capabilities[^3].  
-Furthermore, drawing inspiration from [the Vertical Slice Architecture](https://www.jimmybogard.com/vertical-slice-architecture/) and the [package by feature not by layer pattern](https://phauer.com/2020/package-by-feature/), top-level directories within a module (excluding the `shared` folder) are centered around **business features**[^3] and, optionally, around actors for entities coupled to gateways. It allows not only to [scream the application intent](https://blog.cleancoder.com/uncle-bob/2011/09/30/Screaming-Architecture.html) allowing better discoverability from the domain point of view but also to create cohesive and loosely-coupled components.
+Furthermore, drawing inspiration from [the Vertical Slice Architecture](https://www.jimmybogard.com/vertical-slice-architecture/) and the [package by feature not by layer pattern](https://phauer.com/2020/package-by-feature/), top-level directories within a module (excluding the `shared` folder) are centered around **business features**[^3] and, optionally, around actors for entities coupled to gateways.  
+It allows not only to [scream the application intent](https://blog.cleancoder.com/uncle-bob/2011/09/30/Screaming-Architecture.html) allowing better discoverability from the domain point of view but also to create cohesive and loosely-coupled components.
 Second-level directories and the `shared` directory are organized following the clean architecture layers to enforce/materialize the dependency rule and bring clarity about each layer scope.
 
 [^1]: In this repository, a [bounded context](https://martinfowler.com/bliki/BoundedContext.html) is implemented by one module, so a bounded context is equivalent to a module here. However, it's not always the case since [a bounded context is not strictly equivalent to a module](https://stackoverflow.com/a/77923055). Indeed, while a module is a technical-oriented concept that defines logical boundaries in the code, a [bounded context](https://deviq.com/domain-driven-design/bounded-context) is a business-oriented one (domain-driven design tactical pattern) that represents a [cohesive area of the business domain](https://ddd-practitioners.com/2023/03/07/the-difference-between-domains-subdomains-and-bounded-contexts/). A module is a technical enabler to implement a bounded context, which can contain one or multiple modules.
@@ -28,15 +29,18 @@ Second-level directories and the `shared` directory are organized following the
 
 ### Overview
 
-**TODO (architecture diagram with control flow following [Clean architecture diagram (from the book)](https://i.sstatic.net/K44FQ.jpg)).**
+**TODO:**
 
-### Components
+- Functional view (main modules and features).
+- Architecture diagram with control flow following [Clean architecture diagram (from the book)](https://i.sstatic.net/K44FQ.jpg)).
 
-Used building blocks (including [DDD tactical patterns](https://vaadin.com/blog/ddd-part-2-tactical-domain-driven-design)):
+### Modules
 
-- Entities
-- Value Objects
-- ...
+**TODO: package diagram / choosen feature split (catalog, ...) with slice across the different layers.**
+
+#### A special module: the Shared Kernel.
+
+See [documentation](./modules/shared-kernel/).
 
 ### Layers
 
@@ -48,13 +52,13 @@ Used building blocks (including [DDD tactical patterns](https://vaadin.com/blog/
 - [Frameworks & Drivers](./modules/catalog/src/frameworks/): React views (and hooks), data source (including HttpDataSource to make fetch calls with error management, database client (Redis, SQL, MongoDB, ...), ...), ... TODO (include hosts (main component orchestrator)).
 - [Hosts](./hosts): Act like the configurator instance in the [Hexagonal Architecture](https://alistaircockburn.com/Hexagonal%20Budapest%2023-05-18.pdf). Under the Clean Architecture, the host layer is the outermost layer. It includes the initial entry point of the system called the main component in the Clean Architecture book (in the "Main Component" chapter). This layer is not depicted in the diagram shown above. The main component is on the driver side (for example, Web UI, CLI, Back-end server, ...) and is responsible to instantiate inner layers.
 
-### Modules
-
-**TODO: package diagram / choosen feature split (catalog, ...) with slice across the different layers.**
+### Components
 
-#### A special module: the Shared Kernel.
+Used building blocks (including [DDD tactical patterns](https://vaadin.com/blog/ddd-part-2-tactical-domain-driven-design)):
 
-See [documentation](./modules/shared-kernel/).
+- Entities
+- Value Objects
+- ...
 
 <br>
 

modules/catalog/src/Quote/adapters/QuoteEntityGateway.ts

@@ -11,16 +11,12 @@ export class QuoteEntityGateway implements QuoteEntityGatewayBoundary {
 	}
 
 	public async getOne(id: string) {
-		await Promise.resolve();
-
-		const fullName = "Test Test";
-		const [firstName, lastName] = fullName.split(" ") as [string, string];
-
-		return QuoteEntity.create({
+		const dataSourceOutput = await Promise.resolve({
 			id,
 			content: "Fake content",
-			firstName,
-			lastName,
+			fullName: "Test Test",
 		});
+
+		return QuoteEntity.create(dataSourceOutput);
 	}
 }

modules/catalog/src/Quote/entities/QuoteEntity.ts

@@ -16,11 +16,6 @@ type QuoteEntityAttributes = {
 	createdAt: CreatedAtValueObject;
 };
 
-type QuoteEntityCreateInput = GetValueFromValueObject<AuthorValueObject> &
-	Pick<QuoteEntityAttributes, "content"> & {
-		id: string;
-	};
-
 export class QuoteEntity extends Entity<QuoteEntityAttributes> {
 	private constructor(public override attributes: QuoteEntityAttributes) {
 		super(attributes);
@@ -29,14 +24,16 @@ export class QuoteEntity extends Entity<QuoteEntityAttributes> {
 	public static override create({
 		id,
 		content,
-		firstName,
-		lastName,
-	}: QuoteEntityCreateInput) {
+		fullName,
+	}: GetValueFromValueObject<AuthorValueObject> &
+		Pick<QuoteEntityAttributes, "content"> & {
+			id: string;
+		}) {
 		const guardContentResult = Guard.mustBeLessThanCharacters(content, 280);
 
 		if (guardContentResult.type === "failure") return guardContentResult;
 
-		const author = AuthorValueObject.create({ firstName, lastName });
+		const author = AuthorValueObject.create({ fullName });
 
 		if (author.type === "failure") return author;
 

modules/catalog/src/shared/entities/AuthorValueObject.ts

@@ -1,15 +1,13 @@
 import { Guard, ValueObject, success } from "@clean-architecture/shared-kernel";
 
 type Value = {
-	firstName: string;
-	lastName: string;
+	fullName: string;
 };
 
 export class AuthorValueObject extends ValueObject<Value> {
 	public static override create(input: Value) {
 		const failedGuard = Guard.against(
-			Guard.mustBeNonEmptyString(input.firstName),
-			Guard.mustBeNonEmptyString(input.lastName),
+			Guard.mustBeNonEmptyString(input.fullName),
 		);
 
 		if (failedGuard) return failedGuard;