Ajouter les modifications du module KeyringsModule

Author: tacxou

package.json

@@ -42,6 +42,7 @@
     "schematics:inherit": "nest generate -c @kradihsoy/lt-schematics inherit",
     "generate:doc": "npx @compodoc/compodoc -c .compodocrc",
     "generate:docServer": "npx @compodoc/compodoc -s -c .compodocrc -d ./documentation",
+    "console": "node dist/console",
     "prepare": "husky"
   },
   "dependencies": {
@@ -69,6 +70,7 @@
     "ioredis": "^5.3.2",
     "loglevel": "^1.8.1",
     "mongoose": "^8.0.2",
+    "nest-commander": "^3.12.5",
     "nest-winston": "^1.9.4",
     "nestjs-request-context": "^3.0.0",
     "passport": "^0.6.0",
@@ -96,6 +98,7 @@
     "@swc/core": "^1.4.6",
     "@types/cookie-parser": "^1.4.6",
     "@types/express": "^4.17.17",
+    "@types/inquirer": "^9.0.7",
     "@types/jest": "^29.5.2",
     "@types/node": "^18.0.0",
     "@types/passport": "^1.0.16",

src/_common/abstracts/abstract.service.schema.ts

@@ -219,6 +219,10 @@ export abstract class AbstractServiceSchema extends AbstractService implements S
         { _id },
         {
           ...update,
+          $setOnInsert: {
+            'metadata.createdBy': this.request?.user?.username || 'anonymous',
+            'metadata.createdAt': new Date(),
+          },
           $set: {
             ...(update?.$set || {}),
             'metadata.lastUpdatedBy': this.request?.user?.username || 'anonymous',
@@ -270,6 +274,10 @@ export abstract class AbstractServiceSchema extends AbstractService implements S
         filter,
         {
           ...update,
+          $setOnInsert: {
+            'metadata.createdBy': this.request?.user?.username || 'anonymous',
+            'metadata.createdAt': new Date(),
+          },
           $set: {
             ...(update?.$set || {}),
             'metadata.lastUpdatedBy': this.request?.user?.username || 'anonymous',

src/cli/agents.command.ts

@@ -0,0 +1,64 @@
+import { ModuleRef } from '@nestjs/core';
+import { Command, CommandRunner, InquirerService, Question, QuestionSet, SubCommand } from 'nest-commander';
+import { AgentsCreateDto } from '~/core/agents/_dto/agents.dto';
+import { AgentsService } from '~/core/agents/agents.service';
+
+@QuestionSet({ name: 'agent-create-questions' })
+export class AgentCreateQuestions {
+  @Question({
+    message: 'Username ?',
+    name: 'username',
+  })
+  parseUsername(val: string) {
+    return val;
+  }
+
+  @Question({
+    message: 'Email ?',
+    name: 'email',
+  })
+  parseEmail(val: string) {
+    return val;
+  }
+
+  @Question({
+    message: 'Password ?',
+    name: 'password',
+    type: 'password',
+  })
+  parsePassword(val: string) {
+    return val;
+  }
+}
+
+@SubCommand({ name: 'create' })
+export class AgentsCreateCommand extends CommandRunner {
+  public constructor(
+    protected moduleRef: ModuleRef,
+    private readonly inquirer: InquirerService,
+    private readonly agentsService: AgentsService,
+  ) {
+    super();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async run(inputs: string[], options: any): Promise<void> {
+    const agent = await this.inquirer.ask<AgentsCreateDto>('agent-create-questions', undefined);
+    try {
+      await this.agentsService.create(agent);
+      console.log('Agent created successfully');
+    } catch (error) {
+      console.error('Error creating agent', error);
+    }
+  }
+}
+
+@Command({ name: 'agents', arguments: '<task>', subCommands: [AgentsCreateCommand] })
+export class AgentsCommand extends CommandRunner {
+  public constructor(protected moduleRef: ModuleRef) {
+    super();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async run(inputs: string[], options: any): Promise<void> {}
+}

src/cli/cli.module.ts

@@ -0,0 +1,65 @@
+import { Module } from '@nestjs/common';
+import { AgentCreateQuestions, AgentsCommand } from './agents.command';
+import { ConfigModule, ConfigService } from '@nestjs/config';
+import { BullModule } from '@nestjs/bullmq';
+import { RedisOptions } from 'ioredis';
+import { RedisModule } from '@nestjs-modules/ioredis';
+import { MongooseModule, MongooseModuleOptions } from '@nestjs/mongoose';
+import mongoose from 'mongoose';
+import config, { MongoosePlugin } from '~/config';
+import { AgentsModule } from '~/core/agents/agents.module';
+import { KeyringsCommand, KeyringsCreateQuestions } from './keyrings.command';
+import { KeyringsModule } from '~/core/keyrings/keyrings.module';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [config],
+    }),
+    MongooseModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (config: ConfigService) => {
+        for (const plugin of config.get<MongoosePlugin[]>('mongoose.plugins')) {
+          import(plugin.package).then((plugin) => {
+            mongoose.plugin(plugin.default ? plugin.default : plugin, plugin.options);
+          });
+        }
+        return {
+          ...config.get<MongooseModuleOptions>('mongoose.options'),
+          uri: config.get<string>('mongoose.uri'),
+        };
+      },
+    }),
+    RedisModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (config: ConfigService) => ({
+        config: {
+          ...config.get<RedisOptions>('ioredis.options'),
+          url: config.get<string>('ioredis.uri'),
+        },
+      }),
+    }),
+    BullModule.forRootAsync({
+      imports: [ConfigModule],
+      inject: [ConfigService],
+      useFactory: async (configService: ConfigService) => ({
+        connection: {
+          host: configService.get('ioredis.host'),
+          port: configService.get('ioredis.port'),
+        },
+      }),
+    }),
+    AgentsModule,
+    KeyringsModule,
+  ],
+  providers: [
+    ...AgentsCommand.registerWithSubCommands(),
+    ...KeyringsCommand.registerWithSubCommands(),
+    AgentCreateQuestions,
+    KeyringsCreateQuestions,
+  ],
+})
+export class CliModule {}

src/cli/keyrings.command.ts

@@ -0,0 +1,47 @@
+import { ModuleRef } from '@nestjs/core';
+import { Command, CommandRunner, InquirerService, Question, QuestionSet, SubCommand } from 'nest-commander';
+import { KeyringsCreateDto } from '~/core/keyrings/_dto/keyrings.dto';
+import { KeyringsService } from '~/core/keyrings/keyrings.service';
+
+@QuestionSet({ name: 'keyrings-create-questions' })
+export class KeyringsCreateQuestions {
+  @Question({
+    message: 'Name ?',
+    name: 'name',
+  })
+  parseName(val: string) {
+    return val;
+  }
+}
+
+@SubCommand({ name: 'create' })
+export class KeyringsCreateCommand extends CommandRunner {
+  public constructor(
+    protected moduleRef: ModuleRef,
+    private readonly inquirer: InquirerService,
+    private readonly keyringsService: KeyringsService,
+  ) {
+    super();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async run(inputs: string[], options: any): Promise<void> {
+    const keyring = await this.inquirer.ask<KeyringsCreateDto>('keyrings-create-questions', undefined);
+    try {
+      const key = await this.keyringsService.create(keyring);
+      console.log('Keyring created successfully', key.toJSON());
+    } catch (error) {
+      console.error('Error creating keyring', error);
+    }
+  }
+}
+
+@Command({ name: 'keyrings', arguments: '<task>', subCommands: [KeyringsCreateCommand] })
+export class KeyringsCommand extends CommandRunner {
+  public constructor(protected moduleRef: ModuleRef) {
+    super();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async run(inputs: string[], options: any): Promise<void> {}
+}

src/console.ts

@@ -0,0 +1,27 @@
+import { CommandFactory } from 'nest-commander';
+import configInstance from '~/config';
+import { getLogLevel } from './_common/functions/get-log-level';
+import { CliModule } from './cli/cli.module';
+import { InternalLogger } from './core/logger/internal.logger';
+
+(async () => {
+  try {
+    const cfg = configInstance();
+    const logger = new InternalLogger({
+      logLevel: getLogLevel(cfg?.application?.logLevel),
+      mongoose: cfg?.mongoose,
+    });
+    const app = await CommandFactory.runWithoutClosing(CliModule, {
+      logger,
+      errorHandler: (err) => {
+        console.error(err);
+        process.exit(1);
+      },
+    });
+    await app.close();
+  } catch (err) {
+    console.error(err);
+    process.exit(255);
+  }
+  process.exit(0);
+})();

src/contextId.ts

@@ -0,0 +1,19 @@
+import { INestApplicationContext } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core/injector/module-ref';
+import { ContextIdFactory } from '@nestjs/core';
+
+// eslint-disable-next-line
+export const seedRequestContextId = <T extends { user?: any }>(app: INestApplicationContext | ModuleRef, req?: T) => {
+  const contextId = ContextIdFactory.create();
+  app.registerRequestByContextId(
+    {
+      ...req,
+      user: {
+        _id: '000000000000000000000000',
+        ...req?.user,
+      },
+    },
+    contextId,
+  );
+  return contextId;
+};

src/core/agents/agents.module.ts

@@ -3,6 +3,7 @@ import { MongooseModule } from '@nestjs/mongoose';
 import { AgentsSchema, Agents } from '~/core/agents/_schemas/agents.schema';
 import { AgentsService } from './agents.service';
 import { AgentsController } from './agents.controller';
+// import { AgentsCommand } from '~/cli/agents.command';
 
 @Module({
   imports: [
@@ -13,7 +14,7 @@ import { AgentsController } from './agents.controller';
       },
     ]),
   ],
-  providers: [AgentsService],
+  providers: [AgentsService /* ...AgentsCommand.registerWithSubCommands() */],
   controllers: [AgentsController],
   exports: [AgentsService],
 })

src/core/keyrings/_dto/keyrings.dto.ts

@@ -3,6 +3,11 @@ import { IsDateString, IsIP, IsMongoId, IsNotEmpty, IsString } from 'class-valid
 import { CustomFieldsDto } from '~/_common/abstracts/dto/custom-fields.dto';
 
 export class KeyringsCreateDto extends CustomFieldsDto {
+  @IsString()
+  @IsNotEmpty()
+  @ApiProperty()
+  public name: string;
+
   @IsString()
   @IsNotEmpty()
   @ApiProperty()

src/core/keyrings/_schemas/keyrings.schema.ts

@@ -6,6 +6,12 @@ export type KeyringsDocument = Keyrings & Document;
 
 @Schema({ versionKey: false })
 export class Keyrings extends AbstractSchema {
+  @Prop({
+    type: String,
+    unique: true,
+  })
+  public name: string;
+
   @Prop({
     type: String,
     unique: true,
@@ -14,6 +20,7 @@ export class Keyrings extends AbstractSchema {
 
   @Prop({
     type: [String],
+    default: ['0.0.0.0/0'],
   })
   public allowedNetworks?: string[];