@hamak/smart-data-dico 1.0.0

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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,119 @@
+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

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,24 @@
+#!/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

@@ -0,0 +1,140 @@
+import express, { Request, Response } from 'express';
+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());
+
+// Basic route
+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}`);
+});
+
+
+// Error handling middleware
+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
+  });
+});
+
+// Serve frontend static files in production
+if (config.isProduction) {
+  const publicDir = path.join(process.cwd(), 'public');
+  app.use(express.static(publicDir));
+  app.get('*', (req, res) => {
+    if (!req.path.startsWith('/api') && !req.path.startsWith('/fs') && !req.path.startsWith('/api-docs')) {
+      res.sendFile(path.join(publicDir, 'index.html'));
+    }
+  });
+  logger.info(`Serving frontend from ${publicDir}`);
+}
+
+// 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,88 @@
+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

@@ -0,0 +1,38 @@
+// 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();