feat(kratos-cli): add verification command

Author: getlarge

packages/kratos-cli/src/app/app.module.ts

@@ -11,6 +11,7 @@ import {
   RegistrationCommand,
   RegistrationQuestions,
 } from './registration.command';
+import { VerificationCommand } from './verification.command';
 
 @Module({
   imports: [
@@ -33,6 +34,7 @@ import {
     LoginQuestions,
     RegistrationCommand,
     RegistrationQuestions,
+    VerificationCommand,
   ],
 })
 export class AppModule {}

packages/kratos-cli/src/app/verification.command.spec.ts

@@ -0,0 +1,75 @@
+import { OryFrontendService } from '@getlarge/kratos-client-wrapper';
+import { TestingModule } from '@nestjs/testing';
+import { Configuration } from '@ory/client';
+import { CommandTestFactory } from 'nest-commander-testing';
+
+import { AppModule } from './app.module';
+
+class MockOryFrontendService {
+  createNativeVerificationFlow = jest.fn();
+  updateVerificationFlow = jest.fn();
+  configuration = new Configuration({
+    basePath: 'http://localhost',
+  });
+  get config(): Configuration {
+    return this.configuration;
+  }
+  set config(config: Configuration) {
+    this.configuration = config;
+  }
+}
+
+describe('VerificationCommand', () => {
+  let oryFrontendService: OryFrontendService;
+  let app: TestingModule;
+
+  beforeAll(async () => {
+    app = await CommandTestFactory.createTestingCommand({
+      imports: [AppModule],
+      providers: [],
+    })
+      .overrideProvider(OryFrontendService)
+      .useClass(MockOryFrontendService)
+      .compile();
+
+    oryFrontendService = app.get(OryFrontendService);
+  });
+
+  describe('run', () => {
+    it('should trigger verification flow with code method', async () => {
+      const email = 'test@test.it';
+      const method = 'code';
+      oryFrontendService.createNativeVerificationFlow = jest
+        .fn()
+        .mockResolvedValue({
+          data: {
+            id: 'flow-id',
+          },
+        });
+      expect(oryFrontendService.config.basePath).toBe('http://localhost');
+      await expect(
+        CommandTestFactory.run(app, [
+          'verify',
+          '--email',
+          email,
+          '--method',
+          method,
+          '--basePath',
+          'http://localhost:4433',
+        ])
+      ).resolves.toBeUndefined();
+
+      expect(oryFrontendService.config.basePath).toBe('http://localhost:4433');
+      expect(
+        oryFrontendService.createNativeVerificationFlow
+      ).toHaveBeenCalled();
+      expect(oryFrontendService.updateVerificationFlow).toHaveBeenCalledWith({
+        flow: 'flow-id',
+        updateVerificationFlowBody: {
+          email,
+          method: 'code',
+        },
+      });
+    });
+  });
+});

packages/kratos-cli/src/app/verification.command.ts

@@ -0,0 +1,83 @@
+import { OryFrontendService } from '@getlarge/kratos-client-wrapper';
+import { Logger } from '@nestjs/common';
+import { Configuration } from '@ory/client';
+import { isEmail } from 'class-validator';
+import { Command, CommandRunner, Option } from 'nest-commander';
+
+interface CommandOptions extends Pick<Configuration, 'basePath'> {
+  email: string;
+  method: 'code' | 'link';
+}
+
+@Command({
+  name: 'verify',
+  description: 'Verify email address via Ory Kratos self-service API',
+})
+export class VerificationCommand extends CommandRunner {
+  readonly logger = new Logger(VerificationCommand.name);
+
+  constructor(private readonly oryFrontendService: OryFrontendService) {
+    super();
+  }
+
+  async run(inputs: string[], options: CommandOptions): Promise<void> {
+    const { email, method } = options;
+    if (options.basePath) {
+      this.oryFrontendService.config = new Configuration({
+        ...this.oryFrontendService.config,
+        ...options,
+      });
+    }
+
+    this.logger.debug('init verification flow');
+    const {
+      data: { id: flowId },
+    } = await this.oryFrontendService.createNativeVerificationFlow();
+
+    this.logger.debug('complete verification flow');
+    await this.oryFrontendService.updateVerificationFlow({
+      flow: flowId,
+      updateVerificationFlowBody: {
+        email,
+        method,
+      },
+    });
+    this.logger.debug(`verification flow ${flowId} completed`);
+  }
+
+  @Option({
+    flags: '-e, --email <string>',
+    description: 'Email address to login with',
+    required: true,
+  })
+  parseEmail(val: string): string {
+    if (isEmail(val)) {
+      return val;
+    }
+    throw new TypeError('Invalid email address');
+  }
+
+  @Option({
+    flags: '-m, --method [string]',
+    description: 'Verification method',
+    required: false,
+  })
+  parseVerificationMethod(val: string): string {
+    if (!val) {
+      return 'code';
+    }
+    if (['code', 'link'].includes(val)) {
+      return val;
+    }
+    throw new TypeError('Invalid verification method');
+  }
+
+  @Option({
+    flags: '-b, --basePath [string]',
+    description: 'Ory Kratos Public API URL',
+    required: false,
+  })
+  parseBasePath(val: string): string {
+    return val;
+  }
+}