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

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";

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,4 @@
+export * from "./book";
+export * from "./client";
+export * from "./email";
+export * from "./waitingListEntry";

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

@@ -0,0 +1,17 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as DGenerator from "@duplojs/lang/generator";
+import { WaitingListEntryRepositoryPort } from "../../business/applications/ports";
+import * as DEither from "@duplojs/lang/either";
+
+export const waitingListEntryRepository = WaitingListEntryRepositoryPort.createImplementation({
+	findNextPendingForBook: (book) => Promise.resolve(
+		DInvocation.evidenceResult("no-pending-waiting-list-entry", {
+			book,
+			waitingListEntry: null,
+		}),
+	),
+	findAllActiveByBook: DInvocation.withAdditionalResult((book) => true
+		? DGenerator.asyncLoop(({ exit }) => exit())
+		: Promise.resolve(DEither.left("waiting-list-stream-unavailable", book.id))),
+	save: (entity) => Promise.resolve(entity),
+});

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

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

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

@@ -0,0 +1,3 @@
+# Type-Driven Design
+
+Concevoir un domaine qui impose les états, les preuves et le déroulement des opérations métier, puis satisfaire ses contrats dans l'application et l'infrastructure.