@hamak/smart-data-dico 1.0.3 → 1.1.0

package/backend/src/utils/migration.ts

@@ -1,254 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import YAML from 'yaml';
-import { logger } from './logger.js';
-import { generateUUID, generateEntityFilename } from './uuid.js';
-import { Entity, EntityAttribute, EntityRelationship, createEntityWithUUIDs } from '../models/EntitySchema.js';
-
-const DATA_DICTIONARIES_DIR = path.join(process.cwd(), '..', 'data-dictionaries');
-
-/**
- * Migrates all existing entities to use UUIDs
- */
-export async function migrateEntitiesToUUID(): Promise<void> {
-  logger.info('Starting migration of entities to UUID format...');
-  
-  const microservicesDir = path.join(DATA_DICTIONARIES_DIR, 'microservices');
-  
-  if (!fs.existsSync(microservicesDir)) {
-    logger.info('No microservices directory found, nothing to migrate');
-    return;
-  }
-  
-  const microservices = fs.readdirSync(microservicesDir)
-    .filter(item => fs.statSync(path.join(microservicesDir, item)).isDirectory());
-  
-  let migratedCount = 0;
-  let skippedCount = 0;
-  
-  for (const microservice of microservices) {
-    const microservicePath = path.join(microservicesDir, microservice);
-    const files = fs.readdirSync(microservicePath)
-      .filter(file => file.endsWith('.yaml') || file.endsWith('.yml'));
-    
-    for (const file of files) {
-      const filePath = path.join(microservicePath, file);
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const entity = YAML.parse(content) as any;
-        
-        // Check if entity already has UUID
-        if (entity.uuid) {
-          logger.debug(`Entity ${entity.name} already has UUID, skipping`);
-          skippedCount++;
-          continue;
-        }
-        
-        // Migrate entity to UUID format
-        const migratedEntity = migrateEntityToUUID(entity);
-        
-        // Write to new UUID-based filename
-        const newFilename = generateEntityFilename(migratedEntity.uuid, migratedEntity.name);
-        const newFilePath = path.join(microservicePath, newFilename);
-        
-        const yamlContent = YAML.stringify(migratedEntity);
-        fs.writeFileSync(newFilePath, yamlContent, 'utf8');
-        
-        // Remove old file if it has a different name
-        if (file !== newFilename) {
-          fs.unlinkSync(filePath);
-          logger.info(`Migrated ${microservice}/${entity.name}: ${file} -> ${newFilename}`);
-        } else {
-          logger.info(`Updated ${microservice}/${entity.name} with UUIDs`);
-        }
-        
-        migratedCount++;
-        
-      } catch (error) {
-        logger.error(`Error migrating entity file ${filePath}: ${error}`);
-      }
-    }
-  }
-  
-  logger.info(`Migration completed: ${migratedCount} entities migrated, ${skippedCount} entities skipped`);
-}
-
-/**
- * Migrates a single entity to UUID format
- */
-function migrateEntityToUUID(entity: any): Entity {
-  // Generate UUID for entity if not present
-  if (!entity.uuid) {
-    entity.uuid = generateUUID();
-  }
-  
-  // Migrate attributes
-  if (entity.attributes) {
-    entity.attributes = entity.attributes.map((attr: any) => migrateAttributeToUUID(attr));
-  }
-  
-  // Migrate relationships
-  if (entity.relationships) {
-    entity.relationships = entity.relationships.map((rel: any) => migrateRelationshipToUUID(rel));
-  }
-  
-  return entity as Entity;
-}
-
-/**
- * Migrates a single attribute to UUID format
- */
-function migrateAttributeToUUID(attr: any): EntityAttribute {
-  if (!attr.uuid) {
-    attr.uuid = generateUUID();
-  }
-  
-  // Migrate nested properties if they exist
-  if (attr.properties) {
-    attr.properties = Object.fromEntries(
-      Object.entries(attr.properties).map(([key, prop]: [string, any]) => [
-        key,
-        migrateAttributeToUUID(prop)
-      ])
-    );
-  }
-  
-  // Migrate items if they exist
-  if (attr.items) {
-    attr.items = migrateAttributeToUUID(attr.items);
-  }
-  
-  return attr as EntityAttribute;
-}
-
-/**
- * Migrates a single relationship to UUID format
- */
-function migrateRelationshipToUUID(rel: any): EntityRelationship {
-  if (!rel.uuid) {
-    rel.uuid = generateUUID();
-  }
-  
-  return rel as EntityRelationship;
-}
-
-/**
- * Migrates diagram layouts to use entity UUIDs instead of IDs
- */
-export async function migrateDiagramLayoutsToUUID(): Promise<void> {
-  logger.info('Starting migration of diagram layouts to UUID format...');
-  
-  const diagramsDir = path.join(DATA_DICTIONARIES_DIR, 'diagrams');
-  
-  if (!fs.existsSync(diagramsDir)) {
-    logger.info('No diagrams directory found, nothing to migrate');
-    return;
-  }
-  
-  const files = fs.readdirSync(diagramsDir)
-    .filter(file => file.endsWith('.json'));
-  
-  let migratedCount = 0;
-  
-  // First, build a mapping of entity names to UUIDs
-  const entityNameToUUID = await buildEntityNameToUUIDMapping();
-  
-  for (const file of files) {
-    const filePath = path.join(diagramsDir, file);
-    
-    try {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const layout = JSON.parse(content);
-      
-      // Check if layout already uses UUIDs (UUIDs are 36 characters with dashes)
-      const entityKeys = Object.keys(layout.entities || {});
-      const hasUUIDs = entityKeys.some(key => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(key));
-      
-      if (hasUUIDs) {
-        logger.debug(`Diagram layout ${file} already uses UUIDs, skipping`);
-        continue;
-      }
-      
-      // Migrate entity references from IDs to UUIDs
-      const newEntities: any = {};
-      
-      for (const [entityId, entityData] of Object.entries(layout.entities || {})) {
-        const uuid = entityNameToUUID.get(entityId);
-        if (uuid) {
-          newEntities[uuid] = {
-            ...(entityData as any),
-            name: entityId // Add name for readability
-          };
-        } else {
-          logger.warn(`Could not find UUID for entity ID: ${entityId}`);
-          // Keep the original ID as fallback
-          newEntities[entityId] = entityData;
-        }
-      }
-      
-      layout.entities = newEntities;
-      
-      // Write back the migrated layout
-      fs.writeFileSync(filePath, JSON.stringify(layout, null, 2), 'utf8');
-      logger.info(`Migrated diagram layout: ${file}`);
-      migratedCount++;
-      
-    } catch (error) {
-      logger.error(`Error migrating diagram layout ${filePath}: ${error}`);
-    }
-  }
-  
-  logger.info(`Diagram layout migration completed: ${migratedCount} layouts migrated`);
-}
-
-/**
- * Builds a mapping from entity names to UUIDs by reading all entity files
- */
-async function buildEntityNameToUUIDMapping(): Promise<Map<string, string>> {
-  const mapping = new Map<string, string>();
-  
-  const microservicesDir = path.join(DATA_DICTIONARIES_DIR, 'microservices');
-  
-  if (!fs.existsSync(microservicesDir)) {
-    return mapping;
-  }
-  
-  const microservices = fs.readdirSync(microservicesDir)
-    .filter(item => fs.statSync(path.join(microservicesDir, item)).isDirectory());
-  
-  for (const microservice of microservices) {
-    const microservicePath = path.join(microservicesDir, microservice);
-    const files = fs.readdirSync(microservicePath)
-      .filter(file => file.endsWith('.yaml') || file.endsWith('.yml'));
-    
-    for (const file of files) {
-      const filePath = path.join(microservicePath, file);
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const entity = YAML.parse(content) as Entity;
-        
-        if (entity.uuid && entity.id) {
-          mapping.set(entity.id, entity.uuid);
-        }
-      } catch (error) {
-        logger.warn(`Error reading entity file for mapping: ${filePath}`);
-      }
-    }
-  }
-  
-  return mapping;
-}
-
-/**
- * Runs all migrations
- */
-export async function runAllMigrations(): Promise<void> {
-  logger.info('Starting all migrations...');
-  
-  await migrateEntitiesToUUID();
-  await migrateDiagramLayoutsToUUID();
-  
-  logger.info('All migrations completed');
-}

package/backend/src/utils/swagger.ts

@@ -1,358 +0,0 @@
-import swaggerJsdoc from 'swagger-jsdoc';
-import swaggerUi from 'swagger-ui-express';
-import { Express } from 'express';
-
-/**
- * Swagger definition options
- */
-const options: swaggerJsdoc.Options = {
-  definition: {
-    openapi: '3.0.0',
-    info: {
-      title: 'Data Dictionary Management System API',
-      version: '1.0.0',
-      description: 'API documentation for the Data Dictionary Management System',
-      license: {
-        name: 'MIT',
-        url: 'https://opensource.org/licenses/MIT',
-      },
-      contact: {
-        name: 'API Support',
-        email: 'support@datadictionary.com',
-      },
-    },
-    servers: [
-      {
-        url: 'http://localhost:3001',
-        description: 'Development server',
-      },
-    ],
-    components: {
-      securitySchemes: {
-        basicAuth: {
-          type: 'http',
-          scheme: 'basic',
-          description: 'Basic authentication with username and password',
-        },
-      },
-      schemas: {
-        Entity: {
-          type: 'object',
-          required: ['id', 'name', 'description', 'microservice', 'version', 'attributes'],
-          properties: {
-            id: {
-              type: 'string',
-              description: 'Unique identifier for the entity',
-            },
-            name: {
-              type: 'string',
-              description: 'Name of the entity',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the entity',
-            },
-            microservice: {
-              type: 'string',
-              description: 'Microservice that the entity belongs to',
-            },
-            version: {
-              type: 'string',
-              description: 'Version of the entity schema',
-            },
-            attributes: {
-              type: 'array',
-              description: 'List of attributes for the entity',
-              items: {
-                $ref: '#/components/schemas/EntityAttribute',
-              },
-            },
-            relationships: {
-              type: 'array',
-              description: 'List of relationships for the entity',
-              items: {
-                $ref: '#/components/schemas/EntityRelationship',
-              },
-            },
-            metadata: {
-              type: 'object',
-              description: 'Additional metadata for the entity',
-            },
-            createdAt: {
-              type: 'string',
-              format: 'date-time',
-              description: 'Timestamp when the entity was created',
-            },
-            updatedAt: {
-              type: 'string',
-              format: 'date-time',
-              description: 'Timestamp when the entity was last updated',
-            },
-          },
-        },
-        EntityAttribute: {
-          type: 'object',
-          required: ['name', 'description', 'type', 'required'],
-          properties: {
-            name: {
-              type: 'string',
-              description: 'Name of the attribute',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the attribute',
-            },
-            type: {
-              type: 'string',
-              description: 'Data type of the attribute',
-              enum: ['string', 'number', 'integer', 'boolean', 'datetime', 'date', 'time', 'enum', 'object', 'array', 'reference'],
-            },
-            required: {
-              type: 'boolean',
-              description: 'Whether the attribute is required',
-            },
-            unique: {
-              type: 'boolean',
-              description: 'Whether the attribute value must be unique',
-            },
-            defaultValue: {
-              description: 'Default value for the attribute',
-            },
-            examples: {
-              type: 'array',
-              description: 'Example values for the attribute',
-              items: {
-                type: 'string',
-              },
-            },
-            minLength: {
-              type: 'integer',
-              description: 'Minimum length for string attributes',
-            },
-            maxLength: {
-              type: 'integer',
-              description: 'Maximum length for string attributes',
-            },
-            pattern: {
-              type: 'string',
-              description: 'Regex pattern for string attributes',
-            },
-            format: {
-              type: 'string',
-              description: 'Format for the attribute (e.g., email, uuid)',
-            },
-            minimum: {
-              type: 'number',
-              description: 'Minimum value for number attributes',
-            },
-            maximum: {
-              type: 'number',
-              description: 'Maximum value for number attributes',
-            },
-            precision: {
-              type: 'integer',
-              description: 'Precision for number attributes',
-            },
-            scale: {
-              type: 'integer',
-              description: 'Scale for number attributes',
-            },
-            enumValues: {
-              type: 'array',
-              description: 'Possible values for enum attributes',
-              items: {
-                type: 'string',
-              },
-            },
-            metadata: {
-              type: 'object',
-              description: 'Additional metadata for the attribute',
-            },
-          },
-        },
-        EntityRelationship: {
-          type: 'object',
-          required: ['name', 'description', 'type', 'target', 'required'],
-          properties: {
-            name: {
-              type: 'string',
-              description: 'Name of the relationship',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the relationship',
-            },
-            type: {
-              type: 'string',
-              description: 'Type of the relationship',
-              enum: ['hasOne', 'hasMany', 'belongsTo', 'manyToMany'],
-            },
-            target: {
-              type: 'string',
-              description: 'Target entity of the relationship (format: microservice.entity)',
-            },
-            inverseName: {
-              type: 'string',
-              description: 'Name of the inverse relationship in the target entity',
-            },
-            required: {
-              type: 'boolean',
-              description: 'Whether the relationship is required',
-            },
-            foreignKey: {
-              type: 'string',
-              description: 'Foreign key attribute name',
-            },
-            metadata: {
-              type: 'object',
-              description: 'Additional metadata for the relationship',
-            },
-          },
-        },
-        GraphData: {
-          type: 'object',
-          properties: {
-            nodes: {
-              type: 'array',
-              items: {
-                $ref: '#/components/schemas/GraphNode',
-              },
-            },
-            edges: {
-              type: 'array',
-              items: {
-                $ref: '#/components/schemas/GraphEdge',
-              },
-            },
-          },
-        },
-        GraphNode: {
-          type: 'object',
-          properties: {
-            id: {
-              type: 'string',
-              description: 'Unique identifier for the node',
-            },
-            label: {
-              type: 'string',
-              description: 'Label for the node',
-            },
-            type: {
-              type: 'string',
-              description: 'Type of the node',
-            },
-            service: {
-              type: 'string',
-              description: 'Service that the node belongs to',
-            },
-          },
-        },
-        GraphEdge: {
-          type: 'object',
-          properties: {
-            id: {
-              type: 'string',
-              description: 'Unique identifier for the edge',
-            },
-            source: {
-              type: 'string',
-              description: 'Source node ID',
-            },
-            target: {
-              type: 'string',
-              description: 'Target node ID',
-            },
-            label: {
-              type: 'string',
-              description: 'Label for the edge',
-            },
-            type: {
-              type: 'string',
-              description: 'Type of the edge',
-            },
-          },
-        },
-        CommitInfo: {
-          type: 'object',
-          properties: {
-            hash: {
-              type: 'string',
-              description: 'Commit hash',
-            },
-            date: {
-              type: 'string',
-              description: 'Commit date',
-            },
-            message: {
-              type: 'string',
-              description: 'Commit message',
-            },
-            author_name: {
-              type: 'string',
-              description: 'Author name',
-            },
-            author_email: {
-              type: 'string',
-              description: 'Author email',
-            },
-          },
-        },
-        SearchResult: {
-          type: 'object',
-          properties: {
-            type: {
-              type: 'string',
-              enum: ['entity', 'attribute'],
-              description: 'Type of search result',
-            },
-            service: {
-              type: 'string',
-              description: 'Service name',
-            },
-            entityName: {
-              type: 'string',
-              description: 'Entity name',
-            },
-            attributeName: {
-              type: 'string',
-              description: 'Attribute name (for attribute results)',
-            },
-            description: {
-              type: 'string',
-              description: 'Description of the entity or attribute',
-            },
-            path: {
-              type: 'string',
-              description: 'Path to the entity or attribute',
-            },
-            score: {
-              type: 'number',
-              description: 'Search relevance score',
-            },
-          },
-        },
-      },
-    },
-  },
-  apis: ['./src/routes/*.ts', './src/controllers/*.ts'],
-};
-
-/**
- * Swagger specification
- */
-const swaggerSpec = swaggerJsdoc(options);
-
-/**
- * Configure Swagger middleware for Express
- * @param app Express application
- */
-export const setupSwagger = (app: Express): void => {
-  // Swagger UI route
-  app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));
-
-  // Swagger JSON route
-  app.get('/api-docs.json', (req, res) => {
-    res.setHeader('Content-Type', 'application/json');
-    res.send(swaggerSpec);
-  });
-};

package/backend/src/utils/uuid.ts

@@ -1,41 +0,0 @@
-import { randomUUID } from 'crypto';
-
-/**
- * Generates a UUID v4
- * @returns A new UUID string
- */
-export function generateUUID(): string {
-  return randomUUID();
-}
-
-/**
- * Validates if a string is a valid UUID
- * @param uuid String to validate
- * @returns True if valid UUID
- */
-export function isValidUUID(uuid: string): boolean {
-  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return uuidRegex.test(uuid);
-}
-
-/**
- * Generates a human-readable filename using UUID and name
- * @param uuid The UUID of the entity
- * @param name The name of the entity
- * @returns A filename in format: uuid_name.yaml
- */
-export function generateEntityFilename(uuid: string, name: string): string {
-  // Sanitize name for filename (remove special characters, replace spaces with underscores)
-  const sanitizedName = name.replace(/[^a-zA-Z0-9\s]/g, '').replace(/\s+/g, '_');
-  return `${uuid}_${sanitizedName}.yaml`;
-}
-
-/**
- * Extracts UUID from a filename
- * @param filename The filename to extract UUID from
- * @returns The UUID or null if not found
- */
-export function extractUUIDFromFilename(filename: string): string | null {
-  const match = filename.match(/^([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/i);
-  return match ? match[1] : null;
-}

package/backend/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "sourceMap": true,
-    "isolatedModules": true,
-    "types": ["node", "jest"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules"]
-}