@finos/legend-graph 6.0.1 → 7.0.0

package/src/models/metamodels/pure/packageableElements/mapping/xStore/XStorePropertyMapping.ts

@@ -17,16 +17,12 @@
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../MetaModelConst';
 import type { RawLambda } from '../../../rawValueSpecification/RawLambda';
-import type { Stubable } from '../../../../../../helpers/Stubable';
 import {
   type PropertyMappingVisitor,
   PropertyMapping,
 } from '../PropertyMapping';
 
-export class XStorePropertyMapping
-  extends PropertyMapping
-  implements Hashable, Stubable
-{
+export class XStorePropertyMapping extends PropertyMapping implements Hashable {
   /**
    * Studio does not process value specification, they are left in raw JSON form
    *
@@ -42,11 +38,6 @@ export class XStorePropertyMapping
     ]);
   }
 
-  override get isStub(): boolean {
-    // TODO figure out isStub conditions
-    return false;
-  }
-
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
     return visitor.visit_XStorePropertyMapping(this);
   }

package/src/models/metamodels/pure/packageableElements/runtime/Runtime.ts

@@ -14,26 +14,20 @@
  * limitations under the License.
  */
 
+import { type Hashable, hashArray, uuid } from '@finos/legend-shared';
 import {
-  type Hashable,
-  hashArray,
-  generateEnumerableNameFromToken,
-  assertTrue,
-  uuid,
-} from '@finos/legend-shared';
-import { CORE_HASH_STRUCTURE } from '../../../../../MetaModelConst';
+  CORE_HASH_STRUCTURE,
+  PackageableElementPointerType,
+} from '../../../../../MetaModelConst';
 import type { Connection } from '../connection/Connection';
 import type { PackageableRuntime } from './PackageableRuntime';
 import type { Mapping } from '../mapping/Mapping';
 import type { Store } from '../store/Store';
-import {
-  getElementPointerHashCode,
-  PACKAGEABLE_ELEMENT_POINTER_TYPE,
-} from '../PackageableElement';
 import type { PackageableElementReference } from '../PackageableElementReference';
+import { hashElementPointer } from '../../../../../MetaModelUtils';
 
 export class IdentifiedConnection implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   id: string;
   connection: Connection;
@@ -60,15 +54,11 @@ export class StoreConnections implements Hashable {
     this.store = store;
   }
 
-  get isStub(): boolean {
-    return !this.storeConnections.length;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.STORE_CONNECTIONS,
-      getElementPointerHashCode(
-        PACKAGEABLE_ELEMENT_POINTER_TYPE.STORE,
+      hashElementPointer(
+        PackageableElementPointerType.STORE,
         this.store.hashValue,
       ),
       hashArray(this.storeConnections),
@@ -84,40 +74,23 @@ export class EngineRuntime extends Runtime implements Hashable {
   mappings: PackageableElementReference<Mapping>[] = [];
   connections: StoreConnections[] = [];
 
-  get allIdentifiedConnections(): IdentifiedConnection[] {
-    return this.connections.flatMap(
-      (storeConnections) => storeConnections.storeConnections,
-    );
-  }
-
-  generateIdentifiedConnectionId(): string {
-    const generatedId = generateEnumerableNameFromToken(
-      this.allIdentifiedConnections.map(
-        (identifiedConnection) => identifiedConnection.id,
-      ),
-      'connection',
-    );
-    assertTrue(
-      !this.allIdentifiedConnections.find(
-        (identifiedConnection) => identifiedConnection.id === generatedId,
-      ),
-      `Can't auto-generate connection ID with value '${generatedId}'`,
-    );
-    return generatedId;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENGINE_RUNTIME,
       hashArray(
         this.mappings.map((mapping) =>
-          getElementPointerHashCode(
-            PACKAGEABLE_ELEMENT_POINTER_TYPE.MAPPING,
+          hashElementPointer(
+            PackageableElementPointerType.MAPPING,
             mapping.hashValue,
           ),
         ),
       ),
-      hashArray(this.connections.filter((connection) => !connection.isStub)),
+      hashArray(
+        this.connections.filter(
+          // TODO: use `isStubbed_StoreConnections` when we refactor hashing
+          (connection) => connection.storeConnections.length,
+        ),
+      ),
     ]);
   }
 }

package/src/models/metamodels/pure/packageableElements/section/Section.ts

@@ -22,13 +22,14 @@ import type { SectionIndex } from './SectionIndex';
 import type { PackageableElementExplicitReference } from '../PackageableElementReference';
 
 export abstract class Section implements Hashable {
-  readonly parent: SectionIndex;
+  readonly _OWNER: SectionIndex;
+
   parserName: string;
   elements: PackageableElementExplicitReference<PackageableElement>[] = [];
 
-  constructor(parserName: string, parent: SectionIndex) {
+  constructor(parserName: string, owner: SectionIndex) {
     this.parserName = parserName;
-    this.parent = parent;
+    this._OWNER = owner;
   }
 
   get hashCode(): string {

package/src/models/metamodels/pure/packageableElements/service/DEPRECATED__ServiceTest.ts

@@ -24,10 +24,10 @@ import type { Service } from './Service';
  * @deprecated
  */
 export abstract class DEPRECATED__ServiceTest implements Hashable {
-  owner: Service;
+  readonly _OWNER: Service;
 
   constructor(owner: Service) {
-    this.owner = owner;
+    this._OWNER = owner;
   }
 
   abstract get hashCode(): string;
@@ -38,7 +38,7 @@ export abstract class DEPRECATED__ServiceTest implements Hashable {
  * @deprecated
  */
 export class DEPRECATED__TestContainer implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   parametersValues: unknown[] = []; // Any[*]; // ValueSpecification?
   /**

package/src/models/metamodels/pure/packageableElements/service/Service.ts

@@ -25,10 +25,11 @@ import type { StereotypeReference } from '../domain/StereotypeReference';
 import type { TaggedValue } from '../domain/TaggedValue';
 import type { DEPRECATED__ServiceTest } from './DEPRECATED__ServiceTest';
 import type { ServiceTestSuite } from './ServiceTestSuite';
+import type { Testable } from '../../test/Testable';
 
 export const DEFAULT_SERVICE_PATTERN = '/';
 
-export class Service extends PackageableElement implements Hashable {
+export class Service extends PackageableElement implements Hashable, Testable {
   stereotypes: StereotypeReference[] = [];
   taggedValues: TaggedValue[] = [];
   pattern = '/';

package/src/models/metamodels/pure/packageableElements/service/ServiceExecution.ts

@@ -31,7 +31,8 @@ export abstract class ServiceExecution implements Hashable {
 }
 
 export class PureExecution extends ServiceExecution implements Hashable {
-  owner: Service;
+  readonly _OWNER: Service;
+
   /**
    * Studio does not process value specification, they are left in raw JSON form
    *
@@ -42,11 +43,12 @@ export class PureExecution extends ServiceExecution implements Hashable {
   constructor(func: RawLambda, owner: Service) {
     super();
     this.func = func;
-    this.owner = owner;
+    this._OWNER = owner;
   }
 
   get queryValidationResult(): ValidationIssue | undefined {
-    if (this.func.isStub) {
+    // TODO: use `isStubbed_RawLambda` when we refactor validation
+    if (!this.func.parameters && !this.func.body) {
       return createValidationError([
         'Service execution function cannot be empty',
       ]);
@@ -79,7 +81,8 @@ export class PureSingleExecution extends PureExecution implements Hashable {
   }
 
   get mappingValidationResult(): ValidationIssue | undefined {
-    return this.mapping.value.isStub
+    // TODO: use `isStubbed_PackageableElement` when we refactor validation
+    return !this.mapping.value.package && !this.mapping.value.name
       ? createValidationError(['Service execution mapping cannot be empty'])
       : undefined;
   }
@@ -95,7 +98,7 @@ export class PureSingleExecution extends PureExecution implements Hashable {
 }
 
 export class KeyedExecutionParameter implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
   key: string;
   mapping: PackageableElementReference<Mapping>;
@@ -112,7 +115,8 @@ export class KeyedExecutionParameter implements Hashable {
   }
 
   get mappingValidationResult(): ValidationIssue | undefined {
-    return this.mapping.value.isStub
+    // TODO: use `isStubbed_PackageableElement` when we refactor validation
+    return !this.mapping.value.package && !this.mapping.value.name
       ? createValidationError(['Service execution mapping cannot be empty'])
       : undefined;
   }

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/EmbeddedFlatDataPropertyMapping.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { filterByType, hashArray, type Hashable } from '@finos/legend-shared';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { Mapping } from '../../../mapping/Mapping';
 import { AbstractFlatDataPropertyMapping } from './AbstractFlatDataPropertyMapping';
@@ -34,6 +34,7 @@ import type { InferableMappingElementIdValue } from '../../../mapping/InferableM
 import type { PackageableElementReference } from '../../../PackageableElementReference';
 import { InferableMappingElementRootExplicitValue } from '../../../mapping/InferableMappingElementRoot';
 import type { MappingClass } from '../../../mapping/MappingClass';
+import { FlatDataPropertyMapping } from './FlatDataPropertyMapping';
 
 /**
  * We can think of embedded property mappings as a 'gateway' from one set of property mappings to another. They are in a sense
@@ -50,13 +51,14 @@ export class EmbeddedFlatDataPropertyMapping
   extends AbstractFlatDataPropertyMapping
   implements InstanceSetImplementation, Hashable
 {
+  readonly _PARENT: Mapping;
+  override readonly _isEmbedded = true;
+
   root = InferableMappingElementRootExplicitValue.create(false);
-  override readonly isEmbedded = true;
   class: PackageableElementReference<Class>;
   id: InferableMappingElementIdValue;
   propertyMappings: PropertyMapping[] = [];
   rootInstanceSetImplementation: InstanceSetImplementation; // in Pure we call this `setMappingOwner`
-  readonly parent: Mapping;
   mappingClass?: MappingClass | undefined;
 
   constructor(
@@ -72,12 +74,7 @@ export class EmbeddedFlatDataPropertyMapping
     this.class = _class;
     this.id = id;
     this.rootInstanceSetImplementation = rootInstanceSetImplementation;
-    this.parent = rootInstanceSetImplementation.parent;
-  }
-
-  // As of now, there is no stub cases of Embedded Flat Property Mapping since they are created with an existing property mapping
-  override get isStub(): boolean {
-    return false;
+    this._PARENT = rootInstanceSetImplementation._PARENT;
   }
 
   override get hashCode(): string {
@@ -89,7 +86,18 @@ export class EmbeddedFlatDataPropertyMapping
       // skip `root` since we disregard it in embedded property mappings
       hashArray(
         this.propertyMappings.filter(
-          (propertyMapping) => !propertyMapping.isStub,
+          // TODO: we should also handle of other property mapping types
+          // using some form of extension mechanism
+          (propertyMapping) => {
+            if (propertyMapping instanceof FlatDataPropertyMapping) {
+              // TODO: use `isStubbed_RawLambda` when we move this out of the metamodel
+              return (
+                Boolean(propertyMapping.transform.parameters) ||
+                Boolean(propertyMapping.transform.body)
+              );
+            }
+            return true;
+          },
         ),
       ),
     ]);
@@ -102,34 +110,4 @@ export class EmbeddedFlatDataPropertyMapping
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
     return visitor.visit_EmbeddedFlatDataPropertyMapping(this);
   }
-
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    const embeddedPropertyMappings = this.propertyMappings.filter(
-      filterByType(EmbeddedFlatDataPropertyMapping),
-    );
-    return embeddedPropertyMappings
-      .map((embeddedPropertyMapping) =>
-        embeddedPropertyMapping.getEmbeddedSetImplmentations(),
-      )
-      .flat()
-      .concat(embeddedPropertyMappings);
-  }
-
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): AbstractFlatDataPropertyMapping | undefined {
-    let properties = undefined;
-    properties = this.propertyMappings.filter(
-      (propertyMapping) => propertyMapping.property.value.name === propertyName,
-    );
-    if (targetId === undefined || properties.length === 1) {
-      return properties[0];
-    }
-    return properties.find(
-      (propertyMapping) =>
-        propertyMapping.targetSetImplementation &&
-        propertyMapping.targetSetImplementation.id.value === targetId,
-    );
-  }
 }

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataInputData.ts

@@ -15,18 +15,18 @@
  */
 
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
+import {
+  CORE_HASH_STRUCTURE,
+  PackageableElementPointerType,
+} from '../../../../../../../MetaModelConst';
 import { InputData } from '../../../mapping/InputData';
 import type { FlatData } from '../model/FlatData';
 import type { PackageableElementReference } from '../../../PackageableElementReference';
-import {
-  PACKAGEABLE_ELEMENT_POINTER_TYPE,
-  getElementPointerHashCode,
-} from '../../../PackageableElement';
 import {
   type ValidationIssue,
   createValidationError,
 } from '../../../../../../../helpers/ValidationHelper';
+import { hashElementPointer } from '../../../../../../../MetaModelUtils';
 
 export class FlatDataInputData extends InputData implements Hashable {
   sourceFlatData: PackageableElementReference<FlatData>;
@@ -42,7 +42,8 @@ export class FlatDataInputData extends InputData implements Hashable {
   }
 
   get validationResult(): ValidationIssue | undefined {
-    if (this.sourceFlatData.value.isStub) {
+    // TODO: use `isStubbed_PackageableElement` when we refactor validation
+    if (!this.sourceFlatData.value.package && !this.sourceFlatData.value.name) {
       return createValidationError([
         'Flat-data input data source flat-data store is missing',
       ]);
@@ -53,8 +54,8 @@ export class FlatDataInputData extends InputData implements Hashable {
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA_INPUT_DATA,
-      getElementPointerHashCode(
-        PACKAGEABLE_ELEMENT_POINTER_TYPE.STORE,
+      hashElementPointer(
+        PackageableElementPointerType.STORE,
         this.sourceFlatData.hashValue,
       ),
       this.data,

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataInstanceSetImplementation.ts

@@ -14,19 +14,19 @@
  * limitations under the License.
  */
 
-import { filterByType, hashArray, type Hashable } from '@finos/legend-shared';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { AbstractFlatDataPropertyMapping } from './AbstractFlatDataPropertyMapping';
 import type { Class } from '../../../domain/Class';
 import type { Mapping } from '../../../mapping/Mapping';
 import type { SetImplementationVisitor } from '../../../mapping/SetImplementation';
-import { EmbeddedFlatDataPropertyMapping } from './EmbeddedFlatDataPropertyMapping';
 import type { InferableMappingElementIdValue } from '../../../mapping/InferableMappingElementId';
 import type { RawLambda } from '../../../../rawValueSpecification/RawLambda';
 import type { PackageableElementReference } from '../../../PackageableElementReference';
 import type { RootFlatDataRecordTypeReference } from '../model/RootFlatDataRecordTypeReference';
 import type { InferableMappingElementRoot } from '../../../mapping/InferableMappingElementRoot';
+import { FlatDataPropertyMapping } from './FlatDataPropertyMapping';
 
 export class FlatDataInstanceSetImplementation
   extends InstanceSetImplementation
@@ -52,44 +52,27 @@ export class FlatDataInstanceSetImplementation
     this.sourceRootRecordType = sourceRootRecordType;
   }
 
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): AbstractFlatDataPropertyMapping | undefined {
-    let properties = undefined;
-    properties = this.propertyMappings.filter(
-      (propertyMapping) => propertyMapping.property.value.name === propertyName,
-    );
-    if (targetId === undefined || properties.length === 1) {
-      return properties[0];
-    }
-    return properties.find(
-      (propertyMapping) =>
-        propertyMapping.targetSetImplementation &&
-        propertyMapping.targetSetImplementation.id.value === targetId,
-    );
-  }
-
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    const embeddedPropertyMappings = this.propertyMappings.filter(
-      filterByType(EmbeddedFlatDataPropertyMapping),
-    );
-    return embeddedPropertyMappings
-      .map((propertyMapping) => propertyMapping.getEmbeddedSetImplmentations())
-      .flat()
-      .concat(embeddedPropertyMappings);
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA_INSTANCE_SET_IMPLEMENTATION,
       super.hashCode,
       this.sourceRootRecordType.ownerReference.hashValue,
-      this.sourceRootRecordType.value.owner.name,
+      this.sourceRootRecordType.value._OWNER.name,
       this.filter ?? '',
       hashArray(
         this.propertyMappings.filter(
-          (propertyMapping) => !propertyMapping.isStub,
+          // TODO: we should also handle of other property mapping types
+          // using some form of extension mechanism
+          (propertyMapping) => {
+            if (propertyMapping instanceof FlatDataPropertyMapping) {
+              // TODO: use `isStubbed_RawLambda` when we move this out of the metamodel
+              return (
+                Boolean(propertyMapping.transform.parameters) ||
+                Boolean(propertyMapping.transform.body)
+              );
+            }
+            return true;
+          },
         ),
       ),
     ]);

package/src/models/metamodels/pure/packageableElements/store/flatData/mapping/FlatDataPropertyMapping.ts

@@ -48,10 +48,6 @@ export class FlatDataPropertyMapping
     this.transform = transform;
   }
 
-  override get isStub(): boolean {
-    return this.transform.isStub;
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA_PROPERTY_MAPPING,

package/src/models/metamodels/pure/packageableElements/store/flatData/model/FlatData.ts

@@ -14,34 +14,15 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  guaranteeNonNullable,
-  hashArray,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { FlatDataSection } from './FlatDataSection';
 import { Store } from '../../Store';
 import type { PackageableElementVisitor } from '../../../PackageableElement';
-import type { RootFlatDataRecordType } from './FlatDataDataType';
 
 export class FlatData extends Store implements Hashable {
   sections: FlatDataSection[] = [];
 
-  findSection = (sectionName: string): FlatDataSection =>
-    guaranteeNonNullable(
-      this.sections.find((section) => section.name === sectionName),
-      `Can't find section '${sectionName}' in flat-data store '${this.path}'`,
-    );
-
-  get recordTypes(): RootFlatDataRecordType[] {
-    return this.sections.flatMap((section) =>
-      section.recordType ? [section.recordType] : [],
-    );
-  }
-
-  static createStub = (): FlatData => new FlatData('');
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA,

package/src/models/metamodels/pure/packageableElements/store/flatData/model/FlatDataDataType.ts

@@ -20,10 +20,10 @@ import type { FlatDataSection } from './FlatDataSection';
 import type { PrimitiveType } from '../../../domain/PrimitiveType';
 
 export abstract class FlatDataDataType {
-  readonly correspondingPrimitiveType?: PrimitiveType | undefined;
+  readonly _correspondingPrimitiveType?: PrimitiveType | undefined;
 
   constructor(correspondingPrimitiveType?: PrimitiveType) {
-    this.correspondingPrimitiveType = correspondingPrimitiveType;
+    this._correspondingPrimitiveType = correspondingPrimitiveType;
   }
 
   abstract get hashCode(): string;
@@ -156,11 +156,11 @@ export class RootFlatDataRecordType
   extends FlatDataRecordType
   implements Hashable
 {
-  owner: FlatDataSection;
+  readonly _OWNER: FlatDataSection;
 
   constructor(owner: FlatDataSection) {
     super();
-    this.owner = owner;
+    this._OWNER = owner;
   }
 
   override get hashCode(): string {

package/src/models/metamodels/pure/packageableElements/store/flatData/model/FlatDataSection.ts

@@ -15,17 +15,14 @@
  */
 
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
-import {
-  type Hashable,
-  hashArray,
-  guaranteeNonNullable,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import type { FlatData } from './FlatData';
 import type { FlatDataProperty } from './FlatDataProperty';
 import type { RootFlatDataRecordType } from './FlatDataDataType';
 
 export class FlatDataSection implements Hashable {
-  owner: FlatData;
+  readonly _OWNER: FlatData;
+
   driverId: string;
   name: string;
   sectionProperties: FlatDataProperty[] = [];
@@ -34,15 +31,9 @@ export class FlatDataSection implements Hashable {
   constructor(driverId: string, name: string, owner: FlatData) {
     this.name = name;
     this.driverId = driverId;
-    this.owner = owner;
+    this._OWNER = owner;
   }
 
-  getRecordType = (): RootFlatDataRecordType =>
-    guaranteeNonNullable(
-      this.recordType,
-      `No record type defined in section '${this.name}' of flat-data store '${this.owner.path}'`,
-    );
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.FLAT_DATA_SECTION,

package/src/models/metamodels/pure/packageableElements/store/flatData/model/FlatDataSectionReference.ts

@@ -54,7 +54,7 @@ export class FlatDataSectionExplicitReference extends FlatDataSectionReference {
 
   private constructor(value: FlatDataSection) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner,
+      value._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

package/src/models/metamodels/pure/packageableElements/store/flatData/model/RootFlatDataRecordTypeReference.ts

@@ -42,7 +42,7 @@ export class RootFlatDataRecordTypeExplicitReference extends RootFlatDataRecordT
 
   private constructor(value: RootFlatDataRecordType) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.owner.owner,
+      value._OWNER._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

package/src/models/metamodels/pure/packageableElements/store/modelToModel/mapping/ObjectInputData.ts

@@ -17,7 +17,6 @@
 import {
   type Hashable,
   hashArray,
-  UnsupportedOperationError,
   isValidJSONString,
   tryToMinifyLosslessJSONString,
 } from '@finos/legend-shared';
@@ -35,19 +34,6 @@ export enum ObjectInputType {
   XML = 'XML',
 }
 
-export const getObjectInputType = (type: string): ObjectInputType => {
-  switch (type) {
-    case ObjectInputType.JSON:
-      return ObjectInputType.JSON;
-    case ObjectInputType.XML:
-      return ObjectInputType.XML;
-    default:
-      throw new UnsupportedOperationError(
-        `Encountered unsupported object input type '${type}'`,
-      );
-  }
-};
-
 export class ObjectInputData extends InputData implements Hashable {
   sourceClass: PackageableElementReference<Class>;
   inputType: ObjectInputType;
@@ -71,7 +57,8 @@ export class ObjectInputData extends InputData implements Hashable {
   }
 
   get validationResult(): ValidationIssue | undefined {
-    if (this.sourceClass.value.isStub) {
+    // TODO: use `isStubbed_PackageableElement` when we refactor validation
+    if (!this.sourceClass.value.package && !this.sourceClass.value.name) {
       return createValidationError([
         'Object input data source class is missing',
       ]);