@hamak/smart-data-dico 1.0.3 → 1.1.0

package/backend/src/models/__tests__/Dictionary.test.ts

@@ -1,92 +0,0 @@
-import { Dictionary, DictionaryEntry } from '../Dictionary.js';
-
-describe('Dictionary Model', () => {
-  describe('Dictionary Interface', () => {
-    it('should create a valid Dictionary object', () => {
-      const dictionary: Dictionary = {
-        id: 'test-dict-1',
-        name: 'Test Dictionary',
-        description: 'A test dictionary',
-        version: '1.0.0',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        rootPackage: { id: 'root', name: 'Root', entities: [], subPackages: [] },
-      };
-
-      expect(dictionary).toBeDefined();
-      expect(dictionary.id).toBe('test-dict-1');
-      expect(dictionary.name).toBe('Test Dictionary');
-      expect(dictionary.description).toBe('A test dictionary');
-      expect(dictionary.version).toBe('1.0.0');
-      expect(dictionary.createdAt).toBeInstanceOf(Date);
-      expect(dictionary.updatedAt).toBeInstanceOf(Date);
-    });
-
-    it('should create a Dictionary with only required fields', () => {
-      const dictionary: Dictionary = {
-        id: 'test-dict-2',
-        name: 'Minimal Dictionary',
-        rootPackage: { id: 'root', name: 'Root', entities: [], subPackages: [] },
-      };
-
-      expect(dictionary).toBeDefined();
-      expect(dictionary.id).toBe('test-dict-2');
-      expect(dictionary.name).toBe('Minimal Dictionary');
-      expect(dictionary.description).toBeUndefined();
-      expect(dictionary.version).toBeUndefined();
-      expect(dictionary.createdAt).toBeUndefined();
-      expect(dictionary.updatedAt).toBeUndefined();
-    });
-  });
-
-  describe('DictionaryEntry Interface', () => {
-    it('should create a valid DictionaryEntry object', () => {
-      const entry: DictionaryEntry = {
-        id: 'entry-1',
-        name: 'Test Entry',
-        description: 'A test entry',
-        type: 'string',
-        format: 'email',
-        required: true,
-        defaultValue: 'test@example.com',
-        examples: ['user@example.com', 'admin@example.com'],
-        metadata: {
-          source: 'user',
-          lastUpdated: '2023-01-01',
-        },
-      };
-
-      expect(entry).toBeDefined();
-      expect(entry.id).toBe('entry-1');
-      expect(entry.name).toBe('Test Entry');
-      expect(entry.description).toBe('A test entry');
-      expect(entry.type).toBe('string');
-      expect(entry.format).toBe('email');
-      expect(entry.required).toBe(true);
-      expect(entry.defaultValue).toBe('test@example.com');
-      expect(entry.examples).toHaveLength(2);
-      expect(entry.examples).toContain('user@example.com');
-      expect(entry.metadata).toHaveProperty('source', 'user');
-    });
-
-    it('should create a DictionaryEntry with only required fields', () => {
-      const entry: DictionaryEntry = {
-        id: 'entry-2',
-        name: 'Minimal Entry',
-        description: 'A minimal entry',
-        type: 'number',
-      };
-
-      expect(entry).toBeDefined();
-      expect(entry.id).toBe('entry-2');
-      expect(entry.name).toBe('Minimal Entry');
-      expect(entry.description).toBe('A minimal entry');
-      expect(entry.type).toBe('number');
-      expect(entry.format).toBeUndefined();
-      expect(entry.required).toBeUndefined();
-      expect(entry.defaultValue).toBeUndefined();
-      expect(entry.examples).toBeUndefined();
-      expect(entry.metadata).toBeUndefined();
-    });
-  });
-});

package/backend/src/models/__tests__/EntitySchema.test.ts

@@ -1,119 +0,0 @@
-import { AttributeType, validateEntity } from '../EntitySchema.js';
-
-describe('EntitySchema', () => {
-  describe('validateEntity', () => {
-    it('should validate a valid entity', () => {
-      const validEntity = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: AttributeType.STRING,
-            required: true,
-            primaryKey: true,
-          },
-          {
-            uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5',
-            name: 'name',
-            description: 'Entity name',
-            type: AttributeType.STRING,
-            required: true,
-          },
-        ],
-      };
-
-      const result = validateEntity(validEntity);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should invalidate an entity with missing required fields', () => {
-      const invalidEntity = {
-        // Missing uuid
-        // Missing name
-        description: 'A test entity',
-        attributes: [],
-      };
-
-      const result = validateEntity(invalidEntity as any);
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate an entity with constraints', () => {
-      const entityWithConstraints = {
-        uuid: 'd6b0482a-ff70-4267-8c2b-f686e456f8b6',
-        name: 'Test Entity',
-        description: 'A test entity',
-        attributes: [
-          {
-            uuid: 'e7c1593b-aa81-4378-9d3c-a797f567a9c7',
-            name: 'email',
-            description: 'Email address',
-            type: AttributeType.STRING,
-            required: true,
-            constraints: {
-              maxLength: 255,
-              pattern: '^[^@]+@[^@]+$',
-              format: 'email',
-            },
-          },
-        ],
-      };
-
-      const result = validateEntity(entityWithConstraints);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should invalidate an entity with invalid attribute type', () => {
-      const entityWithInvalidAttribute = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        description: 'A test entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: 'invalid-type', // Invalid type
-            required: true,
-          },
-        ],
-      };
-
-      const result = validateEntity(entityWithInvalidAttribute as any);
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate an entity with metadata entries', () => {
-      const entityWithMetadata = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: AttributeType.STRING,
-            required: true,
-            metadata: [
-              { name: 'sensitive', value: true },
-            ],
-          },
-        ],
-        metadata: [
-          { name: 'owner', value: 'team-a' },
-        ],
-      };
-
-      const result = validateEntity(entityWithMetadata);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(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();