@hamak/smart-data-dico 1.0.4 → 1.1.0

package/backend/src/controllers/perspectiveController.ts

@@ -1,90 +0,0 @@
-import { Request, Response } from 'express';
-import { perspectiveService } from '../services/perspectiveService.js';
-import { logger } from '../utils/logger.js';
-
-export const getAllPerspectives = async (_req: Request, res: Response) => {
-  try {
-    const perspectives = await perspectiveService.getAll();
-    res.json({ message: 'Success', data: perspectives });
-  } catch (error) {
-    logger.error('Error fetching perspectives', error);
-    res.status(500).json({ message: 'Error fetching perspectives', error });
-  }
-};
-
-export const getPerspective = async (req: Request, res: Response) => {
-  try {
-    const perspective = await perspectiveService.getById(req.params.id);
-    if (!perspective) return res.status(404).json({ message: 'Perspective not found' });
-    res.json({ message: 'Success', data: perspective });
-  } catch (error) {
-    logger.error('Error fetching perspective', error);
-    res.status(500).json({ message: 'Error fetching perspective', error });
-  }
-};
-
-export const createPerspective = async (req: Request, res: Response) => {
-  try {
-    const result = await perspectiveService.create(req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to create perspective', errors: result.errors });
-    res.status(201).json({ message: 'Perspective created successfully', data: result.perspective });
-  } catch (error) {
-    logger.error('Error creating perspective', error);
-    res.status(500).json({ message: 'Error creating perspective', error });
-  }
-};
-
-export const updatePerspective = async (req: Request, res: Response) => {
-  try {
-    const result = await perspectiveService.update(req.params.id, req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to update perspective', errors: result.errors });
-    res.json({ message: 'Perspective updated successfully', data: result.perspective });
-  } catch (error) {
-    logger.error('Error updating perspective', error);
-    res.status(500).json({ message: 'Error updating perspective', error });
-  }
-};
-
-export const deletePerspective = async (req: Request, res: Response) => {
-  try {
-    const result = await perspectiveService.delete(req.params.id);
-    if (!result.success) return res.status(400).json({ message: 'Failed to delete perspective', errors: result.errors });
-    res.json({ message: 'Perspective deleted successfully' });
-  } catch (error) {
-    logger.error('Error deleting perspective', error);
-    res.status(500).json({ message: 'Error deleting perspective', error });
-  }
-};
-
-export const resolvePerspective = async (req: Request, res: Response) => {
-  try {
-    const resolved = await perspectiveService.resolve(req.params.id);
-    if (!resolved) return res.status(404).json({ message: 'Perspective not found' });
-    res.json({ message: 'Success', data: resolved });
-  } catch (error) {
-    logger.error('Error resolving perspective', error);
-    res.status(500).json({ message: 'Error resolving perspective', error });
-  }
-};
-
-export const getPerspectiveGraph = async (req: Request, res: Response) => {
-  try {
-    const graph = await perspectiveService.getGraphData(req.params.id);
-    if (!graph) return res.status(404).json({ message: 'Perspective not found' });
-    res.json({ message: 'Success', data: graph });
-  } catch (error) {
-    logger.error('Error getting perspective graph', error);
-    res.status(500).json({ message: 'Error getting perspective graph', error });
-  }
-};
-
-export const upsertPerspectiveNode = async (req: Request, res: Response) => {
-  try {
-    const result = await perspectiveService.upsertNode(req.params.id, req.body);
-    if (!result.success) return res.status(400).json({ message: 'Failed to update node', errors: result.errors });
-    res.json({ message: 'Node updated successfully' });
-  } catch (error) {
-    logger.error('Error updating perspective node', error);
-    res.status(500).json({ message: 'Error updating perspective node', error });
-  }
-};

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 });
-  }
-};