feat: add default user to rafiki admin (#1493)

* Add default user to rafiki admin

* change password

Author: domin191013

docker/dev/docker-compose.yml

@@ -57,6 +57,7 @@ services:
       WM_THRESHOLD: 100000000
       DEBT_THRESHOLD: 5
       REDIS_URL: redis://redis:6379/0
+      KRATOS_ADMIN_URL: 'http://kratos:4434/admin'
     restart: always
     networks:
       - testnet

packages/wallet/backend/src/createContainer.ts

@@ -51,6 +51,7 @@ import { generateKnex } from '@/config/knex'
 import { asClassSingletonWithLogger, RedisClient } from '@shared/backend'
 import { generateLogger } from '@/config/logger'
 import { GraphQLClient } from 'graphql-request'
+import { KratosService } from './rafiki/kratos.service'
 
 export interface Cradle {
   env: Env
@@ -92,6 +93,7 @@ export interface Cradle {
   grantController: GrantController
   walletAddressController: WalletAddressController
   walletAddressKeyController: WalletAddressKeyController
+  kratosService: KratosService
 }
 
 export async function createContainer(
@@ -147,7 +149,8 @@ export async function createContainer(
     quoteController: asClass(QuoteController).singleton(),
     grantController: asClass(GrantController).singleton(),
     walletAddressController: asClass(WalletAddressController).singleton(),
-    walletAddressKeyController: asClass(WalletAddressKeyController).singleton()
+    walletAddressKeyController: asClass(WalletAddressKeyController).singleton(),
+    kratosService: asClassSingletonWithLogger(KratosService, logger)
   })
 
   return container

packages/wallet/backend/src/rafiki/kratos.service.ts

@@ -0,0 +1,135 @@
+import axios from 'axios'
+import process from 'process'
+import { Logger } from 'winston'
+export class KratosService {
+  private KRATOS_INSTANCE: string | undefined
+
+  constructor(private logger: Logger) {
+    this.KRATOS_INSTANCE = process.env.KRATOS_ADMIN_URL
+    if (!this.KRATOS_INSTANCE) {
+      logger.error('No Kratos instance found.')
+    }
+  }
+
+  private getIdentityId = async (userEmail: string) => {
+    try {
+      const response = await axios.get(
+        `${this.KRATOS_INSTANCE}/identities?credentials_identifier=${userEmail}`
+      )
+      if (response.data.length > 0 && response.data[0].id) {
+        this.logger.debug(
+          `User with email ${userEmail} exists on the system with the ID: ${response.data[0].id}`
+        )
+        return response.data[0].id
+      }
+      this.logger.debug(`No user with email ${userEmail} exists on the system`)
+      return null
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        this.logger.error(
+          `Error retrieving identity ${userEmail}:`,
+          error.response?.status,
+          error.response?.data
+        )
+      } else {
+        this.logger.error(
+          `An unexpected error occurred while trying to retrieve the identity for ${userEmail}:`,
+          error
+        )
+      }
+    }
+  }
+
+  private createIdentity = async (userEmail: string) => {
+    try {
+      const response = await axios.post(
+        `${this.KRATOS_INSTANCE}/identities`,
+        {
+          schema_id: 'default',
+          traits: {
+            email: userEmail
+          },
+          verifiable_addresses: [
+            {
+              value: userEmail,
+              verified: true,
+              via: 'email',
+              status: 'completed'
+            }
+          ],
+          credentials: {
+            password: {
+              config: {
+                password: '123456'
+              }
+            }
+          }
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+      this.logger.debug(
+        `Successfully created user ${userEmail} with ID ${response.data.id}`
+      )
+      return response.data.id
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        this.logger.error(
+          `Error creating identity for ${userEmail}:`,
+          error.response?.status,
+          error.response?.data
+        )
+      } else {
+        this.logger.error(
+          `An unexpected error occurred while trying to create an identity for ${userEmail}:`,
+          error
+        )
+      }
+    }
+  }
+
+  private createRecoveryLink = async (
+    identityId: string,
+    userEmail: string
+  ) => {
+    try {
+      const response = await axios.post(
+        `${this.KRATOS_INSTANCE}/recovery/link`,
+        {
+          expires_in: '12h',
+          identity_id: identityId
+        },
+        {
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        }
+      )
+      return response.data.recovery_link
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        this.logger.error(
+          `Error creating password for ${userEmail}:\n status:${error.response?.status}\nresponse:${error.response?.data}`
+        )
+      } else {
+        this.logger.error(
+          `An unexpected error occurred while trying to create an account recovery link for ${userEmail}:`,
+          error
+        )
+      }
+    }
+  }
+
+  public run = async (userEmail: string) => {
+    let identityId = await this.getIdentityId(userEmail)
+    const event = identityId === null ? 'Registration' : 'Recovery'
+    if (event === 'Registration') {
+      identityId = await this.createIdentity(userEmail)
+    }
+    const recoveryLink = await this.createRecoveryLink(identityId, userEmail)
+    this.logger.info(`${event} Link for ${userEmail}: ${recoveryLink}`)
+  }
+}

packages/wallet/backend/src/user/service.ts

@@ -9,6 +9,7 @@ import { getRandomValues } from 'crypto'
 import { RafikiClient } from '@/rafiki/rafiki-client'
 import { WalletAddressKeyService } from '@/walletAddressKeys/service'
 import { BadRequest, Conflict } from '@shared/backend'
+import { KratosService } from '@/rafiki/kratos.service'
 
 interface CreateUserArgs {
   email: string
@@ -32,6 +33,7 @@ export class UserService implements IUserService {
     private walletAddressService: WalletAddressService,
     private walletAddressKeyService: WalletAddressKeyService,
     private rafikiClient: RafikiClient,
+    private kratosService: KratosService,
     private logger: Logger,
     private env: Env
   ) {}
@@ -174,6 +176,7 @@ export class UserService implements IUserService {
       })
     }
 
+    await this.kratosService.run(this.env.DEFAULT_WALLET_ACCOUNT.email)
     this.logger.info('Default users have been successfully created')
   }