Playground - adds a platform for users to fiddle with cloudknit

api/src/app.module.ts

@@ -10,6 +10,7 @@ import { CachingService } from './caching/caching.service';
 import { ComponentModule } from './component/component.module';
 import { EnvironmentModule } from './environment/environment.module';
 import { ErrorsModule } from './errors/errors.module';
+import { GithubApiModule } from './github-api/github-api.module';
 import { AppLoggerMiddleware } from './middleware/logger.middle';
 import { OperationsModule } from './operations/operations.module';
 import { OrganizationModule } from './organization/organization.module';
@@ -45,6 +46,7 @@ import { UsersModule } from './users/users.module';
     StreamModule,
     CachingModule,
     ErrorsModule,
+    GithubApiModule,
   ],
   controllers: [],
   providers: [CachingService],

api/src/config.ts

@@ -9,6 +9,10 @@ export type ApiConfig = {
     database: string;
   };
   port: number;
+  github: {
+    owner: string,
+    repo: string,
+  }
   AWS: {
     accessKeyId: string;
     secretAccessKey: string;
@@ -62,6 +66,10 @@ export function init() {
       database: getEnvVarOrFail('TYPEORM_DATABASE')
     },
     port: parseInt(process.env.APP_PORT) || 3000,
+    github: {
+      owner: getEnvVarOrDefault('GIT_OWNER', 'zlab-tech'),
+      repo: getEnvVarOrDefault('GIT_REPO', 'hooli-config'),
+    },
     AWS: {
       accessKeyId: getEnvVarOrFail('AWS_ACCESS_KEY_ID'),
       secretAccessKey: getEnvVarOrFail('AWS_SECRET_ACCESS_KEY'),

api/src/environment/environment.module.ts

@@ -36,8 +36,9 @@ import { SystemService } from 'src/system/system.service';
     EnvironmentService,
     TeamService,
     ReconciliationService,
-    SystemService
+    SystemService,
   ],
+  exports: [EnvironmentService],
 })
 export class EnvironmentModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {

api/src/github-api/github-api.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { GithubApiController } from './github-api.controller';
+
+describe('GithubApiController', () => {
+  let controller: GithubApiController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [GithubApiController],
+    }).compile();
+
+    controller = module.get<GithubApiController>(GithubApiController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

api/src/github-api/github-api.controller.ts

@@ -0,0 +1,27 @@
+import { Controller, Post, Request } from '@nestjs/common';
+import { ApiTags } from '@nestjs/swagger';
+import { EnvironmentService } from 'src/environment/environment.service';
+import { APIRequest, EnvironmentApiParam } from 'src/types';
+import { GithubApiService } from './github-api.service';
+import { get } from 'src/config';
+
+@Controller({
+  version: '1',
+})
+@ApiTags('github-api')
+export class GithubApiController {
+  constructor(
+    private readonly envSvc: EnvironmentService,
+    private readonly gitSvc: GithubApiService
+  ) {}
+
+  @Post('/:environmentId')
+  @EnvironmentApiParam()
+  async gitCommit(@Request() req: APIRequest) {
+    const { org, team, env } = req;
+    const environment = await this.envSvc.findById(org, env.id);
+    if (environment) {
+      return this.gitSvc.gitCommit(org, get().github.owner, get().github.repo, `environments/demo/env.yaml`);
+    }
+  }
+}

api/src/github-api/github-api.module.ts

@@ -0,0 +1,22 @@
+import { MiddlewareConsumer, Module, RequestMethod } from '@nestjs/common';
+import { GithubApiController } from './github-api.controller';
+import { EnvironmentService } from 'src/environment/environment.service';
+import { EnvironmentMiddleware } from 'src/middleware/environment.middle';
+import { GithubApiService } from './github-api.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Environment } from 'src/typeorm/environment.entity';
+import { SecretsService } from 'src/secrets/secrets.service';
+
+@Module({
+  imports: [TypeOrmModule.forFeature([Environment])],
+  controllers: [GithubApiController],
+  providers: [EnvironmentService, GithubApiService, SecretsService],
+})
+export class GithubApiModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer.apply(EnvironmentMiddleware).forRoutes({
+      path: '*/github/:environmentId*',
+      method: RequestMethod.ALL,
+    });
+  }
+}

api/src/github-api/github-api.service.ts

@@ -0,0 +1,77 @@
+import { Injectable, InternalServerErrorException } from '@nestjs/common';
+import axios from 'axios';
+import { get } from 'src/config';
+import { SecretsService } from 'src/secrets/secrets.service';
+import { Organization } from 'src/typeorm';
+
+@Injectable()
+export class GithubApiService {
+  private readonly baseUri: string = 'https://api.github.com/repos';
+  private readonly headers = async (org: Organization) => ({
+    Accept: 'application/vnd.github+json',
+    Authorization: `Bearer ${await this.getGITPAT(org)}`,
+    'X-GitHub-Api-Version': '2022-11-28',
+  });
+
+  constructor(private readonly secretSvc: SecretsService){}
+
+  private getURL(owner: string, repo: string, filePath: string) {
+    return `${this.baseUri}/${owner}/${repo}/contents/${filePath}`;
+  }
+
+  private async getFileSHA(org: Organization, owner: string, repo: string, filePath: string) {
+    const url = this.getURL(owner, repo, filePath);
+    const { data } = await axios.get<{ sha: string; content: string }>(url, {
+      headers: await this.headers(org),
+    });
+    return data;
+  }
+
+  public setAlternateFlag(yamlString: string) {
+    const decodedYaml = Buffer.from(yamlString, 'base64').toString();
+    console.log(decodedYaml);
+    if (decodedYaml.includes('teardown: true')) {
+      return Buffer.from(
+        decodedYaml.replace('teardown: true', 'teardown: false')
+      ).toString('base64');
+    }
+    return Buffer.from(
+      decodedYaml.replace('teardown: false', 'teardown: true')
+    ).toString('base64');
+  }
+
+  public async gitCommit(org: Organization, owner: string, repo: string, filePath: string) {
+    const { sha, content } = await this.getFileSHA(org, owner, repo, filePath);
+    const payload = {
+      message: 'api testing for playground ',
+      committer: { name: 'playground', email: 'playground@cloudknit.io' },
+      content: this.setAlternateFlag(content),
+      sha,
+    };
+
+    try {
+      const { data } = await axios.put(
+        this.getURL(owner, repo, filePath),
+        payload,
+        {
+          headers: await this.headers(org),
+        }
+      );
+
+      const { commit } = data;
+      const { html_url } = commit;
+      return {
+        status: 'success',
+        html_url,
+      };
+    } catch (err) {
+      throw new InternalServerErrorException(
+        'There was an error while pushing the commit to git'
+      );
+    }
+  }
+
+  private async getGITPAT(org: Organization) {
+    return await this.secretSvc.getSsmSecret(org, 'playground-git-token');
+  }
+}

api/src/organization/organization.module.ts

@@ -15,6 +15,7 @@ import { OrganizationService } from './organization.service';
   imports: [TypeOrmModule.forFeature([Organization, User])],
   controllers: [OrganizationController],
   providers: [OrganizationService, UsersService],
+  exports: [OrganizationService],
 })
 export class OrganizationModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {

api/src/routes.ts

@@ -11,6 +11,7 @@ import { EnvironmentModule } from './environment/environment.module';
 import { ComponentModule } from './component/component.module';
 import { StreamModule } from './stream/stream.module';
 import { ErrorsModule } from './errors/errors.module';
+import { GithubApiModule } from './github-api/github-api.module';
 
 export const appRoutes: Routes = [
   {
@@ -58,10 +59,15 @@ export const appRoutes: Routes = [
                 module: ComponentModule,
               },
             ],
-          }, {
+          },
+          {
+            path: '/:teamId/github',
+            module: GithubApiModule,
+          },
+          {
             path: '/:teamId/errors',
-            module: ErrorsModule
-          }
+            module: ErrorsModule,
+          },
         ],
       },
     ],

api/src/secrets/secrets.module.ts

@@ -5,5 +5,6 @@ import { SecretsService } from './secrets.service';
 @Module({
   controllers: [SecretsController],
   providers: [SecretsService],
+  exports: [SecretsService]
 })
 export class SecretsModule {}

api/src/typeorm/User.entity.ts

@@ -8,6 +8,7 @@ import {
   UpdateDateColumn,
 } from 'typeorm';
 import { Organization } from './Organization.entity';
+import { UserRole } from 'src/types';
 
 @Entity({ name: 'users' })
 export class User {
@@ -35,13 +36,19 @@ export class User {
   @Column({
     default: 'User',
   })
-  role: string;
+  role: UserRole;
 
   @Column({
     default: false,
   })
   archived: boolean;
 
+  @Column({
+    default: null,
+    unique: true
+  })
+  ipv4: string;
+
   @ManyToMany(() => Organization, (org) => org.users)
   organizations: Organization[];
 

api/src/typeorm/migrations/1683899743907-UserIpForPlayground.js

@@ -0,0 +1,9 @@
+module.exports = class UserIpForPlayground1683899743907 {
+  async up(queryRunner) {
+    await queryRunner.query(
+      'ALTER TABLE `USERS` ADD COLUMN `ipv4` varchar(255) UNIQUE default null'
+    );
+  }
+
+  async down(queryRunner) {}
+};

api/src/types.ts

@@ -5,6 +5,12 @@ import { Request } from 'express';
 import { ComponentReconcile, Environment, EnvironmentReconcile, Team } from './typeorm';
 import { Organization } from './typeorm/Organization.entity';
 
+export enum UserRole {
+  ADMIN = 'Admin',
+  USER = 'User',
+  GUEST = 'Guest'
+}
+
 export type APIRequest = Request & {
   org: Organization;
   team: Team;

api/src/users/User.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty } from '@nestjs/swagger';
+import { UserRole } from 'src/types';
 
 export class CreateUserDto {
   @ApiProperty()
@@ -8,14 +9,19 @@ export class CreateUserDto {
   email: string;
 
   @ApiProperty({
-    default: 'User',
+    default: UserRole.USER,
   })
-  role: string;
+  role: UserRole;
 
   @ApiProperty()
   name: string;
 }
 
+export class CreatePlaygroundUserDto {
+  @ApiProperty()
+  ipv4: string;
+}
+
 export class PatchUserDto {
   @ApiProperty({
     default: null,

api/src/users/users.controller.ts

@@ -2,13 +2,11 @@ import {
   Body,
   Controller,
   Get,
-  Logger,
   NotFoundException,
   Param,
-  Post,
+  Post
 } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
-import { AuthController } from 'src/auth/auth.controller';
 import { User } from 'src/typeorm/User.entity';
 import { CreateUserDto } from './User.dto';
 import { UsersService } from './users.service';
@@ -18,12 +16,12 @@ import { UsersService } from './users.service';
 })
 @ApiTags('users')
 export class UsersController {
-  private readonly logger = new Logger(AuthController.name);
 
   constructor(private readonly userService: UsersService) {}
 
   @Get('/:username')
   public async getUser(@Param('username') username: string): Promise<User> {
+    console.log(username);
     const user = await this.userService.getUser(username);
 
     if (!user) {
@@ -35,6 +33,7 @@ export class UsersController {
 
   @Post()
   public async createUser(@Body() body: CreateUserDto): Promise<User> {
+    console.log(body);
     const user = await this.userService.create(body);
 
     return user;

api/src/users/users.module.ts

@@ -3,9 +3,10 @@ import { TypeOrmModule } from '@nestjs/typeorm';
 import { User } from 'src/typeorm/User.entity';
 import { UsersController } from './users.controller';
 import { UsersService } from './users.service';
+import { Organization } from 'src/typeorm';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([User])],
+  imports: [TypeOrmModule.forFeature([User, Organization])],
   controllers: [UsersController],
   providers: [UsersService],
   exports: [UsersService],