@finos/legend-graph 6.0.1 → 7.0.0

package/src/helpers/StoreRelational_Helper.ts

@@ -0,0 +1,161 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  filterByType,
+  guaranteeNonNullable,
+  guaranteeType,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { RelationalInputType } from '../models/metamodels/pure/packageableElements/store/relational/mapping/RelationalInputData';
+import { Column } from '../models/metamodels/pure/packageableElements/store/relational/model/Column';
+import { Database } from '../models/metamodels/pure/packageableElements/store/relational/model/Database';
+import type { Filter } from '../models/metamodels/pure/packageableElements/store/relational/model/Filter';
+import type { Join } from '../models/metamodels/pure/packageableElements/store/relational/model/Join';
+import {
+  JoinType,
+  type Relation,
+} from '../models/metamodels/pure/packageableElements/store/relational/model/RelationalOperationElement';
+import type { Schema } from '../models/metamodels/pure/packageableElements/store/relational/model/Schema';
+import type { Table } from '../models/metamodels/pure/packageableElements/store/relational/model/Table';
+import type { View } from '../models/metamodels/pure/packageableElements/store/relational/model/View';
+
+const collectIncludedDatabases = (
+  results: Set<Database>,
+  databases: Database[],
+): void => {
+  databases.forEach((i) => {
+    const includedDb = guaranteeType(i, Database);
+    if (!results.has(includedDb)) {
+      results.add(includedDb);
+      collectIncludedDatabases(
+        results,
+        includedDb.includes.map((s) => guaranteeType(s.value, Database)),
+      );
+    }
+  });
+};
+
+export const getAllIncludedDatabases = (db: Database): Set<Database> => {
+  const includes = db.includes;
+  const results = new Set<Database>();
+  results.add(db);
+  if (!includes.length) {
+    return results;
+  }
+  collectIncludedDatabases(
+    results,
+    db.includes.map((includedStore) =>
+      guaranteeType(includedStore.value, Database),
+    ),
+  );
+  return results;
+};
+
+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}'`,
+      );
+  }
+};
+
+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 const getNullableSchema = (
+  database: Database,
+  name: string,
+): Schema | undefined =>
+  database.schemas.find((schema) => schema.name === name);
+
+export const getNullableFilter = (
+  database: Database,
+  name: string,
+): Filter | undefined =>
+  Array.from(getAllIncludedDatabases(database))
+    .flatMap((includedDB) => includedDB.filters)
+    .find((filter) => filter.name === name);
+
+export const getSchema = (database: Database, name: string): Schema =>
+  guaranteeNonNullable(
+    getNullableSchema(database, name),
+    `Can't find schema '${name}' in database '${database.path}'`,
+  );
+
+export const getJoin = (database: Database, name: string): Join =>
+  guaranteeNonNullable(
+    Array.from(getAllIncludedDatabases(database))
+      .flatMap((includedDB) => includedDB.joins)
+      .find((join) => join.name === name),
+    `Can't find join '${name}' in database '${database.path}'`,
+  );
+
+export const getFilter = (database: Database, name: string): Filter =>
+  guaranteeNonNullable(
+    getNullableFilter(database, name),
+    `Can't find filter '${name}' in database '${database.path}'`,
+  );
+
+export const getNullableTable = (
+  schema: Schema,
+  name: string,
+): Table | undefined => schema.tables.find((table) => table.name === name);
+
+export const getTable = (schema: Schema, name: string): Table =>
+  guaranteeNonNullable(
+    getNullableTable(schema, name),
+    `Can't find table '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getView = (schema: Schema, name: string): View =>
+  guaranteeNonNullable(
+    schema.views.find((view) => view.name === name),
+    `Can't find view '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+
+export const getRelation = (schema: Schema, name: string): Relation => {
+  const relations: (Table | View)[] = schema.tables;
+  return guaranteeNonNullable(
+    relations.concat(schema.views).find((relation) => relation.name === name),
+    `Can't find relation '${name}' in schema '${schema.name}' of database '${schema._OWNER.path}'`,
+  );
+};
+
+export const getColumn = (relation: Table | View, name: string): Column =>
+  guaranteeNonNullable(
+    relation.columns
+      .filter(filterByType(Column))
+      .find((column) => column.name === name),
+    `Can't find column '${name}' in table '${relation.name}'`,
+  );

package/src/helpers/Testable_Helper.ts

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { isNonNullable } from '@finos/legend-shared';
+import type { PureModel } from '../graph/PureModel';
+import type { PureGraphManagerPlugin } from '../graphManager/PureGraphManagerPlugin';
+import { PackageableElement } from '../models/metamodels/pure/packageableElements/PackageableElement';
+import type { Testable } from '../models/metamodels/pure/test/Testable';
+
+export const getNullableTestable = (
+  id: string,
+  graph: PureModel,
+  plugins: PureGraphManagerPlugin[],
+): Testable | undefined =>
+  graph.allOwnTestables.find(
+    (e) => e instanceof PackageableElement && e.path === id,
+  ) ??
+  plugins
+    .flatMap((plugin) => plugin.getExtraTestableFinders?.() ?? [])
+    .map((getter) => getter(id, graph))
+    .filter(isNonNullable)[0];
+
+export const getNullableIDFromTestable = (
+  testable: Testable,
+  graph: PureModel,
+  plugins: PureGraphManagerPlugin[],
+): string | undefined => {
+  if (testable instanceof PackageableElement) {
+    return testable.path;
+  }
+  return plugins
+    .flatMap((plugin) => plugin.getExtraTestableIDBuilders?.() ?? [])
+    .map((getter) => getter(testable, graph))
+    .filter(isNonNullable)[0];
+};

package/src/index.ts

@@ -32,11 +32,7 @@ export {
   GenericTypeExplicitReference,
 } from './models/metamodels/pure/packageableElements/domain/GenericTypeReference';
 export { GenericType } from './models/metamodels/pure/packageableElements/domain/GenericType';
-export {
-  Class,
-  CLASS_PROPERTY_TYPE,
-  getClassPropertyType,
-} from './models/metamodels/pure/packageableElements/domain/Class';
+export { Class } from './models/metamodels/pure/packageableElements/domain/Class';
 export { type AnnotatedElement } from './models/metamodels/pure/packageableElements/domain/AnnotatedElement';
 export { Package } from './models/metamodels/pure/packageableElements/domain/Package';
 export { Constraint } from './models/metamodels/pure/packageableElements/domain/Constraint';
@@ -161,12 +157,15 @@ export { TDSResultType } from './models/metamodels/pure/executionPlan/result/TDS
 export * from './MetaModelUtils';
 export * from './MetaModelConst';
 
-export * from './helpers/ServiceHelper';
-export * from './helpers/DatabaseHelper';
-export * from './helpers/MappingHelper';
-export * from './helpers/ValidationHelper';
-export * from './helpers/Stubable'; // TODO: to be removed
 export * from './helpers/DomainHelper';
+export * from './helpers/Testable_Helper';
+export * from './helpers/DSLMapping_Helper';
+export * from './helpers/StoreRelational_Helper';
+export * from './helpers/StoreFlatData_Helper';
+export * from './helpers/DSLService_Helper';
+export * from './helpers/DSLGeneration_Helper';
+
+export * from './helpers/ValidationHelper';
 export * from './helpers/PureLanguageHelper';
 
 // --------------------------------------------- GRAPH --------------------------------------------------
@@ -218,7 +217,7 @@ export * from './graphManager/action/generation/GenerationConfigurationDescripti
 export { GenerationOutput } from './graphManager/action/generation/GenerationOutput';
 export { ServiceExecutionMode } from './graphManager/action/service/ServiceExecutionMode';
 export { ServiceRegistrationResult } from './graphManager/action/service/ServiceRegistrationResult';
-export { ServiceTestResult } from './graphManager/action/service/ServiceTestResult';
+export { DEPRECATED__ServiceTestResult } from './graphManager/action/service/DEPRECATED__ServiceTestResult';
 export { SourceInformation } from './graphManager/action/SourceInformation';
 
 export { getGraphManager } from './models/protocols/pure/Pure';
@@ -281,6 +280,19 @@ export * from './models/protocols/pure/v1/transformation/pureGraph/to/V1_DSLExte
 export * from './models/ModelGenerationConfiguration';
 export * from './models/protocols/pure/MappingGeneration_PureProtocolProcessorPlugin_Extension';
 
+// --------------------------------------------- TESTING --------------------------------------------------
+
+export * from './models/metamodels/pure/test/Testable';
+export * from './models/metamodels/pure/test/result/RunTestsTestableInput';
+export * from './models/metamodels/pure/test/result/TestResult';
+export * from './models/metamodels/pure/test/assertion/status/AssertionStatus';
+export * from './models/metamodels/pure/test/assertion/status/AssertFail';
+export * from './models/metamodels/pure/test/assertion/status/AssertPass';
+export * from './models/metamodels/pure/test/assertion/status/EqualToJsonAssertFail';
+export * from './models/metamodels/pure/test/assertion/TestAssertion';
+export * from './models/metamodels/pure/test/Test';
+export * from './models/metamodels/pure/test/result/AtomicTestId';
+
 // --------------------------------------------- OBSERVER --------------------------------------------------
 
 export * from './graphManager/action/changeDetection/PackageableElementObserver';
@@ -296,6 +308,15 @@ export * from './graphManager/action/changeDetection/DSLExternalFormat_ObserverH
 export * from './graphManager/action/changeDetection/DSLService_ObserverHelper';
 export * from './graphManager/action/changeDetection/DSLGenerationSpecification_ObserverHelper';
 
+export * from './graphManager/action/changeDetection/EngineObserverHelper';
+
+// --------------------------------------------- CREATOR --------------------------------------------------
+
+export * from './graphManager/action/creation/DomainModelCreatorHelper';
+export * from './graphManager/action/creation/DSLMapping_ModelCreatorHelper';
+export * from './graphManager/action/creation/RawValueSpecificationCreatorHelper';
+export * from './graphManager/action/creation/StoreRelational_ModelCreatorHelper';
+
 // --------------------------------------------- TO BE MODULARIZED --------------------------------------------------
 
 export * from './DSLMapping_Exports';

package/src/models/metamodels/pure/Reference.ts

@@ -73,3 +73,12 @@ export abstract class ReferenceWithOwner extends RequiredReference {
     this.ownerReference = ownerReference;
   }
 }
+
+export abstract class OptionalReferenceWithOwner extends OptionalReference {
+  readonly ownerReference: OptionalReference;
+
+  protected constructor(ownerReference: OptionalReference) {
+    super();
+    this.ownerReference = ownerReference;
+  }
+}

package/src/models/metamodels/pure/data/EmbeddedData.ts

@@ -20,12 +20,14 @@ import { hashObjectWithoutSourceInformation } from '../../../../MetaModelUtils';
 import type { DataElement } from '../packageableElements/data/DataElement';
 import type { Class } from '../packageableElements/domain/Class';
 import type { PackageableElementReference } from '../packageableElements/PackageableElementReference';
+import type { RelationalData } from './RelationalData';
 
 export interface EmbeddedDataVisitor<T> {
   visit_EmbeddedData(embeddedData: EmbeddedData): T;
   visit_ExternalFormatData(externalFormatData: ExternalFormatData): T;
   visit_ModelStoreData(modelStoreData: ModelStoreData): T;
   visit_DataElementReference(dataElementReference: DataElementReference): T;
+  visit_RelationalData(relationalData: RelationalData): T;
 }
 
 export abstract class EmbeddedData implements Hashable {

package/src/models/metamodels/pure/data/RelationalData.ts

@@ -0,0 +1,71 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../MetaModelConst';
+import { type EmbeddedDataVisitor, EmbeddedData } from './EmbeddedData';
+
+export class RelationalDataTableColumn implements Hashable {
+  value!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE_COLUMN,
+      this.value,
+    ]);
+  }
+}
+export class RelationalDataTableRow implements Hashable {
+  values!: string;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE_ROW,
+      this.values,
+    ]);
+  }
+}
+
+export class RelationalDataTable implements Hashable {
+  schemaName: string | undefined;
+  tableName!: string;
+  columns: RelationalDataTableColumn[] = [];
+  rows: RelationalDataTableRow[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
+      this.schemaName ?? '',
+      this.tableName,
+      hashArray(this.columns),
+      hashArray(this.rows),
+    ]);
+  }
+}
+export class RelationalData extends EmbeddedData implements Hashable {
+  tables: RelationalDataTable[] = [];
+
+  accept_EmbeddedDataVisitor<T>(visitor: EmbeddedDataVisitor<T>): T {
+    return visitor.visit_RelationalData(this);
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.RELATIONAL_DATA_TABLE,
+      hashArray(this.tables),
+    ]);
+  }
+}

package/src/models/metamodels/pure/packageableElements/PackageableElement.ts

@@ -17,7 +17,6 @@
 import {
   type Hashable,
   hashArray,
-  hashString,
   IllegalStateError,
   uuid,
 } from '@finos/legend-shared';
@@ -26,7 +25,6 @@ import {
   ELEMENT_PATH_DELIMITER,
 } from '../../../../MetaModelConst';
 import type { Package } from './domain/Package';
-import type { Stubable } from '../../../../helpers/Stubable';
 import type { Profile } from './domain/Profile';
 import type { Enumeration } from './domain/Enumeration';
 import type { Class } from './domain/Class';
@@ -68,11 +66,11 @@ export interface PackageableElementVisitor<T> {
   visit_DataElement(element: DataElement): T;
 }
 
-export abstract class PackageableElement implements Hashable, Stubable {
-  readonly uuid = uuid();
-
+export abstract class PackageableElement implements Hashable {
+  readonly _UUID = uuid();
   protected _isDeleted = false;
   protected _isDisposed = false;
+
   name: string;
   package?: Package | undefined;
 
@@ -80,30 +78,53 @@ export abstract class PackageableElement implements Hashable, Stubable {
     this.name = name;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   get isDeleted(): boolean {
     return this._isDeleted;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   setIsDeleted(value: boolean): void {
     this._isDeleted = value;
   }
 
+  /**
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
+   */
   get path(): string {
     if (!this.package) {
       return this.name;
     }
-    const parentPackageName = this.package.fullPath;
-    return !parentPackageName
+    const parentPackagePath = this.package.path;
+    return !parentPackagePath
       ? this.name
-      : `${parentPackageName}${ELEMENT_PATH_DELIMITER}${this.name}`;
-  }
-
-  get isStub(): boolean {
-    return !this.name && !this.package;
+      : `${parentPackagePath}${ELEMENT_PATH_DELIMITER}${this.name}`;
   }
 
   /**
-   * Dispose the element and its references to avoid memory leaks
+   * Dispose the element and its references to avoid memory leaks.
+   *
+   * This logic is specific to the codebase and this is not part of the native metamodel.
+   * If needed, we can probably move this out as an utility or do type declaration merge
+   * and define this externally using `Object.defineProperty`.
+   *
+   * @internal model logic
    */
   dispose(): void {
     this._isDisposed = true;
@@ -111,14 +132,12 @@ export abstract class PackageableElement implements Hashable, Stubable {
      * Trigger recomputation on `hashCode` so if the element is observed, hash code computation will now
      * remove itself from all observables it previously observed
      *
-     * NOTE: we used to do this since we decorate `hashCode` with `computed({ keepAlive: true })` which
-     * poses a memory-leak threat
-     *
-     * See https://mobx.js.org/computeds.html#keepalive
-     *
+     * NOTE: for example, we used to do this since we decorate `hashCode` with
+     * `computed({ keepAlive: true })` which poses a memory-leak threat.
      * However, since we're calling `keepAlive` actively now and dispose it right away to return `hashCode` to
      * a normal computed value, we might not need this step anymore. But we're being extremely defensive here
      * to avoid memory leak.
+     * See https://mobx.js.org/computeds.html#keepalive
      */
     try {
       this.hashCode;
@@ -142,43 +161,3 @@ export abstract class PackageableElement implements Hashable, Stubable {
     visitor: PackageableElementVisitor<T>,
   ): T;
 }
-
-// TODO: to be moved out of metamodel
-export enum PACKAGEABLE_ELEMENT_TYPE {
-  PRIMITIVE = 'PRIMITIVE',
-  PACKAGE = 'PACKAGE',
-  PROFILE = 'PROFILE',
-  ENUMERATION = 'ENUMERATION',
-  CLASS = 'CLASS',
-  ASSOCIATION = 'ASSOCIATION',
-  FUNCTION = 'FUNCTION',
-  MEASURE = 'MEASURE',
-  UNIT = 'UNIT',
-  FLAT_DATA_STORE = 'FLAT_DATA_STORE',
-  DATABASE = 'DATABASE',
-  SERVICE_STORE = 'SERVICE_STORE',
-  MAPPING = 'MAPPING',
-  SERVICE = 'SERVICE',
-  CONNECTION = 'CONNECTION',
-  RUNTIME = 'RUNTIME',
-  FILE_GENERATION = 'FILE_GENERATION',
-  GENERATION_SPECIFICATION = 'GENERATION_SPECIFICATION',
-  SECTION_INDEX = 'SECTION_INDEX',
-  DATA = 'Data',
-}
-
-// TODO: to be moved out of metamodel
-export enum PACKAGEABLE_ELEMENT_POINTER_TYPE {
-  STORE = 'STORE',
-  MAPPING = 'MAPPING',
-  FILE_GENERATION = 'FILE_GENERATION',
-  SERVICE = 'SERVICE',
-}
-
-export const getElementPointerHashCode = (
-  pointerType: string,
-  path: string,
-): string =>
-  [CORE_HASH_STRUCTURE.PACKAGEABLE_ELEMENT_POINTER, pointerType, path]
-    .map(hashString)
-    .join(',');

package/src/models/metamodels/pure/packageableElements/PackageableElementReference.ts

@@ -134,7 +134,7 @@ export class PackageableElementImplicitReference<
     // when the parent section does not exist or has been deleted
     if (
       this.parentSection === undefined ||
-      this.parentSection.parent.isDeleted
+      this.parentSection._OWNER.isDeleted
     ) {
       return currentElementPath;
     }
@@ -240,7 +240,7 @@ export class OptionalPackageableElementImplicitReference<
     // when the parent section does not exist or has been deleted
     if (
       this.parentSection === undefined ||
-      this.parentSection.parent.isDeleted
+      this.parentSection._OWNER.isDeleted
     ) {
       return currentElementPath;
     }

package/src/models/metamodels/pure/packageableElements/connection/Connection.ts

@@ -38,9 +38,11 @@ export interface ConnectionVisitor<T> {
 }
 
 export abstract class Connection implements Hashable {
-  readonly uuid = uuid();
+  readonly _UUID = uuid();
 
-  // in Pure right now, this is of type Any[1], but technically it should be a store
+  /**
+   * NOTE: in Pure right now, this is of type Any[1], but technically it should be a store
+   */
   store: PackageableElementReference<Store>;
 
   constructor(store: PackageableElementReference<Store>) {

package/src/models/metamodels/pure/packageableElements/domain/AbstractProperty.ts

@@ -17,16 +17,16 @@
 import type { Hashable } from '@finos/legend-shared';
 import type { GenericTypeReference } from './GenericTypeReference';
 import type { Multiplicity } from './Multiplicity';
-import type { Stubable } from '../../../../../helpers/Stubable';
 import type { Class } from './Class';
 import type { Association } from './Association';
 
 // NOTE: In PURE we have `Class` and `Association` extends `PropertyOwner`, which extends `PackageableElement`
 export type PropertyOwner = Class | Association;
 
-export interface AbstractProperty extends Hashable, Stubable {
+export interface AbstractProperty extends Hashable {
+  _OWNER: PropertyOwner;
+
   name: string;
-  owner: PropertyOwner;
   genericType: GenericTypeReference;
   multiplicity: Multiplicity;
 }