ea 0.6.2 → 0.6.4

data/frontend/src/types.ts

@@ -1,221 +1,218 @@
-export interface SpaCardinality {
-  min?: string
-  max?: string
+export interface SpaStatistics {
+  packages: number
+  classes: number
+  attributes: number
+  operations: number
+  associations: number
+  diagrams: number
 }
 
-export interface SpaAttribute {
-  id: string
-  name: string
-  type: string
-  visibility?: string
-  owner: string
-  ownerName: string
-  cardinality?: SpaCardinality
-  definition?: string
-  stereotypes: string[]
-  isStatic: boolean
-  isReadOnly: boolean
-  defaultValue?: string
+export interface SpaLogoVariant {
+  path?: string
+  url?: string
 }
 
-export interface SpaAssociationEnd {
-  class?: string
-  className?: string
-  role?: string
-  cardinality?: SpaCardinality
-  aggregation?: string
+export interface SpaLogoConfig {
+  light: SpaLogoVariant
+  dark: SpaLogoVariant
 }
 
-export interface SpaAssociation {
-  id: string
-  xmiId: string
-  name: string
-  type: string
-  definition?: string
-  source?: SpaAssociationEnd
-  target?: SpaAssociationEnd
+export interface SpaLogos {
+  square?: SpaLogoConfig
+  long?: SpaLogoConfig
 }
 
-export interface SpaOperation {
-  id: string
-  name: string
-  visibility?: string
-  returnType?: string
-  owner: string
-  ownerName: string
-  parameters: SpaParameter[]
-  isStatic: boolean
-  isAbstract: boolean
+export interface SpaAppearance {
+  logos?: SpaLogos
 }
 
-export interface SpaParameter {
-  name: string
-  type?: string
-  direction?: string
+export interface SpaMetadata {
+  id?: string
+  title?: string
+  description?: string
+  version?: string
+  generated?: string
+  generator?: string
+  createdDate?: string
+  modifiedDate?: string
+  sourceFormat?: string
+  sourceTool?: string
+  sourcePath?: string
+  appearance?: SpaAppearance
+  statistics?: SpaStatistics
 }
 
-export interface SpaLiteral {
+export interface SpaPackageTreeNode {
+  id: string
   name: string
-  definition?: string
-}
-
-export interface SpaInheritedAttribute {
-  attributeId: string
-  attribute: SpaAttribute
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
+  parentId?: string
+  childIds: string[]
+  classifierIds: string[]
+  diagramIds: string[]
 }
 
-export interface SpaInheritedAssociation {
-  associationId: string
-  inheritedFrom: string
-  inheritedFromName: string
-  parentOrder: number
-  localRole: string
+export interface SpaPackageTree {
+  rootIds: string[]
+  nodes: SpaPackageTreeNode[]
 }
 
-export interface SpaClass {
+export interface SpaSkeletonEntry {
   id: string
-  xmiId: string
   name: string
-  qualifiedName: string
-  type: string
-  package?: string
-  stereotypes: string[]
-  definition?: string
-  attributes: string[]
-  operations: string[]
-  associations: string[]
-  generalizations: string[]
-  specializations: string[]
-  isAbstract: boolean
-  literals: SpaLiteral[]
-  inheritedAttributes: SpaInheritedAttribute[]
-  inheritedAssociations: SpaInheritedAssociation[]
+  kind: string
+  packageId?: string
+  qualifiedName?: string
+  shardUrl: string
 }
 
-export interface SpaPackage {
+export interface SpaShard {
   id: string
-  xmiId: string
-  name: string
-  path: string
-  definition?: string
-  stereotypes: string[]
-  classes: string[]
-  subPackages: string[]
-  diagrams: string[]
-  parent?: string
+  kind: string
+  payload: any
 }
 
-export interface SpaTreeClassRef {
+export interface SpaSearchEntry {
   id: string
+  kind: string
   name: string
-  stereotypes: string[]
+  qualifiedName: string
+  package: string
+  content: string
+  boost?: number
 }
 
-export interface SpaPackageTreeNode {
+export interface SpaSearchIndex {
+  version: string
+  fields: string[]
+  entries: SpaSearchEntry[]
+}
+
+export interface SpaAnnotation {
   id: string
-  name: string
-  path: string
-  stereotypes: string[]
-  classCount: number
-  classes: SpaTreeClassRef[]
-  children: SpaPackageTreeNode[]
+  kind: string
+  body?: string
 }
 
-export interface SpaDiagram {
+export interface SpaPropertyPayload {
   id: string
-  xmiId: string
   name: string
-  type: string
-  package?: string
-  objectCount: number
-  linkCount: number
-  svg?: string
+  ownerId: string
+  typeName?: string
+  qualifiedName?: string
+  multiplicityLower?: number
+  multiplicityUpper?: number
+  isDerived: boolean
+  isReadonly: boolean
+  visibility?: string
+  stereotypeRefs: string[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaStatistics {
-  packages: number
-  classes: number
-  associations: number
-  attributes: number
-  operations: number
+export interface SpaParameterPayload {
+  name?: string
+  direction?: string
+  typeName?: string
+  multiplicityLower?: number
+  multiplicityUpper?: number
+  defaultValue?: string
 }
 
-export interface SpaLogoVariant {
-  path?: string
-  url?: string
+export interface SpaOperationPayload {
+  id: string
+  name: string
+  ownerId: string
+  qualifiedName?: string
+  returnTypeName?: string
+  isStatic: boolean
+  isAbstract: boolean
+  visibility?: string
+  parameters: SpaParameterPayload[]
+  stereotypeRefs: string[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaLogoConfig {
-  light: SpaLogoVariant
-  dark: SpaLogoVariant
+export interface SpaGeneralizationStub {
+  id: string
+  targetId: string
 }
 
-export interface SpaLogos {
-  square?: SpaLogoConfig
-  long?: SpaLogoConfig
+export interface SpaAssociationStub {
+  id: string
+  name?: string
+  sourceId: string
+  targetId: string
+  thisEndRoleName?: string
+  otherEndRoleName?: string
+  otherEndId: string
+  otherEndMultiplicity?: [number?, number?]
+  otherEndAggregation?: string
 }
 
-export interface SpaAppearance {
-  logos?: SpaLogos
+export interface SpaEnumerationLiteralPayload {
+  id: string
+  name: string
+  value?: string
+  ordinal?: number
 }
 
-export interface SpaMetadata {
-  title?: string
-  description?: string
-  generated: string
-  generator: string
-  version: string
-  homepage?: string
-  repository?: string
-  license?: string
-  authors?: string
-  tags?: string[]
-  appearance?: SpaAppearance
-  statistics: SpaStatistics
+export interface SpaClassifierPayload {
+  id: string
+  name: string
+  qualifiedName: string
+  packageId: string
+  packageName?: string
+  isAbstract: boolean
+  visibility?: string
+  modelKind: string
+  properties: SpaPropertyPayload[]
+  operations: SpaOperationPayload[]
+  stereotypeRefs: string[]
+  taggedValues: any[]
+  constraints: any[]
+  annotations: SpaAnnotation[]
+  literals?: SpaEnumerationLiteralPayload[]
+  generalizations?: SpaGeneralizationStub[]
+  specializations?: SpaGeneralizationStub[]
+  associations?: SpaAssociationStub[]
+}
+
+export interface SpaPackagePayload {
+  id: string
+  name: string
+  parentId?: string
+  subPackageIds: string[]
+  classifierIds: string[]
+  diagramIds: string[]
+  stereotypeRefs: string[]
+  taggedValues: any[]
+  annotations: SpaAnnotation[]
 }
 
-export interface SpaSearchEntry {
+export interface SpaDiagramPayload {
   id: string
-  type: string
-  entityType: string
-  entityId: string
   name: string
-  qualifiedName: string
-  package: string
-  content: string
-  boost: number
+  packageId?: string
+  diagramType?: string
+  elements: any[]
+  connectors: any[]
+  annotations: SpaAnnotation[]
+  svg?: string
 }
 
-export interface SpaSearchIndex {
-  version: string
-  fields: { name: string; boost: number }[]
-  ref: string
-  documentStore: SpaSearchEntry[]
-  pipeline: string[]
+export interface SpaViewExtras {
+  ui?: Record<string, any>
+  appearance?: SpaAppearance
+  diagrams?: { enabled?: boolean }
 }
 
-export interface SpaDocument {
+export interface SpaSkeleton {
   metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
+  packageTree: SpaPackageTree
+  entries: SpaSkeletonEntry[]
+  viewExtras?: SpaViewExtras
 }
 
-export interface SpaData {
-  metadata: SpaMetadata
-  packageTree: SpaPackageTreeNode
-  packages: Record<string, SpaPackage>
-  classes: Record<string, SpaClass>
-  attributes: Record<string, SpaAttribute>
-  associations: Record<string, SpaAssociation>
-  operations: Record<string, SpaOperation>
-  diagrams: Record<string, SpaDiagram>
+export interface SpaData extends SpaSkeleton {
   searchIndex: SpaSearchIndex
+  shards: SpaShard[]
 }

data/lib/ea/spa/output/single_file_strategy.rb

@@ -19,7 +19,7 @@ module Ea
           payload = {
             metadata: skeleton.metadata,
             packageTree: skeleton.package_tree,
-            skeletonEntries: skeleton.entries,
+            entries: skeleton.entries,
             searchIndex: projector.search_index,
             shards: projector.each_shard.to_a
           }

data/lib/ea/spa/projector.rb

@@ -76,7 +76,22 @@ module Ea
       def metadata_hash
         base = document.metadata
         merged = configuration ? configuration.apply_to_metadata(base) : base
-        JSON.parse(merged.to_json)
+        hash = JSON.parse(merged.to_json)
+        hash["statistics"] = statistics_hash
+        hash
+      end
+
+      def statistics_hash
+        {
+          "packages" => document.packages.size,
+          "classes" => document.classifiers.size,
+          "attributes" => document.classifiers.sum { |c| c.properties.size },
+          "operations" => document.classifiers.sum { |c| c.operations.size },
+          "associations" => document.relationships.count do |r|
+            r.is_a?(Ea::Model::Association)
+          end,
+          "diagrams" => render_diagrams? ? document.diagrams.size : 0
+        }
       end
 
       def view_extras
@@ -84,14 +99,16 @@ module Ea
       end
 
       def build_package_tree
+        sub_ids_by_parent = document.packages.group_by(&:parent_id)
         nodes = document.packages.map do |pkg|
           PackageTreeNode.new(
             id: pkg.id,
             name: pkg.name,
             parent_id: pkg.parent_id,
-            child_ids: pkg.sub_package_ids,
+            child_ids: (pkg.sub_package_ids +
+                        (sub_ids_by_parent[pkg.id] || []).map(&:id)).uniq,
             classifier_ids: classifiers_in_package_ids(pkg.id),
-            diagram_ids: pkg.diagram_ids
+            diagram_ids: diagram_ids_for_package(pkg.id)
           )
         end
         PackageTree.new(
@@ -105,7 +122,7 @@ module Ea
       end
 
       def build_entries
-        document.classifiers.map do |c|
+        classifier_entries = document.classifiers.map do |c|
           SkeletonEntry.new(
             id: c.id,
             name: c.name,
@@ -115,6 +132,27 @@ module Ea
             shard_url: shard_url_for.call(c)
           )
         end
+        package_entries = document.packages.map do |p|
+          SkeletonEntry.new(
+            id: p.id,
+            name: p.name,
+            kind: "package",
+            package_id: p.parent_id,
+            qualified_name: p.qualified_name,
+            shard_url: shard_url_for.call(p)
+          )
+        end
+        diagram_entries = render_diagrams? ? document.diagrams.map do |d|
+          SkeletonEntry.new(
+            id: d.id,
+            name: d.name,
+            kind: "diagram",
+            package_id: d.package_id,
+            qualified_name: d.name,
+            shard_url: shard_url_for.call(d)
+          )
+        end : []
+        classifier_entries + package_entries + diagram_entries
       end
 
       def build_search_entries
@@ -191,8 +229,72 @@ module Ea
         end
       end
 
-      def payload_for(element)
-        JSON.parse(element.to_json)
+      def payload_for(model_element)
+        payload = JSON.parse(model_element.to_json)
+        case model_element
+        when Ea::Model::Classifier
+          augment_classifier_payload!(payload, model_element)
+        when Ea::Model::Package
+          payload["classifierIds"] = classifiers_in_package_ids(model_element.id)
+          payload["diagramIds"] = diagram_ids_for_package(model_element.id)
+        when Ea::Model::Diagram
+          augment_diagram_payload!(payload, model_element)
+        end
+        payload
+      end
+
+      def diagram_ids_for_package(package_id)
+        (document.packages.find { |p| p.id == package_id }&.diagram_ids ||
+          []) + document.diagrams.select { |d| d.package_id == package_id }.map(&:id)
+      end
+
+      def augment_classifier_payload!(payload, classifier)
+        rels = document.relationships_for(classifier.id)
+        payload["generalizations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Generalization) && r.specific_id == classifier.id }
+          .map { |r| { "id" => r.id, "targetId" => r.general_id } }
+        payload["specializations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Generalization) && r.general_id == classifier.id }
+          .map { |r| { "id" => r.id, "targetId" => r.specific_id } }
+        payload["associations"] = rels
+          .select { |r| r.is_a?(Ea::Model::Association) }
+          .map { |r| association_stub(r, classifier.id) }
+        payload
+      end
+
+      def association_stub(assoc, classifier_id)
+        {
+          "id" => assoc.id,
+          "name" => assoc.name,
+          "sourceId" => assoc.source_id,
+          "targetId" => assoc.target_id,
+          "thisEndRoleName" => assoc.source_id == classifier_id ? assoc.source_role_name : assoc.target_role_name,
+          "otherEndRoleName" => assoc.source_id == classifier_id ? assoc.target_role_name : assoc.source_role_name,
+          "otherEndId" => assoc.source_id == classifier_id ? assoc.target_id : assoc.source_id,
+          "otherEndMultiplicity" => cardinality(assoc, classifier_id),
+          "otherEndAggregation" => assoc.source_id == classifier_id ? assoc.target_aggregation : assoc.source_aggregation
+        }
+      end
+
+      def cardinality(assoc, classifier_id)
+        if assoc.source_id == classifier_id
+          [assoc.target_multiplicity_lower, assoc.target_multiplicity_upper]
+        else
+          [assoc.source_multiplicity_lower, assoc.source_multiplicity_upper]
+        end
+      end
+
+      def augment_diagram_payload!(payload, diagram)
+        payload["svg"] = Ea::Svg::EaEmitter::Document.new(
+          diagram,
+          model_index: document.index_by_id,
+          document: document
+        ).render
+        payload
+      rescue StandardError => e
+        warn "ea: skipping SVG render for diagram #{diagram.id} " \
+             "(#{diagram.name.inspect}): #{e.class}: #{e.message}"
+        payload
       end
     end
   end

data/lib/ea/version.rb

@@ -4,5 +4,5 @@ module Ea
   # Gem release version. Extracted to its own file so the
   # `gem-release` tool's `gem bump` can find and update it via the
   # standard `lib/<gem>/version.rb` convention.
-  VERSION = "0.6.2"
+  VERSION = "0.6.4"
 end

data/lib/ea/xmi/liquid_drops/data_type_drop.rb

@@ -57,6 +57,37 @@ module Ea
         def stereotype
           @model.stereotype&.first
         end
+
+        def owned_attributes
+          Array(@model.attributes).filter_map do |owned_attr|
+            ::Ea::Xmi::LiquidDrops::AttributeDrop.new(owned_attr, @options)
+          end
+        end
+
+        def generalization
+          if @model.generalization
+            ::Ea::Xmi::LiquidDrops::GeneralizationDrop.new(
+              @model.generalization, nil, @options
+            )
+          end
+        end
+
+        def upper_packaged_element
+          e = @lookup.find_upper_level_packaged_element(@model.xmi_id)
+          e&.name
+        end
+
+        def subtype_of
+          @lookup.find_subtype_of_from_generalization(@model.xmi_id) ||
+            @lookup.find_subtype_of_from_owned_attribute_type(@model.xmi_id)
+        end
+
+        def inheritances
+          Array(@inheritance_ids).filter_map do |inheritance_id|
+            connector = @lookup.fetch_connector(inheritance_id)
+            ::Ea::Xmi::LiquidDrops::ConnectorDrop.new(connector, @options)
+          end
+        end
       end
     end
   end

data/lib/ea/xmi/parser.rb

@@ -442,6 +442,11 @@ module Ea
               data_type.operations = build_operations(dt)
               data_type.associations = build_associations(dt.id)
               data_type.constraints = build_constraints(dt.id)
+              data_type.association_generalization = build_assoc_generalizations(dt)
+              # build_generalization always returns a Generalization for the
+              # element itself, so only attach when XMI declares a parent.
+              data_type.generalization =
+                build_generalization(dt) if dt.generalization&.any?
             end
           end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ea
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-22 00:00:00.000000000 Z
+date: 2026-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -140,22 +140,16 @@ dependencies:
   name: lutaml-uml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement