@hamak/smart-data-dico 1.0.4 → 1.1.1

package/backend/src/models/EntitySchema.ts

@@ -1,393 +0,0 @@
-import { Validator } from 'jsonschema';
-import { generateUUID, isValidUUID } from '../utils/uuid.js';
-type Schema = any; // Using any as a workaround for missing type definitions
-
-/**
- * Supported attribute types in the data dictionary
- */
-export enum AttributeType {
-  STRING = 'string',
-  NUMBER = 'number',
-  INTEGER = 'integer',
-  BOOLEAN = 'boolean',
-  DATETIME = 'datetime',
-  DATE = 'date',
-  TIME = 'time',
-  DATE_TIME = 'date-time',
-  TIMESTAMP = 'timestamp',
-  DURATION = 'duration',
-  ENUM = 'enum',
-  OBJECT = 'object',
-  ARRAY = 'array'
-}
-
-/**
- * Cardinality for relationship ends
- */
-export enum Cardinality {
-  ONE = 'one',
-  MANY = 'many'
-}
-
-/**
- * Metadata value types for typed metadata definitions
- */
-export enum MetadataValueType {
-  STRING = 'string',
-  NUMBER = 'number',
-  BOOLEAN = 'boolean',
-  DATE = 'date',
-  FLAG = 'flag',
-  RULE = 'rule',
-}
-
-export enum RuleSeverity {
-  INFO = 'info',
-  WARNING = 'warning',
-  ERROR = 'error',
-}
-
-/**
- * A metadata definition (schema for metadata entries)
- */
-export interface MetadataDefinition {
-  name: string;
-  type: MetadataValueType;
-  description?: string;
-  required?: boolean;
-}
-
-/**
- * A typed metadata entry
- */
-export interface MetadataEntry {
-  name: string;
-  value: string | number | boolean;
-  severity?: RuleSeverity;
-}
-
-export enum EntityStatus {
-  DRAFT = 'draft',
-  SUBMITTED = 'submitted',
-  APPROVED = 'approved',
-  RETURNED = 'returned',
-}
-
-export interface ReviewComment {
-  id: string;
-  author: string;
-  timestamp: string;
-  message: string;
-  targetField?: string;
-  resolved?: boolean;
-}
-
-export type StereotypeTarget = 'package' | 'entity' | 'attribute';
-
-export interface Stereotype {
-  id: string;
-  name: string;
-  description?: string;
-  appliesTo: StereotypeTarget;
-  metadataDefinitions: MetadataDefinition[];
-}
-
-/**
- * A node in a perspective — annotates, sets frontier, or excludes a path
- */
-export interface PerspectiveNode {
-  path: string;
-  traverse?: boolean;
-  exclude?: boolean;
-  metadata?: MetadataEntry[];
-}
-
-/**
- * A perspective is a business view over a subset of the data model
- */
-export interface Perspective {
-  uuid: string;
-  name: string;
-  description?: string;
-  rootEntities: string[];
-  nodes?: PerspectiveNode[];
-  maxDepth?: number;
-  metadata?: MetadataEntry[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-
-/**
- * A resolved node from BFS traversal of a perspective
- */
-export interface ResolvedNode {
-  entityUuid: string;
-  entityName: string;
-  service: string;
-  path: string;
-  hopDistance: number;
-  isRoot: boolean;
-  isFrontier: boolean;
-  isManualInclusion: boolean;
-}
-
-/**
- * A perspective with its resolved entity graph
- */
-export interface ResolvedPerspective extends Perspective {
-  resolvedNodes: ResolvedNode[];
-}
-
-/**
- * Grouped constraint fields for attributes
- */
-export interface AttributeConstraints {
-  minLength?: number;
-  maxLength?: number;
-  pattern?: string;
-  format?: string;
-  minimum?: number;
-  maximum?: number;
-  precision?: number;
-  scale?: number;
-  enumValues?: string[];
-}
-
-/**
- * Interface for entity attribute definition
- */
-export interface Attribute {
-  uuid: string;
-  name: string;
-  description: string;
-  type: AttributeType;
-  required: boolean;
-  unique?: boolean;
-  primaryKey?: boolean;
-  defaultValue?: any;
-  examples?: any[];
-  constraints?: AttributeConstraints;
-
-  // For object and array types
-  items?: Attribute;
-  properties?: Attribute[];
-
-  // Typed metadata
-  metadata?: MetadataEntry[];
-}
-
-/**
- * One end of a relationship
- */
-export interface RelationshipEnd {
-  entity: string; // UUID of the entity
-  cardinality: Cardinality;
-  name?: string; // Navigation property name
-  referenceAttributes?: string[];
-}
-
-/**
- * A relationship between two entities, stored at package level
- */
-export type RelationshipType = 'structural' | 'lineage';
-
-export interface Relationship {
-  uuid: string;
-  description?: string;
-  type?: RelationshipType;
-  source: RelationshipEnd;
-  target: RelationshipEnd;
-  metadata?: MetadataEntry[];
-}
-
-export interface LineageNode {
-  entityUuid: string;
-  entityName: string;
-  service: string;
-  direction: 'upstream' | 'downstream';
-  depth: number;
-  relationship: { uuid: string; description: string };
-}
-
-export interface LineageResult {
-  entity: { uuid: string; name: string; service: string };
-  upstream: LineageNode[];
-  downstream: LineageNode[];
-}
-
-/**
- * Interface for entity definition
- */
-export interface Entity {
-  uuid: string;
-  name: string;
-  description?: string;
-  stereotype?: string;
-  status?: EntityStatus;
-  attributes: Attribute[];
-  metadata?: MetadataEntry[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-
-// Backward-compatible alias
-export type EntityAttribute = Attribute;
-
-/**
- * JSON Schema for validating entity definitions
- */
-export const entitySchema: Schema = {
-  type: 'object',
-  required: ['uuid', 'name', 'attributes'],
-  properties: {
-    uuid: { type: 'string', pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$' },
-    name: { type: 'string' },
-    description: { type: 'string' },
-    attributes: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: ['uuid', 'name', 'description', 'type', 'required'],
-        properties: {
-          uuid: { type: 'string', pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$' },
-          name: { type: 'string' },
-          description: { type: 'string' },
-          type: {
-            type: 'string',
-            enum: Object.values(AttributeType)
-          },
-          required: { type: 'boolean' },
-          unique: { type: 'boolean' },
-          primaryKey: { type: 'boolean' },
-          defaultValue: { },
-          examples: { type: 'array' },
-          constraints: {
-            type: 'object',
-            properties: {
-              minLength: { type: 'integer', minimum: 0 },
-              maxLength: { type: 'integer', minimum: 0 },
-              pattern: { type: 'string' },
-              format: { type: 'string' },
-              minimum: { type: 'number' },
-              maximum: { type: 'number' },
-              precision: { type: 'integer', minimum: 0 },
-              scale: { type: 'integer', minimum: 0 },
-              enumValues: {
-                type: 'array',
-                items: { type: 'string' }
-              }
-            }
-          },
-          items: { type: 'object' },
-          properties: { type: 'array' },
-          metadata: { type: 'array' }
-        }
-      }
-    },
-    metadata: { type: 'array' },
-    createdAt: { type: 'string', format: 'date-time' },
-    updatedAt: { type: 'string', format: 'date-time' }
-  }
-};
-
-/**
- * JSON Schema for validating relationship definitions
- */
-export const relationshipSchema: Schema = {
-  type: 'object',
-  required: ['uuid', 'source', 'target'],
-  properties: {
-    uuid: { type: 'string', pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$' },
-    description: { type: 'string' },
-    source: {
-      type: 'object',
-      required: ['entity', 'cardinality'],
-      properties: {
-        entity: { type: 'string' },
-        cardinality: { type: 'string', enum: Object.values(Cardinality) },
-        name: { type: 'string' },
-        referenceAttributes: { type: 'array', items: { type: 'string' } }
-      }
-    },
-    target: {
-      type: 'object',
-      required: ['entity', 'cardinality'],
-      properties: {
-        entity: { type: 'string' },
-        cardinality: { type: 'string', enum: Object.values(Cardinality) },
-        name: { type: 'string' },
-        referenceAttributes: { type: 'array', items: { type: 'string' } }
-      }
-    },
-    metadata: { type: 'array' }
-  }
-};
-
-/**
- * Validates an entity definition against the schema
- */
-export function validateEntity(entity: Entity): { valid: boolean; errors: string[] } {
-  const validator = new Validator();
-  const result = validator.validate(entity, entitySchema);
-
-  const errors: string[] = result.errors.map((error: any) => error.stack);
-
-  // Additional UUID validation
-  if (!isValidUUID(entity.uuid)) {
-    errors.push('Entity UUID is invalid');
-  }
-
-  // Validate attribute UUIDs
-  if (entity.attributes) {
-    entity.attributes.forEach((attr, index) => {
-      if (!isValidUUID(attr.uuid)) {
-        errors.push(`Attribute ${index} UUID is invalid`);
-      }
-    });
-  }
-
-  return {
-    valid: result.valid && errors.length === 0,
-    errors
-  };
-}
-
-/**
- * Validates a relationship definition against the schema
- */
-export function validateRelationship(relationship: Relationship): { valid: boolean; errors: string[] } {
-  const validator = new Validator();
-  const result = validator.validate(relationship, relationshipSchema);
-
-  const errors: string[] = result.errors.map((error: any) => error.stack);
-
-  if (!isValidUUID(relationship.uuid)) {
-    errors.push('Relationship UUID is invalid');
-  }
-
-  return {
-    valid: result.valid && errors.length === 0,
-    errors
-  };
-}
-
-/**
- * Creates a new entity with UUIDs for all components
- */
-export function createEntityWithUUIDs(entityData: Omit<Entity, 'uuid' | 'attributes'> & {
-  attributes: Omit<Attribute, 'uuid'>[];
-}): Entity {
-  return {
-    ...entityData,
-    uuid: generateUUID(),
-    attributes: entityData.attributes.map(attr => ({
-      ...attr,
-      uuid: generateUUID(),
-      properties: attr.properties ? attr.properties.map(prop => ({
-        ...prop,
-        uuid: prop.uuid || generateUUID()
-      })) : attr.properties,
-      items: attr.items ? { ...attr.items, uuid: attr.items.uuid || generateUUID() } : attr.items
-    }))
-  };
-}

package/backend/src/models/__tests__/Dictionary.test.ts

@@ -1,92 +0,0 @@
-import { Dictionary, DictionaryEntry } from '../Dictionary.js';
-
-describe('Dictionary Model', () => {
-  describe('Dictionary Interface', () => {
-    it('should create a valid Dictionary object', () => {
-      const dictionary: Dictionary = {
-        id: 'test-dict-1',
-        name: 'Test Dictionary',
-        description: 'A test dictionary',
-        version: '1.0.0',
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        rootPackage: { id: 'root', name: 'Root', entities: [], subPackages: [] },
-      };
-
-      expect(dictionary).toBeDefined();
-      expect(dictionary.id).toBe('test-dict-1');
-      expect(dictionary.name).toBe('Test Dictionary');
-      expect(dictionary.description).toBe('A test dictionary');
-      expect(dictionary.version).toBe('1.0.0');
-      expect(dictionary.createdAt).toBeInstanceOf(Date);
-      expect(dictionary.updatedAt).toBeInstanceOf(Date);
-    });
-
-    it('should create a Dictionary with only required fields', () => {
-      const dictionary: Dictionary = {
-        id: 'test-dict-2',
-        name: 'Minimal Dictionary',
-        rootPackage: { id: 'root', name: 'Root', entities: [], subPackages: [] },
-      };
-
-      expect(dictionary).toBeDefined();
-      expect(dictionary.id).toBe('test-dict-2');
-      expect(dictionary.name).toBe('Minimal Dictionary');
-      expect(dictionary.description).toBeUndefined();
-      expect(dictionary.version).toBeUndefined();
-      expect(dictionary.createdAt).toBeUndefined();
-      expect(dictionary.updatedAt).toBeUndefined();
-    });
-  });
-
-  describe('DictionaryEntry Interface', () => {
-    it('should create a valid DictionaryEntry object', () => {
-      const entry: DictionaryEntry = {
-        id: 'entry-1',
-        name: 'Test Entry',
-        description: 'A test entry',
-        type: 'string',
-        format: 'email',
-        required: true,
-        defaultValue: 'test@example.com',
-        examples: ['user@example.com', 'admin@example.com'],
-        metadata: {
-          source: 'user',
-          lastUpdated: '2023-01-01',
-        },
-      };
-
-      expect(entry).toBeDefined();
-      expect(entry.id).toBe('entry-1');
-      expect(entry.name).toBe('Test Entry');
-      expect(entry.description).toBe('A test entry');
-      expect(entry.type).toBe('string');
-      expect(entry.format).toBe('email');
-      expect(entry.required).toBe(true);
-      expect(entry.defaultValue).toBe('test@example.com');
-      expect(entry.examples).toHaveLength(2);
-      expect(entry.examples).toContain('user@example.com');
-      expect(entry.metadata).toHaveProperty('source', 'user');
-    });
-
-    it('should create a DictionaryEntry with only required fields', () => {
-      const entry: DictionaryEntry = {
-        id: 'entry-2',
-        name: 'Minimal Entry',
-        description: 'A minimal entry',
-        type: 'number',
-      };
-
-      expect(entry).toBeDefined();
-      expect(entry.id).toBe('entry-2');
-      expect(entry.name).toBe('Minimal Entry');
-      expect(entry.description).toBe('A minimal entry');
-      expect(entry.type).toBe('number');
-      expect(entry.format).toBeUndefined();
-      expect(entry.required).toBeUndefined();
-      expect(entry.defaultValue).toBeUndefined();
-      expect(entry.examples).toBeUndefined();
-      expect(entry.metadata).toBeUndefined();
-    });
-  });
-});

package/backend/src/models/__tests__/EntitySchema.test.ts

@@ -1,119 +0,0 @@
-import { AttributeType, validateEntity } from '../EntitySchema.js';
-
-describe('EntitySchema', () => {
-  describe('validateEntity', () => {
-    it('should validate a valid entity', () => {
-      const validEntity = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: AttributeType.STRING,
-            required: true,
-            primaryKey: true,
-          },
-          {
-            uuid: 'c5af3719-ee6f-4156-bb1a-e575d345f7a5',
-            name: 'name',
-            description: 'Entity name',
-            type: AttributeType.STRING,
-            required: true,
-          },
-        ],
-      };
-
-      const result = validateEntity(validEntity);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should invalidate an entity with missing required fields', () => {
-      const invalidEntity = {
-        // Missing uuid
-        // Missing name
-        description: 'A test entity',
-        attributes: [],
-      };
-
-      const result = validateEntity(invalidEntity as any);
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate an entity with constraints', () => {
-      const entityWithConstraints = {
-        uuid: 'd6b0482a-ff70-4267-8c2b-f686e456f8b6',
-        name: 'Test Entity',
-        description: 'A test entity',
-        attributes: [
-          {
-            uuid: 'e7c1593b-aa81-4378-9d3c-a797f567a9c7',
-            name: 'email',
-            description: 'Email address',
-            type: AttributeType.STRING,
-            required: true,
-            constraints: {
-              maxLength: 255,
-              pattern: '^[^@]+@[^@]+$',
-              format: 'email',
-            },
-          },
-        ],
-      };
-
-      const result = validateEntity(entityWithConstraints);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-
-    it('should invalidate an entity with invalid attribute type', () => {
-      const entityWithInvalidAttribute = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        description: 'A test entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: 'invalid-type', // Invalid type
-            required: true,
-          },
-        ],
-      };
-
-      const result = validateEntity(entityWithInvalidAttribute as any);
-      expect(result.valid).toBe(false);
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should validate an entity with metadata entries', () => {
-      const entityWithMetadata = {
-        uuid: 'a38d1597-cc4f-4934-bb08-c876c023f693',
-        name: 'Test Entity',
-        attributes: [
-          {
-            uuid: 'b49e2608-dd5f-4045-aa09-d464c234e694',
-            name: 'id',
-            description: 'Primary identifier',
-            type: AttributeType.STRING,
-            required: true,
-            metadata: [
-              { name: 'sensitive', value: true },
-            ],
-          },
-        ],
-        metadata: [
-          { name: 'owner', value: 'team-a' },
-        ],
-      };
-
-      const result = validateEntity(entityWithMetadata);
-      expect(result.valid).toBe(true);
-      expect(result.errors).toHaveLength(0);
-    });
-  });
-});