fixing human verification api

Author: signorecello

tooling/sparta/packages/discord/src/api/axios.ts

@@ -1,12 +1,13 @@
-import { OpenAPIClientAxios } from "openapi-client-axios";
-import { apiDocs } from "@sparta/utils";
-import { type Client } from "@sparta/utils/openapi/types";
+// packages/vite/src/api/axios.ts
+import { type OpenAPIV3, OpenAPIClientAxios } from "openapi-client-axios";
+import spec from "@sparta/utils/openapi/api-docs.json";
+import type { Client } from "@sparta/utils/openapi/types";
 
 const apiInstance = new OpenAPIClientAxios({
-	// @ts-ignore
-	definition: apiDocs,
+	definition: spec as OpenAPIV3.Document,
+	// validate: false, // Invalid option, removed
 	axiosConfigDefaults: {
-		baseURL: process.env.VITE_APP_API_URL || "http://localhost:3000",
+		baseURL: process.env.VITE_APP_API_URL,
 		timeout: 10_000,
 		headers: {
 			"Content-Type": "application/json",

tooling/sparta/packages/discord/src/slashCommands/humans/verify.ts

@@ -18,6 +18,7 @@ import { randomUUID } from "crypto";
 import { VERIFICATION_STATUS } from "@sparta/utils/const";
 import { getDiscordInstance } from "../../clients/discord";
 import { HumanSubcommands } from "../../types.js";
+import { clientPromise } from "../../api/axios";
 
 /**
  * Command definition for the verify subcommand
@@ -40,33 +41,29 @@ export async function handleVerifyCommand(
 		let discordUsername = interaction.user.username;
 
 		// Get API client
-		const discord = await getDiscordInstance();
-		const apiProvider = discord.getApiProvider();
-		const client = apiProvider.getClient();
+		const client = await clientPromise;
 
 		logger.debug(
 			{ userId, interactionToken, verificationId },
 			"Verify command"
 		);
 
-		// Check if the user already exists
-		const userResponse = await client.getUserByDiscordId({
-			discordUserId: userId,
-		});
-
 		try {
-			logger.debug({ userResponse }, "User response");
+			// Check if the user already exists
+			const { data } = await client.getUserByDiscordId({
+				discordUserId: userId,
+			});
 
-			const user = userResponse.data.user;
+			logger.debug({ data }, "User response");
 
-			if (user) {
+			if (data.user) {
 				// Update existing user
 				await client.updateUser(
 					{ discordUserId: userId },
 					{
 						humanPassport: {
 							status:
-								user.humanPassport?.status ||
+								data.user.humanPassport?.status ||
 								VERIFICATION_STATUS.NOT_VERIFIED,
 							verificationId,
 							interactionToken,
@@ -79,6 +76,8 @@ export async function handleVerifyCommand(
 					"Updated user verification data"
 				);
 			} else {
+				logger.info("User not found, creating new user");
+
 				// Create a new user
 				const timestamp = Date.now();
 
@@ -96,22 +95,23 @@ export async function handleVerifyCommand(
 					},
 				});
 
-				await client.createUser({
-					discordUserId: userId,
-					discordUsername,
-					walletAddress: undefined,
-					role: undefined,
-					humanPassport: {
-						//@ts-ignore
-						status: VERIFICATION_STATUS.NOT_VERIFIED,
-						verificationId,
-						interactionToken,
-						lastVerificationTime: null,
-						score: null,
-					},
-					createdAt: timestamp,
-					updatedAt: timestamp,
-				});
+				await client.createUser(
+					{},
+					{
+						discordUserId: userId,
+						discordUsername,
+						walletAddress: undefined,
+						role: undefined,
+						humanPassport: {
+							//@ts-ignore
+							status: VERIFICATION_STATUS.NOT_VERIFIED,
+							verificationId,
+							interactionToken,
+							lastVerificationTime: null,
+							score: null,
+						},
+					}
+				);
 
 				logger.info(
 					{ userId, verificationId },

tooling/sparta/packages/express/src/db/userRepository.ts

@@ -12,44 +12,38 @@ import {
 	DeleteCommand,
 	QueryCommand,
 	ScanCommand,
+	DynamoDBDocumentClient,
 } from "@aws-sdk/lib-dynamodb";
 import type { User } from "../routes/users/users.js";
 import DynamoDBService from "@sparta/utils/dynamo-db.js";
 
-// Type for extended DynamoDB with user methods
-interface ExtendedDynamoDB {
-	getUser(discordUserId: string): Promise<User | null>;
-	getUserByVerificationId(verificationId: string): Promise<User | null>;
-	getUserByWalletAddress(walletAddress: string): Promise<User | null>;
-	getAllUsers(): Promise<User[]>;
-	createUser(user: User): Promise<User | null>;
-	updateUser(discordUserId: string, updates: Partial<User>): Promise<boolean>;
-	deleteUser(discordUserId: string): Promise<boolean>;
-	getClient(): any;
-}
-
 const USERS_TABLE_NAME = process.env.USERS_TABLE_NAME || "users";
 
 // Instantiate the shared service for the users table
-const dynamoDB = new DynamoDBService(USERS_TABLE_NAME);
+const dynamoDBService = new DynamoDBService(USERS_TABLE_NAME);
 
-const extendedDynamoDB = dynamoDB as unknown as ExtendedDynamoDB;
+export class UserRepository {
+	private client: DynamoDBDocumentClient;
+	private tableName: string;
 
-logger.info("dynamoDB config", dynamoDB.getClient().config);
+	constructor() {
+		this.tableName = USERS_TABLE_NAME;
+		// Get the client instance from the shared service
+		this.client = dynamoDBService.getClient();
+		logger.info(
+			`UserRepository initialized using shared DynamoDBService for table: ${this.tableName}`
+		);
+	}
 
-// Extend the DynamoDB service with user operations
-export function extendDynamoDBWithUserMethods(): void {
 	// Get user by Discord ID
-	extendedDynamoDB.getUser = async (
-		discordUserId: string
-	): Promise<User | null> => {
+	async getUser(discordUserId: string): Promise<User | null> {
 		try {
 			const command = new GetCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				Key: { discordUserId },
 			});
 
-			const response = await dynamoDB.getClient().send(command);
+			const response = await this.client.send(command);
 			return (response.Item as User) || null;
 		} catch (error: any) {
 			logger.error(
@@ -58,23 +52,23 @@ export function extendDynamoDBWithUserMethods(): void {
 			);
 			return null;
 		}
-	};
+	}
 
 	// Get user by verification ID - uses the flattened verificationId index
-	extendedDynamoDB.getUserByVerificationId = async (
+	async getUserByVerificationId(
 		verificationId: string
-	): Promise<User | null> => {
+	): Promise<User | null> {
 		try {
 			const command = new QueryCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				IndexName: "verificationId-index",
 				KeyConditionExpression: "verificationId = :verificationId",
 				ExpressionAttributeValues: {
 					":verificationId": verificationId,
 				},
 			});
 
-			const response = await dynamoDB.getClient().send(command);
+			const response = await this.client.send(command);
 
 			if (!response.Items || response.Items.length === 0) {
 				return null;
@@ -92,26 +86,24 @@ export function extendDynamoDBWithUserMethods(): void {
 			);
 			return null;
 		}
-	};
+	}
 
 	// Get user by wallet address
-	extendedDynamoDB.getUserByWalletAddress = async (
-		walletAddress: string
-	): Promise<User | null> => {
+	async getUserByWalletAddress(walletAddress: string): Promise<User | null> {
 		try {
 			// Normalize wallet address (lowercase)
 			const normalizedAddress = walletAddress.toLowerCase();
 
 			const command = new QueryCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				IndexName: "walletAddress-index", // This assumes a GSI on walletAddress
 				KeyConditionExpression: "walletAddress = :walletAddress",
 				ExpressionAttributeValues: {
 					":walletAddress": normalizedAddress,
 				},
 			});
 
-			const response = await dynamoDB.getClient().send(command);
+			const response = await this.client.send(command);
 
 			if (response.Items && response.Items.length > 0) {
 				return response.Items[0] as User;
@@ -125,25 +117,25 @@ export function extendDynamoDBWithUserMethods(): void {
 			);
 			return null;
 		}
-	};
+	}
 
 	// Get all users
-	extendedDynamoDB.getAllUsers = async (): Promise<User[]> => {
+	async getAllUsers(): Promise<User[]> {
 		try {
 			const command = new ScanCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 			});
 
-			const response = await dynamoDB.getClient().send(command);
+			const response = await this.client.send(command);
 			return (response.Items as User[]) || [];
 		} catch (error: any) {
 			logger.error({ error: error.message }, "Error getting all users");
 			return [];
 		}
-	};
+	}
 
 	// Create a new user
-	extendedDynamoDB.createUser = async (user: User): Promise<User | null> => {
+	async createUser(user: User): Promise<User | null> {
 		try {
 			// Create a clean version of the user object for DynamoDB
 			const dynamoUser: any = { ...user };
@@ -159,6 +151,12 @@ export function extendDynamoDBWithUserMethods(): void {
 
 			// Handle humanPassport fields - remove any null values to ensure proper indexing
 			if (dynamoUser.humanPassport) {
+				logger.debug(
+					{
+						dynamoUser: dynamoUser.humanPassport,
+					},
+					"Human passport in createUser"
+				);
 				const cleanHumanPassport: Record<string, any> = {};
 
 				// Only keep non-null values
@@ -186,26 +184,24 @@ export function extendDynamoDBWithUserMethods(): void {
 			}
 
 			const command = new PutCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				Item: dynamoUser,
 				ConditionExpression: "attribute_not_exists(discordUserId)",
 			});
 
-			logger.debug({ command }, "Creating user in repository");
-
-			await dynamoDB.getClient().send(command);
+			await this.client.send(command);
 			return user;
 		} catch (error: any) {
 			logger.error({ error: error.message, user }, "Error creating user");
 			return null;
 		}
-	};
+	}
 
 	// Update a user
-	extendedDynamoDB.updateUser = async (
+	async updateUser(
 		discordUserId: string,
 		updates: Partial<User>
-	): Promise<boolean> => {
+	): Promise<boolean> {
 		try {
 			// Build update and remove expressions
 			const updateExpressions: string[] = [];
@@ -289,15 +285,15 @@ export function extendDynamoDBWithUserMethods(): void {
 			}
 
 			const command = new UpdateCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				Key: { discordUserId },
 				UpdateExpression: updateExpression,
 				ExpressionAttributeNames: expressionAttributeNames,
 				ExpressionAttributeValues: expressionAttributeValues,
 				ReturnValues: "UPDATED_NEW",
 			});
 
-			await dynamoDB.getClient().send(command);
+			await this.client.send(command);
 			return true;
 		} catch (error: any) {
 			logger.error(
@@ -306,19 +302,17 @@ export function extendDynamoDBWithUserMethods(): void {
 			);
 			return false;
 		}
-	};
+	}
 
 	// Delete a user
-	extendedDynamoDB.deleteUser = async (
-		discordUserId: string
-	): Promise<boolean> => {
+	async deleteUser(discordUserId: string): Promise<boolean> {
 		try {
 			const command = new DeleteCommand({
-				TableName: process.env.USERS_TABLE_NAME || "users",
+				TableName: this.tableName,
 				Key: { discordUserId },
 			});
 
-			await dynamoDB.getClient().send(command);
+			await this.client.send(command);
 			return true;
 		} catch (error: any) {
 			logger.error(
@@ -327,14 +321,8 @@ export function extendDynamoDBWithUserMethods(): void {
 			);
 			return false;
 		}
-	};
+	}
 }
 
-// Export the extended dynamoDB for use in other modules
-export { extendedDynamoDB };
-
-// Export function to initialize - this will be called during app startup
-export function initializeUserRepository(): void {
-	extendDynamoDBWithUserMethods();
-	logger.info("User repository initialized");
-}
+// Export a singleton instance of the repository
+export const userRepository = new UserRepository();