angular-data-mapper 1.0.0

package/projects/ngx-data-mapper/src/lib/services/schema-parser.service.ts

@@ -0,0 +1,270 @@
+import { Injectable } from '@angular/core';
+import { SchemaField, SchemaDefinition } from '../models/schema.model';
+import { JsonSchema } from '../models/json-schema.model';
+
+// Extended schema document with filtering options
+export interface SchemaDocument extends JsonSchema {
+  $ref?: string;
+  $defs?: Record<string, JsonSchema>;  // Alternative to definitions
+  exclude?: string[];
+  include?: string[];
+}
+
+export interface ModelRegistry {
+  [modelName: string]: JsonSchema;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SchemaParserService {
+  private modelRegistry: ModelRegistry = {};
+  private idCounter = 0;
+
+  registerModels(models: ModelRegistry): void {
+    this.modelRegistry = { ...this.modelRegistry, ...models };
+  }
+
+  clearRegistry(): void {
+    this.modelRegistry = {};
+  }
+
+  parseSchema(
+    schemaJson: string | SchemaDocument,
+    schemaName: string = 'Schema'
+  ): SchemaDefinition {
+    const schema: SchemaDocument =
+      typeof schemaJson === 'string' ? JSON.parse(schemaJson) : schemaJson;
+
+    this.idCounter = 0;
+
+    // Extract definitions from the schema document itself
+    const localDefs = schema.$defs || schema.definitions || {};
+    const combinedRegistry = { ...this.modelRegistry, ...localDefs };
+
+    let resolvedSchema: JsonSchema;
+
+    if (schema.$ref) {
+      // Resolve the reference
+      resolvedSchema = this.resolveRef(schema.$ref, combinedRegistry);
+    } else if (schema.properties) {
+      // Direct schema with properties
+      resolvedSchema = schema as JsonSchema;
+    } else {
+      throw new Error('Schema must have either $ref or properties');
+    }
+
+    // Build fields from the resolved schema
+    let fields = this.buildFields(resolvedSchema, combinedRegistry, '');
+
+    // Apply exclude filter
+    if (schema.exclude && schema.exclude.length > 0) {
+      fields = this.applyExclude(fields, schema.exclude);
+    }
+
+    // Apply include filter (only if specified)
+    if (schema.include && schema.include.length > 0) {
+      fields = this.applyInclude(fields, schema.include);
+    }
+
+    return {
+      name: schema.title || schemaName,
+      fields,
+    };
+  }
+
+  private resolveRef(
+    ref: string,
+    registry: Record<string, JsonSchema>
+  ): JsonSchema {
+    // Handle different ref formats:
+    // #model, #/definitions/model, #/$defs/model, model
+    let modelName: string;
+
+    if (ref.startsWith('#/$defs/')) {
+      modelName = ref.substring(8);
+    } else if (ref.startsWith('#/definitions/')) {
+      modelName = ref.substring(14);
+    } else if (ref.startsWith('#')) {
+      modelName = ref.substring(1);
+    } else {
+      modelName = ref;
+    }
+
+    const resolved = registry[modelName];
+    if (!resolved) {
+      throw new Error(`Cannot resolve reference: ${ref}. Model "${modelName}" not found in registry.`);
+    }
+
+    // If the resolved schema also has a $ref, resolve it recursively
+    if (resolved.$ref) {
+      return this.resolveRef(resolved.$ref, registry);
+    }
+
+    return resolved;
+  }
+
+  private buildFields(
+    schema: JsonSchema,
+    registry: Record<string, JsonSchema>,
+    parentPath: string,
+    arrayContext?: { isArrayItem: boolean; parentArrayPath: string }
+  ): SchemaField[] {
+    const fields: SchemaField[] = [];
+
+    if (!schema.properties) {
+      return fields;
+    }
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const path = parentPath ? `${parentPath}.${name}` : name;
+      const field = this.buildField(name, propSchema, registry, path, arrayContext);
+      fields.push(field);
+    }
+
+    return fields;
+  }
+
+  private buildField(
+    name: string,
+    schema: JsonSchema,
+    registry: Record<string, JsonSchema>,
+    path: string,
+    arrayContext?: { isArrayItem: boolean; parentArrayPath: string }
+  ): SchemaField {
+    // Resolve $ref if present
+    let resolvedSchema = schema;
+    if (schema.$ref) {
+      resolvedSchema = { ...this.resolveRef(schema.$ref, registry), ...schema };
+      delete resolvedSchema.$ref;
+    }
+
+    const fieldType = this.mapType(resolvedSchema);
+    const field: SchemaField = {
+      id: `field-${++this.idCounter}-${name}`,
+      name,
+      type: fieldType,
+      path,
+      description: resolvedSchema.description,
+      isArrayItem: arrayContext?.isArrayItem,
+      parentArrayPath: arrayContext?.parentArrayPath,
+    };
+
+    // Handle nested objects
+    if (fieldType === 'object' && resolvedSchema.properties) {
+      field.children = this.buildFields(resolvedSchema, registry, path, arrayContext);
+      field.expanded = true;
+    }
+
+    // Handle arrays with object items
+    if (fieldType === 'array' && resolvedSchema.items) {
+      let itemSchema = resolvedSchema.items;
+      if (itemSchema.$ref) {
+        itemSchema = this.resolveRef(itemSchema.$ref, registry);
+      }
+      if (itemSchema.properties) {
+        // Mark children as array items with reference to parent array
+        field.children = this.buildFields(itemSchema, registry, `${path}[]`, {
+          isArrayItem: true,
+          parentArrayPath: path,
+        });
+        field.expanded = true;
+      }
+    }
+
+    return field;
+  }
+
+  private mapType(
+    schema: JsonSchema
+  ): 'string' | 'number' | 'boolean' | 'object' | 'array' | 'date' {
+    const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    const format = schema.format;
+
+    // Check format first for date types
+    if (format === 'date' || format === 'date-time' || format === 'time') {
+      return 'date';
+    }
+
+    switch (type) {
+      case 'string':
+        return 'string';
+      case 'number':
+      case 'integer':
+        return 'number';
+      case 'boolean':
+        return 'boolean';
+      case 'object':
+        return 'object';
+      case 'array':
+        return 'array';
+      default:
+        // If type is not specified but has properties, it's an object
+        if (schema.properties) {
+          return 'object';
+        }
+        return 'string';
+    }
+  }
+
+  private applyExclude(fields: SchemaField[], exclude: string[]): SchemaField[] {
+    return fields
+      .filter((field) => !exclude.includes(field.name) && !exclude.includes(field.path))
+      .map((field) => {
+        if (field.children) {
+          // Filter nested fields by checking both full path and relative name
+          const filteredChildren = this.applyExclude(field.children, exclude);
+          return { ...field, children: filteredChildren };
+        }
+        return field;
+      });
+  }
+
+  private applyInclude(fields: SchemaField[], include: string[]): SchemaField[] {
+    return fields
+      .filter((field) => {
+        // Include if field name or path matches
+        if (include.includes(field.name) || include.includes(field.path)) {
+          return true;
+        }
+        // Include if any child path matches
+        if (field.children) {
+          return this.hasIncludedChild(field.children, include);
+        }
+        return false;
+      })
+      .map((field) => {
+        if (field.children) {
+          // Keep parent but filter children
+          const filteredChildren = this.applyInclude(field.children, include);
+          return { ...field, children: filteredChildren.length > 0 ? filteredChildren : field.children };
+        }
+        return field;
+      });
+  }
+
+  private hasIncludedChild(fields: SchemaField[], include: string[]): boolean {
+    return fields.some((field) => {
+      if (include.includes(field.name) || include.includes(field.path)) {
+        return true;
+      }
+      if (field.children) {
+        return this.hasIncludedChild(field.children, include);
+      }
+      return false;
+    });
+  }
+
+  // Utility method to create a schema document from model name
+  createSchemaFromRef(
+    modelRef: string,
+    options?: { exclude?: string[]; include?: string[]; title?: string }
+  ): SchemaDocument {
+    return {
+      $ref: modelRef,
+      title: options?.title,
+      exclude: options?.exclude,
+      include: options?.include,
+    };
+  }
+}

package/projects/ngx-data-mapper/src/lib/services/svg-connector.service.ts

@@ -0,0 +1,135 @@
+import { Injectable } from '@angular/core';
+
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface ConnectionPath {
+  id: string;
+  mappingId: string;
+  path: string;
+  sourcePoints: Point[];
+  targetPoint: Point;
+  midPoint: Point;
+  isSelected: boolean;
+  hasTransformation: boolean;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class SvgConnectorService {
+  createBezierPath(start: Point, end: Point): string {
+    const dx = end.x - start.x;
+    const controlPointOffset = Math.min(Math.abs(dx) * 0.5, 150);
+
+    const cp1x = start.x + controlPointOffset;
+    const cp1y = start.y;
+    const cp2x = end.x - controlPointOffset;
+    const cp2y = end.y;
+
+    return `M ${start.x} ${start.y} C ${cp1x} ${cp1y}, ${cp2x} ${cp2y}, ${end.x} ${end.y}`;
+  }
+
+  createMultiSourcePath(sources: Point[], target: Point): { paths: string[]; mergePoint: Point } {
+    const mergeX = target.x - 80;
+    const mergeY = target.y;
+    const mergePoint = { x: mergeX, y: mergeY };
+
+    const paths = sources.map((source) => {
+      // Path from source to merge point
+      const dx1 = mergeX - source.x;
+      const cp1Offset = Math.min(Math.abs(dx1) * 0.4, 100);
+
+      return `M ${source.x} ${source.y} C ${source.x + cp1Offset} ${source.y}, ${mergeX - cp1Offset} ${mergeY}, ${mergeX} ${mergeY}`;
+    });
+
+    // Add path from merge point to target
+    const finalPath = `M ${mergeX} ${mergeY} L ${target.x} ${target.y}`;
+    paths.push(finalPath);
+
+    return { paths, mergePoint };
+  }
+
+  getMidPoint(start: Point, end: Point): Point {
+    return {
+      x: (start.x + end.x) / 2,
+      y: (start.y + end.y) / 2,
+    };
+  }
+
+  getMultiSourceMidPoint(sources: Point[], target: Point): Point {
+    const mergeX = target.x - 80;
+    return {
+      x: mergeX,
+      y: target.y,
+    };
+  }
+
+  calculateConnectionPoint(
+    rect: DOMRect,
+    side: 'source' | 'target',
+    containerRect: DOMRect
+  ): Point {
+    const relativeY = rect.top - containerRect.top + rect.height / 2;
+    // Offset to position endpoint circles outside the schema panels
+    const endpointOffset = 8;
+
+    if (side === 'source') {
+      return {
+        x: rect.right - containerRect.left + endpointOffset,
+        y: relativeY,
+      };
+    } else {
+      return {
+        x: rect.left - containerRect.left - endpointOffset,
+        y: relativeY,
+      };
+    }
+  }
+
+  isPointNearPath(
+    point: Point,
+    pathStart: Point,
+    pathEnd: Point,
+    threshold: number = 10
+  ): boolean {
+    // Simplified hit detection using distance to line segment
+    const A = point.x - pathStart.x;
+    const B = point.y - pathStart.y;
+    const C = pathEnd.x - pathStart.x;
+    const D = pathEnd.y - pathStart.y;
+
+    const dot = A * C + B * D;
+    const lenSq = C * C + D * D;
+    let param = -1;
+
+    if (lenSq !== 0) {
+      param = dot / lenSq;
+    }
+
+    let xx: number, yy: number;
+
+    if (param < 0) {
+      xx = pathStart.x;
+      yy = pathStart.y;
+    } else if (param > 1) {
+      xx = pathEnd.x;
+      yy = pathEnd.y;
+    } else {
+      xx = pathStart.x + param * C;
+      yy = pathStart.y + param * D;
+    }
+
+    const dx = point.x - xx;
+    const dy = point.y - yy;
+    const distance = Math.sqrt(dx * dx + dy * dy);
+
+    return distance <= threshold;
+  }
+
+  createDragPath(start: Point, end: Point): string {
+    return this.createBezierPath(start, end);
+  }
+}