@duplojs/agents-kit 0.0.0-stage → 0.1.0-beta.6

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/giveBackBook.ts

@@ -0,0 +1,35 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "..";
+import { type Book } from "../../book";
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ClientGiveBackBook = DModeling.createFact<
+	"ClientGiveBackBook",
+	Book.Entity,
+	typeof Client.Entity
+>("ClientGiveBackBook")(
+	({ applyFact }) => (
+		{
+			client,
+			book,
+		}: {
+			client: Client.Entity;
+			book: Book.Entity & Book.BorrowedFlag;
+		},
+	) => {
+		const borrowedBooks = DArray.filter(
+			client.borrowedBooks,
+			(bookId) => bookId !== book.id,
+		);
+
+		return DCommon.pipe(
+			client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(book),
+		);
+	},
+);
+export type ClientGiveBackBook = DModeling.GetFact<typeof ClientGiveBackBook>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/index.ts

@@ -0,0 +1,2 @@
+export * from "./giveBackBook";
+export * from "./rentBook";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/facts/rentBook.ts

@@ -0,0 +1,32 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "..";
+import { type Book } from "../../book";
+import * as DArray from "@duplojs/lang/array";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ClientRentBookFact = DModeling.createFact<
+	"ClientRentBookFact",
+	Client.Entity["borrowedBooks"],
+	typeof Client.Entity
+>("ClientRentBookFact")(
+	({ applyFact }) => (
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) => {
+		const borrowedBooks = DArray.push(
+			Client.CanRentBookFlag.getPayload(params.client),
+			params.book.id,
+		);
+
+		return DCommon.pipe(
+			params.client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(borrowedBooks),
+		);
+	},
+);
+export type ClientRentBookFact = DModeling.GetFact<typeof ClientRentBookFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/client/index.ts

@@ -0,0 +1,59 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DArray from "@duplojs/lang/array";
+import * as DEither from "@duplojs/lang/either";
+import { type ClientRentBookFact, type ClientGiveBackBook } from "./facts";
+import { Book } from "../book";
+
+export * from "./facts";
+
+export namespace Client {
+	const namespace = DModeling.createEntityNamespace("Client");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		borrowedBooks: DDataStructure.array(
+			Book.Id,
+			[DDataStructure.maxElements(5)],
+		),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = (
+		| ClientRentBookFact
+		| ClientGiveBackBook
+	);
+
+	export const CanRentBookFlag = DModeling.createFlag<
+		"CanRentBook",
+		readonly Book.Id[] & DArray.MaxElements<4>,
+		typeof Entity
+	>("CanRentBook");
+	export type CanRentBookFlag = DModeling.GetFlag<typeof CanRentBookFlag>;
+
+	export const NoBookRentalSlotsAvailableFlag = DModeling.createFlag<
+		"NoBookRentalSlotsAvailable",
+		undefined,
+		typeof Entity
+	>("NoBookRentalSlotsAvailable");
+	export type NoBookRentalSlotsAvailableFlag = DModeling.GetFlag<typeof NoBookRentalSlotsAvailableFlag>;
+
+	export function canRentBook<
+		GenericEntity extends Entity,
+	>(client: GenericEntity) {
+		if (DArray.maxElements(client.borrowedBooks, 4)) {
+			return DEither.result(
+				"CanRentBook",
+				CanRentBookFlag.append(client, client.borrowedBooks),
+			);
+		} else {
+			return DEither.result(
+				"NoBookRentalSlotsAvailable",
+				NoBookRentalSlotsAvailableFlag.append(client, undefined),
+			);
+		}
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/index.ts

@@ -0,0 +1,3 @@
+export * from "./book";
+export * from "./client";
+export * from "./waitingListEntry";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/cancel.ts

@@ -0,0 +1,26 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const CancelWaitingListEntryFact = DModeling.createFact<
+	"CancelWaitingListEntry",
+	WaitingListEntry.CancelledState,
+	typeof WaitingListEntry.Entity
+>("CancelWaitingListEntry")(
+	({ applyFact }) => (
+		params: {
+			waitingListEntry: WaitingListEntry.Entity & (WaitingListEntry.PendingFlag | WaitingListEntry.ReadyFlag);
+			reason: WaitingListEntry.CancelledState["reason"];
+		},
+	) => {
+		const state = WaitingListEntry.CancelledState.new({ reason: params.reason });
+
+		return DCommon.pipe(
+			params.waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.CancelledFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CancelWaitingListEntryFact = DModeling.GetFact<typeof CancelWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/create.ts

@@ -0,0 +1,33 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+import { type Book } from "../../book";
+import { type Client } from "../../client";
+
+export const CreateWaitingListEntryFact = DModeling.createFact<
+	"CreateWaitingListEntry",
+	WaitingListEntry.PendingState,
+	typeof WaitingListEntry.Entity
+>("CreateWaitingListEntry")(
+	({ applyFact }) => (params: {
+		id: WaitingListEntry.Id;
+		book: Book.Entity & (Book.AvailableFlag | Book.BorrowedFlag | Book.ReservedFlag);
+		client: Client.Entity;
+		requestedAt: WaitingListEntry.RequestedAt;
+	}) => {
+		const state = WaitingListEntry.PendingState.new({});
+
+		return DCommon.pipe(
+			WaitingListEntry.Entity.new({
+				id: params.id,
+				bookId: params.book.id,
+				clientId: params.client.id,
+				requestedAt: params.requestedAt,
+				state,
+			}),
+			WaitingListEntry.PendingFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type CreateWaitingListEntryFact = DModeling.GetFact<typeof CreateWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/index.ts

@@ -0,0 +1,3 @@
+export * from "./create";
+export * from "./prepare";
+export * from "./cancel";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/facts/prepare.ts

@@ -0,0 +1,23 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { WaitingListEntry } from "..";
+
+export const PrepareWaitingListEntryFact = DModeling.createFact<
+	"PrepareWaitingListEntry",
+	WaitingListEntry.ReadyState,
+	typeof WaitingListEntry.Entity
+>("PrepareWaitingListEntry")(
+	({ applyFact }) => (
+		waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag,
+	) => {
+		const state = WaitingListEntry.ReadyState.new({});
+
+		return DCommon.pipe(
+			waitingListEntry,
+			WaitingListEntry.Entity.update({ state }),
+			WaitingListEntry.ReadyFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type PrepareWaitingListEntryFact = DModeling.GetFact<typeof PrepareWaitingListEntryFact>;

package/docs/concepts/05-type-driven-design/fixtures/business/domains/entities/waitingListEntry/index.ts

@@ -0,0 +1,79 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import { Book } from "../book";
+import { Client } from "../client";
+import { type CreateWaitingListEntryFact, type PrepareWaitingListEntryFact, type CancelWaitingListEntryFact } from "./facts";
+
+export * from "./facts";
+
+export namespace WaitingListEntry {
+	const namespace = DModeling.createEntityNamespace("WaitingListEntry");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const RequestedAt = namespace.createNewType("RequestedAt", DDataStructure.date());
+	export type RequestedAt = DDataStructure.StructureValue<typeof RequestedAt>;
+
+	export const PendingState = DModeling.createTaggedObject("PendingWaitingListEntryState", {});
+	export type PendingState = DDataStructure.StructureValue<typeof PendingState>;
+
+	export const ReadyState = DModeling.createTaggedObject("ReadyWaitingListEntryState", {});
+	export type ReadyState = DDataStructure.StructureValue<typeof ReadyState>;
+
+	export const CancelledState = DModeling.createTaggedObject("CancelledWaitingListEntryState", {
+		reason: DDataStructure.literal(["book-withdrawn", "client-cancelled"]),
+	});
+	export type CancelledState = DDataStructure.StructureValue<typeof CancelledState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		bookId: Book.Id,
+		clientId: Client.Id,
+		requestedAt: RequestedAt,
+		state: DDataStructure.union([PendingState, ReadyState, CancelledState]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = CreateWaitingListEntryFact | PrepareWaitingListEntryFact | CancelWaitingListEntryFact;
+
+	export const PendingFlag = DModeling.createFlag<
+		"PendingWaitingListEntry",
+		PendingState,
+		typeof Entity
+	>("PendingWaitingListEntry");
+	export type PendingFlag = DModeling.GetFlag<typeof PendingFlag>;
+
+	export const ReadyFlag = DModeling.createFlag<
+		"ReadyWaitingListEntry",
+		ReadyState,
+		typeof Entity
+	>("ReadyWaitingListEntry");
+	export type ReadyFlag = DModeling.GetFlag<typeof ReadyFlag>;
+
+	export const CancelledFlag = DModeling.createFlag<
+		"CancelledWaitingListEntry",
+		CancelledState,
+		typeof Entity
+	>("CancelledWaitingListEntry");
+	export type CancelledFlag = DModeling.GetFlag<typeof CancelledFlag>;
+
+	export function refineState<GenericEntity extends Entity>(waitingListEntry: GenericEntity) {
+		return DPattern.matchWithTaggedObject(waitingListEntry.state, {
+			PendingWaitingListEntryState: (state) => DEither.result(
+				"PendingWaitingListEntry",
+				PendingFlag.append(waitingListEntry, state),
+			),
+			ReadyWaitingListEntryState: (state) => DEither.result(
+				"ReadyWaitingListEntry",
+				ReadyFlag.append(waitingListEntry, state),
+			),
+			CancelledWaitingListEntryState: (state) => DEither.result(
+				"CancelledWaitingListEntry",
+				CancelledFlag.append(waitingListEntry, state),
+			),
+		});
+	}
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/index.ts

@@ -0,0 +1,4 @@
+export * from "./aggregates";
+export * from "./entities";
+export * from "./refinements";
+export type * from "./repositories";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/index.ts

@@ -0,0 +1 @@
+export * from "./refineLinkBetweenClientAndBorrowedBook";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/refinements/refineLinkBetweenClientAndBorrowedBook.ts

@@ -0,0 +1,34 @@
+import * as DCommon from "@duplojs/lang/common";
+import * as DArray from "@duplojs/lang/array";
+import { Book, type Client } from "../entities";
+import * as DInvocation from "@duplojs/lang/invocation";
+
+export function refineLinkBetweenClientAndBorrowedBook(
+	client: Client.Entity,
+	book: Book.Entity & Book.BorrowedFlag,
+) {
+	if (
+		DArray.includes(client.borrowedBooks, book.id)
+		&& client.id === Book.BorrowedFlag.getPayload(book).currentBorrowerId
+	) {
+		return DCommon.pipe(
+			{
+				client,
+				book,
+			},
+			DInvocation.evidenceResult(
+				"client-with-borrowed-book",
+			),
+		);
+	}
+
+	return DCommon.pipe(
+		{
+			client,
+			book,
+		},
+		DInvocation.evidenceResult(
+			"client-and-book-without-link",
+		),
+	);
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/book.ts

@@ -0,0 +1,16 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Book } from "../entities";
+import type * as DEither from "@duplojs/lang/either";
+
+export interface BookRepository {
+	generateId(): Book.Id & DInvocation.Evidence<"generated">;
+	titleIsAlreadyRegistered(title: Book.Title): Promise<
+		| DInvocation.EvidenceResult<"title-already-registered", Book.Title>
+		| DInvocation.EvidenceResult<"title-not-registered", Book.Title>
+	>;
+	rankAvailability: DInvocation.SignedFunction<
+		"rankAvailability",
+		(book: Book.Entity) => Promise<void>
+	>;
+	findById(id: Book.Id): Promise<DEither.Maybe<Book.Entity>>;
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/client.ts

@@ -0,0 +1,7 @@
+import type * as DEither from "@duplojs/lang/either";
+import { type Client } from "../entities";
+
+export interface ClientRepository {
+	findById(id: Client.Id): Promise<DEither.Maybe<Client.Entity>>;
+
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/email.ts

@@ -0,0 +1,12 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Client, type Book } from "../entities";
+
+export interface EmailRepository {
+	sendRentInformationalEmail: DInvocation.SignedFunction<
+		"sendRentInformationalEmail",
+		(params: {
+			client: Client.Entity;
+			book: Book.Entity;
+		}) => Promise<void>
+	>;
+}

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/index.ts

@@ -0,0 +1,4 @@
+export type * from "./book";
+export type * from "./client";
+export type * from "./email";
+export type * from "./waitingListEntry";

package/docs/concepts/05-type-driven-design/fixtures/business/domains/repositories/waitingListEntry.ts

@@ -0,0 +1,19 @@
+import type * as DInvocation from "@duplojs/lang/invocation";
+import { type Book, type WaitingListEntry } from "../entities";
+
+export interface WaitingListEntryRepository {
+	findNextPendingForBook(book: Book.Entity & Book.AvailableFlag): Promise<
+		| DInvocation.EvidenceResult<"next-pending-waiting-list-entry", {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag;
+		}>
+		| DInvocation.EvidenceResult<"no-pending-waiting-list-entry", {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: null;
+		}>
+	>;
+	findAllActiveByBook(book: Book.Entity & Book.WithdrawnFlag): AsyncGenerator<{
+		book: Book.Entity & Book.WithdrawnFlag;
+		waitingListEntry: WaitingListEntry.Entity & (WaitingListEntry.PendingFlag | WaitingListEntry.ReadyFlag);
+	} & DInvocation.Evidence<"active-waiting-list-entry-for-withdrawn-book">>;
+}

package/docs/concepts/05-type-driven-design/fixtures/business/index.ts

@@ -0,0 +1,2 @@
+export * from "./applications";
+export * from "./domains";

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/command/clientRentBook.ts

@@ -0,0 +1,62 @@
+import * as DSCommand from "@duplojs/server/command";
+import * as DEither from "@duplojs/lang/either";
+import * as DCommon from "@duplojs/lang/common";
+import { Book, Client } from "../../business/domains";
+import { bookRepository, clientRepository } from "../ports";
+import { useCases } from "../useCases";
+
+export const clientRentBookCommand = DSCommand.create(
+	"rent-book",
+	{
+		description: "Rent a book for a client",
+		subjects: [
+			DSCommand.createArgument("clientId", Client.Id),
+			DSCommand.createArgument("bookId", Book.Id),
+		],
+	},
+	async({ args: { clientId, bookId } }) => {
+		const inputResult = await DEither.asyncGroup({
+			client: async() => DEither.rewriteInformation(
+				await DEither.rightAsyncPipe(
+					clientRepository.findById(clientId),
+					(client) => DCommon.asyncPipe(
+						Client.canRentBook(client),
+						DEither.keepAsRightByInformation("CanRentBook"),
+					),
+				),
+				{ none: "client.notfound" },
+			),
+			book: async() => DEither.rewriteInformation(
+				await DEither.rightAsyncPipe(
+					bookRepository.findById(bookId),
+					(book) => DCommon.asyncPipe(
+						Book.refineState(book),
+						DEither.keepAsRightByInformation("AvailableState"),
+					),
+				),
+				{ none: "book.notfound" },
+			),
+		});
+
+		if (
+			DEither.isSelected(inputResult, {
+				"book.notfound": true,
+				"client.notfound": true,
+				BorrowedState: true,
+				ReservedState: true,
+				WithdrawnState: true,
+				NoBookRentalSlotsAvailable: true,
+				success: false,
+			})
+		) {
+			console.error(inputResult);
+			return;
+		}
+
+		await DCommon.pipe(
+			inputResult,
+			DEither.unwrapRight,
+			useCases.clientRentBookUseCase,
+		);
+	},
+);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/command/index.ts

@@ -0,0 +1,11 @@
+import * as DSCommand from "@duplojs/server/command";
+import { clientRentBookCommand } from "./clientRentBook";
+
+await DSCommand.exec(
+	{
+		displayName: "library",
+		description: "Manage book rentals",
+		subjects: [clientRentBookCommand],
+	},
+	() => {},
+);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/checkers/bookExist.ts

@@ -0,0 +1,19 @@
+import { createPresetChecker, useCheckerBuilder } from "@duplojs/http";
+import * as DEither from "@duplojs/lang/either";
+import { type Book } from "../../../business/domains";
+import { bookRepository } from "../../ports";
+
+export const bookExist = useCheckerBuilder()
+	.handler(async(id: Book.Id, { output }) => {
+		const result = await bookRepository.findById(id);
+
+		return DEither.matchInformation(result, {
+			some: (book) => output("book.find", book),
+			none: () => output("book.notfound", null),
+		});
+	});
+
+export const iWantBookExist = createPresetChecker(bookExist, {
+	result: "book.find",
+	otherwise: ({ response }) => response.notFound("book.notfound"),
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/checkers/clientExist.ts

@@ -0,0 +1,19 @@
+import { createPresetChecker, useCheckerBuilder } from "@duplojs/http";
+import * as DEither from "@duplojs/lang/either";
+import { type Client } from "../../../business/domains";
+import { clientRepository } from "../../ports";
+
+export const clientExist = useCheckerBuilder()
+	.handler(async(id: Client.Id, { output }) => {
+		const result = await clientRepository.findById(id);
+
+		return DEither.matchInformation(result, {
+			some: (client) => output("client.find", client),
+			none: () => output("client.notfound", null),
+		});
+	});
+
+export const iWantClientExist = createPresetChecker(clientExist, {
+	result: "client.find",
+	otherwise: ({ response }) => response.notFound("client.notfound"),
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/checkers/index.ts

@@ -0,0 +1,2 @@
+export * from "./bookExist";
+export * from "./clientExist";

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/main.ts

@@ -0,0 +1,19 @@
+import { createHub } from "@duplojs/http";
+import { createHttpServer } from "@duplojs/http/node";
+import * as DSCommon from "@duplojs/server/common";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as Routes from "./routes";
+
+const envs = await DSCommon.environmentVariableOrThrow({
+	ENVIRONMENT: DDataStructure.literal(["DEV", "PROD"]),
+	HOST: DDataStructure.literal(["localhost", "127.0.0.1", "0.0.0.0", "::1", "::"]),
+	PORT: DDataStructure.number(),
+});
+
+export const hub = createHub({ environment: envs.ENVIRONMENT })
+	.register(Routes);
+
+await createHttpServer(hub, {
+	host: envs.HOST,
+	port: envs.PORT,
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/routes/clientGiveBackBook.ts

@@ -0,0 +1,46 @@
+import { useRouteBuilder } from "@duplojs/http";
+import * as DEither from "@duplojs/lang/either";
+import { Book, Client, refineLinkBetweenClientAndBorrowedBook } from "../../../business/domains";
+import { useCases } from "../../useCases";
+import { iWantBookExist, iWantClientExist } from "../checkers";
+
+export const clientGiveBackBookRoute = useRouteBuilder("POST", "/book-rentals/return")
+	.extract({
+		body: {
+			clientId: Client.Id,
+			bookId: Book.Id,
+		},
+	})
+	.presetCheck(iWantClientExist.indexing("client"), ({ clientId }) => clientId)
+	.presetCheck(iWantBookExist.indexing("book"), ({ bookId }) => bookId)
+	.cut(
+		({ book }, { response, output }) => DEither.matchInformation(
+			Book.refineState(book),
+			{
+				BorrowedState: (book) => output({ book }),
+				AvailableState: () => response.conflict("book.notBorrowed"),
+				ReservedState: () => response.conflict("book.notBorrowed"),
+				WithdrawnState: () => response.conflict("book.notBorrowed"),
+			},
+		),
+	)
+	.cut(
+		({ client, book }, { response, output }) => DEither.matchInformation(
+			refineLinkBetweenClientAndBorrowedBook(client, book),
+			{
+				"client-with-borrowed-book": (clientWithBorrowedBook) => output({ clientWithBorrowedBook }),
+				"client-and-book-without-link": () => response.conflict("client.notHaveBook"),
+			},
+		),
+	)
+	.handler(
+		async({ clientWithBorrowedBook }, { response }) => {
+			const result = await useCases.clientGiveBackBookUseCase(clientWithBorrowedBook);
+
+			return DEither.matchInformation(result, {
+				"book-returned-without-waiting-list-entry": () => response.ok("book.returned", null),
+				"book-returned-and-reserved": () => response.ok("book.returnedAndReserved", null),
+				"waiting-list-selection-unavailable": () => response.serviceUnavailable("waiting-list.selectionUnavailable"),
+			});
+		},
+	);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/routes/clientRentBook.ts

@@ -0,0 +1,45 @@
+import { useRouteBuilder } from "@duplojs/http";
+import * as DEither from "@duplojs/lang/either";
+import { Book, Client } from "../../../business/domains";
+import { useCases } from "../../useCases";
+import { iWantBookExist, iWantClientExist } from "../checkers";
+
+export const clientRentBookRoute = useRouteBuilder("POST", "/book-rentals")
+	.extract({
+		body: {
+			clientId: Client.Id,
+			bookId: Book.Id,
+		},
+	})
+	.presetCheck(iWantClientExist.indexing("client"), ({ clientId }) => clientId)
+	.presetCheck(iWantBookExist.indexing("book"), ({ bookId }) => bookId)
+	.cut(
+		({ client }, { response, output }) => DEither.matchInformation(
+			Client.canRentBook(client),
+			{
+				CanRentBook: (client) => output({ client }),
+				NoBookRentalSlotsAvailable: () => response.conflict("client.noBookRentalSlotsAvailable"),
+			},
+		),
+	)
+	.cut(
+		({ book }, { response, output }) => DEither.matchInformation(
+			Book.refineState(book),
+			{
+				AvailableState: (book) => output({ book }),
+				BorrowedState: () => response.conflict("book.unavailable"),
+				ReservedState: () => response.conflict("book.unavailable"),
+				WithdrawnState: () => response.conflict("book.unavailable"),
+			},
+		),
+	)
+	.handler(
+		async({ client, book }, { response }) => {
+			await useCases.clientRentBookUseCase({
+				client,
+				book,
+			});
+
+			return response.created("book.rented");
+		},
+	);

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/http/routes/index.ts

@@ -0,0 +1,2 @@
+export * from "./clientRentBook";
+export * from "./clientGiveBackBook";