@hamak/smart-data-dico 1.0.3 → 1.1.0

package/backend/src/services/stereotypeService.ts

@@ -1,98 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as YAML from 'yaml';
-import { Stereotype, StereotypeTarget, MetadataEntry } from '../models/EntitySchema.js';
-import { logger } from '../utils/logger.js';
-import { config } from '../kernel/config.js';
-
-const DATA_DICTIONARIES_DIR = config.dataDir;
-const STEREOTYPES_FILE = path.join(DATA_DICTIONARIES_DIR, 'stereotypes.yaml');
-
-class StereotypeService {
-  private readStereotypes(): Stereotype[] {
-    if (!fs.existsSync(STEREOTYPES_FILE)) return [];
-    const content = fs.readFileSync(STEREOTYPES_FILE, 'utf8');
-    return YAML.parse(content) || [];
-  }
-
-  private writeStereotypes(stereotypes: Stereotype[]): void {
-    fs.writeFileSync(STEREOTYPES_FILE, YAML.stringify(stereotypes), 'utf8');
-  }
-
-  async getAllStereotypes(appliesTo?: StereotypeTarget): Promise<Stereotype[]> {
-    const all = this.readStereotypes();
-    if (appliesTo) return all.filter((s) => s.appliesTo === appliesTo);
-    return all;
-  }
-
-  async getStereotype(id: string): Promise<Stereotype | null> {
-    const all = this.readStereotypes();
-    return all.find((s) => s.id === id) || null;
-  }
-
-  async createStereotype(data: Stereotype): Promise<{ success: boolean; stereotype?: Stereotype; errors?: string[] }> {
-    if (!data.id || !data.name || !data.appliesTo) {
-      return { success: false, errors: ['id, name, and appliesTo are required'] };
-    }
-    if (!['package', 'entity', 'attribute'].includes(data.appliesTo)) {
-      return { success: false, errors: ['appliesTo must be package, entity, or attribute'] };
-    }
-
-    const all = this.readStereotypes();
-    if (all.find((s) => s.id === data.id)) {
-      return { success: false, errors: [`Stereotype with id '${data.id}' already exists`] };
-    }
-
-    const stereotype: Stereotype = {
-      id: data.id,
-      name: data.name,
-      description: data.description,
-      appliesTo: data.appliesTo,
-      metadataDefinitions: data.metadataDefinitions || [],
-    };
-
-    all.push(stereotype);
-    this.writeStereotypes(all);
-    return { success: true, stereotype };
-  }
-
-  async updateStereotype(id: string, data: Partial<Stereotype>): Promise<{ success: boolean; stereotype?: Stereotype; errors?: string[] }> {
-    const all = this.readStereotypes();
-    const index = all.findIndex((s) => s.id === id);
-    if (index === -1) return { success: false, errors: ['Stereotype not found'] };
-
-    all[index] = {
-      ...all[index],
-      name: data.name ?? all[index].name,
-      description: data.description ?? all[index].description,
-      appliesTo: data.appliesTo ?? all[index].appliesTo,
-      metadataDefinitions: data.metadataDefinitions ?? all[index].metadataDefinitions,
-    };
-
-    this.writeStereotypes(all);
-    return { success: true, stereotype: all[index] };
-  }
-
-  async deleteStereotype(id: string): Promise<{ success: boolean; errors?: string[] }> {
-    const all = this.readStereotypes();
-    const filtered = all.filter((s) => s.id !== id);
-    if (filtered.length === all.length) return { success: false, errors: ['Stereotype not found'] };
-    this.writeStereotypes(filtered);
-    return { success: true };
-  }
-
-  validateMetadata(stereotype: Stereotype, metadata: MetadataEntry[] = []): string[] {
-    const errors: string[] = [];
-    for (const def of stereotype.metadataDefinitions) {
-      if (def.required) {
-        const entry = metadata.find((m) => m.name === def.name);
-        if (!entry || entry.value === undefined || entry.value === '') {
-          errors.push(`Required metadata '${def.name}' is missing (stereotype: ${stereotype.name})`);
-        }
-      }
-    }
-    return errors;
-  }
-}
-
-export const stereotypeService = new StereotypeService();

package/backend/src/services/versionService.ts

@@ -1,135 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { config } from '../kernel/config.js';
-
-/**
- * Interface for commit information
- */
-interface CommitInfo {
-  hash: string;
-  date: string;
-  message: string;
-  author_name: string;
-  author_email: string;
-}
-
-// Lazy-loaded git service from @hamak/ui-remote-git-fs-backend
-let gitServiceInstance: any = null;
-
-async function getGitService() {
-  if (gitServiceInstance) return gitServiceInstance;
-  try {
-    const gitModule = await import('@hamak/ui-remote-git-fs-backend');
-    const workspaceRoots = new Map<string, string>([
-      ['dictionaries', config.dataDir],
-    ]);
-    gitServiceInstance = gitModule.createGitService(workspaceRoots);
-    return gitServiceInstance;
-  } catch {
-    logger.warn('Git service not available');
-    return null;
-  }
-}
-
-/**
- * Service for version control operations using @hamak/ui-remote-git-fs-backend
- */
-export class VersionService {
-  /**
-   * Commit all changes to the repository
-   */
-  async commitChanges(message: string): Promise<{
-    success: boolean;
-    errors: string[];
-    commitHash?: string;
-    timestamp?: Date;
-  }> {
-    try {
-      const gitService = await getGitService();
-      if (!gitService) {
-        return { success: false, errors: ['Git service not available'] };
-      }
-
-      const status = await gitService.status('dictionaries', '.');
-      if (!status.files || status.files.length === 0) {
-        return { success: false, errors: ['No changes to commit'] };
-      }
-
-      const result = await gitService.commit('dictionaries', '.', { message });
-
-      logger.info(`Changes committed: ${result.hash || 'unknown'}`);
-
-      return {
-        success: true,
-        errors: [],
-        commitHash: result.hash,
-        timestamp: new Date(),
-      };
-    } catch (error) {
-      logger.error(`Error committing changes: ${error}`);
-      return {
-        success: false,
-        errors: [`Error committing changes: ${error}`],
-      };
-    }
-  }
-
-  /**
-   * Get commit history
-   */
-  async getCommitHistory(limit: number = 10): Promise<CommitInfo[]> {
-    try {
-      const gitService = await getGitService();
-      if (!gitService) return [];
-
-      const logResult = await gitService.log('dictionaries', '.', { maxCount: limit });
-
-      if (!logResult || !Array.isArray(logResult)) return [];
-
-      return logResult.map((entry: any) => ({
-        hash: entry.hash || entry.oid || '',
-        date: entry.date || entry.timestamp || '',
-        message: entry.message || '',
-        author_name: entry.author_name || entry.author?.name || '',
-        author_email: entry.author_email || entry.author?.email || '',
-      }));
-    } catch (error) {
-      logger.error(`Error getting commit history: ${error}`);
-      return [];
-    }
-  }
-
-  /**
-   * Revert to a previous commit
-   */
-  async revertToCommit(commitHash: string): Promise<{
-    success: boolean;
-    errors: string[];
-    newCommitHash?: string;
-  }> {
-    try {
-      const gitService = await getGitService();
-      if (!gitService) {
-        return { success: false, errors: ['Git service not available'] };
-      }
-
-      const result = await gitService.revert('dictionaries', '.', { commit: commitHash });
-
-      logger.info(`Reverted to commit ${commitHash}`);
-
-      return {
-        success: true,
-        errors: [],
-        newCommitHash: result?.hash,
-      };
-    } catch (error) {
-      logger.error(`Error reverting to commit: ${error}`);
-      return {
-        success: false,
-        errors: [`Error reverting to commit: ${error}`],
-      };
-    }
-  }
-}
-
-// Export a singleton instance
-export const versionService = new VersionService();

package/backend/src/setupTests.ts

@@ -1,12 +0,0 @@
-// This file is automatically loaded by Jest
-// It sets up the testing environment
-
-// Global setup
-beforeAll(() => {
-  // Any global setup before all tests
-});
-
-// Global teardown
-afterAll(() => {
-  // Any global cleanup after all tests
-});

package/backend/src/utils/__mocks__/fileOperations.ts

@@ -1,116 +0,0 @@
-// Mock implementation of file operations for testing
-import { Entity, AttributeType } from '../../models/EntitySchema.js';
-
-// Mock data
-const mockMicroservices = ['user-service', 'product-service', 'order-service'];
-
-const mockEntities: Record<string, string[]> = {
-  'user-service': ['User', 'Profile'],
-  'product-service': ['Product'],
-  'order-service': ['Order', 'OrderItem']
-};
-
-const mockEntityData: Record<string, Entity> = {
-  'user-service.User': {
-    id: 'User',
-    name: 'User',
-    description: 'User entity',
-    microservice: 'user-service',
-    version: '1.0.0',
-    attributes: [
-      {
-        name: 'id',
-        description: 'User ID',
-        type: AttributeType.STRING,
-        required: true
-      },
-      {
-        name: 'email',
-        description: 'User email',
-        type: AttributeType.STRING,
-        format: 'email',
-        required: true
-      }
-    ]
-  },
-  'product-service.Product': {
-    id: 'Product',
-    name: 'Product',
-    description: 'Product entity',
-    microservice: 'product-service',
-    version: '1.0.0',
-    attributes: [
-      {
-        name: 'id',
-        description: 'Product ID',
-        type: AttributeType.STRING,
-        required: true
-      },
-      {
-        name: 'name',
-        description: 'Product name',
-        type: AttributeType.STRING,
-        required: true
-      },
-      {
-        name: 'price',
-        description: 'Product price',
-        type: AttributeType.NUMBER,
-        required: true
-      }
-    ]
-  }
-};
-
-// Mock functions
-export const listMicroservices = jest.fn().mockImplementation(async () => {
-  return Promise.resolve(mockMicroservices);
-});
-
-export const listMicroserviceEntities = jest.fn().mockImplementation(async (microservice: string) => {
-  return Promise.resolve(mockEntities[microservice] || []);
-});
-
-export const listAllEntities = jest.fn().mockImplementation(async () => {
-  const allEntities: { microservice: string; entity: string }[] = [];
-  
-  for (const microservice of mockMicroservices) {
-    for (const entity of mockEntities[microservice] || []) {
-      allEntities.push({ microservice, entity });
-    }
-  }
-  
-  return Promise.resolve(allEntities);
-});
-
-export const readEntityFile = jest.fn().mockImplementation(async (microservice: string, entity: string) => {
-  const key = `${microservice}.${entity}`;
-  return Promise.resolve(mockEntityData[key] || null);
-});
-
-export const writeEntityFile = jest.fn().mockImplementation(async (entity: Entity) => {
-  const key = `${entity.microservice}.${entity.id}`;
-  mockEntityData[key] = entity;
-  return Promise.resolve(true);
-});
-
-export const deleteEntityFile = jest.fn().mockImplementation(async (microservice: string, entity: string) => {
-  const key = `${microservice}.${entity}`;
-  if (mockEntityData[key]) {
-    delete mockEntityData[key];
-    return Promise.resolve(true);
-  }
-  return Promise.resolve(false);
-});
-
-export const createDirectory = jest.fn().mockImplementation(async (path: string) => {
-  return Promise.resolve(true);
-});
-
-export const ensureDirectoryStructure = jest.fn().mockResolvedValue(undefined);
-
-export const listAllDictionaries = jest.fn().mockResolvedValue([]);
-
-export const writeDictionaryMetadata = jest.fn().mockResolvedValue(undefined);
-
-export const commitChanges = jest.fn().mockResolvedValue({ success: true });