@aurostack/stacks 0.1.0

package/templates/nest-api/files/src/users/__tests__/current-user.service.spec.ts

@@ -0,0 +1,159 @@
+import { TestBed, type Mocked } from '@suites/unit';
+import { Entity } from '@test/factory/entity';
+import { PrismaService } from 'common/services';
+import { MediaService } from 'media/services'; // @feature media
+import { FileEntity } from 'media/entity'; // @feature media
+import { CurrentUserService } from '../services';
+import { CurrentUserEntity } from '../entity';
+
+describe('CurrentUserService', () => {
+	let service: CurrentUserService;
+	let media: Mocked<MediaService>; // @feature media
+	let db: Mocked<PrismaService>;
+
+	beforeAll(async () => {
+		const { unit, unitRef } =
+			await TestBed.solitary(CurrentUserService).compile();
+		service = unit;
+		media = unitRef.get(MediaService); // @feature media
+		db = unitRef.get(PrismaService);
+	});
+
+	// @feature:start media
+	beforeEach(() => {
+		media.uploadAvatar.mockReset();
+		media.deleteFile.mockReset();
+	});
+	// @feature:end
+
+	it('should be defined', () => {
+		expect(service).toBeDefined();
+	});
+
+	describe('completeOnboarding', () => {
+		it('stamps onboardingCompletedAt on the session user', async () => {
+			const user = Entity.requestUser.build();
+			db.user.update.mockResolvedValue(
+				Entity.user.build({ id: user.id, onboardingCompletedAt: new Date() })
+			);
+
+			await service.completeOnboarding(user);
+
+			expect(db.user.update).toHaveBeenCalledWith({
+				where: { id: user.id },
+				data: { onboardingCompletedAt: expect.any(Date) }
+			});
+		});
+
+		it('returns the updated user as a CurrentUserEntity', async () => {
+			const user = Entity.requestUser.build();
+			const at = new Date('2026-04-05T06:07:08.000Z');
+			db.user.update.mockResolvedValue(
+				Entity.user.build({ id: user.id, onboardingCompletedAt: at })
+			);
+
+			const result = await service.completeOnboarding(user);
+
+			expect(result.id).toBe(user.id);
+			expect(result.onboardingCompletedAt).toBe(at);
+			expect(CurrentUserEntity.safeParse(result).success).toBe(true);
+		});
+	});
+
+	// @feature:start media
+	describe('updateAvatar', () => {
+		const file = {
+			originalname: 'avatar.png',
+			buffer: Buffer.from('image-data'),
+			mimetype: 'image/png'
+		} as Express.Multer.File;
+
+		it('should upload the file via MediaService', async () => {
+			const user = Entity.user.build({ image: null });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+			await service.updateAvatar(
+				Entity.requestUser.build({ id: user.id }),
+				file
+			);
+			expect(media.uploadAvatar).toHaveBeenCalledWith(file);
+		});
+
+		it('should update the user record with the new image URL', async () => {
+			const user = Entity.user.build({ image: null });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+
+			await service.updateAvatar(
+				Entity.requestUser.build({ id: user.id }),
+				file
+			);
+
+			expect(db.user.update).toHaveBeenCalledWith({
+				where: { id: user.id },
+				data: { image: newImageUrl }
+			});
+		});
+
+		it('should return a FileEntity with the new image path', async () => {
+			const user = Entity.user.build({ image: null });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+
+			const result = await service.updateAvatar(
+				Entity.requestUser.build(),
+				file
+			);
+
+			expect(FileEntity.safeParse(result).success).toBe(true);
+			expect(result.path).toBe(newImageUrl);
+		});
+
+		it('should delete the old avatar when user already has an image', async () => {
+			const oldImageUrl = 'http://s3.example.com/avatars/old.png';
+			const user = Entity.user.build({ image: oldImageUrl });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+
+			await service.updateAvatar(
+				Entity.requestUser.build({ id: user.id, image: oldImageUrl }),
+				file
+			);
+
+			expect(media.deleteFile).toHaveBeenCalledWith(oldImageUrl);
+		});
+
+		it('should NOT delete old avatar when user has no existing image', async () => {
+			const user = Entity.user.build({ image: null });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+
+			await service.updateAvatar(
+				Entity.requestUser.build({ id: user.id, image: null }),
+				file
+			);
+
+			expect(media.deleteFile).not.toHaveBeenCalled();
+		});
+
+		it('should NOT delete old avatar when user image is empty string', async () => {
+			const user = Entity.user.build({ image: '' });
+			const newImageUrl = 'http://s3.example.com/avatars/new.png';
+			media.uploadAvatar.mockResolvedValue(newImageUrl);
+			db.user.update.mockResolvedValue(user);
+
+			await service.updateAvatar(
+				Entity.requestUser.build({ id: user.id, image: '' }),
+				file
+			);
+
+			expect(media.deleteFile).not.toHaveBeenCalled();
+		});
+	});
+	// @feature:end
+});

package/templates/nest-api/files/src/users/__tests__/user.entity.spec.ts

@@ -0,0 +1,175 @@
+import { Entity } from '@test/factory/entity';
+import {
+	UserEntity,
+	PaginatedUserEntity,
+	CurrentUserEntity,
+	toCurrentUser
+} from '../entity';
+
+// `.parse()` runs a schema in the direction the serializer does: what a service
+// returns (Dates and all) in, the JSON response body out.
+
+describe('UserEntity', () => {
+	it('serializes every User field, dates as ISO strings', () => {
+		const data = Entity.user.build();
+		const body = UserEntity.parse(data);
+
+		expect(body).toEqual({
+			...data,
+			// Emails go out lower-cased, as EmailProperty did.
+			email: data.email.toLowerCase(),
+			createdAt: data.createdAt.toISOString(),
+			updatedAt: data.updatedAt.toISOString(),
+			banExpires: null,
+			onboardingCompletedAt: null
+		});
+	});
+
+	it('serializes a set ban expiry as an ISO string', () => {
+		const banExpires = new Date('2026-05-01T12:00:00.000Z');
+		const body = UserEntity.parse(Entity.user.build({ banExpires }));
+
+		expect(body.banExpires).toBe('2026-05-01T12:00:00.000Z');
+	});
+
+	it('keeps null image and ban fields', () => {
+		const body = UserEntity.parse(
+			Entity.user.build({
+				image: null,
+				banned: null,
+				banReason: null,
+				banExpires: null
+			})
+		);
+
+		expect(body.image).toBeNull();
+		expect(body.banned).toBeNull();
+		expect(body.banReason).toBeNull();
+		expect(body.banExpires).toBeNull();
+	});
+
+	it('drops fields the schema does not declare', () => {
+		const body = UserEntity.parse({
+			...Entity.user.build(),
+			passwordHash: 'secret'
+		});
+
+		expect(body).not.toHaveProperty('passwordHash');
+	});
+
+	it('rejects a row that does not match, rather than sending it', () => {
+		const result = UserEntity.safeParse({
+			...Entity.user.build(),
+			createdAt: 'not a date'
+		});
+
+		expect(result.success).toBe(false);
+	});
+});
+
+describe('PaginatedUserEntity', () => {
+	it('carries the pagination meta and serializes each item', () => {
+		const users = Entity.user.buildList(3);
+		const body = PaginatedUserEntity.parse({
+			list: users,
+			total: 10,
+			currentPage: 2,
+			lastPage: 4,
+			pageSize: 3
+		});
+
+		expect(body).toMatchObject({
+			total: 10,
+			currentPage: 2,
+			lastPage: 4,
+			pageSize: 3
+		});
+		expect(body.list).toHaveLength(3);
+		body.list.forEach((item, i) => {
+			expect(item.id).toBe(users[i].id);
+			expect(item.createdAt).toBe(users[i].createdAt.toISOString());
+		});
+	});
+
+	it('handles an empty page', () => {
+		const body = PaginatedUserEntity.parse({
+			list: [],
+			total: 0,
+			currentPage: 1,
+			lastPage: 1,
+			pageSize: 0
+		});
+
+		expect(body.list).toHaveLength(0);
+		expect(body.total).toBe(0);
+	});
+});
+
+describe('toCurrentUser', () => {
+	it('maps the session user fields', () => {
+		const sessionUser = Entity.requestUser.build({
+			emailVerified: true,
+			role: 'admin'
+		});
+		const user = toCurrentUser(sessionUser);
+
+		expect(user).toMatchObject({
+			id: sessionUser.id,
+			name: sessionUser.name,
+			email: sessionUser.email,
+			emailVerified: true,
+			image: sessionUser.image,
+			createdAt: sessionUser.createdAt,
+			updatedAt: sessionUser.updatedAt,
+			onboardingCompletedAt: null
+		});
+	});
+
+	it('sets image to null when the session user has none', () => {
+		expect(
+			toCurrentUser(Entity.requestUser.build({ image: '' })).image
+		).toBeNull();
+		expect(
+			toCurrentUser(Entity.requestUser.build({ image: undefined })).image
+		).toBeNull();
+	});
+
+	it('uses a string role as is', () => {
+		expect(
+			toCurrentUser(Entity.requestUser.build({ role: 'admin' })).role
+		).toBe('admin');
+	});
+
+	it('takes the first role when better-auth returns several', () => {
+		const sessionUser = Entity.requestUser.build({
+			role: ['superuser', 'admin'] as unknown as string
+		});
+		expect(toCurrentUser(sessionUser).role).toBe('superuser');
+	});
+
+	it('sets role to null when there is none', () => {
+		expect(
+			toCurrentUser(Entity.requestUser.build({ role: undefined })).role
+		).toBeNull();
+	});
+
+	it('carries onboardingCompletedAt when the session has it', () => {
+		const at = new Date('2026-02-03T04:05:06.000Z');
+		const sessionUser = {
+			...Entity.requestUser.build(),
+			onboardingCompletedAt: at
+		};
+		expect(toCurrentUser(sessionUser).onboardingCompletedAt).toBe(at);
+	});
+
+	it('serializes through CurrentUserEntity without the ban fields', () => {
+		const body = CurrentUserEntity.parse(
+			toCurrentUser(Entity.requestUser.build())
+		);
+
+		expect(body).not.toHaveProperty('banned');
+		expect(body).not.toHaveProperty('banReason');
+		expect(body).not.toHaveProperty('banExpires');
+		expect(typeof body.createdAt).toBe('string');
+	});
+});

package/templates/nest-api/files/src/users/__tests__/users.controller.spec.ts

@@ -0,0 +1,89 @@
+import { TestBed, type Mocked } from '@suites/unit';
+import { Entity } from '@test/factory/entity';
+import { Gen } from '@test/factory/gen';
+import { UsersController } from '../controllers';
+import { UsersService } from '../services';
+import type { PaginatedUserEntity } from '../entity';
+
+describe('UsersController', () => {
+	let controller: UsersController;
+	let service: Mocked<UsersService>;
+
+	beforeAll(async () => {
+		const { unit, unitRef } = await TestBed.solitary(UsersController).compile();
+		controller = unit;
+		service = unitRef.get(UsersService);
+	});
+
+	it('should be defined', () => {
+		expect(controller).toBeDefined();
+	});
+
+	describe('findAll', () => {
+		it('should delegate to UsersService.paginate with user and filters', async () => {
+			const user = Entity.user.build({ role: 'admin' });
+			const filters = { page: 1, limit: 10 };
+			const paginated: PaginatedUserEntity = {
+				list: Entity.user.buildList(2),
+				total: 2,
+				currentPage: 1,
+				lastPage: 1,
+				pageSize: 2
+			};
+			service.paginate.mockResolvedValue(paginated);
+
+			const result = await controller.findAll(filters, { user } as any);
+
+			expect(service.paginate).toHaveBeenCalledWith(user, filters);
+			expect(result).toBe(paginated);
+		});
+
+		it('should pass search and role filters through', async () => {
+			const user = Entity.user.build({ role: 'admin' });
+			const filters = { search: 'john', role: 'user', page: 2, limit: 5 };
+			const paginated: PaginatedUserEntity = {
+				list: [],
+				total: 0,
+				currentPage: 2,
+				lastPage: 0,
+				pageSize: 0
+			};
+			service.paginate.mockResolvedValue(paginated);
+
+			await controller.findAll(filters, { user } as any);
+
+			expect(service.paginate).toHaveBeenCalledWith(user, filters);
+		});
+	});
+
+	describe('findOne', () => {
+		// Passes the whole session user, not just its id — visibility depends on
+		// the viewer's role (see UsersService.getUserById).
+		it('should delegate to UsersService.getUserById with the session user and target id', async () => {
+			const currentUserId = Gen.uuid();
+			const targetId = Gen.uuid();
+			const user = Entity.user.build({ id: currentUserId, role: 'admin' });
+			const target = Entity.user.build({ id: targetId, role: 'user' });
+			service.getUserById.mockResolvedValue(target);
+
+			const result = await controller.findOne(targetId, {
+				user
+			} as any);
+
+			expect(service.getUserById).toHaveBeenCalledWith(user, targetId);
+			expect(result).toBe(target);
+		});
+
+		it('should propagate NotFoundException from service', async () => {
+			const currentUserId = Gen.uuid();
+			const user = Entity.user.build({ id: currentUserId, role: 'admin' });
+			service.getUserById.mockRejectedValue(
+				new (await import('@nestjs/common')).NotFoundException()
+			);
+
+			await expect(
+				controller.findOne(Gen.uuid(), { user } as any)
+			).rejects.toThrow('Not Found');
+		});
+	});
+});