@hamak/smart-data-dico 1.0.3 → 1.1.0

package/backend/src/controllers/serviceController.ts

@@ -1,418 +0,0 @@
-import { Request, Response } from 'express';
-import { serviceService } from '../services/serviceService.js';
-import { logger } from '../utils/logger.js';
-import { Entity, Relationship } from '../models/EntitySchema.js';
-
-/**
- * @swagger
- * /api/services:
- *   get:
- *     summary: Get all services (packages)
- *     tags: [Services]
- *     responses:
- *       200:
- *         description: A list of services
- */
-export const getAllServices = async (req: Request, res: Response) => {
-  try {
-    const services = await serviceService.getAllServices();
-    res.json({
-      message: 'Success',
-      data: services
-    });
-  } catch (error) {
-    logger.error('Error fetching services', error);
-    res.status(500).json({ message: 'Error fetching services', error });
-  }
-};
-
-/**
- * @swagger
- * /api/services/{service}/entities:
- *   get:
- *     summary: Get all entities for a specific service
- *     tags: [Entities]
- */
-export const getServiceEntities = async (req: Request, res: Response) => {
-  try {
-    const startTime = process.hrtime();
-    const { service } = req.params;
-
-    logger.info(`Starting to fetch entities for service: ${service}`);
-    const entities = await serviceService.getServiceEntities(service);
-
-    const endTime = process.hrtime(startTime);
-    const executionTimeMs = Number((endTime[0] * 1e3 + endTime[1] / 1e6).toFixed(2));
-
-    logger.info(`Fetched ${entities.length} entities for service: ${service} in ${executionTimeMs}ms`);
-
-    res.json({
-      message: 'Success',
-      data: entities,
-      meta: {
-        count: entities.length,
-        executionTimeMs
-      }
-    });
-  } catch (error) {
-    logger.error(`Error fetching entities for service: ${req.params.service}`, error);
-    res.status(500).json({ message: 'Error fetching service entities', error });
-  }
-};
-
-/**
- * @swagger
- * /api/services/{service}/entities/{entity}:
- *   get:
- *     summary: Get entity schema by service and entity name
- *     tags: [Entities]
- */
-export const getEntitySchema = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const entitySchema = await serviceService.getEntitySchema(service, entity);
-
-    if (!entitySchema) {
-      return res.status(404).json({ message: 'Entity not found' });
-    }
-
-    res.json({
-      message: 'Success',
-      data: entitySchema
-    });
-  } catch (error) {
-    logger.error(`Error fetching entity schema: ${error}`);
-    res.status(500).json({ message: 'Error fetching entity schema', error });
-  }
-};
-
-/**
- * @swagger
- * /api/services/{service}/entities:
- *   post:
- *     summary: Create a new entity
- *     tags: [Entities]
- */
-export const createEntity = async (req: Request, res: Response) => {
-  try {
-    const { service } = req.params;
-    const entityData = req.body as Entity;
-
-    const result = await serviceService.createEntity(service, entityData);
-
-    if (!result.success) {
-      return res.status(400).json({
-        message: 'Failed to create entity',
-        errors: result.errors
-      });
-    }
-
-    res.status(201).json({
-      message: 'Entity created successfully',
-      data: entityData
-    });
-  } catch (error) {
-    logger.error(`Error creating entity: ${error}`);
-    res.status(500).json({ message: 'Error creating entity', error });
-  }
-};
-
-/**
- * @swagger
- * /api/services/{service}/entities/{entity}:
- *   put:
- *     summary: Update an existing entity
- *     tags: [Entities]
- */
-export const updateEntity = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const entityData = req.body as Entity;
-
-    if (entityData.name !== entity) {
-      return res.status(400).json({
-        message: 'Entity name mismatch',
-        error: `Entity name (${entityData.name}) does not match the URL (${entity})`
-      });
-    }
-
-    const existingEntity = await serviceService.getEntitySchema(service, entity);
-    if (!existingEntity) {
-      return res.status(404).json({ message: 'Entity not found' });
-    }
-
-    const result = await serviceService.updateEntity(service, entityData);
-
-    if (!result.success) {
-      return res.status(400).json({
-        message: 'Failed to update entity',
-        errors: result.errors
-      });
-    }
-
-    res.json({
-      message: 'Entity updated successfully',
-      data: entityData
-    });
-  } catch (error) {
-    logger.error(`Error updating entity: ${error}`);
-    res.status(500).json({ message: 'Error updating entity', error });
-  }
-};
-
-/**
- * @swagger
- * /api/services/{service}/entities/{entity}:
- *   delete:
- *     summary: Delete an entity
- *     tags: [Entities]
- */
-export const deleteEntity = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-
-    const existingEntity = await serviceService.getEntitySchema(service, entity);
-    if (!existingEntity) {
-      return res.status(404).json({ message: 'Entity not found' });
-    }
-
-    const result = await serviceService.deleteEntity(service, entity);
-
-    if (!result.success) {
-      return res.status(400).json({
-        message: 'Failed to delete entity',
-        errors: result.errors
-      });
-    }
-
-    res.json({
-      message: 'Entity deleted successfully'
-    });
-  } catch (error) {
-    logger.error(`Error deleting entity: ${error}`);
-    res.status(500).json({ message: 'Error deleting entity', error });
-  }
-};
-
-/**
- * @swagger
- * /api/search:
- *   get:
- *     summary: Search for entities and attributes
- *     tags: [Search]
- */
-export const searchEntities = async (req: Request, res: Response) => {
-  try {
-    const { q, type, service, stereotype, hasMetadata } = req.query;
-
-    if (!q || typeof q !== 'string') {
-      return res.status(400).json({ message: 'Search query is required' });
-    }
-
-    const filters: any = {};
-    if (type) filters.type = String(type);
-    if (service) filters.service = String(service);
-    if (stereotype) filters.stereotype = String(stereotype);
-    if (hasMetadata) filters.hasMetadata = String(hasMetadata);
-
-    const results = await serviceService.searchEntities(q, Object.keys(filters).length > 0 ? filters : undefined);
-
-    res.json({
-      message: 'Success',
-      data: results
-    });
-  } catch (error) {
-    logger.error(`Error searching entities: ${error}`);
-    res.status(500).json({ message: 'Error searching entities', error });
-  }
-};
-
-export const submitEntity = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const result = await serviceService.changeEntityStatus(service, entity, 'submitted' as any);
-    if (!result.success) return res.status(400).json({ message: 'Failed to submit', errors: result.errors });
-    res.json({ message: 'Entity submitted for review' });
-  } catch (error) {
-    logger.error('Error submitting entity', error);
-    res.status(500).json({ message: 'Error submitting entity', error });
-  }
-};
-
-export const approveEntity = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const result = await serviceService.changeEntityStatus(service, entity, 'approved' as any);
-    if (!result.success) return res.status(400).json({ message: 'Failed to approve', errors: result.errors });
-    res.json({ message: 'Entity approved' });
-  } catch (error) {
-    logger.error('Error approving entity', error);
-    res.status(500).json({ message: 'Error approving entity', error });
-  }
-};
-
-export const returnEntity = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const result = await serviceService.changeEntityStatus(service, entity, 'returned' as any);
-    if (!result.success) return res.status(400).json({ message: 'Failed to return', errors: result.errors });
-
-    // Add return comment if provided
-    if (req.body.comment) {
-      await serviceService.addComment(service, entity, {
-        author: req.body.author || 'reviewer',
-        message: req.body.comment,
-      });
-    }
-
-    res.json({ message: 'Entity returned for revision' });
-  } catch (error) {
-    logger.error('Error returning entity', error);
-    res.status(500).json({ message: 'Error returning entity', error });
-  }
-};
-
-export const getEntityComments = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const comments = await serviceService.getComments(service, entity);
-    res.json({ message: 'Success', data: comments });
-  } catch (error) {
-    logger.error('Error fetching comments', error);
-    res.status(500).json({ message: 'Error fetching comments', error });
-  }
-};
-
-export const addEntityComment = async (req: Request, res: Response) => {
-  try {
-    const { service, entity } = req.params;
-    const result = await serviceService.addComment(service, entity, req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to add comment', errors: result.errors });
-    res.status(201).json({ message: 'Comment added', data: result.comment });
-  } catch (error) {
-    logger.error('Error adding comment', error);
-    res.status(500).json({ message: 'Error adding comment', error });
-  }
-};
-
-export const resolveEntityComment = async (req: Request, res: Response) => {
-  try {
-    const { service, entity, id } = req.params;
-    const result = await serviceService.resolveComment(service, entity, id);
-    if (!result.success) return res.status(400).json({ message: 'Failed to resolve comment', errors: result.errors });
-    res.json({ message: 'Comment resolved' });
-  } catch (error) {
-    logger.error('Error resolving comment', error);
-    res.status(500).json({ message: 'Error resolving comment', error });
-  }
-};
-
-export const getLineage = async (req: Request, res: Response) => {
-  try {
-    const { uuid } = req.params;
-    const lineage = await serviceService.getLineage(uuid);
-    res.json({ message: 'Success', data: lineage });
-  } catch (error) {
-    logger.error(`Error getting lineage: ${error}`);
-    res.status(500).json({ message: 'Error getting lineage', error });
-  }
-};
-
-export const getImpactAnalysis = async (req: Request, res: Response) => {
-  try {
-    const { uuid } = req.params;
-    const impact = await serviceService.getImpactAnalysis(uuid);
-    res.json({ message: 'Success', data: impact });
-  } catch (error) {
-    logger.error(`Error getting impact analysis: ${error}`);
-    res.status(500).json({ message: 'Error getting impact analysis', error });
-  }
-};
-
-/**
- * @swagger
- * /api/graph/{service}:
- *   get:
- *     summary: Get graph data for visualization
- *     tags: [Visualization]
- */
-export const getGraphData = async (req: Request, res: Response) => {
-  try {
-    const { service } = req.params;
-    const graphData = await serviceService.getGraphData(service);
-
-    res.json({
-      message: 'Success',
-      data: graphData
-    });
-  } catch (error) {
-    logger.error(`Error generating graph data: ${error}`);
-    res.status(500).json({ message: 'Error generating graph data', error });
-  }
-};
-
-// --- Relationship CRUD controllers ---
-
-export const getPackageRelationships = async (req: Request, res: Response) => {
-  try {
-    const { packageName } = req.params;
-    const relationships = await serviceService.getPackageRelationships(packageName);
-    res.json({ message: 'Success', data: relationships });
-  } catch (error) {
-    logger.error(`Error fetching relationships: ${error}`);
-    res.status(500).json({ message: 'Error fetching relationships', error });
-  }
-};
-
-export const createRelationship = async (req: Request, res: Response) => {
-  try {
-    const { packageName } = req.params;
-    const relationship = req.body as Relationship;
-
-    const result = await serviceService.createRelationship(packageName, relationship);
-
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to create relationship', errors: result.errors });
-    }
-
-    res.status(201).json({ message: 'Relationship created successfully', data: result.relationship });
-  } catch (error) {
-    logger.error(`Error creating relationship: ${error}`);
-    res.status(500).json({ message: 'Error creating relationship', error });
-  }
-};
-
-export const updateRelationship = async (req: Request, res: Response) => {
-  try {
-    const { packageName, uuid } = req.params;
-    const relationship = req.body as Relationship;
-
-    const result = await serviceService.updateRelationship(packageName, uuid, relationship);
-
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to update relationship', errors: result.errors });
-    }
-
-    res.json({ message: 'Relationship updated successfully' });
-  } catch (error) {
-    logger.error(`Error updating relationship: ${error}`);
-    res.status(500).json({ message: 'Error updating relationship', error });
-  }
-};
-
-export const deleteRelationship = async (req: Request, res: Response) => {
-  try {
-    const { packageName, uuid } = req.params;
-
-    const result = await serviceService.deleteRelationship(packageName, uuid);
-
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to delete relationship', errors: result.errors });
-    }
-
-    res.json({ message: 'Relationship deleted successfully' });
-  } catch (error) {
-    logger.error(`Error deleting relationship: ${error}`);
-    res.status(500).json({ message: 'Error deleting relationship', error });
-  }
-};

package/backend/src/controllers/stereotypeController.ts

@@ -1,59 +0,0 @@
-import { Request, Response } from 'express';
-import { stereotypeService } from '../services/stereotypeService.js';
-import { StereotypeTarget } from '../models/EntitySchema.js';
-import { logger } from '../utils/logger.js';
-
-export const getAllStereotypes = async (req: Request, res: Response) => {
-  try {
-    const appliesTo = req.query.appliesTo as StereotypeTarget | undefined;
-    const stereotypes = await stereotypeService.getAllStereotypes(appliesTo);
-    res.json({ message: 'Success', data: stereotypes });
-  } catch (error) {
-    logger.error('Error fetching stereotypes', error);
-    res.status(500).json({ message: 'Error fetching stereotypes', error });
-  }
-};
-
-export const getStereotype = async (req: Request, res: Response) => {
-  try {
-    const stereotype = await stereotypeService.getStereotype(req.params.id);
-    if (!stereotype) return res.status(404).json({ message: 'Stereotype not found' });
-    res.json({ message: 'Success', data: stereotype });
-  } catch (error) {
-    logger.error('Error fetching stereotype', error);
-    res.status(500).json({ message: 'Error fetching stereotype', error });
-  }
-};
-
-export const createStereotype = async (req: Request, res: Response) => {
-  try {
-    const result = await stereotypeService.createStereotype(req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to create stereotype', errors: result.errors });
-    res.status(201).json({ message: 'Stereotype created successfully', data: result.stereotype });
-  } catch (error) {
-    logger.error('Error creating stereotype', error);
-    res.status(500).json({ message: 'Error creating stereotype', error });
-  }
-};
-
-export const updateStereotype = async (req: Request, res: Response) => {
-  try {
-    const result = await stereotypeService.updateStereotype(req.params.id, req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to update stereotype', errors: result.errors });
-    res.json({ message: 'Stereotype updated successfully', data: result.stereotype });
-  } catch (error) {
-    logger.error('Error updating stereotype', error);
-    res.status(500).json({ message: 'Error updating stereotype', error });
-  }
-};
-
-export const deleteStereotype = async (req: Request, res: Response) => {
-  try {
-    const result = await stereotypeService.deleteStereotype(req.params.id);
-    if (!result.success) return res.status(400).json({ message: 'Failed to delete stereotype', errors: result.errors });
-    res.json({ message: 'Stereotype deleted successfully' });
-  } catch (error) {
-    logger.error('Error deleting stereotype', error);
-    res.status(500).json({ message: 'Error deleting stereotype', error });
-  }
-};

package/backend/src/controllers/versionController.ts

@@ -1,226 +0,0 @@
-import { Request, Response } from 'express';
-import { versionService } from '../services/versionService.js';
-import { logger } from '../utils/logger.js';
-
-/**
- * @swagger
- * /api/commit:
- *   post:
- *     summary: Commit changes to the local git repository
- *     description: Creates a new commit with all pending changes
- *     tags: [Version Control]
- *     security:
- *       - basicAuth: []
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - message
- *             properties:
- *               message:
- *                 type: string
- *                 description: Commit message
- *     responses:
- *       200:
- *         description: Changes committed successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Changes committed successfully
- *                 data:
- *                   type: object
- *                   properties:
- *                     commitHash:
- *                       type: string
- *                       description: Hash of the new commit
- *                     commitMessage:
- *                       type: string
- *                       description: Commit message
- *                     timestamp:
- *                       type: string
- *                       format: date-time
- *                       description: Timestamp of the commit
- *       400:
- *         description: Failed to commit changes
- *       401:
- *         description: Unauthorized
- *       403:
- *         description: Forbidden
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const commitChanges = async (req: Request, res: Response) => {
-  try {
-    const { message } = req.body;
-    
-    if (!message) {
-      return res.status(400).json({ message: 'Commit message is required' });
-    }
-    
-    const result = await versionService.commitChanges(message);
-    
-    if (!result.success) {
-      return res.status(400).json({ 
-        message: 'Failed to commit changes', 
-        errors: result.errors 
-      });
-    }
-    
-    res.json({ 
-      message: 'Changes committed successfully',
-      data: {
-        commitHash: result.commitHash,
-        commitMessage: message,
-        timestamp: result.timestamp
-      }
-    });
-  } catch (error) {
-    logger.error(`Error committing changes: ${error}`);
-    res.status(500).json({ message: 'Error committing changes', error });
-  }
-};
-
-/**
- * @swagger
- * /api/history:
- *   get:
- *     summary: Get commit history
- *     description: Returns the commit history for the repository
- *     tags: [Version Control]
- *     parameters:
- *       - in: query
- *         name: limit
- *         schema:
- *           type: integer
- *           default: 10
- *         description: Maximum number of commits to return
- *     responses:
- *       200:
- *         description: Commit history
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Success
- *                 data:
- *                   type: array
- *                   items:
- *                     $ref: '#/components/schemas/CommitInfo'
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const getCommitHistory = async (req: Request, res: Response) => {
-  try {
-    const { limit } = req.query;
-    const limitNum = limit ? parseInt(limit as string, 10) : 10;
-    
-    const history = await versionService.getCommitHistory(limitNum);
-    
-    res.json({
-      message: 'Success',
-      data: history
-    });
-  } catch (error) {
-    logger.error(`Error fetching commit history: ${error}`);
-    res.status(500).json({ message: 'Error fetching commit history', error });
-  }
-};
-
-/**
- * @swagger
- * /api/revert:
- *   post:
- *     summary: Revert to a previous commit
- *     description: Creates a new commit that reverts the changes in the specified commit
- *     tags: [Version Control]
- *     security:
- *       - basicAuth: []
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - commitHash
- *             properties:
- *               commitHash:
- *                 type: string
- *                 description: Hash of the commit to revert
- *     responses:
- *       200:
- *         description: Successfully reverted to commit
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Successfully reverted to commit
- *                 data:
- *                   type: object
- *                   properties:
- *                     commitHash:
- *                       type: string
- *                       description: Hash of the reverted commit
- *                     newCommitHash:
- *                       type: string
- *                       description: Hash of the new revert commit
- *       400:
- *         description: Failed to revert to commit
- *       401:
- *         description: Unauthorized
- *       403:
- *         description: Forbidden
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const revertToCommit = async (req: Request, res: Response) => {
-  try {
-    const { commitHash } = req.body;
-    
-    if (!commitHash) {
-      return res.status(400).json({ message: 'Commit hash is required' });
-    }
-    
-    const result = await versionService.revertToCommit(commitHash);
-    
-    if (!result.success) {
-      return res.status(400).json({ 
-        message: 'Failed to revert to commit', 
-        errors: result.errors 
-      });
-    }
-    
-    res.json({ 
-      message: 'Successfully reverted to commit',
-      data: {
-        commitHash,
-        newCommitHash: result.newCommitHash
-      }
-    });
-  } catch (error) {
-    logger.error(`Error reverting to commit: ${error}`);
-    res.status(500).json({ message: 'Error reverting to commit', error });
-  }
-};