@hamak/smart-data-dico 1.0.0

package/backend/src/adapters/EntityFileAdapter.ts

@@ -0,0 +1,154 @@
+/**
+ * EntityFileAdapter
+ *
+ * Wraps @hamak/filesystem-server-impl's WorkspaceManager to provide
+ * the same API as current fileOperations.ts functions.
+ * Uses dynamic imports since the framework packages are ESM-only.
+ */
+
+import path from 'path';
+import YAML from 'yaml';
+import { logger } from '../utils/logger.js';
+import { Entity, validateEntity } from '../models/EntitySchema.js';
+import { generateEntityFilename } from '../utils/uuid.js';
+import { config } from '../kernel/config.js';
+
+// Lazy-loaded framework modules (ESM)
+let WorkspaceManager: any;
+let FileRouter: any;
+let FileInfoEnricherRegistry: any;
+
+let workspaceManager: any = null;
+let enricherRegistry: any = null;
+let fileRouter: any = null;
+
+/**
+ * Initialize the framework filesystem components.
+ * Must be called once at startup (async because of ESM dynamic imports).
+ */
+export async function initializeFileSystem(): Promise<{
+  workspaceManager: any;
+  fileRouter: any;
+  enricherRegistry: any;
+}> {
+  if (workspaceManager) {
+    return { workspaceManager, fileRouter, enricherRegistry };
+  }
+
+  const fsModule = await import('@hamak/filesystem-server-impl');
+  WorkspaceManager = fsModule.WorkspaceManager;
+  FileRouter = fsModule.FileRouter;
+  FileInfoEnricherRegistry = fsModule.FileInfoEnricherRegistry;
+
+  const baseDirectory = config.dataDir;
+
+  const workspacesConfig: Record<string, string> = {
+    dictionaries: '.',
+  };
+
+  workspaceManager = new WorkspaceManager(workspacesConfig, { baseDirectory });
+  enricherRegistry = new FileInfoEnricherRegistry();
+  fileRouter = new FileRouter(workspaceManager, { enricherRegistry });
+
+  logger.info('Framework filesystem initialized', { baseDirectory });
+
+  return { workspaceManager, fileRouter, enricherRegistry };
+}
+
+/**
+ * Get the Express router for the /fs endpoint.
+ */
+export function getFileRouter(): any {
+  if (!fileRouter) {
+    throw new Error('FileRouter not initialized. Call initializeFileSystem() first.');
+  }
+  return fileRouter.router;
+}
+
+/**
+ * Get the enricher registry for registering file info enrichers.
+ */
+export function getEnricherRegistry(): any {
+  if (!enricherRegistry) {
+    throw new Error('EnricherRegistry not initialized. Call initializeFileSystem() first.');
+  }
+  return enricherRegistry;
+}
+
+/**
+ * Get the workspace manager instance.
+ */
+export function getWorkspaceManager(): any {
+  if (!workspaceManager) {
+    throw new Error('WorkspaceManager not initialized. Call initializeFileSystem() first.');
+  }
+  return workspaceManager;
+}
+
+/**
+ * Read an entity file using WorkspaceManager.
+ */
+export async function readEntityViaAdapter(
+  packageName: string,
+  entityName: string
+): Promise<Entity | null> {
+  if (!workspaceManager) {
+    return null;
+  }
+
+  try {
+    const dirPath = `microservices/${packageName}`;
+    const files = await workspaceManager.listFiles('dictionaries', dirPath);
+
+    for (const file of files) {
+      if (!file.name.endsWith('.yaml') && !file.name.endsWith('.yml')) {
+        continue;
+      }
+      if (file.name === 'metadata.yaml' || file.name === 'relationships.yaml') {
+        continue;
+      }
+
+      const filePath = `${dirPath}/${file.name}`;
+      const content = await workspaceManager.readFile('dictionaries', filePath);
+      const entity = YAML.parse(content) as Entity;
+
+      if (entity.name === entityName) {
+        return entity;
+      }
+    }
+
+    return null;
+  } catch (error) {
+    logger.error(`EntityFileAdapter.readEntity error: ${error}`);
+    return null;
+  }
+}
+
+/**
+ * Write an entity file using WorkspaceManager.
+ */
+export async function writeEntityViaAdapter(entity: Entity, packageName: string): Promise<boolean> {
+  if (!workspaceManager) {
+    return false;
+  }
+
+  try {
+    const validation = validateEntity(entity);
+    if (!validation.valid) {
+      logger.error(`Invalid entity: ${validation.errors.join(', ')}`);
+      return false;
+    }
+
+    const filename = generateEntityFilename(entity.uuid, entity.name);
+    const filePath = `microservices/${packageName}/${filename}`;
+    const yamlContent = YAML.stringify(entity);
+
+    await workspaceManager.writeFile('dictionaries', filePath, yamlContent);
+    logger.info(`Entity written via adapter: ${filePath}`);
+
+    return true;
+  } catch (error) {
+    logger.error(`EntityFileAdapter.writeEntity error: ${error}`);
+    return false;
+  }
+}

package/backend/src/adapters/YamlFileInfoEnricher.ts

@@ -0,0 +1,52 @@
+/**
+ * YamlFileInfoEnricher
+ *
+ * FileInfoEnricher that parses .yaml files and adds entity metadata
+ * (entity name, uuid) to the file info response.
+ */
+
+import YAML from 'yaml';
+import { logger } from '../utils/logger.js';
+
+export interface YamlEnrichedData {
+  entityName?: string;
+  entityUuid?: string;
+}
+
+/**
+ * Creates a YAML file info enricher compatible with
+ * @hamak/filesystem-server-impl's FileInfoEnricherRegistry.
+ */
+export function createYamlFileInfoEnricher() {
+  return {
+    name: 'yaml-entity',
+    extensionKey: 'entity',
+
+    canEnrich(fileInfo: any): boolean {
+      const name: string = fileInfo?.name || '';
+      return name.endsWith('.yaml') || name.endsWith('.yml');
+    },
+
+    async enrich(fileInfo: any, context: any): Promise<YamlEnrichedData | null> {
+      try {
+        const content = context?.content;
+        if (!content) {
+          return null;
+        }
+
+        const parsed = YAML.parse(content);
+        if (!parsed || typeof parsed !== 'object') {
+          return null;
+        }
+
+        return {
+          entityName: parsed.name,
+          entityUuid: parsed.uuid,
+        };
+      } catch (error) {
+        logger.debug(`YamlFileInfoEnricher: could not parse ${fileInfo?.name}: ${error}`);
+        return null;
+      }
+    },
+  };
+}

package/backend/src/controllers/authController.ts

@@ -0,0 +1,131 @@
+import { Request, Response } from 'express';
+import jwt, { SignOptions } from 'jsonwebtoken';
+import { logger } from '../utils/logger.js';
+import { User, UserRole } from '../middleware/auth.js';
+
+// Mock user database - imported from auth middleware
+// In a real application, this would be in a separate database module
+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
+    }
+  }
+};
+
+// JWT secret key - should be in environment variables in production
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+// Token expiration time (default: 24 hours)
+const TOKEN_EXPIRATION = process.env.TOKEN_EXPIRATION || '24h';
+
+/**
+ * Login controller
+ * Validates username and password, generates JWT token
+ * @param req Express request
+ * @param res Express response
+ */
+export const login = (req: Request, res: Response) => {
+  try {
+    const { username, password } = req.body;
+
+    // Validate request body
+    if (!username || !password) {
+      return res.status(400).json({
+        message: 'Bad request',
+        error: 'Username and password are required'
+      });
+    }
+
+    // Validate credentials
+    const userRecord = users[username];
+    
+    if (!userRecord || userRecord.password !== password) {
+      logger.info(`Failed login attempt for user: ${username}`);
+      return res.status(401).json({
+        message: 'Authentication failed',
+        error: 'Invalid username or password'
+      });
+    }
+
+    // Generate JWT token
+    const payload = {
+      id: userRecord.user.id,
+      username: userRecord.user.username,
+      role: userRecord.user.role
+    };
+    const options: SignOptions = { expiresIn: TOKEN_EXPIRATION as any };
+    const token = jwt.sign(payload, JWT_SECRET, options);
+
+    logger.info(`User logged in: ${username}`);
+    
+    // Return token and user info
+    return res.status(200).json({
+      message: 'Authentication successful',
+      token,
+      user: {
+        id: userRecord.user.id,
+        username: userRecord.user.username,
+        role: userRecord.user.role
+      }
+    });
+  } catch (error: any) {
+    logger.error(`Login error: ${error.message}`);
+    return res.status(500).json({
+      message: 'Internal server error',
+      error: process.env.NODE_ENV === 'production' ? undefined : error.message
+    });
+  }
+};
+
+/**
+ * Get current user controller
+ * Returns user information based on JWT token
+ * @param req Express request
+ * @param res Express response
+ */
+export const getCurrentUser = (req: Request, res: Response) => {
+  try {
+    // User should be attached to request by JWT middleware
+    const user = (req as any).user;
+    
+    if (!user) {
+      return res.status(401).json({
+        message: 'Authentication required',
+        error: 'User not authenticated'
+      });
+    }
+    
+    return res.status(200).json({
+      user: {
+        id: user.id,
+        username: user.username,
+        role: user.role
+      }
+    });
+  } catch (error: any) {
+    logger.error(`Get current user error: ${error.message}`);
+    return res.status(500).json({
+      message: 'Internal server error',
+      error: process.env.NODE_ENV === 'production' ? undefined : error.message
+    });
+  }
+};

package/backend/src/controllers/diagramController.ts

@@ -0,0 +1,143 @@
+import { Request, Response } from 'express';
+import { diagramService, DiagramLayout } from '../services/diagramService.js';
+import { logger } from '../utils/logger.js';
+
+export class DiagramController {
+  async saveDiagramLayout(req: Request, res: Response): Promise<void> {
+    try {
+      const layoutData = req.body as Omit<DiagramLayout, 'createdAt' | 'updatedAt'>;
+      
+      if (!layoutData.id || !layoutData.name) {
+        res.status(400).json({
+          message: 'Missing required fields: id and name are required'
+        });
+        return;
+      }
+
+      const savedLayout = await diagramService.saveDiagramLayout(layoutData);
+      
+      res.status(201).json({
+        message: 'Diagram layout saved successfully',
+        data: savedLayout
+      });
+    } catch (error) {
+      logger.error('Error in saveDiagramLayout:', error);
+      res.status(500).json({
+        message: 'Failed to save diagram layout',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+
+  async loadDiagramLayout(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      
+      if (!id) {
+        res.status(400).json({
+          message: 'Diagram layout ID is required'
+        });
+        return;
+      }
+
+      const layout = await diagramService.loadDiagramLayout(id);
+      
+      if (!layout) {
+        res.status(404).json({
+          message: 'Diagram layout not found'
+        });
+        return;
+      }
+
+      res.json({
+        message: 'Diagram layout loaded successfully',
+        data: layout
+      });
+    } catch (error) {
+      logger.error('Error in loadDiagramLayout:', error);
+      res.status(500).json({
+        message: 'Failed to load diagram layout',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+
+  async updateDiagramLayout(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      const updates = req.body;
+      
+      if (!id) {
+        res.status(400).json({
+          message: 'Diagram layout ID is required'
+        });
+        return;
+      }
+
+      const updatedLayout = await diagramService.updateDiagramLayout(id, updates);
+      
+      res.json({
+        message: 'Diagram layout updated successfully',
+        data: updatedLayout
+      });
+    } catch (error) {
+      logger.error('Error in updateDiagramLayout:', error);
+      if (error instanceof Error && error.message === 'Diagram layout not found') {
+        res.status(404).json({
+          message: 'Diagram layout not found'
+        });
+      } else {
+        res.status(500).json({
+          message: 'Failed to update diagram layout',
+          error: error instanceof Error ? error.message : 'Unknown error'
+        });
+      }
+    }
+  }
+
+  async deleteDiagramLayout(req: Request, res: Response): Promise<void> {
+    try {
+      const { id } = req.params;
+      
+      if (!id) {
+        res.status(400).json({
+          message: 'Diagram layout ID is required'
+        });
+        return;
+      }
+
+      await diagramService.deleteDiagramLayout(id);
+      
+      res.json({
+        message: 'Diagram layout deleted successfully'
+      });
+    } catch (error) {
+      logger.error('Error in deleteDiagramLayout:', error);
+      res.status(500).json({
+        message: 'Failed to delete diagram layout',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+
+  async listDiagramLayouts(req: Request, res: Response): Promise<void> {
+    try {
+      const { service } = req.query;
+      
+      const layouts = await diagramService.listDiagramLayouts(service as string);
+      
+      res.json({
+        message: 'Diagram layouts retrieved successfully',
+        data: layouts
+      });
+    } catch (error) {
+      logger.error('Error in listDiagramLayouts:', error);
+      res.status(500).json({
+        message: 'Failed to list diagram layouts',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      });
+    }
+  }
+}
+
+export const diagramController = new DiagramController();