refactor(core): Port 3 more controllers to use DTOs (no-changelog)

packages/@n8n/api-types/src/dto/auth/__tests__/login-request.dto.test.ts

@@ -0,0 +1,93 @@
+import { LoginRequestDto } from '../login-request.dto';
+
+describe('LoginRequestDto', () => {
+	describe('Valid requests', () => {
+		test.each([
+			{
+				name: 'complete valid login request',
+				request: {
+					email: 'test@example.com',
+					password: 'securePassword123',
+					mfaCode: '123456',
+				},
+			},
+			{
+				name: 'login request without optional MFA',
+				request: {
+					email: 'test@example.com',
+					password: 'securePassword123',
+				},
+			},
+			{
+				name: 'login request with both mfaCode and mfaRecoveryCode',
+				request: {
+					email: 'test@example.com',
+					password: 'securePassword123',
+					mfaCode: '123456',
+					mfaRecoveryCode: 'recovery-code-123',
+				},
+			},
+			{
+				name: 'login request with only mfaRecoveryCode',
+				request: {
+					email: 'test@example.com',
+					password: 'securePassword123',
+					mfaRecoveryCode: 'recovery-code-123',
+				},
+			},
+		])('should validate $name', ({ request }) => {
+			const result = LoginRequestDto.safeParse(request);
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe('Invalid requests', () => {
+		test.each([
+			{
+				name: 'invalid email',
+				request: {
+					email: 'invalid-email',
+					password: 'securePassword123',
+				},
+				expectedErrorPath: ['email'],
+			},
+			{
+				name: 'empty password',
+				request: {
+					email: 'test@example.com',
+					password: '',
+				},
+				expectedErrorPath: ['password'],
+			},
+			{
+				name: 'missing email',
+				request: {
+					password: 'securePassword123',
+				},
+				expectedErrorPath: ['email'],
+			},
+			{
+				name: 'missing password',
+				request: {
+					email: 'test@example.com',
+				},
+				expectedErrorPath: ['password'],
+			},
+			{
+				name: 'whitespace in email and password',
+				request: {
+					email: '  test@example.com  ',
+					password: '  securePassword123  ',
+				},
+				expectedErrorPath: ['email'],
+			},
+		])('should fail validation for $name', ({ request, expectedErrorPath }) => {
+			const result = LoginRequestDto.safeParse(request);
+			expect(result.success).toBe(false);
+
+			if (expectedErrorPath) {
+				expect(result.error?.issues[0].path).toEqual(expectedErrorPath);
+			}
+		});
+	});
+});

packages/@n8n/api-types/src/dto/auth/__tests__/resolve-signup-token-query.dto.test.ts

@@ -0,0 +1,87 @@
+import { ResolveSignupTokenQueryDto } from '../resolve-signup-token-query.dto';
+
+describe('ResolveSignupTokenQueryDto', () => {
+	const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+
+	describe('Valid requests', () => {
+		test.each([
+			{
+				name: 'standard UUID',
+				request: {
+					inviterId: validUuid,
+					inviteeId: validUuid,
+				},
+			},
+		])('should validate $name', ({ request }) => {
+			const result = ResolveSignupTokenQueryDto.safeParse(request);
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe('Invalid requests', () => {
+		test.each([
+			{
+				name: 'invalid inviterId UUID',
+				request: {
+					inviterId: 'not-a-valid-uuid',
+					inviteeId: validUuid,
+				},
+				expectedErrorPath: ['inviterId'],
+			},
+			{
+				name: 'invalid inviteeId UUID',
+				request: {
+					inviterId: validUuid,
+					inviteeId: 'not-a-valid-uuid',
+				},
+				expectedErrorPath: ['inviteeId'],
+			},
+			{
+				name: 'missing inviterId',
+				request: {
+					inviteeId: validUuid,
+				},
+				expectedErrorPath: ['inviterId'],
+			},
+			{
+				name: 'missing inviteeId',
+				request: {
+					inviterId: validUuid,
+				},
+				expectedErrorPath: ['inviteeId'],
+			},
+			{
+				name: 'UUID with invalid characters',
+				request: {
+					inviterId: '123e4567-e89b-12d3-a456-42661417400G',
+					inviteeId: validUuid,
+				},
+				expectedErrorPath: ['inviterId'],
+			},
+			{
+				name: 'UUID too long',
+				request: {
+					inviterId: '123e4567-e89b-12d3-a456-426614174001234',
+					inviteeId: validUuid,
+				},
+				expectedErrorPath: ['inviterId'],
+			},
+			{
+				name: 'UUID too short',
+				request: {
+					inviterId: '123e4567-e89b-12d3-a456',
+					inviteeId: validUuid,
+				},
+				expectedErrorPath: ['inviterId'],
+			},
+		])('should fail validation for $name', ({ request, expectedErrorPath }) => {
+			const result = ResolveSignupTokenQueryDto.safeParse(request);
+
+			expect(result.success).toBe(false);
+
+			if (expectedErrorPath) {
+				expect(result.error?.issues[0].path).toEqual(expectedErrorPath);
+			}
+		});
+	});
+});

packages/@n8n/api-types/src/dto/auth/login-request.dto.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { Z } from 'zod-class';
+
+export class LoginRequestDto extends Z.class({
+	email: z.string().email(),
+	password: z.string().min(1),
+	mfaCode: z.string().optional(),
+	mfaRecoveryCode: z.string().optional(),
+}) {}

packages/@n8n/api-types/src/dto/auth/resolve-signup-token-query.dto.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+import { Z } from 'zod-class';
+
+export class ResolveSignupTokenQueryDto extends Z.class({
+	inviterId: z.string().uuid(),
+	inviteeId: z.string().uuid(),
+}) {}

packages/@n8n/api-types/src/dto/index.ts

@@ -1,9 +1,22 @@
 export { AiAskRequestDto } from './ai/ai-ask-request.dto';
 export { AiChatRequestDto } from './ai/ai-chat-request.dto';
 export { AiApplySuggestionRequestDto } from './ai/ai-apply-suggestion-request.dto';
+
+export { LoginRequestDto } from './auth/login-request.dto';
+export { ResolveSignupTokenQueryDto } from './auth/resolve-signup-token-query.dto';
+
+export { OwnerSetupRequestDto } from './owner/owner-setup-request.dto';
+export { DismissBannerRequestDto } from './owner/dismiss-banner-request.dto';
+
+export { ForgotPasswordRequestDto } from './password-reset/forgot-password-request.dto';
+export { ResolvePasswordTokenQueryDto } from './password-reset/resolve-password-token-query.dto';
+export { ChangePasswordRequestDto } from './password-reset/change-password-request.dto';
+
 export { PasswordUpdateRequestDto } from './user/password-update-request.dto';
 export { RoleChangeRequestDto } from './user/role-change-request.dto';
 export { SettingsUpdateRequestDto } from './user/settings-update-request.dto';
 export { UserUpdateRequestDto } from './user/user-update-request.dto';
+
 export { CommunityRegisteredRequestDto } from './license/community-registered-request.dto';
+
 export { VariableListRequestDto } from './variables/variables-list-request.dto';

packages/@n8n/api-types/src/dto/owner/__tests__/dismiss-banner-request.dto.test.ts

@@ -0,0 +1,64 @@
+import { bannerNameSchema } from '../../../schemas/bannerName.schema';
+import { DismissBannerRequestDto } from '../dismiss-banner-request.dto';
+
+describe('DismissBannerRequestDto', () => {
+	describe('Valid requests', () => {
+		test.each(
+			bannerNameSchema.options.map((banner) => ({
+				name: `valid banner: ${banner}`,
+				request: { banner },
+			})),
+		)('should validate $name', ({ request }) => {
+			const result = DismissBannerRequestDto.safeParse(request);
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe('Invalid requests', () => {
+		test.each([
+			{
+				name: 'invalid banner string',
+				request: {
+					banner: 'not-a-valid-banner',
+				},
+				expectedErrorPath: ['banner'],
+			},
+			{
+				name: 'non-string banner',
+				request: {
+					banner: 123,
+				},
+				expectedErrorPath: ['banner'],
+			},
+		])('should fail validation for $name', ({ request, expectedErrorPath }) => {
+			const result = DismissBannerRequestDto.safeParse(request);
+
+			expect(result.success).toBe(false);
+
+			if (expectedErrorPath) {
+				expect(result.error?.issues[0].path).toEqual(expectedErrorPath);
+			}
+		});
+	});
+
+	describe('Optional banner', () => {
+		test('should validate empty request', () => {
+			const result = DismissBannerRequestDto.safeParse({});
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe('Exhaustive banner name check', () => {
+		test('should have all banner names defined', () => {
+			const expectedBanners = [
+				'V1',
+				'TRIAL_OVER',
+				'TRIAL',
+				'NON_PRODUCTION_LICENSE',
+				'EMAIL_CONFIRMATION',
+			];
+
+			expect(bannerNameSchema.options).toEqual(expectedBanners);
+		});
+	});
+});

packages/@n8n/api-types/src/dto/owner/__tests__/owner-setup-request.dto.test.ts

@@ -0,0 +1,93 @@
+import { OwnerSetupRequestDto } from '../owner-setup-request.dto';
+
+describe('OwnerSetupRequestDto', () => {
+	describe('Valid requests', () => {
+		test.each([
+			{
+				name: 'complete valid setup request',
+				request: {
+					email: 'owner@example.com',
+					firstName: 'John',
+					lastName: 'Doe',
+					password: 'SecurePassword123',
+				},
+			},
+		])('should validate $name', ({ request }) => {
+			const result = OwnerSetupRequestDto.safeParse(request);
+			expect(result.success).toBe(true);
+		});
+	});
+
+	describe('Invalid requests', () => {
+		test.each([
+			{
+				name: 'invalid email',
+				request: {
+					email: 'invalid-email',
+					firstName: 'John',
+					lastName: 'Doe',
+					password: 'SecurePassword123',
+				},
+				expectedErrorPath: ['email'],
+			},
+			{
+				name: 'missing first name',
+				request: {
+					email: 'owner@example.com',
+					firstName: '',
+					lastName: 'Doe',
+					password: 'SecurePassword123',
+				},
+				expectedErrorPath: ['firstName'],
+			},
+			{
+				name: 'missing last name',
+				request: {
+					email: 'owner@example.com',
+					firstName: 'John',
+					lastName: '',
+					password: 'SecurePassword123',
+				},
+				expectedErrorPath: ['lastName'],
+			},
+			{
+				name: 'password too short',
+				request: {
+					email: 'owner@example.com',
+					firstName: 'John',
+					lastName: 'Doe',
+					password: 'short',
+				},
+				expectedErrorPath: ['password'],
+			},
+			{
+				name: 'password without number',
+				request: {
+					email: 'owner@example.com',
+					firstName: 'John',
+					lastName: 'Doe',
+					password: 'NoNumberPassword',
+				},
+				expectedErrorPath: ['password'],
+			},
+			{
+				name: 'password without uppercase letter',
+				request: {
+					email: 'owner@example.com',
+					firstName: 'John',
+					lastName: 'Doe',
+					password: 'nouppercasepassword123',
+				},
+				expectedErrorPath: ['password'],
+			},
+		])('should fail validation for $name', ({ request, expectedErrorPath }) => {
+			const result = OwnerSetupRequestDto.safeParse(request);
+
+			expect(result.success).toBe(false);
+
+			if (expectedErrorPath) {
+				expect(result.error?.issues[0].path).toEqual(expectedErrorPath);
+			}
+		});
+	});
+});

packages/@n8n/api-types/src/dto/owner/dismiss-banner-request.dto.ts

@@ -0,0 +1,7 @@
+import { Z } from 'zod-class';
+
+import { bannerNameSchema } from '../../schemas/bannerName.schema';
+
+export class DismissBannerRequestDto extends Z.class({
+	banner: bannerNameSchema.optional(),
+}) {}