@hamak/smart-data-dico 1.0.4 → 1.1.1

package/backend/src/controllers/authController.ts

@@ -1,131 +0,0 @@
-import { Request, Response } from 'express';
-import jwt, { SignOptions } from 'jsonwebtoken';
-import { logger } from '../utils/logger.js';
-import { User, UserRole } from '../middleware/auth.js';
-
-// Mock user database - imported from auth middleware
-// In a real application, this would be in a separate database module
-const users: Record<string, { password: string; user: User }> = {
-  'admin': {
-    password: 'admin123',
-    user: {
-      id: '1',
-      username: 'admin',
-      role: UserRole.ADMIN
-    }
-  },
-  'editor': {
-    password: 'editor123',
-    user: {
-      id: '2',
-      username: 'editor',
-      role: UserRole.EDITOR
-    }
-  },
-  'viewer': {
-    password: 'viewer123',
-    user: {
-      id: '3',
-      username: 'viewer',
-      role: UserRole.VIEWER
-    }
-  }
-};
-
-// JWT secret key - should be in environment variables in production
-const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
-// Token expiration time (default: 24 hours)
-const TOKEN_EXPIRATION = process.env.TOKEN_EXPIRATION || '24h';
-
-/**
- * Login controller
- * Validates username and password, generates JWT token
- * @param req Express request
- * @param res Express response
- */
-export const login = (req: Request, res: Response) => {
-  try {
-    const { username, password } = req.body;
-
-    // Validate request body
-    if (!username || !password) {
-      return res.status(400).json({
-        message: 'Bad request',
-        error: 'Username and password are required'
-      });
-    }
-
-    // Validate credentials
-    const userRecord = users[username];
-    
-    if (!userRecord || userRecord.password !== password) {
-      logger.info(`Failed login attempt for user: ${username}`);
-      return res.status(401).json({
-        message: 'Authentication failed',
-        error: 'Invalid username or password'
-      });
-    }
-
-    // Generate JWT token
-    const payload = {
-      id: userRecord.user.id,
-      username: userRecord.user.username,
-      role: userRecord.user.role
-    };
-    const options: SignOptions = { expiresIn: TOKEN_EXPIRATION as any };
-    const token = jwt.sign(payload, JWT_SECRET, options);
-
-    logger.info(`User logged in: ${username}`);
-    
-    // Return token and user info
-    return res.status(200).json({
-      message: 'Authentication successful',
-      token,
-      user: {
-        id: userRecord.user.id,
-        username: userRecord.user.username,
-        role: userRecord.user.role
-      }
-    });
-  } catch (error: any) {
-    logger.error(`Login error: ${error.message}`);
-    return res.status(500).json({
-      message: 'Internal server error',
-      error: process.env.NODE_ENV === 'production' ? undefined : error.message
-    });
-  }
-};
-
-/**
- * Get current user controller
- * Returns user information based on JWT token
- * @param req Express request
- * @param res Express response
- */
-export const getCurrentUser = (req: Request, res: Response) => {
-  try {
-    // User should be attached to request by JWT middleware
-    const user = (req as any).user;
-    
-    if (!user) {
-      return res.status(401).json({
-        message: 'Authentication required',
-        error: 'User not authenticated'
-      });
-    }
-    
-    return res.status(200).json({
-      user: {
-        id: user.id,
-        username: user.username,
-        role: user.role
-      }
-    });
-  } catch (error: any) {
-    logger.error(`Get current user error: ${error.message}`);
-    return res.status(500).json({
-      message: 'Internal server error',
-      error: process.env.NODE_ENV === 'production' ? undefined : error.message
-    });
-  }
-};

package/backend/src/controllers/diagramController.ts

@@ -1,143 +0,0 @@
-import { Request, Response } from 'express';
-import { diagramService, DiagramLayout } from '../services/diagramService.js';
-import { logger } from '../utils/logger.js';
-
-export class DiagramController {
-  async saveDiagramLayout(req: Request, res: Response): Promise<void> {
-    try {
-      const layoutData = req.body as Omit<DiagramLayout, 'createdAt' | 'updatedAt'>;
-      
-      if (!layoutData.id || !layoutData.name) {
-        res.status(400).json({
-          message: 'Missing required fields: id and name are required'
-        });
-        return;
-      }
-
-      const savedLayout = await diagramService.saveDiagramLayout(layoutData);
-      
-      res.status(201).json({
-        message: 'Diagram layout saved successfully',
-        data: savedLayout
-      });
-    } catch (error) {
-      logger.error('Error in saveDiagramLayout:', error);
-      res.status(500).json({
-        message: 'Failed to save diagram layout',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      });
-    }
-  }
-
-  async loadDiagramLayout(req: Request, res: Response): Promise<void> {
-    try {
-      const { id } = req.params;
-      
-      if (!id) {
-        res.status(400).json({
-          message: 'Diagram layout ID is required'
-        });
-        return;
-      }
-
-      const layout = await diagramService.loadDiagramLayout(id);
-      
-      if (!layout) {
-        res.status(404).json({
-          message: 'Diagram layout not found'
-        });
-        return;
-      }
-
-      res.json({
-        message: 'Diagram layout loaded successfully',
-        data: layout
-      });
-    } catch (error) {
-      logger.error('Error in loadDiagramLayout:', error);
-      res.status(500).json({
-        message: 'Failed to load diagram layout',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      });
-    }
-  }
-
-  async updateDiagramLayout(req: Request, res: Response): Promise<void> {
-    try {
-      const { id } = req.params;
-      const updates = req.body;
-      
-      if (!id) {
-        res.status(400).json({
-          message: 'Diagram layout ID is required'
-        });
-        return;
-      }
-
-      const updatedLayout = await diagramService.updateDiagramLayout(id, updates);
-      
-      res.json({
-        message: 'Diagram layout updated successfully',
-        data: updatedLayout
-      });
-    } catch (error) {
-      logger.error('Error in updateDiagramLayout:', error);
-      if (error instanceof Error && error.message === 'Diagram layout not found') {
-        res.status(404).json({
-          message: 'Diagram layout not found'
-        });
-      } else {
-        res.status(500).json({
-          message: 'Failed to update diagram layout',
-          error: error instanceof Error ? error.message : 'Unknown error'
-        });
-      }
-    }
-  }
-
-  async deleteDiagramLayout(req: Request, res: Response): Promise<void> {
-    try {
-      const { id } = req.params;
-      
-      if (!id) {
-        res.status(400).json({
-          message: 'Diagram layout ID is required'
-        });
-        return;
-      }
-
-      await diagramService.deleteDiagramLayout(id);
-      
-      res.json({
-        message: 'Diagram layout deleted successfully'
-      });
-    } catch (error) {
-      logger.error('Error in deleteDiagramLayout:', error);
-      res.status(500).json({
-        message: 'Failed to delete diagram layout',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      });
-    }
-  }
-
-  async listDiagramLayouts(req: Request, res: Response): Promise<void> {
-    try {
-      const { service } = req.query;
-      
-      const layouts = await diagramService.listDiagramLayouts(service as string);
-      
-      res.json({
-        message: 'Diagram layouts retrieved successfully',
-        data: layouts
-      });
-    } catch (error) {
-      logger.error('Error in listDiagramLayouts:', error);
-      res.status(500).json({
-        message: 'Failed to list diagram layouts',
-        error: error instanceof Error ? error.message : 'Unknown error'
-      });
-    }
-  }
-}
-
-export const diagramController = new DiagramController();

package/backend/src/controllers/dictionaryController.ts

@@ -1,306 +0,0 @@
-import { Request, Response } from 'express';
-
-import { Dictionary } from '../models/Dictionary.js';
-import { Entity } from '../models/EntitySchema.js';
-import { dictionaryService } from '../services/dictionaryService.js';
-import { entityService } from '../services/entityService.js';
-import { logger } from '../utils/logger.js';
-
-// Dictionary controller methods
-export const getDictionaries = async (req: Request, res: Response) => {
-  try {
-    const dictionaries = await dictionaryService.getAllDictionaries();
-    res.json({
-      message: 'Success',
-      data: dictionaries
-    });
-  } catch (error) {
-    logger.error('Error fetching dictionaries', error);
-    res.status(500).json({ message: 'Error fetching dictionaries', error });
-  }
-};
-
-export const getDictionaryById = async (req: Request, res: Response) => {
-  try {
-    const { id } = req.params;
-    const dictionary = await dictionaryService.getDictionaryById(id);
-
-    if (!dictionary) {
-      return res.status(404).json({ message: 'Dictionary not found' });
-    }
-
-    res.json({
-      message: 'Success',
-      data: dictionary
-    });
-  } catch (error) {
-    logger.error(`Error fetching dictionary with ID: ${req.params.id}`, error);
-    res.status(500).json({ message: 'Error fetching dictionary', error });
-  }
-};
-
-export const getDictionaryEntries = async (req: Request, res: Response) => {
-  try {
-    const { id } = req.params;
-    const entries = await dictionaryService.getDictionaryEntries(id);
-
-    res.json({
-      message: 'Success',
-      data: entries
-    });
-  } catch (error) {
-    logger.error(`Error in getDictionaryEntries: ${error}`);
-    res.status(500).json({ message: 'Error fetching dictionary entries', error });
-  }
-};
-
-export const getEntityAttributes = async (req: Request, res: Response) => {
-  try {
-    const { microservice, entityName } = req.params;
-    const attributes = await dictionaryService.getEntityAttributes(microservice, entityName);
-
-    if (attributes.length === 0) {
-      return res.status(404).json({ message: 'Entity not found' });
-    }
-
-    res.json({
-      message: 'Success',
-      data: attributes
-    });
-  } catch (error) {
-    logger.error(`Error in getEntityAttributes: ${error}`);
-    res.status(500).json({ message: 'Error fetching entity attributes', error });
-  }
-};
-
-export const saveEntity = async (req: Request, res: Response) => {
-  try {
-    const entity = req.body as Entity;
-    const packageName = req.body.packageName || req.query.packageName as string;
-
-    if (!entity) {
-      return res.status(400).json({ message: 'Invalid entity data' });
-    }
-
-    if (!packageName) {
-      return res.status(400).json({ message: 'packageName is required' });
-    }
-
-    const result = await entityService.saveEntity(entity, packageName);
-
-    if (!result.success) {
-      return res.status(400).json({
-        message: 'Failed to save entity',
-        errors: result.errors
-      });
-    }
-
-    res.status(200).json({
-      message: 'Entity saved successfully',
-      data: entity
-    });
-  } catch (error) {
-    logger.error(`Error in saveEntity: ${error}`);
-    res.status(500).json({ message: 'Error saving entity', error });
-  }
-};
-
-export const getRelatedEntities = async (req: Request, res: Response) => {
-  try {
-    const { microservice, entityName } = req.params;
-    const relatedEntities = await entityService.getRelatedEntities(microservice, entityName);
-
-    res.json({
-      message: 'Success',
-      data: relatedEntities
-    });
-  } catch (error) {
-    logger.error(`Error in getRelatedEntities: ${error}`);
-    res.status(500).json({ message: 'Error fetching related entities', error });
-  }
-};
-
-export const createDictionary = async (req: Request, res: Response) => {
-  try {
-    const dictionaryData = req.body as Dictionary;
-
-    if (!dictionaryData || !dictionaryData.name) {
-      return res.status(400).json({ message: 'Dictionary name is required' });
-    }
-
-    const result = await dictionaryService.createDictionary(dictionaryData);
-
-    if (result && 'error' in result) {
-      if (result.code === 'DUPLICATE_NAME') {
-        logger.warn(`Attempted to create dictionary with duplicate name: ${dictionaryData.name}`);
-        return res.status(409).json({
-          message: result.error,
-          code: result.code
-        });
-      } else if (result.code === 'MISSING_NAME') {
-        return res.status(400).json({
-          message: result.error,
-          code: result.code
-        });
-      } else {
-        return res.status(400).json({
-          message: result.error,
-          code: result.code
-        });
-      }
-    }
-
-    if (!result) {
-      return res.status(500).json({ message: 'Failed to create dictionary due to an unknown error' });
-    }
-
-    res.status(201).json({
-      message: 'Dictionary created successfully',
-      data: result
-    });
-  } catch (error) {
-    logger.error(`Error in createDictionary: ${error}`);
-    res.status(500).json({ message: 'Error creating dictionary', error });
-  }
-};
-
-export const getPackageHierarchy = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const hierarchy = await dictionaryService.getPackageHierarchy(rootPackage);
-    res.json({ message: 'Success', data: hierarchy });
-  } catch (error) {
-    logger.error('Error fetching package hierarchy', error);
-    res.status(500).json({ message: 'Error fetching package hierarchy', error });
-  }
-};
-
-export const getTabularData = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const tabularData = await dictionaryService.getTabularData(rootPackage);
-    res.json({ message: 'Success', data: tabularData });
-  } catch (error) {
-    logger.error('Error fetching tabular data', error);
-    res.status(500).json({ message: 'Error fetching tabular data', error });
-  }
-};
-
-export const getPackageByPath = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const packagePath = req.params[0]?.split('/').filter(Boolean) || [];
-    const pkg = await dictionaryService.getPackageByPath(rootPackage, packagePath);
-    if (!pkg) {
-      return res.status(404).json({ message: 'Package not found' });
-    }
-    res.json({ message: 'Success', data: pkg });
-  } catch (error) {
-    logger.error('Error fetching package by path', error);
-    res.status(500).json({ message: 'Error fetching package by path', error });
-  }
-}
-
-export const listAllPackagesAndEntities = async (req: Request, res: Response) => {
-  try {
-    const result = await dictionaryService.listAllPackagesAndEntities();
-    res.json({ message: 'Success', data: result });
-  } catch (error) {
-    logger.error('Error listing all packages and entities', error);
-    res.status(500).json({ message: 'Error listing all packages and entities', error });
-  }
-};
-
-export const createPackageAtPath = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const packagePath = req.params[0]?.split('/').filter(Boolean) || [];
-    const packageData = req.body;
-    const result = await dictionaryService.createPackageAtPath(rootPackage, packagePath, packageData);
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to create package', errors: result.errors });
-    }
-    res.status(201).json({ message: 'Package created successfully', data: result.package });
-  } catch (error) {
-    logger.error('Error creating package', error);
-    res.status(500).json({ message: 'Error creating package', error });
-  }
-};
-
-export const updatePackageAtPath = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const packagePath = req.params[0]?.split('/').filter(Boolean) || [];
-    const packageData = req.body;
-    const result = await dictionaryService.updatePackageAtPath(rootPackage, packagePath, packageData);
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to update package', errors: result.errors });
-    }
-    res.status(200).json({ message: 'Package updated successfully', data: result.package });
-  } catch (error) {
-    logger.error('Error updating package', error);
-    res.status(500).json({ message: 'Error updating package', error });
-  }
-};
-
-export const createRootPackage = async (req: Request, res: Response) => {
-  try {
-    const { name, description, type, metadata } = req.body;
-    if (!name) {
-      return res.status(400).json({ message: 'Package name is required' });
-    }
-    const result = await dictionaryService.createPackageAtPath(name, [], { name, description, type, metadata });
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to create package', errors: result.errors });
-    }
-    res.status(201).json({ message: 'Package created successfully', data: result.package });
-  } catch (error) {
-    logger.error('Error creating root package', error);
-    res.status(500).json({ message: 'Error creating package', error });
-  }
-};
-
-export const deletePackageAtPath = async (req: Request, res: Response) => {
-  try {
-    const { rootPackage } = req.params;
-    const packagePath = req.params[0]?.split('/').filter(Boolean) || [];
-    const force = req.query.force === 'true';
-    const result = await dictionaryService.deletePackageAtPath(rootPackage, packagePath, force);
-    if (!result.success) {
-      return res.status(400).json({ message: 'Failed to delete package', errors: result.errors });
-    }
-    res.status(200).json({ message: 'Package deleted successfully' });
-  } catch (error) {
-    logger.error('Error deleting package', error);
-    res.status(500).json({ message: 'Error deleting package', error });
-  }
-};
-
-export const getFlatEntitiesAndAttributes = async (req: Request, res: Response) => {
-  try {
-    const { name, type, package: pkg } = req.query;
-    const filters: any = {};
-    if (name) filters.name = String(name);
-    if (type) filters.type = String(type);
-    if (pkg) filters.package = String(pkg);
-    const result = await dictionaryService.getFlatEntitiesAndAttributes(filters);
-    res.json({ message: 'Success', data: result });
-  } catch (error) {
-    logger.error('Error getting flat entities/attributes', error);
-    res.status(500).json({ message: 'Error getting flat entities/attributes', error });
-  }
-};
-
-export const getEntityHierarchy = async (req: Request, res: Response) => {
-  try {
-    const { microservice, entityName } = req.params;
-    const result = await dictionaryService.getEntityHierarchy(microservice, entityName);
-    if (!result) {
-      return res.status(404).json({ message: 'Entity not found' });
-    }
-    res.json({ message: 'Success', data: result });
-  } catch (error) {
-    logger.error('Error getting entity hierarchy', error);
-    res.status(500).json({ message: 'Error getting entity hierarchy', error });
-  }
-};

package/backend/src/controllers/importExportController.ts

@@ -1,64 +0,0 @@
-import { Request, Response } from 'express';
-import { importService } from '../services/importService.js';
-import { exportService } from '../services/exportService.js';
-import { qualityService } from '../services/qualityService.js';
-import { logger } from '../utils/logger.js';
-
-export const importJsonSchema = async (req: Request, res: Response) => {
-  try {
-    const { schema, service } = req.body;
-    if (!schema || !service) return res.status(400).json({ message: 'schema and service are required' });
-    const result = await importService.importFromJsonSchema(schema, service);
-    res.json({ message: `Imported ${result.entities.length} entities`, data: result });
-  } catch (error) {
-    logger.error('Error importing JSON Schema', error);
-    res.status(500).json({ message: 'Error importing JSON Schema', error });
-  }
-};
-
-export const importSqlDdl = async (req: Request, res: Response) => {
-  try {
-    const { sql, service } = req.body;
-    if (!sql || !service) return res.status(400).json({ message: 'sql and service are required' });
-    const result = await importService.importFromSqlDdl(sql, service);
-    res.json({ message: `Imported ${result.entities.length} entities`, data: result });
-  } catch (error) {
-    logger.error('Error importing SQL DDL', error);
-    res.status(500).json({ message: 'Error importing SQL DDL', error });
-  }
-};
-
-export const exportJsonSchema = async (req: Request, res: Response) => {
-  try {
-    const { service } = req.params;
-    const schema = await exportService.exportToJsonSchema(service);
-    res.json(schema);
-  } catch (error) {
-    logger.error('Error exporting JSON Schema', error);
-    res.status(500).json({ message: 'Error exporting JSON Schema', error });
-  }
-};
-
-export const exportMarkdown = async (req: Request, res: Response) => {
-  try {
-    const { service } = req.params;
-    const markdown = await exportService.exportToMarkdown(service);
-    res.setHeader('Content-Type', 'text/markdown');
-    res.setHeader('Content-Disposition', `attachment; filename="${service}-data-dictionary.md"`);
-    res.send(markdown);
-  } catch (error) {
-    logger.error('Error exporting Markdown', error);
-    res.status(500).json({ message: 'Error exporting Markdown', error });
-  }
-};
-
-export const getQualityReport = async (req: Request, res: Response) => {
-  try {
-    const service = req.query.service as string | undefined;
-    const report = await qualityService.getQualityReport(service);
-    res.json({ message: 'Success', data: report });
-  } catch (error) {
-    logger.error('Error getting quality report', error);
-    res.status(500).json({ message: 'Error getting quality report', error });
-  }
-};