Merge pull request #8 from freemocap/jon/users

Create User schema

src/shared/ai/langchain/langchain.module.ts → src/core/ai/langchain/langchain.module.ts

@@ -4,11 +4,10 @@ import { GcpModule } from '../../gcp/gcp.module';
 import { LangchainService } from './langchain.service';
 import { OpenaiModule } from '../openai/openai.module';
 import { DatabaseModule } from '../../database/database.module';
-import { LangchainChainService } from './langchain-chain.service';
 
 @Module({
   imports: [GcpModule, OpenaiModule, DatabaseModule],
-  providers: [LangchainService, LangchainChainService, Logger],
-  exports: [LangchainService, LangchainChainService],
+  providers: [LangchainService, Logger],
+  exports: [LangchainService],
 })
 export class LangchainModule {}

src/shared/ai/langchain/langchain-chain.service.ts → src/core/ai/langchain/langchain.service.ts

@@ -8,7 +8,7 @@ import { BufferMemory } from 'langchain/memory';
 import { RunnableSequence } from 'langchain/runnables';
 
 @Injectable()
-export class LangchainChainService {
+export class LangchainService {
   private _model: OpenAI<any>;
 
   constructor(
@@ -62,7 +62,7 @@ export class LangchainChainService {
     return { chain, memory };
   }
 
-  private async demo(chain: RunnableSequence, memory?: BufferMemory) {
+  public async demo(chain: RunnableSequence, memory?: BufferMemory) {
     if (memory) {
       console.log(
         `Current Memory - await memory.loadMemoryVariables({}): ${JSON.stringify(

src/shared/ai/openai/openai-secrets.service.ts → src/core/ai/openai/openai-secrets.service.ts

@@ -1,11 +1,11 @@
-import { SecretsManagerService } from '../../gcp/secretsManager.service';
+import { GcpSecretsService } from '../../gcp/gcp-secrets.service';
 import { Injectable } from '@nestjs/common';
 
 @Injectable()
 export class OpenaiSecretsService {
-  constructor(private readonly _sms: SecretsManagerService) {}
+  constructor(private readonly _sms: GcpSecretsService) {}
   async getOpenAIKey() {
-    const [secret] = await this._sms.getManager().accessSecretVersion({
+    const [secret] = await this._sms.getSecretsManager().accessSecretVersion({
       name: 'projects/588063171007/secrets/OPENAI_API_KEY/versions/latest',
     });
     return secret.payload.data.toString();

src/shared/chatbot/chatbot.module.ts → src/core/bot/bot.module.ts

@@ -1,10 +1,10 @@
 import { Logger, Module } from '@nestjs/common';
 import { LangchainModule } from '../ai/langchain/langchain.module';
-import { ChatbotService } from './chatbot.service';
+import { BotService } from './bot.service';
 
 @Module({
   imports: [LangchainModule],
-  providers: [ChatbotService, Logger],
-  exports: [ChatbotService],
+  providers: [BotService, Logger],
+  exports: [BotService],
 })
-export class ChatbotModule {}
+export class BotModule {}

src/shared/chatbot/chatbot.service.ts → src/core/bot/bot.service.ts

@@ -1,7 +1,6 @@
-import { Chatbot } from './chatbot.dto';
+import { Chatbot } from './bot.dto';
 import { LangchainService } from '../ai/langchain/langchain.service';
 import { Injectable, Logger } from '@nestjs/common';
-import { LangchainChainService } from '../ai/langchain/langchain-chain.service';
 
 class StreamResponseOptions {
   /**
@@ -11,37 +10,20 @@ class StreamResponseOptions {
 }
 
 @Injectable()
-export class ChatbotService {
+export class BotService {
   private _chatbots: Map<string, Chatbot> = new Map();
   constructor(
     private readonly _logger: Logger,
-    private readonly _langchainChainService: LangchainChainService,
     private readonly _langchainService: LangchainService,
   ) {}
 
-  public async createChatbot(chatbotId: string, modelName?: string) {
+  public async createBot(chatbotId: string, modelName?: string) {
     this._logger.log(
-      `Creating chatbot with id: ${chatbotId} and model: ${modelName}`,
-    );
-    const chain =
-      await this._langchainService.createMongoMemoryChatChain(modelName);
-
-    // @ts-ignore
-    const chatbot = { chain } as Chatbot;
-    this._chatbots.set(chatbotId, chatbot);
-    this._logger.log(`Chatbot with id: ${chatbotId} created successfully`);
-
-    return chatbot;
-  }
-
-  public async createChatbot2(chatbotId: string, modelName?: string) {
-    this._logger.log(
-      `Creating chatbot with id: ${chatbotId} and model: ${modelName}`,
+      `Creating chatbot with id: ${chatbotId} and language model (llm): ${modelName}`,
     );
     const { chain, memory } =
-      await this._langchainChainService.createBufferMemoryChain(modelName);
+      await this._langchainService.createBufferMemoryChain(modelName);
 
-    // @ts-ignore
     const chatbot = { chain, memory } as Chatbot;
     this._chatbots.set(chatbotId, chatbot);
     this._logger.log(`Chatbot with id: ${chatbotId} created successfully`);

src/core/database/database.module.ts

@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { GcpModule } from '../gcp/gcp.module';
+import { UsersModule } from './schema/users/users.module';
+import { DatabaseConnectionService } from './services/database-connection.service';
+
+@Module({
+  imports: [
+    GcpModule,
+    MongooseModule.forRoot('mongodb://localhost:27017/test'),
+    // CatsModule,
+    UsersModule,
+  ],
+  providers: [],
+  exports: [UsersModule],
+})
+export class DatabaseModule {}

src/core/database/schema/users/user.dto.ts

@@ -0,0 +1,6 @@
+export class UserDto {
+  readonly favoriteColor?: string;
+  readonly slackID?: string;
+  readonly discordId?: string;
+  readonly metadata?: object;
+}

src/core/database/schema/users/user.schema.ts

@@ -0,0 +1,35 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+
+@Schema({ timestamps: true })
+export class User {
+  @Prop({ required: true, unique: true })
+  uuid: string;
+
+  @Prop({ required: true })
+  favoriteColor: string;
+
+  @Prop({ unique: true })
+  discordId: string;
+
+  @Prop({ unique: true })
+  slackId: string;
+
+  @Prop({ type: Object })
+  metadata: Record<string, unknown>;
+}
+
+export const UserSchema = SchemaFactory.createForClass(User);
+
+function validateFavoriteColor(color: string) {
+  const regex = /^([A-Fa-f0-9]{6})$/;
+  return regex.test(`${color}`);
+}
+
+UserSchema.pre<User>('save', function (next) {
+  if (!validateFavoriteColor(this.favoriteColor)) {
+    throw new Error(
+      'User.favoriteColor should be a valid 6 digit hex color code (e.g. FF00FF)',
+    );
+  }
+  next();
+});

src/core/database/schema/users/users.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { UsersService } from './users.service';
+import { User, UserSchema } from './user.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+  ],
+  providers: [UsersService],
+  exports: [UsersService],
+})
+export class UsersModule {}

src/core/database/schema/users/users.service.ts

@@ -0,0 +1,84 @@
+import { HttpException, HttpStatus, Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { User } from './user.schema';
+import { UserDto } from './user.dto';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable()
+export class UsersService {
+  constructor(
+    @InjectModel(User.name)
+    private readonly userModel: Model<User>,
+  ) {}
+
+  async findAll(): Promise<User[]> {
+    return this.userModel.find().exec();
+  }
+
+  async findOne(userDto: UserDto): Promise<User> {
+    let user: User;
+    if (userDto.discordId) {
+      user = await this.userModel
+        .findOne({ discordId: userDto.discordId })
+        .exec();
+    } else if (userDto.slackID) {
+      user = await this.userModel.findOne({ slackID: userDto.slackID }).exec();
+    }
+
+    return user;
+  }
+
+  async getOrCreate(userDto: UserDto): Promise<User> {
+    const existingUser = await this.findOne(userDto);
+
+    if (existingUser) {
+      return existingUser;
+    }
+
+    return this.create(userDto);
+  }
+
+  _generateHexColorId() {
+    const letters = '0123456789ABCDEF';
+    let color = '';
+    const digits = 6;
+    for (let i = 0; i < digits; i++) {
+      color += letters[Math.floor(Math.random() * 16)];
+    }
+    return color;
+  }
+
+  async create(userDto: UserDto): Promise<User> {
+    if (await this.findOne(userDto)) {
+      throw new HttpException('User ID already exists', HttpStatus.CONFLICT);
+    }
+
+    const createdUser = new this.userModel({
+      ...userDto,
+      uuid: uuidv4(),
+      favoriteColor: this._generateHexColorId() || userDto.favoriteColor,
+    });
+    return createdUser.save();
+  }
+
+  async update(id: string, userDto: UserDto) {
+    const existingUser = await this.userModel.findOne({ id: id }).exec();
+    if (!existingUser) {
+      throw new Error(`User with id ${id} not found`);
+    }
+    return this.userModel
+      .findOneAndUpdate({ id: id }, userDto, { new: true })
+      .exec();
+  }
+
+  async delete(id: string) {
+    const deletedUser = await this.userModel
+      .findOneAndDelete({ id: id })
+      .exec();
+    if (!deletedUser) {
+      throw new Error(`User with id ${id} not found`);
+    }
+    return deletedUser;
+  }
+}

src/interfaces/chat/discord/services/necordConfig.service.ts → src/core/database/services/database-config.service.ts

@@ -1,17 +1,17 @@
 import { Injectable } from '@nestjs/common';
 import { NecordModuleOptions } from 'necord';
 import { IntentsBitField } from 'discord.js';
-import { SecretsManagerService } from '../../../../shared/gcp/secretsManager.service';
 import { ConfigService } from '@nestjs/config';
+import { GcpSecretsService } from '../../gcp/gcp-secrets.service';
 
 @Injectable()
-export class NecordConfigService {
+export class DiscordConfigService {
   private _tokenMap = {
     DISCORD_BOT_TOKEN:
       'projects/588063171007/secrets/DISCORD_BOT_TOKEN/versions/latest',
   };
   constructor(
-    private readonly sms: SecretsManagerService,
+    private readonly sms: GcpSecretsService,
     private readonly _cfgService: ConfigService,
   ) {}
 
@@ -30,7 +30,7 @@ export class NecordConfigService {
   private async _createTokenByNodeEnv() {
     if (process.env.NODE_ENV === 'production') {
       const secretName = this._tokenMap.DISCORD_BOT_TOKEN;
-      const [secret] = await this.sms.getManager().accessSecretVersion({
+      const [secret] = await this.sms.getSecretsManager().accessSecretVersion({
         name: secretName,
       });
       return secret.payload.data.toString();

src/shared/gcp/secretsManager.service.ts → src/core/gcp/gcp-secrets.service.ts

@@ -7,8 +7,8 @@ import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
  * in the future, we'll have additional options for the secrets manager stuff from GCP.
  */
 @Injectable()
-export class SecretsManagerService {
-  getManager() {
+export class GcpSecretsService {
+  getSecretsManager() {
     return new SecretManagerServiceClient();
   }
 }

src/core/gcp/gcp.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { GcpSecretsService } from './gcp-secrets.service';
+
+@Module({
+  providers: [GcpSecretsService],
+  exports: [GcpSecretsService],
+})
+export class GcpModule {}