@hamak/smart-data-dico 1.0.4 → 1.1.1

package/backend/src/controllers/versionController.ts

@@ -1,226 +0,0 @@
-import { Request, Response } from 'express';
-import { versionService } from '../services/versionService.js';
-import { logger } from '../utils/logger.js';
-
-/**
- * @swagger
- * /api/commit:
- *   post:
- *     summary: Commit changes to the local git repository
- *     description: Creates a new commit with all pending changes
- *     tags: [Version Control]
- *     security:
- *       - basicAuth: []
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - message
- *             properties:
- *               message:
- *                 type: string
- *                 description: Commit message
- *     responses:
- *       200:
- *         description: Changes committed successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Changes committed successfully
- *                 data:
- *                   type: object
- *                   properties:
- *                     commitHash:
- *                       type: string
- *                       description: Hash of the new commit
- *                     commitMessage:
- *                       type: string
- *                       description: Commit message
- *                     timestamp:
- *                       type: string
- *                       format: date-time
- *                       description: Timestamp of the commit
- *       400:
- *         description: Failed to commit changes
- *       401:
- *         description: Unauthorized
- *       403:
- *         description: Forbidden
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const commitChanges = async (req: Request, res: Response) => {
-  try {
-    const { message } = req.body;
-    
-    if (!message) {
-      return res.status(400).json({ message: 'Commit message is required' });
-    }
-    
-    const result = await versionService.commitChanges(message);
-    
-    if (!result.success) {
-      return res.status(400).json({ 
-        message: 'Failed to commit changes', 
-        errors: result.errors 
-      });
-    }
-    
-    res.json({ 
-      message: 'Changes committed successfully',
-      data: {
-        commitHash: result.commitHash,
-        commitMessage: message,
-        timestamp: result.timestamp
-      }
-    });
-  } catch (error) {
-    logger.error(`Error committing changes: ${error}`);
-    res.status(500).json({ message: 'Error committing changes', error });
-  }
-};
-
-/**
- * @swagger
- * /api/history:
- *   get:
- *     summary: Get commit history
- *     description: Returns the commit history for the repository
- *     tags: [Version Control]
- *     parameters:
- *       - in: query
- *         name: limit
- *         schema:
- *           type: integer
- *           default: 10
- *         description: Maximum number of commits to return
- *     responses:
- *       200:
- *         description: Commit history
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Success
- *                 data:
- *                   type: array
- *                   items:
- *                     $ref: '#/components/schemas/CommitInfo'
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const getCommitHistory = async (req: Request, res: Response) => {
-  try {
-    const { limit } = req.query;
-    const limitNum = limit ? parseInt(limit as string, 10) : 10;
-    
-    const history = await versionService.getCommitHistory(limitNum);
-    
-    res.json({
-      message: 'Success',
-      data: history
-    });
-  } catch (error) {
-    logger.error(`Error fetching commit history: ${error}`);
-    res.status(500).json({ message: 'Error fetching commit history', error });
-  }
-};
-
-/**
- * @swagger
- * /api/revert:
- *   post:
- *     summary: Revert to a previous commit
- *     description: Creates a new commit that reverts the changes in the specified commit
- *     tags: [Version Control]
- *     security:
- *       - basicAuth: []
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - commitHash
- *             properties:
- *               commitHash:
- *                 type: string
- *                 description: Hash of the commit to revert
- *     responses:
- *       200:
- *         description: Successfully reverted to commit
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: Successfully reverted to commit
- *                 data:
- *                   type: object
- *                   properties:
- *                     commitHash:
- *                       type: string
- *                       description: Hash of the reverted commit
- *                     newCommitHash:
- *                       type: string
- *                       description: Hash of the new revert commit
- *       400:
- *         description: Failed to revert to commit
- *       401:
- *         description: Unauthorized
- *       403:
- *         description: Forbidden
- *       500:
- *         description: Server error
- *
- * @param req Express request
- * @param res Express response
- */
-export const revertToCommit = async (req: Request, res: Response) => {
-  try {
-    const { commitHash } = req.body;
-    
-    if (!commitHash) {
-      return res.status(400).json({ message: 'Commit hash is required' });
-    }
-    
-    const result = await versionService.revertToCommit(commitHash);
-    
-    if (!result.success) {
-      return res.status(400).json({ 
-        message: 'Failed to revert to commit', 
-        errors: result.errors 
-      });
-    }
-    
-    res.json({ 
-      message: 'Successfully reverted to commit',
-      data: {
-        commitHash,
-        newCommitHash: result.newCommitHash
-      }
-    });
-  } catch (error) {
-    logger.error(`Error reverting to commit: ${error}`);
-    res.status(500).json({ message: 'Error reverting to commit', error });
-  }
-};

package/backend/src/kernel/config.ts

@@ -1,43 +0,0 @@
-/**
- * Centralized Configuration
- *
- * Single source of truth for backend configuration values.
- * Reads from environment variables with sensible defaults.
- */
-
-import path from 'path';
-import dotenv from 'dotenv';
-
-dotenv.config();
-
-const isProduction = process.env.NODE_ENV === 'production';
-
-export const config = {
-  /** Server port */
-  port: parseInt(process.env.PORT || '3001', 10),
-
-  /** Base directory for data dictionaries (YAML files) */
-  dataDir: process.env.DATA_DIR
-    || (isProduction
-      ? path.join(process.cwd(), 'data-dictionaries')
-      : path.join(process.cwd(), '..', 'data-dictionaries')),
-
-  /** Deployment profile: local | team | server */
-  profile: (process.env.PROFILE || 'local') as 'local' | 'team' | 'server',
-
-  /** JWT configuration */
-  jwt: {
-    secret: process.env.JWT_SECRET || 'dev-secret-key',
-    expiresIn: process.env.JWT_EXPIRES_IN || '24h',
-  },
-
-  /** Git configuration */
-  git: {
-    /** Whether to auto-commit on entity changes */
-    autoCommit: process.env.GIT_AUTO_COMMIT !== 'false',
-  },
-
-  /** Environment */
-  nodeEnv: process.env.NODE_ENV || 'development',
-  isProduction,
-};

package/backend/src/middleware/auth.ts

@@ -1,128 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import { logger } from '../utils/logger.js';
-
-// Interface for user roles
-export enum UserRole {
-  ADMIN = 'admin',
-  EDITOR = 'editor',
-  VIEWER = 'viewer'
-}
-
-// Interface for user information
-export interface User {
-  id: string;
-  username: string;
-  role: UserRole;
-}
-
-/**
- * Mock user database - in a real application, this would be stored in a database
- * and passwords would be hashed
- */
-const users: Record<string, { password: string; user: User }> = {
-  'admin': {
-    password: 'admin123',
-    user: {
-      id: '1',
-      username: 'admin',
-      role: UserRole.ADMIN
-    }
-  },
-  'editor': {
-    password: 'editor123',
-    user: {
-      id: '2',
-      username: 'editor',
-      role: UserRole.EDITOR
-    }
-  },
-  'viewer': {
-    password: 'viewer123',
-    user: {
-      id: '3',
-      username: 'viewer',
-      role: UserRole.VIEWER
-    }
-  }
-};
-
-/**
- * Basic authentication middleware
- * Extracts credentials from Authorization header and validates them
- * @param req Express request
- * @param res Express response
- * @param next Next function
- */
-export const basicAuth = (req: Request, res: Response, next: NextFunction) => {
-  // Get authorization header
-  const authHeader = req.headers.authorization;
-  
-  if (!authHeader || !authHeader.startsWith('Basic ')) {
-    return res.status(401).json({ 
-      message: 'Authentication required',
-      error: 'Missing or invalid Authorization header'
-    });
-  }
-  
-  // Extract and decode credentials
-  try {
-    const base64Credentials = authHeader.split(' ')[1];
-    const credentials = Buffer.from(base64Credentials, 'base64').toString('utf-8');
-    const [username, password] = credentials.split(':');
-    
-    // Validate credentials
-    const userRecord = users[username];
-    
-    if (!userRecord || userRecord.password !== password) {
-      return res.status(401).json({ 
-        message: 'Authentication failed',
-        error: 'Invalid username or password'
-      });
-    }
-    
-    // Add user to request object
-    (req as any).user = userRecord.user;
-    
-    next();
-  } catch (error) {
-    logger.error(`Authentication error: ${error}`);
-    return res.status(401).json({ 
-      message: 'Authentication failed',
-      error: 'Invalid credentials format'
-    });
-  }
-};
-
-/**
- * Role-based authorization middleware
- * Checks if the authenticated user has one of the required roles
- * @param allowedRoles Array of allowed roles
- * @returns Middleware function
- */
-export const authenticate = (allowedRoles: UserRole[]) => {
-  return (req: Request, res: Response, next: NextFunction) => {
-    // First apply basic authentication
-    basicAuth(req, res, (err) => {
-      if (err) return next(err);
-      
-      // Check if user has required role
-      const user = (req as any).user as User;
-      
-      if (!user) {
-        return res.status(401).json({ 
-          message: 'Authentication required',
-          error: 'User not authenticated'
-        });
-      }
-      
-      if (!allowedRoles.includes(user.role)) {
-        return res.status(403).json({ 
-          message: 'Access denied',
-          error: 'Insufficient permissions'
-        });
-      }
-      
-      next();
-    });
-  };
-};

package/backend/src/middleware/jwtAuth.ts

@@ -1,100 +0,0 @@
-import { Request, Response, NextFunction } from 'express';
-import jwt from 'jsonwebtoken';
-import { logger } from '../utils/logger.js';
-import { User } from './auth.js';
-
-// JWT secret key - should be in environment variables in production
-const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
-
-/**
- * JWT authentication middleware
- * Verifies JWT token from Authorization header
- * @param req Express request
- * @param res Express response
- * @param next Next function
- */
-export const verifyToken = (req: Request, res: Response, next: NextFunction) => {
-  // Development mode bypass for testing
-  if (process.env.NODE_ENV === 'development' && req.headers.authorization === 'Bearer mock-token-for-testing') {
-    logger.info('Using mock authentication token for development');
-    // Set a mock user for development
-    (req as any).user = {
-      id: 'dev-user',
-      username: 'developer',
-      email: 'dev@example.com',
-      role: 'admin'
-    };
-    return next();
-  }
-
-  // Get authorization header
-  const authHeader = req.headers.authorization;
-  
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    return res.status(401).json({
-      message: 'Authentication required',
-      error: 'Missing or invalid Authorization header'
-    });
-  }
-  
-  // Extract token
-  const token = authHeader.split(' ')[1];
-  
-  try {
-    // Verify token
-    const decoded = jwt.verify(token, JWT_SECRET as jwt.Secret) as User;
-    
-    // Add user to request object
-    (req as any).user = decoded;
-    
-    next();
-  } catch (error: any) {
-    logger.error(`JWT verification error: ${error.message}`);
-    
-    if (error.name === 'TokenExpiredError') {
-      return res.status(401).json({ 
-        message: 'Authentication failed',
-        error: 'Token expired'
-      });
-    }
-    
-    return res.status(401).json({ 
-      message: 'Authentication failed',
-      error: 'Invalid token'
-    });
-  }
-};
-
-/**
- * Role-based authorization middleware using JWT
- * Checks if the authenticated user has one of the required roles
- * @param allowedRoles Array of allowed roles
- * @returns Middleware function
- */
-export const authorizeJwt = (allowedRoles: string[]) => {
-  return (req: Request, res: Response, next: NextFunction) => {
-    // First verify token
-    verifyToken(req, res, (err) => {
-      if (err) return next(err);
-      
-      // Check if user has required role
-      const user = (req as any).user as User;
-      
-      if (!user) {
-        return res.status(401).json({ 
-          message: 'Authentication required',
-          error: 'User not authenticated'
-        });
-      }
-      
-      if (!allowedRoles.includes(user.role)) {
-        return res.status(403).json({ 
-          message: 'Access denied',
-          error: 'Insufficient permissions'
-        });
-      }
-      
-      next();
-    });
-  };
-};

package/backend/src/models/Dictionary.ts

@@ -1,38 +0,0 @@
-import { Entity, MetadataDefinition, MetadataEntry, Relationship } from './EntitySchema.js';
-
-/**
- * Package type annotation
- */
-export enum PackageType {
-  PROJECT = 'project',
-  MICROSERVICE = 'microservice',
-  MODULE = 'module'
-}
-
-/**
- * Represents a hierarchical package, which can contain subpackages and/or entities.
- */
-export interface Package {
-  id: string;
-  name: string;
-  description?: string;
-  type?: PackageType | string;
-  entities: Entity[];
-  subPackages: Package[];
-  relationships: Relationship[];
-  metadata?: MetadataEntry[];
-}
-
-/**
- * Dictionary model interface.
- * Supports a hierarchy of packages via the rootPackage property.
- */
-export interface Dictionary {
-  id: string;
-  name: string;
-  description?: string;
-  metadataDefinitions?: MetadataDefinition[];
-  createdAt?: Date;
-  updatedAt?: Date;
-  rootPackage: Package;
-}