create-einja-app 0.1.1

package/templates/turborepo-pandacss/packages/server-core/src/infrastructure/database/mappers/UserMapper.test.ts

@@ -0,0 +1,278 @@
+import type { User as PrismaUser, UserRole as PrismaUserRole, UserStatus as PrismaUserStatus } from "@prisma/client";
+import { beforeAll, describe, expect, it } from "vitest";
+import { User } from "../../../domain/entities/User";
+import { UserFactory, initialize } from "../../../testing";
+import { UserMapper } from "./UserMapper";
+
+describe("UserMapper", () => {
+	beforeAll(() => {
+		// マッパーテストではPrismaクライアントは使用しないため、空のオブジェクトを渡す
+		// biome-ignore lint/suspicious/noExplicitAny: test fixture initialization
+		initialize({ prisma: {} as any });
+	});
+
+	describe("toDomain", () => {
+		it("PrismaUserをDomain Userに変換できる", async () => {
+			// Given
+			const prismaUser = await UserFactory.build();
+
+			// When
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			const domainUser = UserMapper.toDomain(prismaUser as any);
+
+			// Then
+			expect(domainUser).toBeInstanceOf(User);
+			expect(domainUser.id).toBe(prismaUser.id);
+			expect(domainUser.email).toBe(prismaUser.email);
+			expect(domainUser.name).toBe(prismaUser.name);
+			expect(domainUser.status).toBe(prismaUser.status);
+			expect(domainUser.role).toBe(prismaUser.role);
+			expect(domainUser.createdAt).toEqual(prismaUser.createdAt);
+			expect(domainUser.lastLogin).toEqual(prismaUser.lastLogin);
+		});
+
+		it("nameがnullでも変換できる", async () => {
+			// Given
+			const prismaUser = await UserFactory.build({ name: null });
+
+			// When
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			const domainUser = UserMapper.toDomain(prismaUser as any);
+
+			// Then
+			expect(domainUser.name).toBeNull();
+		});
+
+		it("lastLoginがnullでも変換できる", async () => {
+			// Given
+			const prismaUser = await UserFactory.build({ lastLogin: null });
+
+			// When
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			const domainUser = UserMapper.toDomain(prismaUser as any);
+
+			// Then
+			expect(domainUser.lastLogin).toBeNull();
+		});
+
+		describe("status変換", () => {
+			it("activeを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ status: "active" as PrismaUserStatus });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.status).toBe("active");
+			});
+
+			it("inactiveを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ status: "inactive" as PrismaUserStatus });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.status).toBe("inactive");
+			});
+
+			it("pendingを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ status: "pending" as PrismaUserStatus });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.status).toBe("pending");
+			});
+		});
+
+		describe("role変換", () => {
+			it("adminを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ role: "admin" as PrismaUserRole });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.role).toBe("admin");
+			});
+
+			it("userを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ role: "user" as PrismaUserRole });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.role).toBe("user");
+			});
+
+			it("moderatorを変換できる", async () => {
+				// Given
+				const prismaUser = await UserFactory.build({ role: "moderator" as PrismaUserRole });
+
+				// When
+				// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+				const domainUser = UserMapper.toDomain(prismaUser as any);
+
+				// Then
+				expect(domainUser.role).toBe("moderator");
+			});
+		});
+	});
+
+	describe("toPrismaUpdate", () => {
+		it("Domain UserをPrisma更新データに変換できる", async () => {
+			// Given
+			const props = await UserFactory.build({
+				name: "Updated Name",
+				status: "active" as PrismaUserStatus,
+				role: "admin" as PrismaUserRole,
+				lastLogin: new Date("2025-01-03T00:00:00Z"),
+			});
+			const domainUser = new User(props);
+
+			// When
+			const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+			// Then
+			expect(prismaData.name).toBe("Updated Name");
+			expect(prismaData.status).toBe("active");
+			expect(prismaData.role).toBe("admin");
+			expect(prismaData.lastLogin).toEqual(new Date("2025-01-03T00:00:00Z"));
+		});
+
+		it("nameがnullでも変換できる", async () => {
+			// Given
+			const props = await UserFactory.build({
+				name: null,
+				status: "active" as PrismaUserStatus,
+				role: "user" as PrismaUserRole,
+				lastLogin: null,
+			});
+			const domainUser = new User(props);
+
+			// When
+			const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+			// Then
+			expect(prismaData.name).toBeNull();
+		});
+
+		it("lastLoginがnullでも変換できる", async () => {
+			// Given
+			const props = await UserFactory.build({
+				name: "Test",
+				status: "pending" as PrismaUserStatus,
+				role: "user" as PrismaUserRole,
+				lastLogin: null,
+			});
+			const domainUser = new User(props);
+
+			// When
+			const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+			// Then
+			expect(prismaData.lastLogin).toBeNull();
+		});
+
+		describe("status逆変換", () => {
+			it("activeをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					status: "active" as PrismaUserStatus,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.status).toBe("active");
+			});
+
+			it("inactiveをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					status: "inactive" as PrismaUserStatus,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.status).toBe("inactive");
+			});
+
+			it("pendingをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					status: "pending" as PrismaUserStatus,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.status).toBe("pending");
+			});
+		});
+
+		describe("role逆変換", () => {
+			it("adminをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					role: "admin" as PrismaUserRole,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.role).toBe("admin");
+			});
+
+			it("userをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					role: "user" as PrismaUserRole,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.role).toBe("user");
+			});
+
+			it("moderatorをPrisma形式に変換できる", async () => {
+				// Given
+				const props = await UserFactory.build({
+					role: "moderator" as PrismaUserRole,
+				});
+				const domainUser = new User(props);
+
+				// When
+				const prismaData = UserMapper.toPrismaUpdate(domainUser);
+
+				// Then
+				expect(prismaData.role).toBe("moderator");
+			});
+		});
+	});
+});

package/templates/turborepo-pandacss/packages/server-core/src/infrastructure/database/mappers/UserMapper.ts

@@ -0,0 +1,103 @@
+/**
+ * UserMapper
+ *
+ * Prismaモデル ⇔ ドメインエンティティの変換を担当。
+ */
+
+import type { User as PrismaUser, UserRole as PrismaUserRole, UserStatus as PrismaUserStatus } from "@prisma/client";
+import { User, type UserRole, type UserStatus } from "../../../domain/entities/User";
+
+/**
+ * Prismaのステータスをドメインのステータスに変換
+ */
+function mapPrismaStatusToDomain(status: PrismaUserStatus): UserStatus {
+	switch (status) {
+		case "active":
+			return "active";
+		case "inactive":
+			return "inactive";
+		case "pending":
+			return "pending";
+	}
+}
+
+/**
+ * Prismaのロールをドメインのロールに変換
+ */
+function mapPrismaRoleToDomain(role: PrismaUserRole): UserRole {
+	switch (role) {
+		case "admin":
+			return "admin";
+		case "user":
+			return "user";
+		case "moderator":
+			return "moderator";
+	}
+}
+
+/**
+ * ドメインのステータスをPrismaのステータスに変換
+ */
+function mapDomainStatusToPrisma(status: UserStatus): PrismaUserStatus {
+	switch (status) {
+		case "active":
+			return "active";
+		case "inactive":
+			return "inactive";
+		case "pending":
+			return "pending";
+	}
+}
+
+/**
+ * ドメインのロールをPrismaのロールに変換
+ */
+function mapDomainRoleToPrisma(role: UserRole): PrismaUserRole {
+	switch (role) {
+		case "admin":
+			return "admin";
+		case "user":
+			return "user";
+		case "moderator":
+			return "moderator";
+	}
+}
+
+/**
+ * UserMapper
+ *
+ * Prisma ⇔ Domain の変換を行うマッパークラス
+ */
+export const UserMapper = {
+	/**
+	 * PrismaのUserをドメインのUserに変換
+	 */
+	toDomain(prismaUser: PrismaUser): User {
+		return new User({
+			id: prismaUser.id,
+			email: prismaUser.email,
+			name: prismaUser.name,
+			status: mapPrismaStatusToDomain(prismaUser.status),
+			role: mapPrismaRoleToDomain(prismaUser.role),
+			createdAt: prismaUser.createdAt,
+			lastLogin: prismaUser.lastLogin,
+		});
+	},
+
+	/**
+	 * ドメインのUserをPrismaの更新用データに変換
+	 */
+	toPrismaUpdate(user: User): {
+		name: string | null;
+		status: PrismaUserStatus;
+		role: PrismaUserRole;
+		lastLogin: Date | null;
+	} {
+		return {
+			name: user.name,
+			status: mapDomainStatusToPrisma(user.status),
+			role: mapDomainRoleToPrisma(user.role),
+			lastLogin: user.lastLogin,
+		};
+	},
+};

package/templates/turborepo-pandacss/packages/server-core/src/infrastructure/database/repositories/UserRepository.test.ts

@@ -0,0 +1,317 @@
+import type { User as PrismaUser, UserRole as PrismaUserRole, UserStatus as PrismaUserStatus } from "@prisma/client";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { isFailure, isSuccess } from "../../../core/result";
+import { UserFactory, initialize } from "../../../testing";
+
+// Prismaクライアントをモック
+vi.mock("../client", () => ({
+	prisma: {
+		user: {
+			findMany: vi.fn(),
+			findFirst: vi.fn(),
+			findUnique: vi.fn(),
+			count: vi.fn(),
+			update: vi.fn(),
+		},
+	},
+}));
+
+// モックしたprismaをインポート
+import { prisma } from "../client";
+import { userRepository } from "./UserRepository";
+
+describe("UserRepository", () => {
+	beforeEach(() => {
+		// リポジトリテストではモックprismaを使用するため、空のオブジェクトを渡す
+		// biome-ignore lint/suspicious/noExplicitAny: test fixture initialization
+		initialize({ prisma: {} as any });
+		vi.clearAllMocks();
+	});
+
+	describe("search", () => {
+		it("ページネーション付きでユーザー一覧を取得できる", async () => {
+			// Given
+			const mockUsers = [
+				await UserFactory.build({ id: "user-1", email: "user1@example.com" }),
+				await UserFactory.build({ id: "user-2", email: "user2@example.com" }),
+			];
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.findMany).mockResolvedValue(mockUsers as any);
+			vi.mocked(prisma.user.count).mockResolvedValue(25);
+
+			// When
+			const result = await userRepository.search({}, { page: 2, limit: 10 });
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value.items).toHaveLength(2);
+				expect(result.value.total).toBe(25);
+				expect(result.value.page).toBe(2);
+				expect(result.value.limit).toBe(10);
+				expect(result.value.totalPages).toBe(3);
+			}
+		});
+
+		it("検索条件なしで全件取得できる", async () => {
+			// Given
+			const mockUsers = [await UserFactory.build()];
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.findMany).mockResolvedValue(mockUsers as any);
+			vi.mocked(prisma.user.count).mockResolvedValue(1);
+
+			// When
+			const result = await userRepository.search({});
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value.items).toHaveLength(1);
+			}
+		});
+
+		it("statusで絞り込みできる", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockResolvedValue([]);
+			vi.mocked(prisma.user.count).mockResolvedValue(0);
+
+			// When
+			await userRepository.search({ status: "active" });
+
+			// Then
+			expect(prisma.user.findMany).toHaveBeenCalledWith(
+				expect.objectContaining({
+					where: expect.objectContaining({ status: "active" }),
+				}),
+			);
+		});
+
+		it("roleで絞り込みできる", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockResolvedValue([]);
+			vi.mocked(prisma.user.count).mockResolvedValue(0);
+
+			// When
+			await userRepository.search({ role: "admin" });
+
+			// Then
+			expect(prisma.user.findMany).toHaveBeenCalledWith(
+				expect.objectContaining({
+					where: expect.objectContaining({ role: "admin" }),
+				}),
+			);
+		});
+
+		it("検索テキストで名前・メールを絞り込みできる", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockResolvedValue([]);
+			vi.mocked(prisma.user.count).mockResolvedValue(0);
+
+			// When
+			await userRepository.search({ search: "john" });
+
+			// Then
+			expect(prisma.user.findMany).toHaveBeenCalledWith(
+				expect.objectContaining({
+					where: expect.objectContaining({
+						OR: [
+							{ name: { contains: "john", mode: "insensitive" } },
+							{ email: { contains: "john", mode: "insensitive" } },
+						],
+					}),
+				}),
+			);
+		});
+
+		it("空の検索結果でも成功を返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockResolvedValue([]);
+			vi.mocked(prisma.user.count).mockResolvedValue(0);
+
+			// When
+			const result = await userRepository.search({});
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value.items).toHaveLength(0);
+				expect(result.value.total).toBe(0);
+				expect(result.value.totalPages).toBe(0);
+			}
+		});
+
+		it("ページネーションのデフォルト値が適用される", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockResolvedValue([]);
+			vi.mocked(prisma.user.count).mockResolvedValue(0);
+
+			// When
+			const result = await userRepository.search({});
+
+			// Then
+			expect(prisma.user.findMany).toHaveBeenCalledWith(
+				expect.objectContaining({
+					skip: 0,
+					take: 10,
+				}),
+			);
+			if (isSuccess(result)) {
+				expect(result.value.page).toBe(1);
+				expect(result.value.limit).toBe(10);
+			}
+		});
+
+		it("DBエラー時にfailure Resultを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findMany).mockRejectedValue(new Error("DB connection failed"));
+
+			// When
+			const result = await userRepository.search({});
+
+			// Then
+			expect(isFailure(result)).toBe(true);
+			if (isFailure(result)) {
+				expect(result.error.message).toBe("DB connection failed");
+			}
+		});
+	});
+
+	describe("find", () => {
+		it("条件に一致するユーザーを取得できる", async () => {
+			// Given
+			const mockUser = await UserFactory.build();
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.findFirst).mockResolvedValue(mockUser as any);
+
+			// When
+			const result = await userRepository.find({ email: "test@example.com" });
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value).not.toBeNull();
+				expect(result.value?.email).toBeDefined();
+			}
+		});
+
+		it("見つからない場合はnullを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findFirst).mockResolvedValue(null);
+
+			// When
+			const result = await userRepository.find({ email: "notfound@example.com" });
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value).toBeNull();
+			}
+		});
+
+		it("DBエラー時にfailure Resultを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findFirst).mockRejectedValue(new Error("Query failed"));
+
+			// When
+			const result = await userRepository.find({ email: "test@example.com" });
+
+			// Then
+			expect(isFailure(result)).toBe(true);
+		});
+	});
+
+	describe("findById", () => {
+		it("IDでユーザーを取得できる", async () => {
+			// Given
+			const mockUser = await UserFactory.build({ id: "user-456" });
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser as any);
+
+			// When
+			const result = await userRepository.findById("user-456");
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value?.id).toBe("user-456");
+			}
+		});
+
+		it("見つからない場合はnullを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findUnique).mockResolvedValue(null);
+
+			// When
+			const result = await userRepository.findById("nonexistent");
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value).toBeNull();
+			}
+		});
+	});
+
+	describe("findByEmail", () => {
+		it("メールアドレスでユーザーを取得できる", async () => {
+			// Given
+			const mockUser = await UserFactory.build({ email: "specific@example.com" });
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.findUnique).mockResolvedValue(mockUser as any);
+
+			// When
+			const result = await userRepository.findByEmail("specific@example.com");
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value?.email).toBe("specific@example.com");
+			}
+		});
+
+		it("見つからない場合はnullを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.findUnique).mockResolvedValue(null);
+
+			// When
+			const result = await userRepository.findByEmail("notfound@example.com");
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			if (isSuccess(result)) {
+				expect(result.value).toBeNull();
+			}
+		});
+	});
+
+	describe("updateLastLogin", () => {
+		it("最終ログイン日時を更新できる", async () => {
+			// Given
+			const loginTime = new Date("2025-01-03T12:00:00Z");
+			const updatedUser = await UserFactory.build({ lastLogin: loginTime });
+			// biome-ignore lint/suspicious/noExplicitAny: test with factory-generated data
+			vi.mocked(prisma.user.update).mockResolvedValue(updatedUser as any);
+
+			// When
+			const result = await userRepository.updateLastLogin("user-123", loginTime);
+
+			// Then
+			expect(isSuccess(result)).toBe(true);
+			expect(prisma.user.update).toHaveBeenCalledWith({
+				where: { id: "user-123" },
+				data: { lastLogin: loginTime },
+			});
+		});
+
+		it("存在しないユーザーの更新でfailure Resultを返す", async () => {
+			// Given
+			vi.mocked(prisma.user.update).mockRejectedValue(new Error("Record not found"));
+
+			// When
+			const result = await userRepository.updateLastLogin("nonexistent", new Date());
+
+			// Then
+			expect(isFailure(result)).toBe(true);
+		});
+	});
+});