@hamak/smart-data-dico 1.0.4 → 1.1.0

package/backend/src/routes/index.ts

@@ -1,120 +0,0 @@
-import { Router } from 'express';
-
-import { getCurrentUser, login } from '../controllers/authController.js';
-import { diagramController } from '../controllers/diagramController.js';
-import { createDictionary, getDictionaries, getDictionaryById, getDictionaryEntries, getEntityAttributes, getPackageByPath, getPackageHierarchy, getRelatedEntities, getTabularData, saveEntity, listAllPackagesAndEntities, getFlatEntitiesAndAttributes, getEntityHierarchy, createRootPackage, createPackageAtPath, updatePackageAtPath, deletePackageAtPath } from '../controllers/dictionaryController.js';
-import { createEntity, deleteEntity, getAllServices, getEntitySchema, getGraphData, getServiceEntities, searchEntities, updateEntity, getPackageRelationships, createRelationship, updateRelationship, deleteRelationship, getImpactAnalysis, getLineage, submitEntity, approveEntity, returnEntity, getEntityComments, addEntityComment, resolveEntityComment } from '../controllers/serviceController.js';
-import { getAllStereotypes, getStereotype, createStereotype, updateStereotype, deleteStereotype } from '../controllers/stereotypeController.js';
-import { getAllPerspectives, getPerspective, createPerspective, updatePerspective, deletePerspective, resolvePerspective, getPerspectiveGraph, upsertPerspectiveNode } from '../controllers/perspectiveController.js';
-import { commitChanges, getCommitHistory, revertToCommit } from '../controllers/versionController.js';
-import { importJsonSchema, importSqlDdl, exportJsonSchema, exportMarkdown, getQualityReport } from '../controllers/importExportController.js';
-import { authenticate, UserRole } from '../middleware/auth.js';
-import { authorizeJwt, verifyToken } from '../middleware/jwtAuth.js';
-
-const router = Router();
-
-// API status route
-router.get('/api/status', (req, res) => {
-  res.json({ status: 'operational' });
-});
-
-router.get('/api/packages/hierarchy/:rootPackage', getPackageHierarchy);
-router.get('/api/packages/tabular/:rootPackage', getTabularData);
-
-// Package CRUD routes
-router.post('/api/packages', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createRootPackage);
-router.post('/api/packages/:rootPackage/subpackages/*', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createPackageAtPath);
-router.put('/api/packages/:rootPackage/path/*', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), updatePackageAtPath);
-router.delete('/api/packages/:rootPackage/path/*', authorizeJwt([UserRole.ADMIN]), deletePackageAtPath);
-
-router.get('/api/packages/:rootPackage/path/*', getPackageByPath);
-
-// Auth routes
-router.post('/api/auth/login', login);
-router.get('/api/auth/me', verifyToken, getCurrentUser);
-
-// Legacy Dictionary routes
-router.get('/api/dictionaries', getDictionaries);
-router.post('/api/dictionaries', createDictionary);
-router.get('/api/dictionaries/:id', getDictionaryById);
-router.get('/api/dictionaries/:id/entries', getDictionaryEntries);
-router.get('/api/entities/:microservice/:entityName/attributes', getEntityAttributes);
-router.get('/api/entities/:microservice/:entityName/related', getRelatedEntities);
-router.post('/api/entities', saveEntity);
-
-// Data Dictionary/Entity/Package API extensions
-router.get('/api/packages/all', listAllPackagesAndEntities);
-router.get('/api/entities/flat', getFlatEntitiesAndAttributes);
-router.get('/api/entities/hierarchy/:microservice/:entityName', getEntityHierarchy);
-
-// New Service/Entity API routes
-router.get('/api/services', getAllServices);
-router.get('/api/services/:service/entities', getServiceEntities);
-router.get('/api/services/:service/entities/:entity', getEntitySchema);
-router.post('/api/services/:service/entities', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createEntity);
-router.put('/api/services/:service/entities/:entity', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), updateEntity);
-router.delete('/api/services/:service/entities/:entity', authorizeJwt([UserRole.ADMIN]), deleteEntity);
-
-// Entity review workflow
-router.post('/api/services/:service/entities/:entity/submit', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), submitEntity);
-router.post('/api/services/:service/entities/:entity/approve', authorizeJwt([UserRole.ADMIN]), approveEntity);
-router.post('/api/services/:service/entities/:entity/return', authorizeJwt([UserRole.ADMIN]), returnEntity);
-router.get('/api/services/:service/entities/:entity/comments', getEntityComments);
-router.post('/api/services/:service/entities/:entity/comments', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), addEntityComment);
-router.put('/api/services/:service/entities/:entity/comments/:id', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), resolveEntityComment);
-
-// Package-level relationship CRUD routes
-router.get('/api/packages/:packageName/relationships', getPackageRelationships);
-router.post('/api/packages/:packageName/relationships', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createRelationship);
-router.put('/api/packages/:packageName/relationships/:uuid', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), updateRelationship);
-router.delete('/api/packages/:packageName/relationships/:uuid', authorizeJwt([UserRole.ADMIN]), deleteRelationship);
-
-// Stereotype API
-router.get('/api/stereotypes', getAllStereotypes);
-router.get('/api/stereotypes/:id', getStereotype);
-router.post('/api/stereotypes', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createStereotype);
-router.put('/api/stereotypes/:id', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), updateStereotype);
-router.delete('/api/stereotypes/:id', authorizeJwt([UserRole.ADMIN]), deleteStereotype);
-
-// Perspective API
-router.get('/api/perspectives', getAllPerspectives);
-router.get('/api/perspectives/:id', getPerspective);
-router.post('/api/perspectives', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), createPerspective);
-router.put('/api/perspectives/:id', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), updatePerspective);
-router.delete('/api/perspectives/:id', authorizeJwt([UserRole.ADMIN]), deletePerspective);
-router.get('/api/perspectives/:id/resolve', resolvePerspective);
-router.get('/api/perspectives/:id/graph', getPerspectiveGraph);
-router.put('/api/perspectives/:id/nodes', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), upsertPerspectiveNode);
-
-// Search API
-router.get('/api/search', searchEntities);
-
-// Impact analysis & lineage
-router.get('/api/entities/:uuid/impact', getImpactAnalysis);
-router.get('/api/entities/:uuid/lineage', getLineage);
-
-// Import/Export
-router.post('/api/import/json-schema', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), importJsonSchema);
-router.post('/api/import/sql-ddl', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), importSqlDdl);
-router.get('/api/export/json-schema/:service', exportJsonSchema);
-router.get('/api/export/markdown/:service', exportMarkdown);
-
-// Quality
-router.get('/api/quality/report', getQualityReport);
-
-// Graph API for visualization
-router.get('/api/graph/:service', getGraphData);
-
-// Version control API
-router.post('/api/commit', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), commitChanges);
-router.get('/api/history', getCommitHistory);
-router.post('/api/revert', authorizeJwt([UserRole.ADMIN]), revertToCommit);
-
-// Diagram layout API
-router.get('/api/diagrams', diagramController.listDiagramLayouts.bind(diagramController));
-router.post('/api/diagrams', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), diagramController.saveDiagramLayout.bind(diagramController));
-router.get('/api/diagrams/:id', diagramController.loadDiagramLayout.bind(diagramController));
-router.put('/api/diagrams/:id', authorizeJwt([UserRole.ADMIN, UserRole.EDITOR]), diagramController.updateDiagramLayout.bind(diagramController));
-router.delete('/api/diagrams/:id', authorizeJwt([UserRole.ADMIN]), diagramController.deleteDiagramLayout.bind(diagramController));
-
-export default router;

package/backend/src/scripts/migrate-to-uuid.ts

@@ -1,24 +0,0 @@
-#!/usr/bin/env ts-node
-
-import { runAllMigrations } from '../utils/migration.js';
-import { logger } from '../utils/logger.js';
-
-/**
- * Migration script to convert existing entities to UUID format
- */
-async function main() {
-  try {
-    logger.info('Starting migration to UUID format...');
-    await runAllMigrations();
-    logger.info('Migration completed successfully!');
-    process.exit(0);
-  } catch (error) {
-    logger.error('Migration failed:', error);
-    process.exit(1);
-  }
-}
-
-// Run the migration if this script is executed directly
-if (require.main === module) {
-  main();
-}

package/backend/src/server.ts

@@ -1,158 +0,0 @@
-import express, { Request, Response } from 'express';
-import fs from 'fs';
-import path from 'path';
-import cors from 'cors';
-import dotenv from 'dotenv';
-import routes from './routes/index.js';
-import { setupSwagger } from './utils/swagger.js';
-import { logger } from './utils/logger.js';
-import { config } from './kernel/config.js';
-import { initializeFileSystem, getFileRouter } from './adapters/EntityFileAdapter.js';
-import { createYamlFileInfoEnricher } from './adapters/YamlFileInfoEnricher.js';
-
-// Load environment variables
-dotenv.config();
-
-// Initialize Express app
-const app = express();
-const port = config.port;
-
-// Middleware
-app.use(cors());
-// Access logging middleware
-app.use((req: Request, res: Response, next) => {
-  const start = process.hrtime();
-  res.on('finish', () => {
-    const diff = process.hrtime(start);
-    const executionTimeMs = Number((diff[0] * 1e3 + diff[1] / 1e6).toFixed(2));
-    logger.info('HTTP Access', {
-      method: req.method,
-      path: req.originalUrl,
-      status: res.statusCode,
-      executionTimeMs
-    });
-  });
-  next();
-});
-
-app.use(express.json());
-
-// API welcome route (only in dev — production serves frontend at /)
-if (!config.isProduction) {
-  app.get('/', (req: Request, res: Response) => {
-    res.json({ message: 'Welcome to the Data Dictionary Management System API' });
-  });
-}
-
-// Health check endpoint
-app.get('/health', (req: Request, res: Response) => {
-  res.json({ status: 'ok' });
-});
-
-// API routes
-app.use(routes);
-
-// Setup Swagger documentation
-setupSwagger(app);
-
-// =============================================================================
-// Framework Filesystem & Git Routes (Phase 1)
-// =============================================================================
-
-async function mountFrameworkRoutes() {
-  try {
-    // Initialize filesystem framework
-    const { enricherRegistry } = await initializeFileSystem();
-
-    // Register YAML entity enricher
-    const yamlEnricher = createYamlFileInfoEnricher();
-    enricherRegistry.register(yamlEnricher);
-
-    // Initialize git service and routes
-    try {
-      const gitModule = await import('@hamak/ui-remote-git-fs-backend');
-      const workspaceRoots = new Map<string, string>([
-        ['dictionaries', config.dataDir],
-      ]);
-
-      const gitService = gitModule.createGitService(workspaceRoots);
-      const gitEnricher = gitModule.createGitFileInfoEnricher({
-        gitService,
-        workspaceRoots,
-      });
-      enricherRegistry.register(gitEnricher);
-
-      const gitRoutes = gitModule.createGitRoutes({ gitService, debug: !config.isProduction });
-      app.use('/api/git', gitRoutes as any);
-      app.use('/api/git', gitModule.gitErrorHandler as any);
-
-      logger.info('Git routes mounted at /api/git');
-    } catch (gitError) {
-      logger.warn(`Git integration not available: ${gitError}`);
-    }
-
-    // Mount filesystem routes
-    const fsRouter = getFileRouter();
-    app.use('/fs', fsRouter);
-
-    logger.info('Filesystem routes mounted at /fs');
-  } catch (error) {
-    logger.warn(`Framework filesystem not initialized: ${error}`);
-  }
-}
-
-// Mount framework routes (non-blocking — existing routes work regardless)
-mountFrameworkRoutes().catch((err) => {
-  logger.warn(`Failed to mount framework routes: ${err}`);
-});
-
-
-// Serve frontend static files in production (BEFORE error handler)
-if (config.isProduction) {
-  // Check multiple possible frontend dist locations
-  const candidates = [
-    path.join(process.cwd(), 'public'),                    // Docker (copied to public/)
-    path.join(process.cwd(), '..', 'frontend', 'dist'),    // npm package / monorepo
-    path.join(process.cwd(), 'frontend', 'dist'),           // alt layout
-  ];
-  const publicDir = candidates.find(d => {
-    try { return fs.statSync(d).isDirectory(); } catch { return false; }
-  });
-
-  if (publicDir) {
-    app.use(express.static(publicDir));
-    // SPA fallback — only for navigation requests, not assets/API
-    app.get('*', (req, res, next) => {
-      if (req.path.startsWith('/api') || req.path.startsWith('/fs') || req.path.startsWith('/api-docs') || req.path.includes('.')) {
-        return next();
-      }
-      res.sendFile(path.join(publicDir, 'index.html'));
-    });
-    logger.info(`Serving frontend from ${publicDir}`);
-  } else {
-    logger.warn('Frontend dist not found. API-only mode.');
-  }
-}
-
-// Error handling middleware (after static files)
-app.use((err: any, req: Request, res: Response, _next: any) => {
-  logger.error(`Unhandled error: ${err.message}`);
-  res.status(500).json({
-    message: 'Internal server error',
-    error: config.isProduction ? undefined : err.message
-  });
-});
-
-// Start server only when run directly (not when imported by tests)
-const isMainModule = process.argv[1] && (
-  process.argv[1].endsWith('server.ts') || process.argv[1].endsWith('server.js')
-);
-
-if (isMainModule) {
-  app.listen(port, () => {
-    logger.info(`Server running on port ${port}`);
-    logger.info(`API documentation available at http://localhost:${port}/api-docs`);
-  });
-}
-
-export default app;

package/backend/src/services/__mocks__/entityService.ts

@@ -1,38 +0,0 @@
-import { Entity, AttributeType } from '../../models/EntitySchema.js';
-
-const mockEntities: Record<string, Entity> = {
-  'user-service.User': {
-    uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-    name: 'User',
-    description: 'User entity',
-    attributes: [
-      { uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694', name: 'id', description: 'User ID', type: AttributeType.STRING, required: true, primaryKey: true },
-      { uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5', name: 'email', description: 'User email', type: AttributeType.STRING, required: true },
-    ],
-  } as Entity,
-};
-
-// Mock entity service matching actual EntityService API
-class EntityServiceMock {
-  validateEntity(entity: Entity) {
-    return { valid: true, errors: [] as string[] };
-  }
-
-  async validateRelationships(packageName: string, relationships: any[]) {
-    return { valid: true, errors: [] as string[] };
-  }
-
-  async saveEntity(entity: Entity, packageName: string) {
-    return { success: true, errors: [] as string[] };
-  }
-
-  async getEntity(packageName: string, entityName: string): Promise<Entity | null> {
-    return mockEntities[`${packageName}.${entityName}`] || null;
-  }
-
-  async getRelatedEntities(packageName: string, entityName: string): Promise<Entity[]> {
-    return [];
-  }
-}
-
-export const entityService = new EntityServiceMock();

package/backend/src/services/__mocks__/serviceService.ts

@@ -1,88 +0,0 @@
-import { AttributeType } from '../../models/EntitySchema.js';
-
-// Mock service service matching actual ServiceService API
-class ServiceServiceMock {
-  async getAllServices(): Promise<string[]> {
-    return ['user-service', 'product-service', 'order-service'];
-  }
-
-  async getServiceEntities(service: string) {
-    const serviceEntities: Record<string, any[]> = {
-      'user-service': [
-        {
-          uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-          name: 'User', description: 'User entity',
-          attributes: [
-            { uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694', name: 'id', description: 'User ID', type: AttributeType.STRING, required: true, primaryKey: true },
-            { uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5', name: 'email', description: 'User email', type: AttributeType.STRING, required: true },
-          ],
-        },
-      ],
-      'product-service': [],
-      'order-service': [],
-    };
-    return serviceEntities[service] || [];
-  }
-
-  async getEntitySchema(service: string, entity: string) {
-    if (service === 'user-service' && entity === 'User') {
-      return {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'User', description: 'User entity',
-        attributes: [
-          { uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694', name: 'id', description: 'User ID', type: AttributeType.STRING, required: true, primaryKey: true },
-          { uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5', name: 'email', description: 'User email', type: AttributeType.STRING, required: true },
-        ],
-      };
-    }
-    return null;
-  }
-
-  async createEntity(service: string, entity: any) {
-    return { success: true, errors: [] };
-  }
-
-  async updateEntity(service: string, entity: any) {
-    return { success: true, errors: [] };
-  }
-
-  async deleteEntity(service: string, entityName: string) {
-    return { success: true, errors: [] };
-  }
-
-  async searchEntities(query: string) {
-    return [
-      { entity: 'User', service: 'user-service', matches: ['name', 'description'] },
-    ];
-  }
-
-  async getGraphData(service: string) {
-    return {
-      nodes: [
-        { id: 'User', label: 'User', type: 'entity' },
-        { id: 'Profile', label: 'Profile', type: 'entity' },
-      ],
-      edges: [
-        { source: 'User', target: 'Profile', label: 'hasOne' },
-      ],
-    };
-  }
-
-  async getPackageRelationships(packageName: string) {
-    return [];
-  }
-
-  async createRelationship(packageName: string, relationship: any) {
-    return { success: true, errors: [], relationship };
-  }
-
-  async updateRelationship(packageName: string, uuid: string, relationship: any) {
-    return { success: true, errors: [] };
-  }
-
-  async deleteRelationship(packageName: string, uuid: string) {
-    return { success: true, errors: [] };
-  }
-}
-
-export const serviceService = new ServiceServiceMock();

package/backend/src/services/__mocks__/versionService.ts

@@ -1,38 +0,0 @@
-// Mock version service matching actual VersionService API
-class VersionServiceMock {
-  async commitChanges(message: string) {
-    return {
-      success: true,
-      errors: [] as string[],
-      commitHash: 'mock-commit-hash-abc123',
-      timestamp: new Date('2026-01-01T12:00:00Z'),
-    };
-  }
-
-  async getCommitHistory(limit: number = 10) {
-    return [
-      {
-        hash: 'mock-commit-1',
-        message: 'Initial commit',
-        author: 'Test User',
-        date: '2023-01-01T12:00:00Z',
-      },
-      {
-        hash: 'mock-commit-2',
-        message: 'Update User entity',
-        author: 'Test User',
-        date: '2023-01-02T12:00:00Z',
-      },
-    ];
-  }
-
-  async revertToCommit(commitHash: string) {
-    return {
-      success: true,
-      errors: [] as string[],
-      newCommitHash: 'mock-revert-hash-def456',
-    };
-  }
-}
-
-export const versionService = new VersionServiceMock();

package/backend/src/services/__tests__/dictionaryService.test.ts

@@ -1,74 +0,0 @@
-import { listMicroserviceEntities, listAllDictionaries, readEntityFile } from '../../utils/fileOperations.js';
-import { dictionaryService } from '../dictionaryService.js';
-
-// Mock dependencies
-jest.mock('../../utils/fileOperations');
-jest.mock('../../utils/logger');
-
-describe('DictionaryService', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('getAllDictionaries', () => {
-    it('should return all dictionaries', async () => {
-      (listAllDictionaries as jest.Mock).mockResolvedValue(['microservices/svc-a', 'microservices/svc-b']);
-
-      const dictionaries = await dictionaryService.getAllDictionaries();
-
-      expect(listAllDictionaries).toHaveBeenCalledTimes(1);
-      // getDictionaryById creates dictionaries from microservices/ IDs
-      expect(dictionaries).toHaveLength(2);
-    });
-
-    it('should return empty array on error', async () => {
-      (listAllDictionaries as jest.Mock).mockRejectedValueOnce(new Error('Test error'));
-
-      const dictionaries = await dictionaryService.getAllDictionaries();
-
-      expect(listAllDictionaries).toHaveBeenCalledTimes(1);
-      expect(dictionaries).toHaveLength(0);
-    });
-  });
-
-  describe('getEntityAttributes', () => {
-    it('should return attributes for an entity', async () => {
-      (readEntityFile as jest.Mock).mockResolvedValue({
-        id: 'User',
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'User',
-        microservice: 'user-service',
-        version: '1.0.0',
-        attributes: [
-          { uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694', name: 'id', type: 'string', description: 'ID', required: true },
-          { uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5', name: 'email', type: 'string', description: 'Email', required: true },
-        ],
-      });
-
-      const attributes = await dictionaryService.getEntityAttributes('user-service', 'User');
-
-      expect(readEntityFile).toHaveBeenCalledWith('user-service', 'User');
-      expect(attributes).toHaveLength(2);
-      expect(attributes[0].name).toBe('id');
-      expect(attributes[1].name).toBe('email');
-    });
-
-    it('should return empty array for non-existent entity', async () => {
-      (readEntityFile as jest.Mock).mockResolvedValue(null);
-
-      const attributes = await dictionaryService.getEntityAttributes('user-service', 'NonExistent');
-
-      expect(readEntityFile).toHaveBeenCalledWith('user-service', 'NonExistent');
-      expect(attributes).toHaveLength(0);
-    });
-
-    it('should return empty array on error', async () => {
-      (readEntityFile as jest.Mock).mockRejectedValueOnce(new Error('Test error'));
-
-      const attributes = await dictionaryService.getEntityAttributes('user-service', 'User');
-
-      expect(readEntityFile).toHaveBeenCalledWith('user-service', 'User');
-      expect(attributes).toHaveLength(0);
-    });
-  });
-});