deepsource-mcp-server
Version:
Model Context Protocol server for DeepSource
208 lines • 7.33 kB
JavaScript
/**
* @fileoverview Project repository implementation
*
* Concrete implementation of IProjectRepository using DeepSource API.
*/
import { ProjectMapper } from '../mappers/project.mapper.js';
import { createLogger } from '../../utils/logging/logger.js';
const logger = createLogger('ProjectRepository');
/**
* Concrete implementation of IProjectRepository using DeepSource API
*
* This repository provides access to Project aggregates by fetching data
* from the DeepSource API and mapping it to domain models.
*
* Note: Since the DeepSource API doesn't support individual project queries
* or persistence operations, some methods fetch all projects and filter locally.
* This ensures fresh data retrieval on every request as per requirements.
*/
export class ProjectRepository {
projectsClient;
constructor(projectsClient) {
this.projectsClient = projectsClient;
// projectsClient is stored for use in methods
}
/**
* Finds a project by its unique identifier
*
* @param id - The project key
* @returns The project if found, null otherwise
*/
async findById(id) {
return this.findByKey(id);
}
/**
* Finds a project by its unique key
*
* @param key - The project key
* @returns The project if found, null otherwise
*/
async findByKey(key) {
try {
logger.debug('Finding project by key', { key });
// Fetch all projects and find the one with matching key
const apiProjects = await this.projectsClient.listProjects();
const matchingProject = apiProjects.find((p) => p.key === key);
if (!matchingProject) {
logger.debug('Project not found', { key });
return null;
}
const project = ProjectMapper.toDomain(matchingProject);
logger.debug('Project found and mapped', { key, name: project.name });
return project;
}
catch (error) {
logger.error('Error finding project by key', { key, error });
throw error;
}
}
/**
* Finds all projects
*
* @returns All projects in the repository
*/
async findAll() {
try {
logger.debug('Finding all projects');
const apiProjects = await this.projectsClient.listProjects();
const projects = ProjectMapper.toDomainList(apiProjects);
logger.debug('Projects found', { count: projects.length });
return projects;
}
catch (error) {
logger.error('Error finding all projects', { error });
throw error;
}
}
/**
* Finds all active projects
*
* @returns All projects with ACTIVE status
*/
async findActive() {
try {
logger.debug('Finding active projects');
const allProjects = await this.findAll();
const activeProjects = allProjects.filter((p) => p.status === 'ACTIVE');
logger.debug('Active projects found', { count: activeProjects.length });
return activeProjects;
}
catch (error) {
logger.error('Error finding active projects', { error });
throw error;
}
}
/**
* Finds projects by repository provider
*
* @param provider - The VCS provider (e.g., 'GITHUB', 'GITLAB')
* @returns Projects using the specified provider
*/
async findByProvider(provider) {
try {
logger.debug('Finding projects by provider', { provider });
const allProjects = await this.findAll();
const providerProjects = allProjects.filter((p) => p.repository.provider === provider);
logger.debug('Projects found for provider', {
provider,
count: providerProjects.length,
});
return providerProjects;
}
catch (error) {
logger.error('Error finding projects by provider', { provider, error });
throw error;
}
}
/**
* Checks if a project exists with the given key
*
* @param key - The project key to check
* @returns True if the project exists, false otherwise
*/
async exists(key) {
try {
logger.debug('Checking if project exists', { key });
const project = await this.findByKey(key);
const exists = project !== null;
logger.debug('Project existence check', { key, exists });
return exists;
}
catch (error) {
logger.error('Error checking project existence', { key, error });
throw error;
}
}
/**
* Counts the total number of projects
*
* @returns The total project count
*/
async count() {
try {
logger.debug('Counting all projects');
const projects = await this.findAll();
const count = projects.length;
logger.debug('Total project count', { count });
return count;
}
catch (error) {
logger.error('Error counting projects', { error });
throw error;
}
}
/**
* Counts the number of active projects
*
* @returns The active project count
*/
async countActive() {
try {
logger.debug('Counting active projects');
const activeProjects = await this.findActive();
const count = activeProjects.length;
logger.debug('Active project count', { count });
return count;
}
catch (error) {
logger.error('Error counting active projects', { error });
throw error;
}
}
/**
* Saves a project
*
* Note: The DeepSource API doesn't support creating/updating projects
* through the GraphQL API. This method is implemented to satisfy the
* interface but will throw an error indicating the operation is not supported.
*
* @param project - The project to save
* @throws Error indicating the operation is not supported
*/
// skipcq: JS-0105 - Repository method required by interface contract
async save(project) {
logger.warn('Attempted to save project', {
key: project.key,
name: project.name,
});
throw new Error('Save operation is not supported by DeepSource API. ' +
'Projects must be created and managed through the DeepSource UI.');
}
/**
* Deletes a project
*
* Note: The DeepSource API doesn't support deleting projects
* through the GraphQL API. This method is implemented to satisfy the
* interface but will throw an error indicating the operation is not supported.
*
* @param key - The project key to delete
* @throws Error indicating the operation is not supported
*/
// skipcq: JS-0105 - Repository method required by interface contract
async delete(key) {
logger.warn('Attempted to delete project', { key });
throw new Error('Delete operation is not supported by DeepSource API. ' +
'Projects must be deleted through the DeepSource UI.');
}
}
//# sourceMappingURL=project.repository.js.map