@api-client/core 0.18.15 → 0.18.17

package/src/modeling/types.ts

@@ -13,6 +13,7 @@ import type {
   DomainAssociationKind,
   DataDomainKind,
 } from '../models/kinds.js'
+import type { DataDomain } from './DataDomain.js'
 
 export interface DataDomainRemoveOptions {
   /**
@@ -55,7 +56,7 @@ export interface DomainGraphEdge {
   /**
    * The type of the edge.
    * - `association` The edge is to an association object.
-   *   - When coming **from** an entiry (the `v` property), that entity owns the association.
+   *   - When coming **from** an entity (the `v` property), that entity owns the association.
    *   - When coming **to** an entity (the `w` property), that entity is the target of the association.
    *     An association can have multiple targets.
    * - `property` The edge is to a property object. Can only be created between an entity and a property.
@@ -684,7 +685,7 @@ export interface MatchUserPropertyAccessRule extends BaseAccessRule {
 /**
  * The action is allowed if the authenticated user's email domain matches a specific domain.
  * This is used to restrict access based on the user's email address.
- * For example, only users with an email address from "mycompany.com" can access certain resources.
+ * For example, only users with an email address from "my-company.com" can access certain resources.
  */
 export interface MatchEmailDomainAccessRule extends BaseAccessRule {
   type: 'matchEmailDomain'
@@ -822,3 +823,73 @@ export interface DomainImpactItem {
    */
   parent?: string
 }
+
+export interface DeserializeOptions {
+  /**
+   * The mode to use for deserialization.
+   */
+  mode?: DeserializationMode
+  /**
+   * The serialized graph to deserialize.
+   * This is the JSON representation of the graph.
+   */
+  json?: SerializedGraph
+  /**
+   * The list of foreign domains that this domain depends on.
+   */
+  dependencies?: DataDomain[]
+}
+
+/**
+ * Describes the mode for deserializing a domain graph.
+ */
+export type DeserializationMode = 'strict' | 'lenient'
+
+/**
+ * Describes an issue found during deserialization.
+ */
+export interface DeserializationIssue {
+  /**
+   * The type of issue encountered.
+   */
+  type: 'missing_node' | 'missing_edge' | 'invalid_parent' | 'missing_dependency' | 'malformed_entry' | 'unknown_kind'
+  /**
+   * The severity of the issue.
+   */
+  severity: 'error' | 'warning' | 'info'
+  /**
+   * A human-readable description of the issue.
+   */
+  message: string
+  /**
+   * The key of the affected node, edge, or entity if applicable.
+   */
+  affectedKey?: string
+  /**
+   * Additional context about the issue.
+   */
+  context?: Record<string, unknown>
+  /**
+   * The action taken to handle this issue in lenient mode.
+   */
+  resolution?: string
+}
+
+/**
+ * The result of a deserialization operation.
+ */
+export interface DeserializationResult {
+  /**
+   * The deserialized graph.
+   */
+  graph: DataDomainGraph
+  /**
+   * Issues encountered during deserialization.
+   */
+  issues: DeserializationIssue[]
+  /**
+   * Whether the deserialization was successful.
+   * This is set to true when a critical failures occurred.
+   */
+  success: boolean
+}

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

@@ -392,3 +392,507 @@ 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 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)
+
+    assert.throws(() => 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'])
+})

package/tests/unit/modeling/importers/schema_filtering.spec.ts

@@ -36,14 +36,14 @@ test.group('SchemaFilteringStrategy', () => {
   test('should identify conceptual marker schemas', ({ assert }) => {
     const strategy = new SchemaFilteringStrategy({ excludeConceptualMarkers: true })
 
-    // StatusEnumeration-like schema
+    // StatusEnumeration-like schema (empty object, should be excluded)
     const statusEnum: JSONSchema7 = {
       type: 'object',
       title: 'StatusEnumeration',
       description: 'Lists or enumerations dealing with status types.',
     }
 
-    // ActionStatusType-like schema (allOf with reference only)
+    // ActionStatusType-like schema (allOf with reference only - represents inheritance, should NOT be excluded)
     const actionStatus: JSONSchema7 = {
       type: 'object',
       title: 'ActionStatusType',
@@ -61,10 +61,54 @@ test.group('SchemaFilteringStrategy', () => {
     }
 
     assert.isTrue(strategy.shouldExcludeSchema(statusEnum))
-    assert.isTrue(strategy.shouldExcludeSchema(actionStatus))
+    assert.isFalse(strategy.shouldExcludeSchema(actionStatus)) // Changed: inheritance should not be excluded
     assert.isFalse(strategy.shouldExcludeSchema(person))
   })
 
+  test('should preserve schema inheritance patterns', ({ assert }) => {
+    const strategy = new SchemaFilteringStrategy({ excludeConceptualMarkers: true })
+
+    // BlogPosting schema - extends SocialMediaPosting via allOf
+    const blogPosting: JSONSchema7 = {
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      $id: 'schema:BlogPosting',
+      title: 'BlogPosting',
+      description: 'A blog post.',
+      type: 'object',
+      allOf: [
+        {
+          description: 'A post to a social media platform, including blog posts, tweets, Facebook posts, etc.',
+          $ref: 'schema:SocialMediaPosting',
+        },
+      ],
+    }
+
+    // SocialMediaPosting schema - has properties and extends Article
+    const socialMediaPosting: JSONSchema7 = {
+      $schema: 'https://json-schema.org/draft/2020-12/schema',
+      $id: 'schema:SocialMediaPosting',
+      title: 'SocialMediaPosting',
+      description: 'A post to a social media platform, including blog posts, tweets, Facebook posts, etc.',
+      type: 'object',
+      allOf: [
+        {
+          description: 'An article, such as a news article or piece of investigative report.',
+          $ref: 'schema:Article',
+        },
+      ],
+      properties: {
+        sharedContent: {
+          description: 'A CreativeWork such as an image, video, or audio clip shared as part of this posting.',
+          oneOf: [{ $ref: 'schema:CreativeWork' }, { type: 'array', items: { $ref: 'schema:CreativeWork' } }],
+        },
+      },
+    }
+
+    // Both schemas represent valid inheritance and should be included
+    assert.isFalse(strategy.shouldExcludeSchema(blogPosting, 'schema:BlogPosting'))
+    assert.isFalse(strategy.shouldExcludeSchema(socialMediaPosting, 'schema:SocialMediaPosting'))
+  })
+
   test('should filter by patterns', ({ assert }) => {
     const strategy = new SchemaFilteringStrategy({
       excludePatterns: [/.*Enumeration$/, /.*Type$/],