546 lines
15 KiB
TypeScript
546 lines
15 KiB
TypeScript
import {
|
|
DataSource,
|
|
DeepPartial,
|
|
FindManyOptions,
|
|
FindOneOptions,
|
|
FindOptionsWhere
|
|
} from 'typeorm';
|
|
import path from 'path';
|
|
import debug from 'debug';
|
|
import assert from 'assert';
|
|
import { customAlphabet } from 'nanoid';
|
|
import { lowercase, numbers } from 'nanoid-dictionary';
|
|
|
|
import { DatabaseConfig, MiscConfig } from './config';
|
|
import { User } from './entity/User';
|
|
import { Organization } from './entity/Organization';
|
|
import { Project } from './entity/Project';
|
|
import { Deployment } from './entity/Deployment';
|
|
import { ProjectMember } from './entity/ProjectMember';
|
|
import { EnvironmentVariable } from './entity/EnvironmentVariable';
|
|
import { Domain } from './entity/Domain';
|
|
import { getEntities, loadAndSaveData } from './utils';
|
|
import { UserOrganization } from './entity/UserOrganization';
|
|
|
|
const ORGANIZATION_DATA_PATH = '../test/fixtures/organizations.json';
|
|
|
|
const log = debug('snowball:database');
|
|
|
|
const nanoid = customAlphabet(lowercase + numbers, 8);
|
|
|
|
// TODO: Fix order of methods
|
|
export class Database {
|
|
private dataSource: DataSource;
|
|
private projectDomain: string;
|
|
|
|
constructor ({ dbPath } : DatabaseConfig, { projectDomain } : MiscConfig) {
|
|
this.dataSource = new DataSource({
|
|
type: 'better-sqlite3',
|
|
database: dbPath,
|
|
entities: [path.join(__dirname, '/entity/*')],
|
|
synchronize: true,
|
|
logging: false
|
|
});
|
|
|
|
this.projectDomain = projectDomain;
|
|
}
|
|
|
|
async init (): Promise<void> {
|
|
await this.dataSource.initialize();
|
|
log('database initialized');
|
|
|
|
const organizations = await this.getOrganizations({});
|
|
|
|
// Load an organization if none exist
|
|
if (!organizations.length) {
|
|
const orgEntities = await getEntities(path.resolve(__dirname, ORGANIZATION_DATA_PATH));
|
|
await loadAndSaveData(Organization, this.dataSource, [orgEntities[0]]);
|
|
}
|
|
}
|
|
|
|
async getUser (options: FindOneOptions<User>): Promise<User | null> {
|
|
const userRepository = this.dataSource.getRepository(User);
|
|
const user = await userRepository.findOne(options);
|
|
|
|
return user;
|
|
}
|
|
|
|
async addUser (data: DeepPartial<User>): Promise<User> {
|
|
const userRepository = this.dataSource.getRepository(User);
|
|
const user = await userRepository.save(data);
|
|
|
|
return user;
|
|
}
|
|
|
|
async updateUser (user: User, data: DeepPartial<User>): Promise<boolean> {
|
|
const userRepository = this.dataSource.getRepository(User);
|
|
const updateResult = await userRepository.update({ id: user.id }, data);
|
|
assert(updateResult.affected);
|
|
|
|
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);
|
|
|
|
return organization;
|
|
}
|
|
|
|
async getOrganizationsByUserId (userId: string): Promise<Organization[]> {
|
|
const organizationRepository = this.dataSource.getRepository(Organization);
|
|
|
|
const userOrgs = await organizationRepository.find({
|
|
where: {
|
|
userOrganizations: {
|
|
member: {
|
|
id: userId
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
return userOrgs;
|
|
}
|
|
|
|
async addUserOrganization (data: DeepPartial<UserOrganization>): Promise<UserOrganization> {
|
|
const userOrganizationRepository = this.dataSource.getRepository(UserOrganization);
|
|
const newUserOrganization = await userOrganizationRepository.save(data);
|
|
|
|
return newUserOrganization;
|
|
}
|
|
|
|
async getProjects (options: FindManyOptions<Project>): Promise<Project[]> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
const projects = await projectRepository.find(options);
|
|
|
|
return projects;
|
|
}
|
|
|
|
async getProjectById (projectId: string): Promise<Project | null> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
|
|
const project = await projectRepository
|
|
.createQueryBuilder('project')
|
|
.leftJoinAndSelect(
|
|
'project.deployments',
|
|
'deployments',
|
|
'deployments.isCurrent = true'
|
|
)
|
|
.leftJoinAndSelect('deployments.createdBy', 'user')
|
|
.leftJoinAndSelect('deployments.domain', 'domain')
|
|
.leftJoinAndSelect('project.owner', 'owner')
|
|
.leftJoinAndSelect('project.organization', 'organization')
|
|
.where('project.id = :projectId', {
|
|
projectId
|
|
})
|
|
.getOne();
|
|
|
|
return project;
|
|
}
|
|
|
|
async getProjectsInOrganization (
|
|
userId: string,
|
|
organizationSlug: string
|
|
): Promise<Project[]> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
|
|
const projects = await projectRepository
|
|
.createQueryBuilder('project')
|
|
.leftJoinAndSelect(
|
|
'project.deployments',
|
|
'deployments',
|
|
'deployments.isCurrent = true'
|
|
)
|
|
.leftJoinAndSelect('deployments.domain', 'domain')
|
|
.leftJoin('project.projectMembers', 'projectMembers')
|
|
.leftJoin('project.organization', 'organization')
|
|
.where(
|
|
'(project.ownerId = :userId OR projectMembers.userId = :userId) AND organization.slug = :organizationSlug',
|
|
{
|
|
userId,
|
|
organizationSlug
|
|
}
|
|
)
|
|
.getMany();
|
|
|
|
return projects;
|
|
}
|
|
|
|
/**
|
|
* Get deployments with specified filter
|
|
*/
|
|
async getDeployments (
|
|
options: FindManyOptions<Deployment>
|
|
): Promise<Deployment[]> {
|
|
const deploymentRepository = this.dataSource.getRepository(Deployment);
|
|
const deployments = await deploymentRepository.find(options);
|
|
|
|
return deployments;
|
|
}
|
|
|
|
async getDeploymentsByProjectId (projectId: string): Promise<Deployment[]> {
|
|
return this.getDeployments({
|
|
relations: {
|
|
project: true,
|
|
domain: true,
|
|
createdBy: true
|
|
},
|
|
where: {
|
|
project: {
|
|
id: projectId
|
|
}
|
|
},
|
|
order: {
|
|
createdAt: 'DESC'
|
|
}
|
|
});
|
|
}
|
|
|
|
async getDeployment (
|
|
options: FindOneOptions<Deployment>
|
|
): Promise<Deployment | null> {
|
|
const deploymentRepository = this.dataSource.getRepository(Deployment);
|
|
const deployment = await deploymentRepository.findOne(options);
|
|
|
|
return deployment;
|
|
}
|
|
|
|
async getDomains (options: FindManyOptions<Domain>): Promise<Domain[]> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
const domains = await domainRepository.find(options);
|
|
|
|
return domains;
|
|
}
|
|
|
|
async addDeployment (data: DeepPartial<Deployment>): Promise<Deployment> {
|
|
const deploymentRepository = this.dataSource.getRepository(Deployment);
|
|
|
|
const id = nanoid();
|
|
|
|
const updatedData = {
|
|
...data,
|
|
id
|
|
};
|
|
const deployment = await deploymentRepository.save(updatedData);
|
|
|
|
return deployment;
|
|
}
|
|
|
|
async getProjectMembersByProjectId (
|
|
projectId: string
|
|
): Promise<ProjectMember[]> {
|
|
const projectMemberRepository =
|
|
this.dataSource.getRepository(ProjectMember);
|
|
|
|
const projectMembers = await projectMemberRepository.find({
|
|
relations: {
|
|
project: true,
|
|
member: true
|
|
},
|
|
where: {
|
|
project: {
|
|
id: projectId
|
|
}
|
|
}
|
|
});
|
|
|
|
return projectMembers;
|
|
}
|
|
|
|
async getEnvironmentVariablesByProjectId (
|
|
projectId: string,
|
|
filter?: FindOptionsWhere<EnvironmentVariable>
|
|
): Promise<EnvironmentVariable[]> {
|
|
const environmentVariableRepository =
|
|
this.dataSource.getRepository(EnvironmentVariable);
|
|
|
|
const environmentVariables = await environmentVariableRepository.find({
|
|
where: {
|
|
project: {
|
|
id: projectId
|
|
},
|
|
...filter
|
|
}
|
|
});
|
|
|
|
return environmentVariables;
|
|
}
|
|
|
|
async removeProjectMemberById (projectMemberId: string): Promise<boolean> {
|
|
const projectMemberRepository =
|
|
this.dataSource.getRepository(ProjectMember);
|
|
|
|
const deleteResult = await projectMemberRepository.delete({
|
|
id: projectMemberId
|
|
});
|
|
|
|
if (deleteResult.affected) {
|
|
return deleteResult.affected > 0;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async updateProjectMemberById (
|
|
projectMemberId: string,
|
|
data: DeepPartial<ProjectMember>
|
|
): Promise<boolean> {
|
|
const projectMemberRepository =
|
|
this.dataSource.getRepository(ProjectMember);
|
|
const updateResult = await projectMemberRepository.update(
|
|
{ id: projectMemberId },
|
|
data
|
|
);
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async addProjectMember (
|
|
data: DeepPartial<ProjectMember>
|
|
): Promise<ProjectMember> {
|
|
const projectMemberRepository =
|
|
this.dataSource.getRepository(ProjectMember);
|
|
const newProjectMember = await projectMemberRepository.save(data);
|
|
|
|
return newProjectMember;
|
|
}
|
|
|
|
async addEnvironmentVariables (
|
|
data: DeepPartial<EnvironmentVariable>[]
|
|
): Promise<EnvironmentVariable[]> {
|
|
const environmentVariableRepository =
|
|
this.dataSource.getRepository(EnvironmentVariable);
|
|
const savedEnvironmentVariables =
|
|
await environmentVariableRepository.save(data);
|
|
|
|
return savedEnvironmentVariables;
|
|
}
|
|
|
|
async updateEnvironmentVariable (
|
|
environmentVariableId: string,
|
|
data: DeepPartial<EnvironmentVariable>
|
|
): Promise<boolean> {
|
|
const environmentVariableRepository =
|
|
this.dataSource.getRepository(EnvironmentVariable);
|
|
const updateResult = await environmentVariableRepository.update(
|
|
{ id: environmentVariableId },
|
|
data
|
|
);
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async deleteEnvironmentVariable (
|
|
environmentVariableId: string
|
|
): Promise<boolean> {
|
|
const environmentVariableRepository =
|
|
this.dataSource.getRepository(EnvironmentVariable);
|
|
const deleteResult = await environmentVariableRepository.delete({
|
|
id: environmentVariableId
|
|
});
|
|
|
|
if (deleteResult.affected) {
|
|
return deleteResult.affected > 0;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async getProjectMemberById (projectMemberId: string): Promise<ProjectMember> {
|
|
const projectMemberRepository =
|
|
this.dataSource.getRepository(ProjectMember);
|
|
|
|
const projectMemberWithProject = await projectMemberRepository.find({
|
|
relations: {
|
|
project: {
|
|
owner: true
|
|
},
|
|
member: true
|
|
},
|
|
where: {
|
|
id: projectMemberId
|
|
}
|
|
});
|
|
|
|
if (projectMemberWithProject.length === 0) {
|
|
throw new Error('Member does not exist');
|
|
}
|
|
|
|
return projectMemberWithProject[0];
|
|
}
|
|
|
|
async getProjectsBySearchText (
|
|
userId: string,
|
|
searchText: string
|
|
): Promise<Project[]> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
|
|
const projects = await projectRepository
|
|
.createQueryBuilder('project')
|
|
.leftJoinAndSelect('project.organization', 'organization')
|
|
.leftJoin('project.projectMembers', 'projectMembers')
|
|
.where(
|
|
'(project.owner = :userId OR projectMembers.member.id = :userId) AND project.name LIKE :searchText',
|
|
{
|
|
userId,
|
|
searchText: `%${searchText}%`
|
|
}
|
|
)
|
|
.getMany();
|
|
|
|
return projects;
|
|
}
|
|
|
|
async updateDeploymentById (
|
|
deploymentId: string,
|
|
data: DeepPartial<Deployment>
|
|
): Promise<boolean> {
|
|
return this.updateDeployment({ id: deploymentId }, data);
|
|
}
|
|
|
|
async updateDeployment (
|
|
criteria: FindOptionsWhere<Deployment>,
|
|
data: DeepPartial<Deployment>
|
|
): Promise<boolean> {
|
|
const deploymentRepository = this.dataSource.getRepository(Deployment);
|
|
const updateResult = await deploymentRepository.update(criteria, data);
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async updateDeploymentsByProjectIds (
|
|
projectIds: string[],
|
|
data: DeepPartial<Deployment>
|
|
): Promise<boolean> {
|
|
const deploymentRepository = this.dataSource.getRepository(Deployment);
|
|
|
|
const updateResult = await deploymentRepository
|
|
.createQueryBuilder()
|
|
.update(Deployment)
|
|
.set(data)
|
|
.where('projectId IN (:...projectIds)', { projectIds })
|
|
.execute();
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async addProject (user: User, organizationId: string, data: DeepPartial<Project>): Promise<Project> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
|
|
// TODO: Check if organization exists
|
|
const newProject = projectRepository.create(data);
|
|
// TODO: Set default empty array for webhooks in TypeORM
|
|
newProject.webhooks = [];
|
|
// TODO: Set icon according to framework
|
|
newProject.icon = '';
|
|
|
|
newProject.owner = user;
|
|
|
|
newProject.organization = Object.assign(new Organization(), {
|
|
id: organizationId
|
|
});
|
|
|
|
newProject.subDomain = `${newProject.name}.${this.projectDomain}`;
|
|
|
|
return projectRepository.save(newProject);
|
|
}
|
|
|
|
async updateProjectById (
|
|
projectId: string,
|
|
data: DeepPartial<Project>
|
|
): Promise<boolean> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
const updateResult = await projectRepository.update(
|
|
{ id: projectId },
|
|
data
|
|
);
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async deleteProjectById (projectId: string): Promise<boolean> {
|
|
const projectRepository = this.dataSource.getRepository(Project);
|
|
const project = await projectRepository.findOneOrFail({
|
|
where: {
|
|
id: projectId
|
|
},
|
|
relations: {
|
|
projectMembers: true
|
|
}
|
|
});
|
|
|
|
const deleteResult = await projectRepository.softRemove(project);
|
|
|
|
return Boolean(deleteResult);
|
|
}
|
|
|
|
async deleteDomainById (domainId: string): Promise<boolean> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
|
|
const deleteResult = await domainRepository.softDelete({ id: domainId });
|
|
|
|
if (deleteResult.affected) {
|
|
return deleteResult.affected > 0;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async addDomain (data: DeepPartial<Domain>): Promise<Domain> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
const newDomain = await domainRepository.save(data);
|
|
|
|
return newDomain;
|
|
}
|
|
|
|
async getDomain (options: FindOneOptions<Domain>): Promise<Domain | null> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
const domain = await domainRepository.findOne(options);
|
|
|
|
return domain;
|
|
}
|
|
|
|
async updateDomainById (
|
|
domainId: string,
|
|
data: DeepPartial<Domain>
|
|
): Promise<boolean> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
const updateResult = await domainRepository.update({ id: domainId }, data);
|
|
|
|
return Boolean(updateResult.affected);
|
|
}
|
|
|
|
async getDomainsByProjectId (
|
|
projectId: string,
|
|
filter?: FindOptionsWhere<Domain>
|
|
): Promise<Domain[]> {
|
|
const domainRepository = this.dataSource.getRepository(Domain);
|
|
|
|
const domains = await domainRepository.find({
|
|
relations: {
|
|
redirectTo: true
|
|
},
|
|
where: {
|
|
project: {
|
|
id: projectId
|
|
},
|
|
...filter
|
|
}
|
|
});
|
|
|
|
return domains;
|
|
}
|
|
}
|