@api-client/core 0.18.16 → 0.18.18

package/tests/unit/modeling/data_domain_serialization.spec.ts

@@ -392,3 +392,511 @@ test.group('DataDomain Serialization and Deserialization', () => {
     )
   }).tags(['@modeling', '@serialization'])
 })
+
+test.group('Validation Tests', () => {
+  test('should throw validation error when property has no parent entity edge', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+
+    // Manually break the graph by removing the property edge
+    domain.graph.removeEdge(e1.key, p1.key)
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when association has no parent entity edge', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    // Manually break the graph by removing the association edge to parent
+    domain.graph.removeEdge(e1.key, a1.key)
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when property has multiple parent edges', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+
+    // Manually add an extra edge to create multiple parents
+    domain.graph.setEdge(e2.key, p1.key, { type: 'property' })
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when property has non-entity parent', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+
+    // Remove the proper edge and add an edge from model to property (invalid)
+    domain.graph.removeEdge(e1.key, p1.key)
+    domain.graph.setEdge(m1.key, p1.key, { type: 'property' })
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when entity has no model parent', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+
+    // Remove the entity from its model parent
+    domain.graph.setParent(e1.key, undefined)
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should not throw validation error when association has no target entities', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    // Remove the association target edge
+    domain.graph.removeEdge(a1.key, e2.key)
+
+    // Note, we specifically removed this from the validation as it would throw errors
+    // when associations were created without targets. This is not a structural issue and because
+    // of that, it shouldn't be considered a validation error in this context.
+    // It is reported through the validator, though.
+    assert.doesNotThrow(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when association references non-existent target', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    // Remove the target entity but keep the edge pointing to it
+    domain.graph.removeNode(e2.key)
+    // Re-add the association with a broken target
+    domain.graph.setEdge(a1.key, 'non-existent-entity', { type: 'association' })
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should throw validation error when association references non-entity target', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    // Remove the proper target and make it point to the model instead
+    domain.graph.removeEdge(a1.key, e2.key)
+    domain.graph.setEdge(a1.key, m1.key, { type: 'association' })
+
+    assert.throws(() => domain.toJSON())
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should pass validation for valid domain structure', ({ assert }) => {
+    const domain = new DataDomain()
+
+    // Create a valid structure with all elements
+    const ns1 = domain.addNamespace()
+    const m1 = ns1.addModel()
+    const m2 = domain.addModel() // Root level model (valid)
+    const e1 = m1.addEntity()
+    const e2 = m2.addEntity()
+    e1.addProperty({ type: 'string' })
+    e1.addAssociation({ key: e2.key })
+
+    // This should not throw any validation errors
+    assert.doesNotThrow(() => {
+      domain.toJSON()
+    })
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should pass validation for models at root level without namespaces', ({ assert }) => {
+    const domain = new DataDomain()
+
+    // Create models directly at domain level (should be valid)
+    const m1 = domain.addModel()
+    const m2 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m2.addEntity()
+    e1.addProperty({ type: 'string' })
+    e1.addAssociation({ key: e2.key })
+
+    // This should not throw any validation errors
+    assert.doesNotThrow(() => {
+      domain.toJSON()
+    })
+  }).tags(['@modeling', '@serialization', '@validation'])
+
+  test('should pass validation for foreign associations', ({ assert }) => {
+    const fd = new DataDomain()
+    const fm1 = fd.addModel()
+    const fe1 = fm1.addEntity()
+    fd.info.version = '1.0.0'
+
+    const domain = new DataDomain()
+    domain.registerForeignDomain(fd)
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    e1.addAssociation({ key: fe1.key, domain: fd.key })
+
+    // Foreign associations should pass validation
+    assert.doesNotThrow(() => {
+      domain.toJSON()
+    })
+  }).tags(['@modeling', '@serialization', '@validation'])
+})
+
+test.group('DataDomain Lenient Mode Deserialization', () => {
+  test('should handle malformed node entries in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    e1.addProperty({ type: 'string' })
+
+    const serialized = domain.toJSON()
+
+    // Corrupt a node entry by removing its kind
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes?.[2]) {
+      // Find the property node and corrupt it
+      for (const node of corruptedSerialized.graph.nodes) {
+        if (
+          node.value &&
+          typeof node.value === 'object' &&
+          'kind' in node.value &&
+          node.value.kind === DomainPropertyKind
+        ) {
+          delete node.value.kind
+          break
+        }
+      }
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have issues recorded
+    assert.isAbove(restored.issues.length, 0)
+    const malformedIssues = restored.issues.filter((issue) => issue.type === 'malformed_entry')
+    assert.isAbove(malformedIssues.length, 0)
+
+    // Should have fewer nodes than original (corrupted node was skipped)
+    assert.isBelow([...restored.graph.nodes()].length, [...domain.graph.nodes()].length)
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should handle missing parent edges in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+
+    const serialized = domain.toJSON()
+
+    // Remove the edge from entity to property
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.edges) {
+      corruptedSerialized.graph.edges = corruptedSerialized.graph.edges.filter(
+        (edge) => !(edge.v === e1.key && edge.w === p1.key)
+      )
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have issues recorded
+    assert.isAbove(restored.issues.length, 0)
+    const missingEdgeIssues = restored.issues.filter((issue) => issue.type === 'missing_edge')
+    assert.isAbove(missingEdgeIssues.length, 0)
+
+    // Property should be missing (was skipped due to missing parent edge)
+    assert.isUndefined(restored.findProperty(p1.key))
+
+    // But entity should still exist
+    assert.isDefined(restored.findEntity(e1.key))
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should handle missing target nodes in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const a1 = e1.addAssociation({ key: e2.key })
+
+    const serialized = domain.toJSON()
+
+    // Remove the target entity node but keep the edge
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes) {
+      corruptedSerialized.graph.nodes = corruptedSerialized.graph.nodes.filter((node) => node.v !== e2.key)
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have issues recorded
+    assert.isAbove(restored.issues.length, 0)
+    const missingNodeIssues = restored.issues.filter((issue) => issue.type === 'missing_node')
+    assert.isAbove(missingNodeIssues.length, 0)
+
+    // Source entity and association should exist
+    assert.isDefined(restored.findEntity(e1.key))
+    assert.isDefined(restored.findAssociation(a1.key))
+
+    // Target entity should be missing
+    assert.isUndefined(restored.findEntity(e2.key))
+
+    // Association should have no targets
+    const restoredAssociation = restored.findAssociation(a1.key)
+    assert.equal([...restoredAssociation!.listTargets()].length, 0)
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should handle invalid parent relationships in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const ns1 = domain.addNamespace()
+    const m1 = ns1.addModel()
+    const e1 = m1.addEntity()
+
+    const serialized = domain.toJSON()
+
+    // Corrupt parent relationship - make entity point to non-existent parent
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes) {
+      for (const node of corruptedSerialized.graph.nodes) {
+        if (node.v === e1.key && node.parents) {
+          node.parents = ['non-existent-parent'] // Invalid - non-existent parent
+          break
+        }
+      }
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have issues recorded about missing parent node
+    assert.isAbove(restored.issues.length, 0)
+    const missingNodeIssues = restored.issues.filter((issue) => issue.type === 'missing_node')
+    assert.isAbove(missingNodeIssues.length, 0)
+
+    // Entity should still exist but may not have proper parent relationship
+    assert.isDefined(restored.findEntity(e1.key))
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should handle missing foreign dependencies gracefully in lenient mode', ({ assert }) => {
+    const fd = new DataDomain()
+    const fm1 = fd.addModel()
+    const fe1 = fm1.addEntity()
+    fd.info.version = '1.0.0'
+
+    const domain = new DataDomain()
+    domain.registerForeignDomain(fd)
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    e1.addAssociation({ key: fe1.key, domain: fd.key })
+
+    const serialized = domain.toJSON()
+
+    // Deserialize without providing the foreign dependency
+    const restored = new DataDomain(serialized, [], 'lenient')
+
+    // Should have issues recorded about missing dependency
+    assert.isAbove(restored.issues.length, 0)
+    const missingNodeIssues = restored.issues.filter(
+      (issue) => issue.type === 'missing_node' && issue.message.includes('foreign')
+    )
+    assert.isAbove(missingNodeIssues.length, 0)
+
+    // Local entities should still exist
+    assert.isDefined(restored.findEntity(e1.key))
+
+    // Foreign entity should not exist
+    assert.isUndefined(restored.findForeignEntity(fe1.key, fd.key))
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should handle unknown node kinds in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+
+    const serialized = domain.toJSON()
+
+    // Add a node with unknown kind
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes) {
+      corruptedSerialized.graph.nodes.push({
+        v: 'unknown-node',
+        value: {
+          kind: 'UnknownKind',
+          key: 'unknown-node',
+          info: { name: 'Unknown Node' },
+        },
+      })
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have issues recorded
+    assert.isAbove(restored.issues.length, 0)
+    const unknownKindIssues = restored.issues.filter((issue) => issue.type === 'unknown_kind')
+    assert.isAbove(unknownKindIssues.length, 0)
+
+    // Original model should still exist
+    assert.isDefined(restored.findModel(m1.key))
+
+    // Unknown node should not exist in graph
+    assert.isFalse(restored.graph.hasNode('unknown-node'))
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should collect multiple issues and continue processing in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const e2 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string' })
+    e1.addAssociation({ key: e2.key })
+
+    const serialized = domain.toJSON()
+
+    // Introduce multiple types of corruption
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes && corruptedSerialized.graph?.edges) {
+      // 1. Remove kind from property node
+      for (const node of corruptedSerialized.graph.nodes) {
+        if (
+          node.value &&
+          typeof node.value === 'object' &&
+          'kind' in node.value &&
+          node.value.kind === DomainPropertyKind
+        ) {
+          delete node.value.kind
+          break
+        }
+      }
+
+      // 2. Remove target entity
+      corruptedSerialized.graph.nodes = corruptedSerialized.graph.nodes.filter((node) => node.v !== e2.key)
+
+      // 3. Add unknown kind node
+      corruptedSerialized.graph.nodes.push({
+        v: 'unknown-node',
+        value: {
+          kind: 'UnknownKind',
+          key: 'unknown-node',
+          info: { name: 'Unknown Node' },
+        },
+      })
+    }
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have multiple issues recorded
+    assert.isAtLeast(restored.issues.length, 3)
+
+    // Should have different types of issues
+    const issueTypes = new Set(restored.issues.map((issue) => issue.type))
+    assert.isTrue(issueTypes.has('malformed_entry') || issueTypes.has('unknown_kind'))
+    assert.isTrue(issueTypes.has('missing_node'))
+
+    // Should still have functional entities where possible
+    assert.isDefined(restored.findEntity(e1.key))
+    assert.isDefined(restored.findModel(m1.key))
+
+    // Corrupted elements should be missing
+    assert.isUndefined(restored.findProperty(p1.key)) // Property was corrupted
+    assert.isUndefined(restored.findEntity(e2.key)) // Entity was removed
+  }).tags(['@modeling', '@serialization', '@lenient'])
+
+  test('should have empty issues array in strict mode on successful deserialization', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    e1.addProperty({ type: 'string' })
+
+    const serialized = domain.toJSON()
+    const restored = new DataDomain(serialized, [], 'strict')
+
+    // Should have no issues in strict mode for valid data
+    assert.equal(restored.issues.length, 0)
+  }).tags(['@modeling', '@serialization', '@strict'])
+
+  test('should throw in strict mode but collect issues in lenient mode for same corrupted data', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    e1.addProperty({ type: 'string' })
+
+    const serialized = domain.toJSON()
+
+    // Corrupt the data
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.nodes?.[2]) {
+      for (const node of corruptedSerialized.graph.nodes) {
+        if (
+          node.value &&
+          typeof node.value === 'object' &&
+          'kind' in node.value &&
+          node.value.kind === DomainPropertyKind
+        ) {
+          delete node.value.kind
+          break
+        }
+      }
+    }
+
+    // Should throw in strict mode
+    assert.throws(() => {
+      new DataDomain(corruptedSerialized, [], 'strict')
+    })
+
+    // Should not throw in lenient mode
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+    assert.isAbove(restored.issues.length, 0)
+  }).tags(['@modeling', '@serialization', '@lenient', '@strict'])
+
+  test('should provide helpful issue messages and context in lenient mode', ({ assert }) => {
+    const domain = new DataDomain()
+    const m1 = domain.addModel()
+    const e1 = m1.addEntity()
+    const p1 = e1.addProperty({ type: 'string', info: { name: 'testProperty' } })
+
+    const serialized = domain.toJSON()
+
+    // Remove the edge from entity to property
+    const corruptedSerialized = structuredClone(serialized)
+    if (corruptedSerialized.graph?.edges) {
+      corruptedSerialized.graph.edges = corruptedSerialized.graph.edges.filter(
+        (edge) => !(edge.v === e1.key && edge.w === p1.key)
+      )
+    }
+
+    const restored = new DataDomain(corruptedSerialized, [], 'lenient')
+
+    // Should have detailed issue information
+    assert.isAbove(restored.issues.length, 0)
+    const missingEdgeIssue = restored.issues.find((issue) => issue.type === 'missing_edge')
+    assert.isDefined(missingEdgeIssue)
+
+    // Should have helpful message
+    assert.include(missingEdgeIssue!.message, 'testProperty')
+    assert.include(missingEdgeIssue!.message.toLowerCase(), 'parent entity edge')
+
+    // Should have affected key
+    assert.equal(missingEdgeIssue!.affectedKey, p1.key)
+
+    // Should have resolution info
+    assert.include(missingEdgeIssue!.resolution!, 'skipped')
+
+    // Should have appropriate severity
+    assert.equal(missingEdgeIssue!.severity, 'error')
+  }).tags(['@modeling', '@serialization', '@lenient'])
+})