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

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

@@ -0,0 +1,31 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { type Client } from "../../client";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export type BookRentalFact = DModeling.Fact<
+	"BookRental",
+	Book.BorrowedState
+>;
+export const BookRentalFact = DModeling.createFact<
+	BookRentalFact,
+	typeof Book.Entity
+>("BookRental")(
+	({ applyFact }) => (
+		client: Client.Entity & Client.CanRentBookFlag,
+		book: Book.Entity & Book.AvailableFlag,
+	) => {
+		const borrowedState = Book.BorrowedState.new({
+			currentBorrowerId: client.id,
+		});
+
+		return DCommon.pipe(
+			book,
+			Book.Entity.update({
+				state: borrowedState,
+			}),
+			Book.BorrowedFlag.append(borrowedState),
+			applyFact(borrowedState),
+		);
+	},
+);

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

@@ -0,0 +1,30 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "../../client";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export type ReturnBookFact = DModeling.Fact<
+	"ReturnBook",
+	Client.Id
+>;
+export const ReturnBookFact = DModeling.createFact<
+	ReturnBookFact,
+	typeof Book.Entity
+>("ReturnBook")(
+	({ applyFact }) => (
+		client: Client.Entity & Client.HaveBookFlag,
+	) => {
+		const book = Client.HaveBookFlag.getPayload(client);
+
+		const availableState = Book.AvailableState.new({});
+
+		return DCommon.pipe(
+			book,
+			Book.Entity.update({
+				state: availableState,
+			}),
+			Book.AvailableFlag.append(availableState),
+			applyFact(client.id),
+		);
+	},
+);

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

@@ -0,0 +1,87 @@
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DModeling from "@duplojs/lang/modeling";
+import { Client } from "../client";
+import * as DPattern from "@duplojs/lang/pattern";
+import * as DEither from "@duplojs/lang/either";
+import { type CreateBookFact, type BookRentalFact, type ReturnBookFact } from "./facts";
+
+export * from "./facts";
+
+export namespace Book {
+	const namespace = DModeling.createEntityNamespace("Book");
+
+	export const Id = namespace.createNewType("Id", DDataStructure.string(), [DDataStructure.uuid()]);
+	export type Id = DDataStructure.StructureValue<typeof Id>;
+
+	export const Title = namespace.createNewType("Title", DDataStructure.string(), [
+		DDataStructure.minCharacters(1),
+		DDataStructure.maxCharacters(150),
+	]);
+	export type Title = DDataStructure.StructureValue<typeof Title>;
+
+	export const AvailableState = DModeling.createTaggedObject(
+		"AvailableState",
+		{},
+	);
+	export type AvailableState = DDataStructure.StructureValue<typeof AvailableState>;
+
+	export const BorrowedState = DModeling.createTaggedObject(
+		"BorrowedState",
+		{
+			currentBorrowerId: Client.Id,
+		},
+	);
+	export type BorrowedState = DDataStructure.StructureValue<typeof BorrowedState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		title: Title,
+		state: DDataStructure.union([
+			AvailableState,
+			BorrowedState,
+		]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = (
+		| CreateBookFact
+		| BookRentalFact
+		| ReturnBookFact
+	);
+
+	export type AvailableFlag = DModeling.Flag<
+		"Available",
+		AvailableState
+	>;
+	export const AvailableFlag = DModeling.createFlag<
+		AvailableFlag,
+		typeof Entity
+	>("Available");
+
+	export type BorrowedFlag = DModeling.Flag<
+		"Borrowed",
+		BorrowedState
+	>;
+	export const BorrowedFlag = DModeling.createFlag<
+		BorrowedFlag,
+		typeof Entity
+	>("Borrowed");
+
+	export function refineState<
+		GenericEntity extends Entity,
+	>(entity: GenericEntity) {
+		return DPattern.matchWithTaggedObject(
+			entity.state,
+			{
+				AvailableState: (state) => DEither.result(
+					"AvailableState",
+					AvailableFlag.append(entity, state),
+				),
+				BorrowedState: (state) => DEither.result(
+					"BorrowedState",
+					BorrowedFlag.append(entity, state),
+				),
+			},
+		);
+	}
+}

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

@@ -0,0 +1,33 @@
+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 type ClientGiveBackBook = DModeling.Fact<
+	"ClientGiveBackBook",
+	Book.Entity
+>;
+export const ClientGiveBackBook = DModeling.createFact<
+	ClientGiveBackBook,
+	typeof Client.Entity
+>("ClientGiveBackBook")(
+	({ applyFact }) => (
+		client: Client.Entity & Client.HaveBookFlag,
+	) => {
+		const book = Client.HaveBookFlag.getPayload(client);
+
+		const borrowedBooks = DArray.filter(
+			client.borrowedBooks,
+			(bookId) => bookId === book.id,
+		);
+
+		return DCommon.pipe(
+			client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(book),
+		);
+	},
+);

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 type ClientRentBookFact = DModeling.Fact<
+	"ClientRentBookFact",
+	Client.Entity["borrowedBooks"]
+>;
+export const ClientRentBookFact = DModeling.createFact<
+	ClientRentBookFact,
+	typeof Client.Entity
+>("ClientRentBookFact")(
+	({ applyFact }) => (
+		client: Client.Entity & Client.CanRentBookFlag,
+		book: Book.Entity & Book.AvailableFlag,
+	) => {
+		const borrowedBooks = DArray.push(
+			Client.CanRentBookFlag.getPayload(client),
+			book.id,
+		);
+
+		return DCommon.pipe(
+			client,
+			Client.Entity.update({
+				borrowedBooks,
+			}),
+			applyFact(borrowedBooks),
+		);
+	},
+);

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

@@ -0,0 +1,82 @@
+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 type CanRentBookFlag = DModeling.Flag<
+		"CanRentBook",
+		readonly Book.Id[] & DArray.MaxElements<4>
+	>;
+	export const CanRentBookFlag = DModeling.createFlag<
+		CanRentBookFlag,
+		typeof Entity
+	>("CanRentBook");
+
+	export type NoBookRentalSlotsAvailableFlag = DModeling.Flag<
+		"NoBookRentalSlotsAvailable",
+		undefined
+	>;
+	export const NoBookRentalSlotsAvailableFlag = DModeling.createFlag<
+		NoBookRentalSlotsAvailableFlag,
+		typeof Entity
+	>("NoBookRentalSlotsAvailable");
+
+	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),
+			);
+		}
+	}
+
+	export type HaveBookFlag = DModeling.Flag<
+		"HaveBook",
+		Book.Entity
+	>;
+	export const HaveBookFlag = DModeling.createFlag<
+		HaveBookFlag,
+		typeof Entity
+	>("HaveBook");
+	export function clientHaveBook(client: Entity, book: Book.Entity) {
+		if (DArray.includes(client.borrowedBooks, book.id)) {
+			return DEither.right(
+				"client-have-book",
+				HaveBookFlag.append(client, book),
+			);
+		}
+
+		return DEither.left("client-not-have-book");
+	}
+}

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

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

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

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

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",
+		(params: { 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,3 @@
+export type * from "./book";
+export type * from "./client";
+export type * from "./email";

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,
+				NoBookRentalSlotsAvailable: true,
+				success: false,
+			})
+		) {
+			console.error(inputResult);
+			return;
+		}
+
+		const result = await DCommon.pipe(
+			inputResult,
+			DEither.unwrapRight,
+			useCases.clientRentBookUseCase,
+		);
+
+		console.log(JSON.stringify(result));
+	},
+);

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, ResponseContract, 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: ResponseContract.notFound("book.notfound"),
+});

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

@@ -0,0 +1,19 @@
+import { createPresetChecker, ResponseContract, 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: ResponseContract.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,37 @@
+import { ResponseContract, useRouteBuilder } from "@duplojs/http";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+import * as DEither from "@duplojs/lang/either";
+import { Book, Client } 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(
+		ResponseContract.conflict("client.notHaveBook"),
+		({ client, book }, { response, output }) => DEither.matchInformation(
+			Client.clientHaveBook(client, book),
+			{
+				"client-have-book": (clientWithFlag) => output({ client: clientWithFlag }),
+				"client-not-have-book": () => response("client.notHaveBook"),
+			},
+		),
+	)
+	.handler(
+		ResponseContract.ok("book.returned", DDataStructure.object({
+			client: Client.Entity,
+			book: Book.Entity,
+		})),
+		async({ client }, { response }) => {
+			const result = await useCases.clientGiveBackBookUseCase({ client });
+
+			return response("book.returned", DEither.unwrapRight(result));
+		},
+	);

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

@@ -0,0 +1,50 @@
+import { ResponseContract, useRouteBuilder } from "@duplojs/http";
+import * as DDataStructure from "@duplojs/lang/dataStructure";
+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(
+		ResponseContract.conflict("client.noBookRentalSlotsAvailable"),
+		({ client }, { response, output }) => DEither.matchInformation(
+			Client.canRentBook(client),
+			{
+				CanRentBook: (client) => output({ client }),
+				NoBookRentalSlotsAvailable: () => response("client.noBookRentalSlotsAvailable"),
+			},
+		),
+	)
+	.cut(
+		ResponseContract.conflict("book.unavailable"),
+		({ book }, { response, output }) => DEither.matchInformation(
+			Book.refineState(book),
+			{
+				AvailableState: (book) => output({ book }),
+				BorrowedState: () => response("book.unavailable"),
+			},
+		),
+	)
+	.handler(
+		ResponseContract.created("book.rented", DDataStructure.object({
+			client: Client.Entity,
+			book: Book.Entity,
+		})),
+		async({ client, book }, { response }) => {
+			const result = await useCases.clientRentBookUseCase({
+				client,
+				book,
+			});
+
+			return response("book.rented", DEither.unwrapRight(result));
+		},
+	);

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

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

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/book.ts

@@ -0,0 +1,25 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as DEither from "@duplojs/lang/either";
+import { BookRepositoryPort } from "../../business/applications/ports";
+import * as DCommon from "@duplojs/lang/common";
+import { Book } from "../../business";
+
+export const bookRepository = BookRepositoryPort.createImplementation({
+	findById: (id) => Promise.resolve(DEither.none()),
+	generateId: () => DCommon.pipe(
+		"SuperId",
+		Book.Id.map,
+		DEither.unwrapRightOrThrow,
+		DInvocation.appendEvidence("generated"),
+	),
+	save: (entity) => Promise.resolve(entity),
+	rankAvailability: DInvocation.signedFunction(
+		"rankAvailability",
+		async({ book }) => {
+
+		},
+	),
+	titleIsAlreadyRegistered: (title) => Promise.resolve(
+		DInvocation.evidenceResult("title-already-registered", title),
+	),
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/client.ts

@@ -0,0 +1,7 @@
+import { ClientRepositoryPort } from "../../business/applications/ports";
+import * as DEither from "@duplojs/lang/either";
+
+export const clientRepository = ClientRepositoryPort.createImplementation({
+	findById: (id) => Promise.resolve(DEither.none()),
+	save: (entity) => Promise.resolve(entity),
+});

package/docs/concepts/05-type-driven-design/fixtures/infrastructure/ports/email.ts

@@ -0,0 +1,10 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { EmailRepositoryPort } from "../../business/applications/ports";
+
+export const emailRepository = EmailRepositoryPort.createImplementation({
+	sendRentInformationalEmail: DInvocation.signedFunction(
+		"sendRentInformationalEmail",
+		async({ client, book }) => {
+		},
+	),
+});

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

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

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

@@ -0,0 +1,12 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as UseCases from "../../business/applications/useCases";
+import { bookRepository, clientRepository, emailRepository } from "../ports";
+
+export const useCases = DInvocation.resolveReaders(
+	UseCases,
+	{
+		bookRepository,
+		clientRepository,
+		emailRepository,
+	},
+);

package/docs/concepts/05-type-driven-design/index.md

@@ -0,0 +1,3 @@
+# Type Driven Design
+
+Architecture en couches, modélisation du domaine et orchestration applicative pour faire vivre les cycles de vie métier.