feat: improve onboarding flow

Author: beeman

api-schema.graphql

@@ -120,10 +120,29 @@ type Mutation {
   syncUserProfile: JSON
   userDeleteIdentity(identityId: String!): Boolean
   userLinkIdentity(input: IdentityUserLinkInput!): Identity
+  userOnboardingCreateProfile(publicKey: String!): [Int!]
+  userOnboardingCustomizeProfile(avatarUrl: String!, username: String!): Boolean
   userUpdateUser(input: UserUserUpdateInput!): User
   userVerifyIdentityChallenge(input: IdentityVerifyChallengeInput!): IdentityChallenge
 }
 
+type OnboardingRequirements {
+  profileAccount: String
+  socialIdentities: Int
+  solanaIdentities: Int
+  step: OnboardingStep!
+  validAvatarUrl: Boolean
+  validUsername: Boolean
+}
+
+enum OnboardingStep {
+  CreateProfile
+  CustomizeProfile
+  Finished
+  LinkSocialIdentities
+  LinkSolanaWallets
+}
+
 type PagingMeta {
   currentPage: Int!
   isFirstPage: Boolean!
@@ -138,7 +157,6 @@ type PubkeyProfile {
   authorities: [String!]!
   avatarUrl: String!
   bump: Int!
-  feePayer: String!
   identities: [PubkeyProfileIdentity!]!
   publicKey: String!
   username: String!
@@ -170,6 +188,7 @@ type Query {
   userFindOneUser(username: String!): User
   userGetOnboardingAvatarUrls: [String!]
   userGetOnboardingUsernames: [String!]
+  userOnboardingRequirements: OnboardingRequirements
   userRequestIdentityChallenge(input: IdentityRequestChallengeInput!): IdentityChallenge
 }
 

libs/api/core/data-access/src/lib/api-core.service.ts

@@ -1,6 +1,6 @@
 import { Injectable } from '@nestjs/common'
 import { EventEmitter2 } from '@nestjs/event-emitter'
-import { IdentityProvider } from '@prisma/client'
+import { IdentityProvider, Prisma } from '@prisma/client'
 import { ApiCorePrismaClient, prismaClient } from './api-core-prisma-client'
 import { ApiCoreConfigService } from './config/api-core-config.service'
 import { slugifyId } from './helpers/slugify-id'
@@ -11,6 +11,17 @@ export class ApiCoreService {
   readonly data: ApiCorePrismaClient = prismaClient
   constructor(readonly config: ApiCoreConfigService, readonly eventEmitter: EventEmitter2) {}
 
+  async ensureUserById(userId: string) {
+    const user = await this.data.user.findUnique({
+      where: { id: userId },
+      include: { identities: true },
+    })
+    if (!user) {
+      throw new Error(`User ${userId} not found`)
+    }
+    return user
+  }
+
   async findUserByIdentity({ provider, providerId }: { provider: IdentityProvider; providerId: string }) {
     return this.data.identity.findUnique({
       where: { provider_providerId: { provider, providerId } },
@@ -45,4 +56,8 @@ export class ApiCoreService {
       include: { identities: true },
     })
   }
+
+  async updateUserById(userId: string, data: Prisma.UserUpdateInput) {
+    return this.data.user.update({ where: { id: userId }, data })
+  }
 }

libs/api/core/data-access/src/lib/config/api-core-config.service.ts

@@ -238,6 +238,10 @@ export class ApiCoreConfigService {
     return '/api'
   }
 
+  get pubkeyProtocolCommunity(): string {
+    return this.service.get<string>('pubkeyProtocolCommunity') as string
+  }
+
   get pubkeyProtocolSigner(): Keypair {
     return this.service.get<Keypair>('pubkeyProtocolSigner') as Keypair
   }

libs/api/core/data-access/src/lib/config/configuration.ts

@@ -64,6 +64,7 @@ export interface ApiCoreConfig {
   jwtSecret: string
   port: number
   sessionSecret: string
+  pubkeyProtocolCommunity: string
   pubkeyProtocolSigner: Keypair
   pubkeyProtocolSignerMinimalBalance: number
   solanaEndpoint: string
@@ -106,6 +107,7 @@ export function configuration(): ApiCoreConfig {
     host: process.env['HOST'] as string,
     jwtSecret: process.env['JWT_SECRET'] as string,
     port: parseInt(process.env['PORT'] as string, 10) || 3000,
+    pubkeyProtocolCommunity: process.env['PUBKEY_PROTOCOL_COMMUNITY'] as string,
     pubkeyProtocolSigner: getKeypairFromByteArray(
       JSON.parse(process.env['PUBKEY_PROTOCOL_SIGNER_SECRET_KEY'] as string),
     ),

libs/api/core/data-access/src/lib/config/validation-schema.ts

@@ -47,6 +47,7 @@ export const validationSchema = Joi.object({
   HOST: Joi.string().default('0.0.0.0'),
   NODE_ENV: Joi.string().valid('development', 'production', 'test', 'provision').default('development'),
   PORT: Joi.number().default(3000),
+  PUBKEY_PROTOCOL_COMMUNITY: Joi.string().required(),
   PUBKEY_PROTOCOL_SIGNER_SECRET_KEY: Joi.string().required(),
   PUBKEY_PROTOCOL_SIGNER_MINIMAL_BALANCE: Joi.number().default(1),
   SESSION_SECRET: Joi.string().required(),

libs/api/onboarding/data-access/src/index.ts

@@ -1,2 +1,4 @@
 export * from './lib/api-onboarding.data-access.module'
 export * from './lib/api-onboarding.service'
+export * from './lib/entity/onboarding-step'
+export * from './lib/entity/onboarding.entity'

libs/api/onboarding/data-access/src/lib/api-onboarding.data-access.module.ts

@@ -1,9 +1,10 @@
 import { Module } from '@nestjs/common'
 import { ApiCoreDataAccessModule } from '@pubkey-network/api-core-data-access'
+import { ApiProtocolDataAccessModule } from '@pubkey-network/api-protocol-data-access'
 import { ApiOnboardingService } from './api-onboarding.service'
 
 @Module({
-  imports: [ApiCoreDataAccessModule],
+  imports: [ApiCoreDataAccessModule, ApiProtocolDataAccessModule],
   providers: [ApiOnboardingService],
   exports: [ApiOnboardingService],
 })

libs/api/onboarding/data-access/src/lib/api-onboarding.service.ts

@@ -1,30 +1,34 @@
-import { Injectable } from '@nestjs/common'
+import { Injectable, Logger } from '@nestjs/common'
 import { IdentityProvider } from '@prisma/client'
 import { ApiCoreService, ellipsify } from '@pubkey-network/api-core-data-access'
+import { ApiProtocolService } from '@pubkey-network/api-protocol-data-access'
+import { OnboardingStep } from './entity/onboarding-step'
+import { OnboardingRequirements } from './entity/onboarding.entity'
 
 @Injectable()
 export class ApiOnboardingService {
-  constructor(private readonly core: ApiCoreService) {}
+  readonly socialProviders = [
+    IdentityProvider.Discord,
+    IdentityProvider.Github,
+    IdentityProvider.Google,
+    // IdentityProvider.Telegram,
+    IdentityProvider.X,
+  ]
+
+  private readonly logger = new Logger(ApiOnboardingService.name)
+  constructor(private readonly core: ApiCoreService, private readonly protocol: ApiProtocolService) {}
 
   async getOnboardingUsernames(userId: string) {
-    const found = await this.core.data.user.findUnique({
-      where: { id: userId },
-      include: { identities: true },
-    })
-    if (!found) {
-      throw new Error(`User ${userId} not found`)
-    }
-    const usernames = found.identities
+    const user = await this.core.ensureUserById(userId)
+    const rawUsernames = user.identities
       .filter((i) => i?.profile)
       .map((i) => i.profile as { username?: string })
       // Remove any identities that don't have a username
       .filter((i) => i.username)
       // Take the username property
       .map((i) => i.username as string)
-      // Take the first part of any email addresses
-      .map((i) => i?.split('@')[0])
-      // Convert any special characters to lowercase
-      .map((i) => i.replace(/[^a-z0-9]/gi, '_').toLowerCase())
+
+    const usernames = cleanupUsernames(rawUsernames)
 
     // For all usernames with an underscore, also offer the username without the underscore
     for (const username of usernames) {
@@ -33,32 +37,29 @@ export class ApiOnboardingService {
       }
     }
 
-    const wallets = found.identities
+    // Remove any duplicates and sort the usernames
+    const sortedUsernames = Array.from(new Set(usernames)).sort()
+
+    // Create usernames based on Solana wallets for users that like to be pseudonymous
+    const wallets = user.identities
       // Remove any identities that are not Solana wallets
       .filter((i) => i?.provider === IdentityProvider.Solana)
       // Take the providerId property
       .map((i) => i.providerId as string)
       // Convert any special characters to lowercase
       .map((i) => ellipsify(i, 4, '__').toLowerCase())
 
-    usernames.push(...wallets)
+    // Remove any duplicates and sort the wallets
+    const sortedWallets = Array.from(new Set(wallets)).sort()
 
-    // Remove any duplicates and sort the usernames
-    return Array.from(new Set(usernames)).sort()
+    return [...sortedUsernames, ...sortedWallets]
   }
 
   async getOnboardingAvatarUrls(userId: string) {
-    const found = await this.core.data.user.findUnique({
-      where: { id: userId },
-      include: { identities: true },
-    })
-    if (!found) {
-      throw new Error(`User ${userId} not found`)
-    }
-
+    const user = await this.core.ensureUserById(userId)
     const usernames: string[] = []
 
-    const avatarUrls = found.identities
+    const avatarUrls = user.identities
       .filter((i) => i?.profile)
       .map((i) => i.profile as { avatarUrl?: string; username?: string })
       .map((i) => {
@@ -76,14 +77,98 @@ export class ApiOnboardingService {
     const cleaned = cleanupUsernames(usernames)
 
     for (const username of cleaned) {
+      avatarUrls.push(
+        `https://api.dicebear.com/9.x/avataaars/svg?backgroundColor=b6e3f4,c0aede,d1d4f9&seed=${username}`,
+      )
       avatarUrls.push(`https://api.dicebear.com/9.x/initials/svg?backgroundColor=b6e3f4,c0aede,d1d4f9&seed=${username}`)
     }
 
     // Remove any duplicates and sort the avatarUrls
     return Array.from(new Set(avatarUrls))
   }
+
+  async getOnboardingRequirements(userId: string): Promise<OnboardingRequirements> {
+    const user = await this.core.ensureUserById(userId)
+
+    const [usernames, avatarUrls] = await Promise.all([
+      this.getOnboardingUsernames(userId),
+      this.getOnboardingAvatarUrls(userId),
+    ])
+
+    const socialIdentities = user.identities.filter((i) => identityProvidersSocial.includes(i?.provider))
+    const solanaIdentities = user.identities.filter((i) => i?.provider === IdentityProvider.Solana)
+    const validAvatarUrl = avatarUrls.includes(user.avatarUrl ?? '')
+    const validUsername = usernames.includes(user.username)
+    const profileAccount = user.profile ?? null
+
+    let step: OnboardingStep
+
+    if (!socialIdentities.length) {
+      step = OnboardingStep.LinkSocialIdentities
+    } else if (!solanaIdentities.length) {
+      step = OnboardingStep.LinkSolanaWallets
+    } else if (!validAvatarUrl || !validUsername) {
+      step = OnboardingStep.CustomizeProfile
+    } else if (!user.profile) {
+      step = OnboardingStep.CreateProfile
+    } else {
+      step = OnboardingStep.Finished
+    }
+
+    return {
+      profileAccount,
+      socialIdentities: socialIdentities.length ?? 0,
+      solanaIdentities: solanaIdentities.length ?? 0,
+      validAvatarUrl: avatarUrls.includes(user.avatarUrl ?? ''),
+      validUsername: usernames.includes(user.username),
+      step,
+    }
+  }
+
+  async createProfile(userId: string, publicKey: string) {
+    const user = await this.core.ensureUserById(userId)
+    const requirementsMet = await this.getOnboardingRequirements(user.id)
+    if (!requirementsMet) {
+      throw new Error(`User ${user.id} has not met the onboarding requirements`)
+    }
+
+    return this.protocol.createUserProfile(user.id, publicKey)
+  }
+
+  async customizeProfile(userId: string, username: string, avatarUrl: string) {
+    const user = await this.core.ensureUserById(userId)
+    const [usernames, avatarUrls] = await Promise.all([
+      this.getOnboardingUsernames(user.id),
+      this.getOnboardingAvatarUrls(user.id),
+    ])
+
+    if (!usernames.includes(username)) {
+      throw new Error(`User ${user.username} has not met the onboarding requirements`)
+    }
+
+    if (!avatarUrls.includes(avatarUrl)) {
+      throw new Error(`User ${user.username} has not met the onboarding requirements`)
+    }
+
+    try {
+      const updated = await this.core.updateUserById(user.id, { username, avatarUrl })
+      this.logger.log(`User ${user.username} has been updated to ${updated.username} and ${updated.avatarUrl}`)
+      return true
+    } catch (error) {
+      console.error(error)
+      throw new Error(`User ${user.username} could not be updated`)
+    }
+  }
 }
 
+const identityProvidersSocial: IdentityProvider[] = [
+  IdentityProvider.Discord,
+  IdentityProvider.Github,
+  IdentityProvider.Google,
+  IdentityProvider.Telegram,
+  IdentityProvider.X,
+]
+
 function cleanupUsernames(usernames: string[]) {
   return (
     usernames // Take the first part of any email addresses

libs/api/onboarding/data-access/src/lib/entity/onboarding-step.ts

@@ -0,0 +1,11 @@
+import { registerEnumType } from '@nestjs/graphql'
+
+export enum OnboardingStep {
+  CreateProfile = 'CreateProfile',
+  CustomizeProfile = 'CustomizeProfile',
+  Finished = 'Finished',
+  LinkSocialIdentities = 'LinkSocialIdentities',
+  LinkSolanaWallets = 'LinkSolanaWallets',
+}
+
+registerEnumType(OnboardingStep, { name: 'OnboardingStep' })

libs/api/onboarding/data-access/src/lib/entity/onboarding.entity.ts

@@ -0,0 +1,18 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql'
+import { OnboardingStep } from './onboarding-step'
+
+@ObjectType()
+export class OnboardingRequirements {
+  @Field(() => String, { nullable: true })
+  profileAccount!: string | null
+  @Field(() => Int, { nullable: true })
+  socialIdentities!: number | null
+  @Field(() => Int, { nullable: true })
+  solanaIdentities!: number | null
+  @Field(() => Boolean, { nullable: true })
+  validUsername!: boolean
+  @Field(() => Boolean, { nullable: true })
+  validAvatarUrl!: boolean
+  @Field(() => OnboardingStep)
+  step!: OnboardingStep
+}