Implement polling for project deployment updates (#87)

* Populate organization and user if db is empty

* Use hardcoded user id from fixtures

* Implement polling for get deployments query

* Handle review changes

---------

Co-authored-by: neeraj <neeraj.rtly@gmail.com>

packages/backend/src/constants.ts

@@ -5,6 +5,6 @@ export const DEFAULT_CONFIG_FILE_PATH = process.env.SNOWBALL_BACKEND_CONFIG_FILE
 export const DEFAULT_GQL_PATH = '/graphql';
 
 // Note: temporary hardcoded user, later to be derived from auth token
-export const USER_ID = process.env.SNOWBALL_BACKEND_USER_ID || '60f4355d-9549-4aac-9b54-eeefceeabef0';
+export const USER_ID = process.env.SNOWBALL_BACKEND_USER_ID || '59f4355d-9549-4aac-9b54-eeefceeabef0';
 
 export const PROJECT_DOMAIN = process.env.SNOWBALL_BACKEND_PROJECT_DOMAIN || 'snowball.xyz';

packages/backend/src/database.ts

@@ -14,6 +14,12 @@ import { ProjectMember } from './entity/ProjectMember';
 import { EnvironmentVariable } from './entity/EnvironmentVariable';
 import { Domain } from './entity/Domain';
 import { PROJECT_DOMAIN } from './constants';
+import { getEntities, loadAndSaveData } from './utils';
+import { UserOrganization } from './entity/UserOrganization';
+
+const ORGANIZATION_DATA_PATH = '../test/fixtures/organizations.json';
+const USER_DATA_PATH = '../test/fixtures/users.json';
+const USER_ORGANIZATION_DATA_PATH = '../test/fixtures/user-organizations.json';
 
 const log = debug('snowball:database');
 
@@ -36,6 +42,25 @@ export class Database {
   async init (): Promise<void> {
     await this.dataSource.initialize();
     log('database initialized');
+
+    const organizations = await this.getOrganizations({});
+
+    if (!organizations.length) {
+      const orgEntities = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH));
+      const savedOrgs = await loadAndSaveData(Organization, this.dataSource, [orgEntities[0]]);
+
+      // TODO: Remove user once authenticated
+      const userEntities = await getEntities(path.resolve(__dirname, USER_DATA_PATH));
+      const savedUsers = await loadAndSaveData(User, this.dataSource, [userEntities[0]]);
+
+      const userOrganizationRelations = {
+        member: savedUsers,
+        organization: savedOrgs
+      };
+
+      const userOrgEntities = await getEntities(path.resolve(__dirname, USER_ORGANIZATION_DATA_PATH));
+      await loadAndSaveData(UserOrganization, this.dataSource, [userOrgEntities[0]], userOrganizationRelations);
+    }
   }
 
   async getUser (options: FindOneOptions<User>): Promise<User | null> {
@@ -60,6 +85,13 @@ export class Database {
     return updateResult.affected > 0;
   }
 
+  async getOrganizations (options: FindManyOptions<Organization>): Promise<Organization[]> {
+    const organizationRepository = this.dataSource.getRepository(Organization);
+    const organizations = await organizationRepository.find(options);
+
+    return organizations;
+  }
+
   async getOrganization (options: FindOneOptions<Organization>): Promise<Organization | null> {
     const organizationRepository = this.dataSource.getRepository(Organization);
     const organization = await organizationRepository.findOne(options);

packages/backend/src/utils.ts

@@ -2,6 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import toml from 'toml';
 import debug from 'debug';
+import { DataSource, DeepPartial, EntityTarget, ObjectLiteral } from 'typeorm';
 
 const log = debug('snowball:utils');
 
@@ -19,3 +20,44 @@ export const getConfig = async <ConfigType>(
 
   return config;
 };
+
+export const checkFileExists = async (filePath: string): Promise<boolean> => {
+  try {
+    await fs.access(filePath, fs.constants.F_OK);
+    return true;
+  } catch (err) {
+    log(err);
+    return false;
+  }
+};
+
+export const getEntities = async (filePath: string): Promise<any> => {
+  const entitiesData = await fs.readFile(filePath, 'utf-8');
+  const entities = JSON.parse(entitiesData);
+  return entities;
+};
+
+export const loadAndSaveData = async <Entity extends ObjectLiteral>(entityType: EntityTarget<Entity>, dataSource: DataSource, entities: any, relations?: any | undefined): Promise<Entity[]> => {
+  const entityRepository = dataSource.getRepository(entityType);
+
+  const savedEntity:Entity[] = [];
+
+  for (const entityData of entities) {
+    let entity = entityRepository.create(entityData as DeepPartial<Entity>);
+
+    if (relations) {
+      for (const field in relations) {
+        const valueIndex = String(field + 'Index');
+
+        entity = {
+          ...entity,
+          [field]: relations[field][entityData[valueIndex]]
+        };
+      }
+    }
+    const dbEntity = await entityRepository.save(entity);
+    savedEntity.push(dbEntity);
+  }
+
+  return savedEntity;
+};