@hamak/smart-data-dico 1.0.4 → 1.1.1

package/backend/src/services/exportService.ts

@@ -1,172 +0,0 @@
-import { Entity, AttributeType, Attribute, Relationship } from '../models/EntitySchema.js';
-import { listMicroserviceEntities, readEntityFile, readRelationshipsFile, getPackagePath } from '../utils/fileOperations.js';
-import { logger } from '../utils/logger.js';
-
-const ATTR_TO_JSON_SCHEMA: Record<string, string> = {
-  [AttributeType.STRING]: 'string',
-  [AttributeType.NUMBER]: 'number',
-  [AttributeType.INTEGER]: 'integer',
-  [AttributeType.BOOLEAN]: 'boolean',
-  [AttributeType.DATETIME]: 'string',
-  [AttributeType.DATE]: 'string',
-  [AttributeType.TIME]: 'string',
-  [AttributeType.DATE_TIME]: 'string',
-  [AttributeType.TIMESTAMP]: 'string',
-  [AttributeType.DURATION]: 'string',
-  [AttributeType.ENUM]: 'string',
-  [AttributeType.OBJECT]: 'object',
-  [AttributeType.ARRAY]: 'array',
-};
-
-class ExportService {
-  async exportToJsonSchema(service: string): Promise<any> {
-    const entityNames = await listMicroserviceEntities(service);
-    const definitions: Record<string, any> = {};
-
-    for (const rawName of entityNames) {
-      const name = rawName.includes('_') ? rawName.split('_').slice(1).join('_') : rawName;
-      const entity = await readEntityFile(service, name);
-      if (!entity || !Array.isArray(entity.attributes)) continue;
-
-      const properties: Record<string, any> = {};
-      const required: string[] = [];
-
-      for (const attr of entity.attributes) {
-        properties[attr.name] = this.attributeToJsonSchema(attr);
-        if (attr.required) required.push(attr.name);
-      }
-
-      definitions[entity.name] = {
-        type: 'object',
-        description: entity.description || undefined,
-        properties,
-        ...(required.length > 0 ? { required } : {}),
-      };
-    }
-
-    return {
-      $schema: 'http://json-schema.org/draft-07/schema#',
-      title: `${service} Data Dictionary`,
-      definitions,
-    };
-  }
-
-  private attributeToJsonSchema(attr: Attribute): any {
-    const schema: any = {
-      type: ATTR_TO_JSON_SCHEMA[attr.type] || 'string',
-      description: attr.description || undefined,
-    };
-
-    if (attr.constraints) {
-      if (attr.constraints.minLength !== undefined) schema.minLength = attr.constraints.minLength;
-      if (attr.constraints.maxLength !== undefined) schema.maxLength = attr.constraints.maxLength;
-      if (attr.constraints.pattern) schema.pattern = attr.constraints.pattern;
-      if (attr.constraints.minimum !== undefined) schema.minimum = attr.constraints.minimum;
-      if (attr.constraints.maximum !== undefined) schema.maximum = attr.constraints.maximum;
-      if (attr.constraints.enumValues) {
-        schema.enum = attr.constraints.enumValues;
-      }
-    }
-
-    if (attr.type === AttributeType.DATETIME || attr.type === AttributeType.DATE_TIME) {
-      schema.format = 'date-time';
-    } else if (attr.type === AttributeType.DATE) {
-      schema.format = 'date';
-    } else if (attr.type === AttributeType.TIME) {
-      schema.format = 'time';
-    }
-
-    if (attr.defaultValue !== undefined) schema.default = attr.defaultValue;
-
-    return schema;
-  }
-
-  async exportToMarkdown(service: string): Promise<string> {
-    const entityNames = await listMicroserviceEntities(service);
-    const entities: Entity[] = [];
-    for (const rawName of entityNames) {
-      const name = rawName.includes('_') ? rawName.split('_').slice(1).join('_') : rawName;
-      const entity = await readEntityFile(service, name);
-      if (entity) entities.push(entity);
-    }
-
-    let relationships: Relationship[] = [];
-    try {
-      relationships = await readRelationshipsFile(getPackagePath(service));
-    } catch { /* ok */ }
-
-    const lines: string[] = [];
-    lines.push(`# ${service} Data Dictionary`);
-    lines.push('');
-    lines.push(`> Generated on ${new Date().toISOString().split('T')[0]}`);
-    lines.push('');
-    lines.push(`## Summary`);
-    lines.push('');
-    lines.push(`- **Entities**: ${entities.length}`);
-    lines.push(`- **Relationships**: ${relationships.length}`);
-    lines.push('');
-
-    // Table of contents
-    lines.push('## Entities');
-    lines.push('');
-    for (const entity of entities) {
-      lines.push(`- [${entity.name}](#${entity.name.toLowerCase()})`);
-    }
-    lines.push('');
-
-    // Entity details
-    for (const entity of entities) {
-      lines.push(`---`);
-      lines.push('');
-      lines.push(`### ${entity.name}`);
-      lines.push('');
-      if (entity.description) {
-        lines.push(entity.description);
-        lines.push('');
-      }
-      if (entity.stereotype) {
-        lines.push(`**Stereotype**: ${entity.stereotype}`);
-        lines.push('');
-      }
-
-      // Attributes table
-      lines.push('| Attribute | Type | Required | Description |');
-      lines.push('|-----------|------|----------|-------------|');
-      for (const attr of entity.attributes) {
-        const req = attr.required ? 'Yes' : 'No';
-        const desc = (attr.description || '').replace(/\|/g, '\\|');
-        const pk = attr.primaryKey ? ' (PK)' : '';
-        lines.push(`| ${attr.name}${pk} | ${attr.type} | ${req} | ${desc} |`);
-      }
-      lines.push('');
-
-      // Metadata
-      if (entity.metadata && entity.metadata.length > 0) {
-        lines.push('**Metadata**:');
-        for (const m of entity.metadata) {
-          lines.push(`- ${m.name}: ${m.value}`);
-        }
-        lines.push('');
-      }
-    }
-
-    // Relationships
-    if (relationships.length > 0) {
-      lines.push('---');
-      lines.push('');
-      lines.push('## Relationships');
-      lines.push('');
-      lines.push('| Description | Source | Target | Cardinality |');
-      lines.push('|-------------|--------|--------|-------------|');
-      for (const rel of relationships) {
-        const card = `${rel.source.cardinality}:${rel.target.cardinality}`;
-        lines.push(`| ${rel.description || '-'} | ${rel.source.entity.slice(0, 8)}... | ${rel.target.entity.slice(0, 8)}... | ${card} |`);
-      }
-      lines.push('');
-    }
-
-    return lines.join('\n');
-  }
-}
-
-export const exportService = new ExportService();

package/backend/src/services/importService.ts

@@ -1,208 +0,0 @@
-import { Entity, Attribute, AttributeType, EntityStatus } from '../models/EntitySchema.js';
-import { writeEntityFile } from '../utils/fileOperations.js';
-import { generateUUID } from '../utils/uuid.js';
-import { logger } from '../utils/logger.js';
-
-const JSON_SCHEMA_TYPE_MAP: Record<string, AttributeType> = {
-  string: AttributeType.STRING,
-  number: AttributeType.NUMBER,
-  integer: AttributeType.INTEGER,
-  boolean: AttributeType.BOOLEAN,
-  object: AttributeType.OBJECT,
-  array: AttributeType.ARRAY,
-};
-
-const SQL_TYPE_MAP: Record<string, AttributeType> = {
-  varchar: AttributeType.STRING,
-  char: AttributeType.STRING,
-  text: AttributeType.STRING,
-  int: AttributeType.INTEGER,
-  integer: AttributeType.INTEGER,
-  bigint: AttributeType.INTEGER,
-  smallint: AttributeType.INTEGER,
-  decimal: AttributeType.NUMBER,
-  numeric: AttributeType.NUMBER,
-  float: AttributeType.NUMBER,
-  double: AttributeType.NUMBER,
-  real: AttributeType.NUMBER,
-  boolean: AttributeType.BOOLEAN,
-  bool: AttributeType.BOOLEAN,
-  date: AttributeType.DATE,
-  timestamp: AttributeType.TIMESTAMP,
-  datetime: AttributeType.DATETIME,
-  time: AttributeType.TIME,
-  json: AttributeType.OBJECT,
-  jsonb: AttributeType.OBJECT,
-  uuid: AttributeType.STRING,
-  serial: AttributeType.INTEGER,
-  bigserial: AttributeType.INTEGER,
-};
-
-class ImportService {
-  async importFromJsonSchema(schema: any, service: string): Promise<{ entities: Entity[]; errors: string[] }> {
-    const entities: Entity[] = [];
-    const errors: string[] = [];
-
-    try {
-      // Handle definitions/components/properties at root level
-      const definitions = schema.definitions || schema.components?.schemas || schema.properties;
-
-      if (!definitions || typeof definitions !== 'object') {
-        return { entities: [], errors: ['No definitions found in JSON Schema'] };
-      }
-
-      for (const [name, def] of Object.entries(definitions)) {
-        const schemaDef = def as any;
-        if (schemaDef.type !== 'object' && !schemaDef.properties) continue;
-
-        const requiredFields = new Set(schemaDef.required || []);
-        const attributes: Attribute[] = [];
-
-        for (const [propName, propDef] of Object.entries(schemaDef.properties || {})) {
-          const prop = propDef as any;
-          const attrType = JSON_SCHEMA_TYPE_MAP[prop.type] || AttributeType.STRING;
-
-          const attr: Attribute = {
-            uuid: generateUUID(),
-            name: propName,
-            description: prop.description || '',
-            type: attrType,
-            required: requiredFields.has(propName),
-          };
-
-          // Map constraints
-          if (prop.minLength || prop.maxLength || prop.pattern || prop.minimum || prop.maximum || prop.enum) {
-            attr.constraints = {};
-            if (prop.minLength !== undefined) attr.constraints.minLength = prop.minLength;
-            if (prop.maxLength !== undefined) attr.constraints.maxLength = prop.maxLength;
-            if (prop.pattern) attr.constraints.pattern = prop.pattern;
-            if (prop.minimum !== undefined) attr.constraints.minimum = prop.minimum;
-            if (prop.maximum !== undefined) attr.constraints.maximum = prop.maximum;
-            if (prop.enum) {
-              attr.type = AttributeType.ENUM;
-              attr.constraints.enumValues = prop.enum;
-            }
-          }
-
-          attributes.push(attr);
-        }
-
-        const entity: Entity = {
-          uuid: generateUUID(),
-          name,
-          description: schemaDef.description || '',
-          status: EntityStatus.DRAFT,
-          attributes,
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-        };
-
-        const ok = await writeEntityFile(entity, service);
-        if (ok) {
-          entities.push(entity);
-        } else {
-          errors.push(`Failed to write entity: ${name}`);
-        }
-      }
-    } catch (error: any) {
-      errors.push(`Import error: ${error.message}`);
-    }
-
-    return { entities, errors };
-  }
-
-  async importFromSqlDdl(sql: string, service: string): Promise<{ entities: Entity[]; errors: string[] }> {
-    const entities: Entity[] = [];
-    const errors: string[] = [];
-
-    try {
-      // Simple SQL DDL parser — handles CREATE TABLE statements
-      const tableRegex = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:`|")?(\w+)(?:`|")?\s*\(([\s\S]*?)\);/gi;
-      let match;
-
-      while ((match = tableRegex.exec(sql)) !== null) {
-        const tableName = match[1];
-        const columnsBlock = match[2];
-        const attributes: Attribute[] = [];
-        const primaryKeys = new Set<string>();
-
-        // Extract PRIMARY KEY constraint
-        const pkMatch = columnsBlock.match(/PRIMARY\s+KEY\s*\(([^)]+)\)/i);
-        if (pkMatch) {
-          pkMatch[1].split(',').forEach(k => primaryKeys.add(k.trim().replace(/[`"]/g, '')));
-        }
-
-        // Parse columns
-        const lines = columnsBlock.split(',').map(l => l.trim()).filter(Boolean);
-        for (const line of lines) {
-          // Skip constraint lines
-          if (/^\s*(PRIMARY|FOREIGN|UNIQUE|CHECK|CONSTRAINT|INDEX|KEY)/i.test(line)) continue;
-
-          const colMatch = line.match(/^(?:`|")?(\w+)(?:`|")?\s+(\w+)(?:\(([^)]*)\))?(.*)/i);
-          if (!colMatch) continue;
-
-          const [, colName, sqlType, typeParams, rest] = colMatch;
-          const normalizedType = sqlType.toLowerCase();
-          const attrType = SQL_TYPE_MAP[normalizedType] || AttributeType.STRING;
-          const isNotNull = /NOT\s+NULL/i.test(rest);
-          const isPK = primaryKeys.has(colName) || /PRIMARY\s+KEY/i.test(rest);
-
-          const attr: Attribute = {
-            uuid: generateUUID(),
-            name: colName,
-            description: '',
-            type: attrType,
-            required: isNotNull || isPK,
-            primaryKey: isPK || undefined,
-          };
-
-          // Map type params to constraints
-          if (typeParams) {
-            attr.constraints = {};
-            const params = typeParams.split(',').map(p => parseInt(p.trim()));
-            if (normalizedType === 'varchar' || normalizedType === 'char') {
-              attr.constraints.maxLength = params[0];
-            } else if (normalizedType === 'decimal' || normalizedType === 'numeric') {
-              attr.constraints.precision = params[0];
-              if (params[1] !== undefined) attr.constraints.scale = params[1];
-            }
-          }
-
-          attributes.push(attr);
-        }
-
-        if (attributes.length === 0) continue;
-
-        // Convert table name to PascalCase entity name
-        const entityName = tableName.replace(/(^|_)(\w)/g, (_, __, c) => c.toUpperCase());
-
-        const entity: Entity = {
-          uuid: generateUUID(),
-          name: entityName,
-          description: `Imported from SQL table: ${tableName}`,
-          status: EntityStatus.DRAFT,
-          attributes,
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-        };
-
-        const ok = await writeEntityFile(entity, service);
-        if (ok) {
-          entities.push(entity);
-        } else {
-          errors.push(`Failed to write entity: ${entityName}`);
-        }
-      }
-
-      if (entities.length === 0 && errors.length === 0) {
-        errors.push('No CREATE TABLE statements found in the SQL');
-      }
-    } catch (error: any) {
-      errors.push(`SQL import error: ${error.message}`);
-    }
-
-    return { entities, errors };
-  }
-}
-
-export const importService = new ImportService();

package/backend/src/services/perspectiveService.ts

@@ -1,276 +0,0 @@
-import { Perspective, ResolvedNode, ResolvedPerspective, PerspectiveNode, Relationship } from '../models/EntitySchema.js';
-import { listPerspectives, readPerspectiveFile, writePerspectiveFile, deletePerspectiveFile, getAllRelationships, listAllEntities, readEntityFile } from '../utils/fileOperations.js';
-import { generateUUID } from '../utils/uuid.js';
-import { logger } from '../utils/logger.js';
-
-interface AdjacencyEntry {
-  neighborUuid: string;
-  navName: string;
-  relationshipUuid: string;
-}
-
-interface EntityInfo {
-  uuid: string;
-  name: string;
-  service: string;
-}
-
-class PerspectiveService {
-  // --- CRUD ---
-
-  async getAll(): Promise<Perspective[]> {
-    return listPerspectives();
-  }
-
-  async getById(uuid: string): Promise<Perspective | null> {
-    return readPerspectiveFile(uuid);
-  }
-
-  async create(data: Partial<Perspective>): Promise<{ success: boolean; perspective?: Perspective; errors?: string[] }> {
-    if (!data.name) return { success: false, errors: ['Name is required'] };
-    if (!data.rootEntities?.length) return { success: false, errors: ['At least one root entity is required'] };
-
-    const perspective: Perspective = {
-      uuid: data.uuid || generateUUID(),
-      name: data.name,
-      description: data.description,
-      rootEntities: data.rootEntities,
-      nodes: data.nodes || [],
-      maxDepth: data.maxDepth ?? 10,
-      metadata: data.metadata || [],
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-    };
-
-    const ok = await writePerspectiveFile(perspective);
-    if (!ok) return { success: false, errors: ['Failed to write perspective file'] };
-    return { success: true, perspective };
-  }
-
-  async update(uuid: string, data: Partial<Perspective>): Promise<{ success: boolean; perspective?: Perspective; errors?: string[] }> {
-    const existing = await readPerspectiveFile(uuid);
-    if (!existing) return { success: false, errors: ['Perspective not found'] };
-
-    const updated: Perspective = {
-      ...existing,
-      name: data.name ?? existing.name,
-      description: data.description ?? existing.description,
-      rootEntities: data.rootEntities ?? existing.rootEntities,
-      nodes: data.nodes ?? existing.nodes,
-      maxDepth: data.maxDepth ?? existing.maxDepth,
-      metadata: data.metadata ?? existing.metadata,
-      updatedAt: new Date().toISOString(),
-    };
-
-    const ok = await writePerspectiveFile(updated);
-    if (!ok) return { success: false, errors: ['Failed to write perspective file'] };
-    return { success: true, perspective: updated };
-  }
-
-  async delete(uuid: string): Promise<{ success: boolean; errors?: string[] }> {
-    const ok = await deletePerspectiveFile(uuid);
-    if (!ok) return { success: false, errors: ['Perspective not found'] };
-    return { success: true };
-  }
-
-  // --- Node (annotation) management ---
-
-  async upsertNode(uuid: string, node: PerspectiveNode): Promise<{ success: boolean; errors?: string[] }> {
-    const perspective = await readPerspectiveFile(uuid);
-    if (!perspective) return { success: false, errors: ['Perspective not found'] };
-
-    const nodes = perspective.nodes || [];
-    const idx = nodes.findIndex(n => n.path === node.path);
-    if (idx >= 0) {
-      nodes[idx] = node;
-    } else {
-      nodes.push(node);
-    }
-    perspective.nodes = nodes;
-    perspective.updatedAt = new Date().toISOString();
-
-    const ok = await writePerspectiveFile(perspective);
-    if (!ok) return { success: false, errors: ['Failed to write'] };
-    return { success: true };
-  }
-
-  // --- BFS Resolution ---
-
-  async resolve(uuid: string): Promise<ResolvedPerspective | null> {
-    const perspective = await readPerspectiveFile(uuid);
-    if (!perspective) return null;
-
-    // Build entity info map: uuid → { name, service }
-    const entityMap = await this.buildEntityMap();
-
-    // Build adjacency map from all relationships
-    const adjacency = await this.buildAdjacencyMap();
-
-    // Build node lookup for exclude/traverse checks
-    const nodesByPath = new Map<string, PerspectiveNode>();
-    for (const node of perspective.nodes || []) {
-      nodesByPath.set(node.path, node);
-    }
-
-    const maxDepth = perspective.maxDepth ?? 10;
-    const resolvedNodes: ResolvedNode[] = [];
-
-    // BFS from each root entity
-    const queue: { entityUuid: string; hopDistance: number; pathSegments: string[]; usedRelationships: Set<string> }[] = [];
-
-    for (const rootUuid of perspective.rootEntities) {
-      const info = entityMap.get(rootUuid);
-      if (!info) continue;
-      queue.push({ entityUuid: rootUuid, hopDistance: 0, pathSegments: [info.name], usedRelationships: new Set() });
-    }
-
-    // Track visited paths to avoid duplicate processing
-    const visitedPaths = new Set<string>();
-
-    while (queue.length > 0) {
-      const { entityUuid, hopDistance, pathSegments, usedRelationships } = queue.shift()!;
-      const currentPath = pathSegments.join('/');
-
-      // Skip if already visited this exact path
-      if (visitedPaths.has(currentPath)) continue;
-      visitedPaths.add(currentPath);
-
-      // Check for exclusion
-      const node = nodesByPath.get(currentPath);
-      if (node?.exclude) continue;
-
-      // Check depth
-      if (hopDistance > maxDepth) continue;
-
-      const info = entityMap.get(entityUuid);
-      if (!info) continue;
-
-      const isFrontier = node?.traverse === false;
-
-      resolvedNodes.push({
-        entityUuid,
-        entityName: info.name,
-        service: info.service,
-        path: currentPath,
-        hopDistance,
-        isRoot: hopDistance === 0,
-        isFrontier,
-        isManualInclusion: false,
-      });
-
-      // Don't traverse further from frontier nodes
-      if (isFrontier) continue;
-
-      // Enqueue neighbors — skip relationships already used in this path (prevents cycles)
-      const neighbors = adjacency.get(entityUuid) || [];
-      for (const { neighborUuid, navName, relationshipUuid } of neighbors) {
-        if (usedRelationships.has(relationshipUuid)) continue;
-
-        const neighborInfo = entityMap.get(neighborUuid);
-        if (!neighborInfo) continue;
-        const newPath = [...pathSegments, navName];
-        const newPathStr = newPath.join('/');
-
-        // Check if this path is excluded
-        const prefixNode = nodesByPath.get(newPathStr);
-        if (prefixNode?.exclude) continue;
-
-        const newUsed = new Set(usedRelationships);
-        newUsed.add(relationshipUuid);
-
-        queue.push({
-          entityUuid: neighborUuid,
-          hopDistance: hopDistance + 1,
-          pathSegments: newPath,
-          usedRelationships: newUsed,
-        });
-      }
-    }
-
-    return { ...perspective, resolvedNodes };
-  }
-
-  // --- Graph Data ---
-
-  async getGraphData(uuid: string): Promise<{ nodes: any[]; edges: any[] } | null> {
-    const resolved = await this.resolve(uuid);
-    if (!resolved) return null;
-
-    // Deduplicate entities for graph display (same entity shown once as node)
-    const entityUuids = new Set(resolved.resolvedNodes.map(n => n.entityUuid));
-    const entityMap = await this.buildEntityMap();
-
-    const nodes = [...entityUuids].map(eUuid => {
-      const info = entityMap.get(eUuid);
-      const resolvedNode = resolved.resolvedNodes.find(n => n.entityUuid === eUuid);
-      return {
-        id: eUuid,
-        label: info?.name || eUuid,
-        type: 'entity',
-        service: info?.service || '',
-        isRoot: resolvedNode?.isRoot || false,
-        isFrontier: resolvedNode?.isFrontier || false,
-      };
-    });
-
-    // Get all relationships that connect entities within the resolved set
-    const allRels = await getAllRelationships();
-    const edges: any[] = [];
-    for (const { relationships } of allRels) {
-      for (const rel of relationships) {
-        if (entityUuids.has(rel.source.entity) && entityUuids.has(rel.target.entity)) {
-          edges.push({
-            id: rel.uuid,
-            source: rel.source.entity,
-            target: rel.target.entity,
-            label: rel.description || '',
-            sourceCardinality: rel.source.cardinality,
-            targetCardinality: rel.target.cardinality,
-          });
-        }
-      }
-    }
-
-    return { nodes, edges };
-  }
-
-  // --- Internal helpers ---
-
-  private async buildEntityMap(): Promise<Map<string, EntityInfo>> {
-    const map = new Map<string, EntityInfo>();
-    const allEntities = await listAllEntities();
-    for (const entry of allEntities) {
-      const entity = await readEntityFile(entry.microservice, entry.name);
-      if (entity) {
-        map.set(entity.uuid, { uuid: entity.uuid, name: entity.name, service: entry.microservice });
-      }
-    }
-    return map;
-  }
-
-  private async buildAdjacencyMap(): Promise<Map<string, AdjacencyEntry[]>> {
-    const adjacency = new Map<string, AdjacencyEntry[]>();
-
-    const allRels = await getAllRelationships();
-    for (const { relationships } of allRels) {
-      for (const rel of relationships) {
-        const srcUuid = rel.source.entity;
-        const tgtUuid = rel.target.entity;
-        const srcNav = rel.source.name || rel.description || rel.uuid;
-        const tgtNav = rel.target.name || rel.description || rel.uuid;
-
-        // Source → Target (using target nav name or description)
-        if (!adjacency.has(srcUuid)) adjacency.set(srcUuid, []);
-        adjacency.get(srcUuid)!.push({ neighborUuid: tgtUuid, navName: tgtNav, relationshipUuid: rel.uuid });
-
-        // Target → Source (using source nav name or description)
-        if (!adjacency.has(tgtUuid)) adjacency.set(tgtUuid, []);
-        adjacency.get(tgtUuid)!.push({ neighborUuid: srcUuid, navName: srcNav, relationshipUuid: rel.uuid });
-      }
-    }
-
-    return adjacency;
-  }
-}
-
-export const perspectiveService = new PerspectiveService();