@finos/legend-graph 6.0.1 → 7.0.0

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

@@ -20,10 +20,6 @@ import type { Class } from '../../../domain/Class';
 import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { PurePropertyMapping } from './PurePropertyMapping';
 import type { SetImplementationVisitor } from '../../../mapping/SetImplementation';
-import {
-  type Stubable,
-  isStubArray,
-} from '../../../../../../../helpers/Stubable';
 import type { RawLambda } from '../../../../rawValueSpecification/RawLambda';
 import type {
   PackageableElementReference,
@@ -35,7 +31,7 @@ import type { InferableMappingElementRoot } from '../../../mapping/InferableMapp
 
 export class PureInstanceSetImplementation
   extends InstanceSetImplementation
-  implements Hashable, Stubable
+  implements Hashable
 {
   declare propertyMappings: PurePropertyMapping[];
   srcClass: OptionalPackageableElementReference<Class>;
@@ -57,28 +53,6 @@ export class PureInstanceSetImplementation
     this.srcClass = srcClass;
   }
 
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): PurePropertyMapping | 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,
-    );
-  }
-
-  override get isStub(): boolean {
-    return super.isStub && isStubArray(this.propertyMappings);
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PURE_INSTANCE_SET_IMPLEMENTATION,
@@ -87,7 +61,12 @@ export class PureInstanceSetImplementation
       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) =>
+            // TODO: use `isStubbed_RawLambda` when we move this out of the metamodel
+            Boolean(propertyMapping.transform.parameters) ||
+            Boolean(propertyMapping.transform.body),
         ),
       ),
     ]);
@@ -96,8 +75,4 @@ export class PureInstanceSetImplementation
   accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
     return visitor.visit_PureInstanceSetImplementation(this);
   }
-
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    return [];
-  }
 }

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

@@ -25,12 +25,8 @@ import type { PropertyReference } from '../../../domain/PropertyReference';
 import type { SetImplementation } from '../../../mapping/SetImplementation';
 import type { PropertyMappingsImplementation } from '../../../mapping/PropertyMappingsImplementation';
 import type { RawLambda } from '../../../../rawValueSpecification/RawLambda';
-import type { Stubable } from '../../../../../../../helpers/Stubable';
 
-export class PurePropertyMapping
-  extends PropertyMapping
-  implements Hashable, Stubable
-{
+export class PurePropertyMapping extends PropertyMapping implements Hashable {
   // TODO: convert to reference
   transformer?: EnumerationMapping | undefined;
   /**
@@ -54,10 +50,6 @@ export class PurePropertyMapping
     this.explodeProperty = explodeProperty;
   }
 
-  override get isStub(): boolean {
-    return this.transform.isStub;
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PURE_PROPERTY_MAPPING,

package/src/models/metamodels/pure/packageableElements/store/relational/connection/DatasourceSpecification.ts

@@ -219,6 +219,8 @@ export class BigQueryDatasourceSpecification
 {
   projectId: string;
   defaultDataset: string;
+  proxyHost?: string | undefined;
+  proxyPort?: string | undefined;
 
   constructor(projectId: string, defaultDataset: string) {
     super();
@@ -231,6 +233,8 @@ export class BigQueryDatasourceSpecification
       CORE_HASH_STRUCTURE.BIGQUERY_DATASOURCE_SPECIFICATION,
       this.projectId,
       this.defaultDataset,
+      this.proxyHost ?? '',
+      this.proxyPort ?? '',
     ]);
   }
 }

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.ts

@@ -18,6 +18,7 @@ import {
   UnsupportedOperationError,
   hashArray,
   type Hashable,
+  isEmpty,
 } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { RelationalOperationElement } from '../model/RelationalOperationElement';
@@ -33,7 +34,6 @@ import {
   type PropertyMappingVisitor,
   PropertyMapping,
 } from '../../../mapping/PropertyMapping';
-import type { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { RootRelationalInstanceSetImplementation } from './RootRelationalInstanceSetImplementation';
 import type { InferableMappingElementIdValue } from '../../../mapping/InferableMappingElementId';
 import type { PackageableElementReference } from '../../../PackageableElementReference';
@@ -41,6 +41,7 @@ import type { PropertyReference } from '../../../domain/PropertyReference';
 import type { RelationalInstanceSetImplementation } from './RelationalInstanceSetImplementation';
 import { InferableMappingElementRootExplicitValue } from '../../../mapping/InferableMappingElementRoot';
 import type { MappingClass } from '../../../mapping/MappingClass';
+import { RelationalPropertyMapping } from './RelationalPropertyMapping';
 
 export class EmbeddedRelationalInstanceSetImplementation
   extends PropertyMapping
@@ -49,14 +50,15 @@ export class EmbeddedRelationalInstanceSetImplementation
     RelationalInstanceSetImplementation,
     Hashable
 {
+  readonly _PARENT: Mapping;
+  override readonly _isEmbedded = true;
+
   root = InferableMappingElementRootExplicitValue.create(false);
-  override readonly isEmbedded = true;
   id: InferableMappingElementIdValue;
   propertyMappings: PropertyMapping[] = [];
   class: PackageableElementReference<Class>;
   rootInstanceSetImplementation: RootRelationalInstanceSetImplementation; // in Pure we call this `setMappingOwner`
   primaryKey: RelationalOperationElement[] = [];
-  readonly parent: Mapping;
   mappingClass?: MappingClass | undefined;
 
   constructor(
@@ -72,33 +74,7 @@ export class EmbeddedRelationalInstanceSetImplementation
     this.class = _class;
     this.id = id;
     this.rootInstanceSetImplementation = rootInstanceSetImplementation;
-    this.parent = rootInstanceSetImplementation.parent;
-  }
-
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    throw new UnsupportedOperationError();
-  }
-
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): PropertyMapping | 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,
-    );
-  }
-
-  override get isStub(): boolean {
-    return false;
+    this._PARENT = rootInstanceSetImplementation._PARENT;
   }
 
   accept_PropertyMappingVisitor<T>(visitor: PropertyMappingVisitor<T>): T {
@@ -115,11 +91,17 @@ export class EmbeddedRelationalInstanceSetImplementation
       super.hashCode,
       this.class.hashValue,
       hashArray(this.primaryKey),
-      //skip `root` since we disregard it in embedded property mappings
+      // skip `root` since we disregard it in embedded property mappings
       hashArray(
-        this.propertyMappings.filter(
-          (propertyMapping) => !propertyMapping.isStub,
-        ),
+        this.propertyMappings.filter((propertyMapping) => {
+          // TODO: we should also handle of other property mapping types
+          // using some form of extension mechanism
+          if (propertyMapping instanceof RelationalPropertyMapping) {
+            // TODO: use `isStubbed_RawRelationalOperationElement` when we move this out of the metamodel
+            return !isEmpty(propertyMapping.relationalOperation);
+          }
+          return true;
+        }),
       ),
     ]);
   }

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalInputData.ts

@@ -14,11 +14,7 @@
  * limitations under the License.
  */
 
-import {
-  hashArray,
-  UnsupportedOperationError,
-  type Hashable,
-} from '@finos/legend-shared';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { InputData } from '../../../mapping/InputData';
 import {
@@ -33,19 +29,6 @@ export enum RelationalInputType {
   CSV = 'CSV',
 }
 
-export const getRelationalInputType = (type: string): RelationalInputType => {
-  switch (type) {
-    case RelationalInputType.SQL:
-      return RelationalInputType.SQL;
-    case RelationalInputType.CSV:
-      return RelationalInputType.CSV;
-    default:
-      throw new UnsupportedOperationError(
-        `Encountered unsupported relational input type '${type}'`,
-      );
-  }
-};
-
 export class RelationalInputData extends InputData implements Hashable {
   database: PackageableElementReference<Database>;
   data: string;
@@ -63,7 +46,8 @@ export class RelationalInputData extends InputData implements Hashable {
   }
 
   get validationResult(): ValidationIssue | undefined {
-    if (this.database.value.isStub) {
+    // TODO: use `isStubbed_PackageableElement` when we refactor validation
+    if (!this.database.value.package && !this.database.value.name) {
       return createValidationError([
         'Relational input data source database store is missing',
       ]);

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalInstanceSetImplementation.ts

@@ -14,13 +14,12 @@
  * limitations under the License.
  */
 
-import { type Hashable, hashArray, filterByType } from '@finos/legend-shared';
+import { type Hashable, hashArray, isEmpty } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { InstanceSetImplementation } from '../../../mapping/InstanceSetImplementation';
 import type { SetImplementationVisitor } from '../../../mapping/SetImplementation';
 import type { RelationalOperationElement } from '../model/RelationalOperationElement';
-import type { PropertyMapping } from '../../../mapping/PropertyMapping';
-import { EmbeddedRelationalInstanceSetImplementation } from './EmbeddedRelationalInstanceSetImplementation';
+import { RelationalPropertyMapping } from './RelationalPropertyMapping';
 
 export class RelationalInstanceSetImplementation
   extends InstanceSetImplementation
@@ -28,34 +27,6 @@ export class RelationalInstanceSetImplementation
 {
   primaryKey: RelationalOperationElement[] = [];
 
-  getEmbeddedSetImplmentations(): InstanceSetImplementation[] {
-    const embeddedPropertyMappings = this.propertyMappings.filter(
-      filterByType(EmbeddedRelationalInstanceSetImplementation),
-    );
-    return embeddedPropertyMappings
-      .map((propertyMapping) => propertyMapping.getEmbeddedSetImplmentations())
-      .flat()
-      .concat(embeddedPropertyMappings);
-  }
-
-  findPropertyMapping(
-    propertyName: string,
-    targetId: string | undefined,
-  ): PropertyMapping | 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,
-    );
-  }
-
   accept_SetImplementationVisitor<T>(visitor: SetImplementationVisitor<T>): T {
     return visitor.visit_RelationalInstanceSetImplementation(this);
   }
@@ -67,7 +38,15 @@ export class RelationalInstanceSetImplementation
       hashArray(this.primaryKey),
       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 RelationalPropertyMapping) {
+              // TODO: use `isStubbed_RawRelationalOperationElement` when we move this out of the metamodel
+              return !isEmpty(propertyMapping.relationalOperation);
+            }
+            return true;
+          },
         ),
       ),
     ]);

package/src/models/metamodels/pure/packageableElements/store/relational/mapping/RelationalPropertyMapping.ts

@@ -22,10 +22,7 @@ import {
   PropertyMapping,
 } from '../../../mapping/PropertyMapping';
 import { hashObjectWithoutSourceInformation } from '../../../../../../../MetaModelUtils';
-import {
-  isStubRelationalOperationElement,
-  type RawRelationalOperationElement,
-} from '../model/RawRelationalOperationElement';
+import type { RawRelationalOperationElement } from '../model/RawRelationalOperationElement';
 import type { BindingTransformer } from '../../../externalFormat/store/DSLExternalFormat_BindingTransformer';
 
 export class RelationalPropertyMapping
@@ -46,10 +43,6 @@ export class RelationalPropertyMapping
     return visitor.visit_RelationalPropertyMapping(this);
   }
 
-  override get isStub(): boolean {
-    return isStubRelationalOperationElement(this.relationalOperation);
-  }
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.REALTIONAL_PROPERTY_MAPPING,

package/src/models/metamodels/pure/packageableElements/store/relational/model/ColumnReference.ts

@@ -22,7 +22,21 @@ import {
 import { ReferenceWithOwner } from '../../../../Reference';
 import type { Database } from './Database';
 import type { Column } from './Column';
-import { getSchemaFromRelation } from './RelationReference';
+import type { Relation } from './RelationalOperationElement';
+import type { Schema } from './Schema';
+import { View } from './View';
+import { Table } from './Table';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+const getSchemaFromRelation = (value: Relation): Schema => {
+  if (value instanceof Table || value instanceof View) {
+    return value.schema;
+  }
+  throw new UnsupportedOperationError(
+    `Can't derive schema for relation`,
+    value,
+  );
+};
 
 export abstract class ColumnReference extends ReferenceWithOwner {
   override readonly ownerReference: PackageableElementReference<Database>;
@@ -43,7 +57,7 @@ export class ColumnExplicitReference extends ColumnReference {
 
   private constructor(value: Column) {
     const ownerReference = PackageableElementExplicitReference.create(
-      getSchemaFromRelation(value.owner).owner,
+      getSchemaFromRelation(value.owner)._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

package/src/models/metamodels/pure/packageableElements/store/relational/model/Database.ts

@@ -14,46 +14,19 @@
  * limitations under the License.
  */
 
-import {
-  hashArray,
-  guaranteeNonNullable,
-  type Hashable,
-} from '@finos/legend-shared';
+import { hashArray, type Hashable } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import { Store } from '../../Store';
 import type { PackageableElementVisitor } from '../../../PackageableElement';
 import type { Schema } from './Schema';
 import type { Join } from './Join';
 import type { Filter } from './Filter';
-import { getAllIncludedDbs } from '../../../../../../../helpers/DatabaseHelper';
 
 export class Database extends Store implements Hashable {
   schemas: Schema[] = [];
   joins: Join[] = [];
   filters: Filter[] = [];
 
-  static createStub = (): Database => new Database('');
-
-  getSchema = (name: string): Schema =>
-    guaranteeNonNullable(
-      this.schemas.find((schema) => schema.name === name),
-      `Can't find schema '${name}' in database '${this.path}'`,
-    );
-
-  getJoin = (name: string): Join =>
-    guaranteeNonNullable(
-      Array.from(getAllIncludedDbs(this))
-        .flatMap((db) => db.joins)
-        .find((join) => join.name === name),
-      `Can't find join '${name}' in database '${this.path}'`,
-    );
-
-  getFilter = (name: string): Filter =>
-    guaranteeNonNullable(
-      this.filters.find((filter) => filter.name === name),
-      `Can't find filter '${name}' in database '${this.path}'`,
-    );
-
   protected override get _elementHashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.DATABASE,

package/src/models/metamodels/pure/packageableElements/store/relational/model/RawRelationalOperationElement.ts

@@ -14,18 +14,9 @@
  * limitations under the License.
  */
 
-import { isEmpty } from '@finos/legend-shared';
-
 /**
  * Studio does not process value specification, they are left in raw JSON form
  *
  * @discrepancy model
  */
 export type RawRelationalOperationElement = object;
-
-export const createStubRelationalOperationElement =
-  (): RawRelationalOperationElement => ({});
-
-export const isStubRelationalOperationElement = (
-  operation: RawRelationalOperationElement,
-): boolean => isEmpty(operation);

package/src/models/metamodels/pure/packageableElements/store/relational/model/RelationReference.ts

@@ -21,22 +21,11 @@ import { Table } from './Table';
 import type { Relation } from './RelationalOperationElement';
 import { ViewExplicitReference, ViewImplicitReference } from './ViewReference';
 import { View } from './View';
-import type { Schema } from './Schema';
 import {
   TableExplicitReference,
   TableImplicitReference,
 } from './TableReference';
 
-export const getSchemaFromRelation = (value: Relation): Schema => {
-  if (value instanceof Table || value instanceof View) {
-    return value.schema;
-  }
-  throw new UnsupportedOperationError(
-    `Can't derive schema for relation`,
-    value,
-  );
-};
-
 export const createExplicitRelationReference = (
   value: Relation,
 ): TableExplicitReference | ViewExplicitReference => {

package/src/models/metamodels/pure/packageableElements/store/relational/model/RelationalOperationElement.ts

@@ -85,21 +85,6 @@ export enum JoinType {
   RIGHT_OUTER = 'RIGHT_OUTER',
 }
 
-export const getJoinType = (type: string): JoinType => {
-  switch (type) {
-    case JoinType.INNER:
-      return JoinType.INNER;
-    case JoinType.LEFT_OUTER:
-      return JoinType.LEFT_OUTER;
-    case JoinType.RIGHT_OUTER:
-      return JoinType.RIGHT_OUTER;
-    default:
-      throw new UnsupportedOperationError(
-        `Encountered unsupported join type '${type}'`,
-      );
-  }
-};
-
 // TODO: create RelationalTreeNode like in PURE?
 export class JoinTreeNode {
   alias?: TableAlias | undefined; // required in PURE

package/src/models/metamodels/pure/packageableElements/store/relational/model/Schema.ts

@@ -15,45 +15,23 @@
  */
 
 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 { Database } from './Database';
 import type { Table } from './Table';
 import type { View } from './View';
-import type { Relation } from './RelationalOperationElement';
 
 export class Schema implements Hashable {
-  owner: Database;
+  readonly _OWNER: Database;
+
   name: string;
   tables: Table[] = [];
   views: View[] = [];
 
   constructor(name: string, owner: Database) {
     this.name = name;
-    this.owner = owner;
+    this._OWNER = owner;
   }
 
-  getTable = (name: string): Table =>
-    guaranteeNonNullable(
-      this.tables.find((table) => table.name === name),
-      `Can't find table '${name}' in schema '${this.name}' of database '${this.owner.path}'`,
-    );
-  getView = (name: string): View =>
-    guaranteeNonNullable(
-      this.views.find((view) => view.name === name),
-      `Can't find view '${name}' in schema '${this.name}' of database '${this.owner.path}'`,
-    );
-  getRelation = (name: string): Relation => {
-    const relations: (Table | View)[] = this.tables;
-    return guaranteeNonNullable(
-      relations.concat(this.views).find((relation) => relation.name === name),
-      `Can't find relation '${name}' in schema '${this.name}' of database '${this.owner.path}'`,
-    );
-  };
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.DATABASE_SCHEMA,

package/src/models/metamodels/pure/packageableElements/store/relational/model/Table.ts

@@ -15,15 +15,10 @@
  */
 
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
-import {
-  type Hashable,
-  hashArray,
-  guaranteeNonNullable,
-  filterByType,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { NamedRelation } from './RelationalOperationElement';
 import type { Schema } from './Schema';
-import { Column } from './Column';
+import type { Column } from './Column';
 import type { Milestoning } from './milestoning/Milestoning';
 
 export class Table extends NamedRelation implements Hashable {
@@ -37,14 +32,6 @@ export class Table extends NamedRelation implements Hashable {
     this.schema = schema;
   }
 
-  getColumn = (name: string): Column =>
-    guaranteeNonNullable(
-      this.columns
-        .filter(filterByType(Column))
-        .find((column) => column.name === name),
-      `Can't find column '${name}' in table '${this.name}'`,
-    );
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.DATABASE_SCHEMA_TABLE,

package/src/models/metamodels/pure/packageableElements/store/relational/model/TableReference.ts

@@ -74,7 +74,7 @@ export class TableExplicitReference extends TableReference {
 
   private constructor(value: Table) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.schema.owner,
+      value.schema._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

package/src/models/metamodels/pure/packageableElements/store/relational/model/View.ts

@@ -14,16 +14,11 @@
  * limitations under the License.
  */
 
-import {
-  type Hashable,
-  hashArray,
-  guaranteeNonNullable,
-  filterByType,
-} from '@finos/legend-shared';
+import { type Hashable, hashArray } from '@finos/legend-shared';
 import { CORE_HASH_STRUCTURE } from '../../../../../../../MetaModelConst';
 import type { ColumnMapping } from './ColumnMapping';
 import type { Schema } from './Schema';
-import { Column } from './Column';
+import type { Column } from './Column';
 import {
   type RelationalMappingSpecification,
   NamedRelation,
@@ -47,14 +42,6 @@ export class View
     this.schema = schema;
   }
 
-  getColumn = (name: string): Column =>
-    guaranteeNonNullable(
-      this.columns
-        .filter(filterByType(Column))
-        .find((column) => column.name === name),
-      `Can't find column '${name}' in table '${this.name}'`,
-    );
-
   override get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.DATBASE_VIEW,

package/src/models/metamodels/pure/packageableElements/store/relational/model/ViewReference.ts

@@ -65,7 +65,7 @@ export class ViewExplicitReference extends ViewReference {
 
   private constructor(value: View) {
     const ownerReference = PackageableElementExplicitReference.create(
-      value.schema.owner,
+      value.schema._OWNER,
     );
     super(ownerReference, value);
     this.ownerReference = ownerReference;

package/src/models/metamodels/pure/rawValueSpecification/RawLambda.ts

@@ -21,12 +21,8 @@ import {
   type RawValueSpecificationVisitor,
   RawValueSpecification,
 } from './RawValueSpecification';
-import type { Stubable } from '../../../../helpers/Stubable';
 
-export class RawLambda
-  extends RawValueSpecification
-  implements Hashable, Stubable
-{
+export class RawLambda extends RawValueSpecification implements Hashable {
   body?: object | undefined;
   parameters?: object | undefined;
 
@@ -36,11 +32,6 @@ export class RawLambda
     this.body = body;
   }
 
-  static createStub = (): RawLambda => new RawLambda(undefined, undefined);
-  get isStub(): boolean {
-    return !this.body && !this.parameters;
-  }
-
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.RAW_LAMBDA,