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

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

@@ -0,0 +1,10 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { type Client, type ClientRepository } from "../../domains";
+
+export interface ClientRepositoryPort extends ClientRepository {
+	save<
+		GenericEntity extends Client.Entity & Client.Facts,
+	>(entity: GenericEntity): Promise<GenericEntity>;
+}
+
+export const ClientRepositoryPort = DInvocation.createPort<ClientRepositoryPort>();

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

@@ -0,0 +1,7 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { type EmailRepository } from "../../domains";
+
+export interface EmailRepositoryPort extends EmailRepository {
+}
+
+export const EmailRepositoryPort = DInvocation.createPort<EmailRepositoryPort>();

package/docs/concepts/05-type-driven-design/fixtures/business/applications/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/business/applications/ports/waitingListEntry.ts

@@ -0,0 +1,17 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import type * as DEither from "@duplojs/lang/either";
+import { type Book, type WaitingListEntry, type WaitingListEntryRepository } from "../../domains";
+
+export interface WaitingListEntryRepositoryPort extends DInvocation.AddAdditionalResultOnMethods<
+	WaitingListEntryRepository,
+	{
+		findNextPendingForBook: DEither.Left<"waiting-list-selection-unavailable", Book.Id>;
+		findAllActiveByBook: DEither.Left<"waiting-list-stream-unavailable", Book.Id>;
+	}
+> {
+	save<
+		GenericEntity extends WaitingListEntry.Entity & WaitingListEntry.Facts,
+	>(entity: GenericEntity): Promise<GenericEntity>;
+}
+
+export const WaitingListEntryRepositoryPort = DInvocation.createPort<WaitingListEntryRepositoryPort>();

package/docs/concepts/05-type-driven-design/fixtures/business/applications/useCases/clientGiveBackBook.ts

@@ -0,0 +1,45 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { clientGiveBackBook, type refineLinkBetweenClientAndBorrowedBook } from "../../domains";
+import { BookRepositoryPort, ClientRepositoryPort, WaitingListEntryRepositoryPort } from "../ports";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+
+export const ClientGiveBackBookUseCase = DInvocation.createReader(
+	{
+		BookRepositoryPort,
+		ClientRepositoryPort,
+		WaitingListEntryRepositoryPort,
+	},
+	({
+		bookRepository,
+		clientRepository,
+		waitingListEntryRepository,
+	}) => (
+		params: DInvocation.GetEvidenceResult<
+			typeof refineLinkBetweenClientAndBorrowedBook,
+			"client-with-borrowed-book"
+		>,
+	) => DInvocation.consumeWorkflow(
+		clientGiveBackBook(params),
+		{
+			"resolve/next-pending-waiting-list-entry": (book) => DCommon.asyncPipe(
+				waitingListEntryRepository.findNextPendingForBook(book),
+				DEither.keepAsRightByInformation(["next-pending-waiting-list-entry", "no-pending-waiting-list-entry"]),
+			),
+			"commit/book-and-client": ({ clientGivenBackBook, givenBackBook }) => DCommon.promiseObject({
+				client: clientRepository.save(clientGivenBackBook),
+				book: bookRepository.save(givenBackBook),
+			}),
+			"commit/book-client-and-waiting-list-entry": ({
+				reservedBook,
+				clientGivenBackBook,
+				readyWaitingListEntry,
+			}) => DCommon.promiseObject({
+				book: bookRepository.save(reservedBook),
+				client: clientRepository.save(clientGivenBackBook),
+				waitingListEntry: waitingListEntryRepository.save(readyWaitingListEntry),
+			}),
+			"commit/rank-availability": bookRepository.rankAvailability,
+		},
+	),
+);

package/docs/concepts/05-type-driven-design/fixtures/business/applications/useCases/clientRentBook.ts

@@ -0,0 +1,31 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { type Book, type Client, clientRentBook } from "../../domains";
+import { BookRepositoryPort, ClientRepositoryPort, EmailRepositoryPort } from "../ports";
+import * as DCommon from "@duplojs/lang/common";
+
+export const ClientRentBookUseCase = DInvocation.createReader(
+	{
+		BookRepositoryPort,
+		ClientRepositoryPort,
+		EmailRepositoryPort,
+	},
+	({
+		bookRepository,
+		clientRepository,
+		emailRepository,
+	}) => (
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) => DInvocation.consumeWorkflow(
+		clientRentBook(params),
+		{
+			"commit/book-and-client": ({ clientWithBorrowedBook, borrowedBook }) => DCommon.promiseObject({
+				client: clientRepository.save(clientWithBorrowedBook),
+				book: bookRepository.save(borrowedBook),
+			}),
+			"commit/send-informational-email": emailRepository.sendRentInformationalEmail,
+		},
+	),
+);

package/docs/concepts/05-type-driven-design/fixtures/business/applications/useCases/createBook.ts

@@ -0,0 +1,32 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { createBook, type Book } from "../../domains";
+import * as DEither from "@duplojs/lang/either";
+import { BookRepositoryPort } from "../ports";
+import * as DCommon from "@duplojs/lang/common";
+
+export const CreateBookUseCase = DInvocation.createReader(
+	{
+		BookRepositoryPort,
+	},
+	({
+		bookRepository,
+	}) => (
+		params: {
+			title: Book.Title;
+		},
+	) => DEither.rightAsyncPipe(
+		DCommon.asyncPipe(
+			bookRepository.titleIsAlreadyRegistered(params.title),
+			DEither.keepAsRightByInformation(
+				"title-not-registered",
+			),
+		),
+		(title) => DInvocation.consumeWorkflow(
+			createBook({
+				id: bookRepository.generateId(),
+				title,
+			}),
+			{ "commit/book": bookRepository.save },
+		),
+	),
+);

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

@@ -0,0 +1,4 @@
+export * from "./clientGiveBackBook";
+export * from "./clientRentBook";
+export * from "./createBook";
+export * from "./withdrawBook";

package/docs/concepts/05-type-driven-design/fixtures/business/applications/useCases/withdrawBook.ts

@@ -0,0 +1,32 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as DEither from "@duplojs/lang/either";
+import { type Book, withdrawBook } from "../../domains";
+import { BookRepositoryPort, WaitingListEntryRepositoryPort } from "../ports";
+
+export const WithdrawBookUseCase = DInvocation.createReader(
+	{
+		BookRepositoryPort,
+		WaitingListEntryRepositoryPort,
+	},
+	({
+		bookRepository,
+		waitingListEntryRepository,
+	}) => (
+		params: {
+			book: Book.Entity & (Book.AvailableFlag | Book.ReservedFlag);
+		},
+	) => DEither.rightAsyncPipe(
+		params.book,
+		(book) => DInvocation.consumeWorkflow(
+			withdrawBook(book),
+			{
+				"commit/withdrawn-book": bookRepository.save,
+				"iterate/active-waiting-list-entries-for-withdrawn-book": {
+					getIterator: waitingListEntryRepository.findAllActiveByBook,
+					concurrency: 5,
+				},
+				"commit/cancelled-waiting-list-entry": waitingListEntryRepository.save,
+			},
+		),
+	),
+);

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

@@ -0,0 +1,74 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { ClientGiveBackBook, ReturnBookFact, ReserveBookFact, PrepareWaitingListEntryFact } from "../entities";
+import * as DEither from "@duplojs/lang/either";
+import { type BookRepository, type WaitingListEntryRepository } from "../repositories";
+import * as DCommon from "@duplojs/lang/common";
+import { type refineLinkBetweenClientAndBorrowedBook } from "../refinements";
+
+export const clientGiveBackBook = DInvocation.createWorkflow(
+	({ commit, resolve }) => function *(
+		clientWithBorrowedBook: DInvocation.GetEvidenceResult<
+			typeof refineLinkBetweenClientAndBorrowedBook,
+			"client-with-borrowed-book"
+		>,
+	) {
+		const givenBackBook = DCommon.pipe(
+			clientWithBorrowedBook,
+			ReturnBookFact.run,
+			DEither.unwrapRight,
+		);
+
+		const clientGivenBackBook = DCommon.pipe(
+			clientWithBorrowedBook,
+			ClientGiveBackBook.run,
+			DEither.unwrapRight,
+		);
+
+		const selection: DInvocation.GetEvidenceResult<
+			WaitingListEntryRepository["findNextPendingForBook"],
+			"next-pending-waiting-list-entry" | "no-pending-waiting-list-entry"
+		> = yield *resolve("next-pending-waiting-list-entry", givenBackBook);
+
+		if (selection.waitingListEntry === null) {
+			yield *commit("book-and-client", {
+				givenBackBook,
+				clientGivenBackBook,
+			});
+
+			yield *commit("rank-availability", givenBackBook)
+				.withSignature<BookRepository["rankAvailability"]>();
+
+			return DEither.result("book-returned-without-waiting-list-entry", {
+				book: givenBackBook,
+				client: clientGivenBackBook,
+			});
+		}
+
+		const reservedBook = DCommon.pipe(
+			selection,
+			ReserveBookFact.run,
+			DEither.unwrapRight,
+		);
+
+		const readyWaitingListEntry = DCommon.pipe(
+			selection.waitingListEntry,
+			PrepareWaitingListEntryFact.run,
+			DEither.unwrapRight,
+		);
+
+		yield *commit("book-client-and-waiting-list-entry", {
+			reservedBook,
+			clientGivenBackBook,
+			readyWaitingListEntry,
+		});
+
+		yield *commit("rank-availability", reservedBook)
+			.withSignature<BookRepository["rankAvailability"]>();
+
+		return DEither.result("book-returned-and-reserved", {
+			book: reservedBook,
+			client: clientGivenBackBook,
+			waitingListEntry: readyWaitingListEntry,
+		});
+	},
+);

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

@@ -0,0 +1,42 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { BookRentalFact, ClientRentBookFact, type Book, type Client } from "../entities";
+import * as DEither from "@duplojs/lang/either";
+import { type EmailRepository } from "../repositories/email";
+import * as DCommon from "@duplojs/lang/common";
+
+export const clientRentBook = DInvocation.createWorkflow(
+	({ commit }) => function *(
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) {
+		const clientWithBorrowedBook = DCommon.pipe(
+			params,
+			ClientRentBookFact.run,
+			DEither.unwrapRight,
+		);
+
+		const borrowedBook = DCommon.pipe(
+			params,
+			BookRentalFact.run,
+			DEither.unwrapRight,
+		);
+
+		yield *commit("book-and-client", {
+			borrowedBook,
+			clientWithBorrowedBook,
+		});
+
+		yield *commit("send-informational-email", {
+			book: borrowedBook,
+			client: clientWithBorrowedBook,
+		})
+			.withSignature<EmailRepository["sendRentInformationalEmail"]>();
+
+		return {
+			book: borrowedBook,
+			client: clientWithBorrowedBook,
+		};
+	},
+);

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

@@ -0,0 +1,33 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import { type BookRepository } from "../repositories";
+import { CreateBookFact } from "../entities";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+
+export const createBook = DInvocation.createWorkflow(
+	({ commit }) => function *(
+		params: {
+			id: DInvocation.GetEvidenceResult<
+				BookRepository["generateId"],
+				"generated"
+			>;
+			title: DInvocation.GetEvidenceResult<
+				BookRepository["titleIsAlreadyRegistered"],
+				"title-not-registered"
+			>;
+		},
+	) {
+		const createdBook = DCommon.pipe(
+			{
+				id: params.id,
+				title: params.title,
+			},
+			CreateBookFact.run,
+			DEither.unwrapRight,
+		);
+
+		yield *commit("book", createdBook);
+
+		return createdBook;
+	},
+);

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

@@ -0,0 +1,4 @@
+export * from "./clientGiveBackBook";
+export * from "./clientRentBook";
+export * from "./createBook";
+export * from "./withdrawBook";

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

@@ -0,0 +1,37 @@
+import * as DInvocation from "@duplojs/lang/invocation";
+import * as DCommon from "@duplojs/lang/common";
+import * as DEither from "@duplojs/lang/either";
+import { type Book, WithdrawBookFact, CancelWaitingListEntryFact } from "../entities";
+import { type WaitingListEntryRepository } from "../repositories";
+
+export const withdrawBook = DInvocation.createWorkflow(
+	({ commit, iterate }) => function *(book: Book.Entity & (Book.AvailableFlag | Book.ReservedFlag)) {
+		const withdrawnBook = DCommon.pipe(
+			book,
+			WithdrawBookFact.run,
+			DEither.unwrapRight,
+		);
+
+		yield *commit("withdrawn-book", withdrawnBook);
+
+		yield *iterate("active-waiting-list-entries-for-withdrawn-book", withdrawnBook)(function *(
+			linkedWaitingListEntry: DInvocation.GetEvidenceResult<
+				WaitingListEntryRepository["findAllActiveByBook"],
+				"active-waiting-list-entry-for-withdrawn-book"
+			>,
+		) {
+			const cancelledWaitingListEntry = DCommon.pipe(
+				{
+					waitingListEntry: linkedWaitingListEntry.waitingListEntry,
+					reason: "book-withdrawn",
+				},
+				CancelWaitingListEntryFact.run,
+				DEither.unwrapRight,
+			);
+
+			yield *commit("cancelled-waiting-list-entry", cancelledWaitingListEntry);
+		});
+
+		return withdrawnBook;
+	},
+);

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

@@ -0,0 +1,33 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import { Book } from "..";
+import * as DCommon from "@duplojs/lang/common";
+
+export const CreateBookFact = DModeling.createFact<
+	"CreateBook",
+	{
+		id: Book.Id;
+		title: Book.Title;
+		state: Book.AvailableState;
+	},
+	typeof Book.Entity
+>("CreateBook")(
+	({ applyFact }) => (
+		params: {
+			id: Book.Id;
+			title: Book.Title;
+		},
+	) => {
+		const payload = {
+			id: params.id,
+			title: params.title,
+			state: Book.AvailableState.new({}),
+		};
+
+		return DCommon.pipe(
+			Book.Entity.new(payload),
+			Book.AvailableFlag.append(payload.state),
+			applyFact(payload),
+		);
+	},
+);
+export type CreateBookFact = DModeling.GetFact<typeof CreateBookFact>;

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

@@ -0,0 +1,5 @@
+export * from "./create";
+export * from "./rental";
+export * from "./returnBook";
+export * from "./reserve";
+export * from "./withdraw";

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 const BookRentalFact = DModeling.createFact<
+	"BookRental",
+	Book.BorrowedState,
+	typeof Book.Entity
+>("BookRental")(
+	({ applyFact }) => (
+		params: {
+			client: Client.Entity & Client.CanRentBookFlag;
+			book: Book.Entity & Book.AvailableFlag;
+		},
+	) => {
+		const borrowedState = Book.BorrowedState.new({
+			currentBorrowerId: params.client.id,
+		});
+
+		return DCommon.pipe(
+			params.book,
+			Book.Entity.update({
+				state: borrowedState,
+			}),
+			Book.BorrowedFlag.append(borrowedState),
+			applyFact(borrowedState),
+		);
+	},
+);
+export type BookRentalFact = DModeling.GetFact<typeof BookRentalFact>;

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

@@ -0,0 +1,37 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { Book } from "..";
+import { type Client } from "../../client";
+import { type WaitingListEntry } from "../../waitingListEntry";
+
+export const ReserveBookFact = DModeling.createFact<
+	"ReserveBook",
+	{
+		waitingListEntryId: WaitingListEntry.Id;
+		clientId: Client.Id;
+	},
+	typeof Book.Entity
+>("ReserveBook")(
+	({ applyFact }) => (
+		params: {
+			book: Book.Entity & Book.AvailableFlag;
+			waitingListEntry: WaitingListEntry.Entity & WaitingListEntry.PendingFlag;
+		},
+	) => {
+		const payload = {
+			waitingListEntryId: params.waitingListEntry.id,
+			clientId: params.waitingListEntry.clientId,
+		};
+		const state = Book.ReservedState.new({
+			waitingListEntryId: payload.waitingListEntryId,
+		});
+
+		return DCommon.pipe(
+			params.book,
+			Book.Entity.update({ state }),
+			Book.ReservedFlag.append(state),
+			applyFact(payload),
+		);
+	},
+);
+export type ReserveBookFact = DModeling.GetFact<typeof ReserveBookFact>;

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

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

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

@@ -0,0 +1,21 @@
+import * as DModeling from "@duplojs/lang/modeling";
+import * as DCommon from "@duplojs/lang/common";
+import { Book } from "..";
+
+export const WithdrawBookFact = DModeling.createFact<
+	"WithdrawBook",
+	Book.WithdrawnState,
+	typeof Book.Entity
+>("WithdrawBook")(
+	({ applyFact }) => (book: Book.Entity & (Book.AvailableFlag | Book.ReservedFlag)) => {
+		const state = Book.WithdrawnState.new({});
+
+		return DCommon.pipe(
+			book,
+			Book.Entity.update({ state }),
+			Book.WithdrawnFlag.append(state),
+			applyFact(state),
+		);
+	},
+);
+export type WithdrawBookFact = DModeling.GetFact<typeof WithdrawBookFact>;

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

@@ -0,0 +1,118 @@
+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, type ReserveBookFact, type WithdrawBookFact } from "./facts";
+import { WaitingListEntry } from "../waitingListEntry";
+
+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 ReservedState = DModeling.createTaggedObject("ReservedState", {
+		waitingListEntryId: WaitingListEntry.Id,
+	});
+	export type ReservedState = DDataStructure.StructureValue<typeof ReservedState>;
+
+	export const WithdrawnState = DModeling.createTaggedObject("WithdrawnState", {});
+	export type WithdrawnState = DDataStructure.StructureValue<typeof WithdrawnState>;
+
+	export const Entity = namespace.createEntity(() => ({
+		id: Id,
+		title: Title,
+		state: DDataStructure.union([
+			AvailableState,
+			BorrowedState,
+			ReservedState,
+			WithdrawnState,
+		]),
+	}));
+	export type Entity = DDataStructure.StructureValue<typeof Entity>;
+
+	export type Facts = (
+		| CreateBookFact
+		| BookRentalFact
+		| ReturnBookFact
+		| ReserveBookFact
+		| WithdrawBookFact
+	);
+
+	export const AvailableFlag = DModeling.createFlag<
+		"Available",
+		AvailableState,
+		typeof Entity
+	>("Available");
+	export type AvailableFlag = DModeling.GetFlag<typeof AvailableFlag>;
+
+	export const BorrowedFlag = DModeling.createFlag<
+		"Borrowed",
+		BorrowedState,
+		typeof Entity
+	>("Borrowed");
+	export type BorrowedFlag = DModeling.GetFlag<typeof BorrowedFlag>;
+
+	export const ReservedFlag = DModeling.createFlag<
+		"Reserved",
+		ReservedState,
+		typeof Entity
+	>("Reserved");
+	export type ReservedFlag = DModeling.GetFlag<typeof ReservedFlag>;
+
+	export const WithdrawnFlag = DModeling.createFlag<
+		"Withdrawn",
+		WithdrawnState,
+		typeof Entity
+	>("Withdrawn");
+	export type WithdrawnFlag = DModeling.GetFlag<typeof WithdrawnFlag>;
+
+	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),
+				),
+				ReservedState: (state) => DEither.result(
+					"ReservedState",
+					ReservedFlag.append(entity, state),
+				),
+				WithdrawnState: (state) => DEither.result(
+					"WithdrawnState",
+					WithdrawnFlag.append(entity, state),
+				),
+			},
+		);
+	}
+}