2021-04-20 12:32:02 +02:00
|
|
|
import { Knex } from 'knex';
|
|
|
|
import { Logger, LogProvider } from '../logger';
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
import NotFoundError from '../error/notfound-error';
|
|
|
|
import { IEnvironmentOverview, IFeatureOverview } from '../types/model';
|
2020-09-28 21:54:44 +02:00
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
const COLUMNS = ['id', 'name', 'description', 'created_at', 'health'];
|
2020-09-28 21:54:44 +02:00
|
|
|
const TABLE = 'projects';
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
export interface IProject {
|
2021-04-30 12:51:46 +02:00
|
|
|
id: string;
|
2021-04-20 12:32:02 +02:00
|
|
|
name: string;
|
|
|
|
description: string;
|
2021-07-07 10:46:50 +02:00
|
|
|
health: number;
|
2021-04-20 12:32:02 +02:00
|
|
|
createdAt: Date;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface IProjectInsert {
|
2021-04-30 12:51:46 +02:00
|
|
|
id: string;
|
2021-04-20 12:32:02 +02:00
|
|
|
name: string;
|
|
|
|
description: string;
|
|
|
|
}
|
|
|
|
|
|
|
|
interface IProjectArchived {
|
2021-04-30 12:51:46 +02:00
|
|
|
id: string;
|
2021-04-20 12:32:02 +02:00
|
|
|
archived: boolean;
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
interface IProjectHealthUpdate {
|
|
|
|
id: string;
|
|
|
|
health: number;
|
|
|
|
}
|
|
|
|
|
2020-09-28 21:54:44 +02:00
|
|
|
class ProjectStore {
|
2021-04-20 12:32:02 +02:00
|
|
|
private db: Knex;
|
|
|
|
|
|
|
|
private logger: Logger;
|
|
|
|
|
|
|
|
constructor(db: Knex, getLogger: LogProvider) {
|
2020-09-28 21:54:44 +02:00
|
|
|
this.db = db;
|
|
|
|
this.logger = getLogger('project-store.js');
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
fieldToRow(data): IProjectInsert {
|
2020-09-28 21:54:44 +02:00
|
|
|
return {
|
|
|
|
id: data.id,
|
|
|
|
name: data.name,
|
|
|
|
description: data.description,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
async getAll(): Promise<IProject[]> {
|
2020-09-28 21:54:44 +02:00
|
|
|
const rows = await this.db
|
|
|
|
.select(COLUMNS)
|
|
|
|
.from(TABLE)
|
|
|
|
.orderBy('name', 'asc');
|
|
|
|
|
|
|
|
return rows.map(this.mapRow);
|
|
|
|
}
|
|
|
|
|
2021-04-30 12:51:46 +02:00
|
|
|
async get(id: string): Promise<IProject> {
|
2020-09-28 21:54:44 +02:00
|
|
|
return this.db
|
|
|
|
.first(COLUMNS)
|
|
|
|
.from(TABLE)
|
|
|
|
.where({ id })
|
|
|
|
.then(this.mapRow);
|
|
|
|
}
|
|
|
|
|
2021-04-30 12:51:46 +02:00
|
|
|
async hasProject(id: string): Promise<IProjectArchived> {
|
2020-09-28 21:54:44 +02:00
|
|
|
return this.db
|
|
|
|
.first('id')
|
|
|
|
.from(TABLE)
|
|
|
|
.where({ id })
|
|
|
|
.then(row => {
|
|
|
|
if (!row) {
|
|
|
|
throw new NotFoundError(`No project with id=${id} found`);
|
|
|
|
}
|
|
|
|
return {
|
|
|
|
id: row.id,
|
|
|
|
archived: row.archived === 1,
|
|
|
|
};
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async updateHealth(healthUpdate: IProjectHealthUpdate): Promise<void> {
|
|
|
|
await this.db(TABLE)
|
|
|
|
.where({ id: healthUpdate.id })
|
|
|
|
.update({ health: healthUpdate.health });
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
async create(project): Promise<IProject> {
|
2021-03-11 22:51:58 +01:00
|
|
|
const [id] = await this.db(TABLE)
|
2020-09-28 21:54:44 +02:00
|
|
|
.insert(this.fieldToRow(project))
|
2021-03-11 22:51:58 +01:00
|
|
|
.returning('id');
|
|
|
|
return { ...project, id };
|
2020-09-28 21:54:44 +02:00
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
async update(data): Promise<void> {
|
2020-09-28 21:54:44 +02:00
|
|
|
try {
|
|
|
|
await this.db(TABLE)
|
|
|
|
.where({ id: data.id })
|
|
|
|
.update(this.fieldToRow(data));
|
|
|
|
} catch (err) {
|
|
|
|
this.logger.error('Could not update project, error: ', err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
async importProjects(projects): Promise<IProject[]> {
|
2021-03-12 11:08:10 +01:00
|
|
|
const rows = await this.db(TABLE)
|
|
|
|
.insert(projects.map(this.fieldToRow))
|
|
|
|
.returning(COLUMNS)
|
|
|
|
.onConflict('id')
|
|
|
|
.ignore();
|
|
|
|
if (rows.length > 0) {
|
|
|
|
return rows.map(this.mapRow);
|
|
|
|
}
|
|
|
|
return [];
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
async dropProjects(): Promise<void> {
|
2021-03-12 11:08:10 +01:00
|
|
|
await this.db(TABLE).del();
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async delete(id: string): Promise<void> {
|
2020-09-28 21:54:44 +02:00
|
|
|
try {
|
|
|
|
await this.db(TABLE)
|
|
|
|
.where({ id })
|
|
|
|
.del();
|
|
|
|
} catch (err) {
|
|
|
|
this.logger.error('Could not delete project, error: ', err);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-07 10:46:50 +02:00
|
|
|
async deleteEnvironment(id: string, environment: string): Promise<void> {
|
|
|
|
await this.db('project_environments')
|
|
|
|
.where({
|
|
|
|
project_id: id,
|
|
|
|
environment_name: environment,
|
|
|
|
})
|
|
|
|
.del();
|
|
|
|
}
|
|
|
|
|
|
|
|
async getMembers(projectId: string): Promise<number> {
|
|
|
|
const rolesFromProject = this.db('role_permission')
|
|
|
|
.select('role_id')
|
|
|
|
.distinct()
|
|
|
|
.where({ project: projectId });
|
|
|
|
|
|
|
|
const numbers = await this.db('role_user')
|
|
|
|
.countDistinct('user_id as members')
|
|
|
|
.whereIn('role_id', rolesFromProject)
|
|
|
|
.first();
|
|
|
|
const { members } = numbers;
|
|
|
|
if (typeof members === 'string') {
|
|
|
|
return parseInt(members, 10);
|
|
|
|
}
|
|
|
|
return members;
|
|
|
|
}
|
|
|
|
|
|
|
|
async getProjectOverview(
|
|
|
|
projectId: string,
|
|
|
|
archived: boolean = false,
|
|
|
|
): Promise<IFeatureOverview[]> {
|
|
|
|
const rows = await this.db('features')
|
|
|
|
.where({ project: projectId, archived })
|
|
|
|
.select(
|
|
|
|
'features.name as feature_name',
|
|
|
|
'features.type as type',
|
|
|
|
'features.created_at as created_at',
|
|
|
|
'features.last_seen_at as last_seen_at',
|
|
|
|
'features.stale as stale',
|
|
|
|
'feature_environments.enabled as enabled',
|
|
|
|
'feature_environments.environment as environment',
|
|
|
|
'environments.display_name as display_name',
|
|
|
|
)
|
|
|
|
.fullOuterJoin(
|
|
|
|
'feature_environments',
|
|
|
|
'feature_environments.feature_name',
|
|
|
|
'features.name',
|
|
|
|
)
|
|
|
|
.fullOuterJoin(
|
|
|
|
'environments',
|
|
|
|
'feature_environments.environment',
|
|
|
|
'environments.name',
|
|
|
|
);
|
|
|
|
if (rows.length > 0) {
|
|
|
|
const overview = rows.reduce((acc, r) => {
|
|
|
|
if (acc[r.feature_name] !== undefined) {
|
|
|
|
acc[r.feature_name].environments.push(
|
|
|
|
this.getEnvironment(r),
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
acc[r.feature_name] = {
|
|
|
|
type: r.type,
|
|
|
|
name: r.feature_name,
|
|
|
|
createdAt: r.created_at,
|
|
|
|
lastSeenAt: r.last_seen_at,
|
|
|
|
stale: r.stale,
|
|
|
|
environments: [this.getEnvironment(r)],
|
|
|
|
};
|
|
|
|
}
|
|
|
|
return acc;
|
|
|
|
}, {});
|
|
|
|
return Object.values(overview).map((o: IFeatureOverview) => ({
|
|
|
|
...o,
|
|
|
|
environments: o.environments.filter(f => f.name),
|
|
|
|
}));
|
|
|
|
}
|
2021-07-14 13:17:16 +02:00
|
|
|
return [];
|
2021-07-07 10:46:50 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
|
|
|
|
private getEnvironment(r: any): IEnvironmentOverview {
|
|
|
|
return {
|
|
|
|
name: r.environment,
|
|
|
|
displayName: r.display_name,
|
|
|
|
enabled: r.enabled,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-04-20 12:32:02 +02:00
|
|
|
mapRow(row): IProject {
|
2020-09-28 21:54:44 +02:00
|
|
|
if (!row) {
|
|
|
|
throw new NotFoundError('No project found');
|
|
|
|
}
|
|
|
|
|
|
|
|
return {
|
|
|
|
id: row.id,
|
|
|
|
name: row.name,
|
|
|
|
description: row.description,
|
|
|
|
createdAt: row.created_at,
|
2021-07-07 10:46:50 +02:00
|
|
|
health: row.health || 100,
|
2020-09-28 21:54:44 +02:00
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
2021-04-20 12:32:02 +02:00
|
|
|
export default ProjectStore;
|
2020-09-28 21:54:44 +02:00
|
|
|
module.exports = ProjectStore;
|