@finos/legend-graph 0.0.3 → 0.1.0

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

@@ -39,10 +39,11 @@ export class RootRelationalInstanceSetImplementation
   implements RelationalMappingSpecification, Hashable
 {
   columnMappings: ColumnMapping[] = [];
-  filter?: FilterMapping;
-  distinct?: boolean;
-  groupBy?: GroupByMapping;
-  mainTableAlias!: TableAlias;
+  filter?: FilterMapping | undefined;
+  distinct?: boolean | undefined;
+  groupBy?: GroupByMapping | undefined;
+  mainTableAlias?: TableAlias;
+  superSetImplementationId?: string | undefined;
 
   constructor(
     id: InferableMappingElementIdValue,
@@ -58,6 +59,7 @@ export class RootRelationalInstanceSetImplementation
       distinct: observable,
       groupBy: observable,
       mainTableAlias: observable,
+      superSetImplementationId: observable,
       setPropertyMappings: action,
       hashCode: computed,
     });
@@ -77,10 +79,11 @@ export class RootRelationalInstanceSetImplementation
     return hashArray([
       CORE_HASH_STRUCTURE.ROOT_RELATIONAL_INSTANCE_SET_IMPLEMENTATION,
       super.hashCode,
-      this.mainTableAlias.relation.pointerHashCode,
+      this.mainTableAlias?.relation.pointerHashCode ?? '',
       this.distinct?.toString() ?? '',
       hashArray(this.groupBy?.columns ?? []),
       this.filter ?? '',
+      this.superSetImplementationId ?? '',
     ]);
   }
 }

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

@@ -26,7 +26,7 @@ export class Column extends RelationalOperationElement implements Hashable {
   owner!: Relation;
   name!: string;
   type!: RelationalDataType;
-  nullable?: boolean;
+  nullable?: boolean | undefined;
 
   constructor() {
     super();

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

@@ -32,7 +32,7 @@ export class Join implements Hashable {
    * Target is used to show the direction of the join. Since cross table join is symmetrical in nature,
    * the direction is not required at all, whereas for self-join, the direction really matters
    */
-  target?: TableAlias;
+  target?: TableAlias | undefined;
   /**
    * This is an optimization for looking up tables/views involved in a join.
    * Normally, it has 2 pairs (A,B) and (B,A)

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

@@ -104,10 +104,10 @@ export class DynaFunction extends Operation {
 }
 
 export interface RelationalMappingSpecification {
-  filter?: FilterMapping;
-  distinct?: boolean;
-  groupBy?: GroupByMapping;
-  mainTableAlias?: TableAlias;
+  filter?: FilterMapping | undefined;
+  distinct?: boolean | undefined;
+  groupBy?: GroupByMapping | undefined;
+  mainTableAlias?: TableAlias | undefined;
 }
 
 export enum JoinType {
@@ -134,10 +134,10 @@ export const getJoinType = (type: string): JoinType => {
 // TODO: create RelationalTreeNode like in PURE?
 export class JoinTreeNode {
   // FIXME: required in PURE
-  alias?: TableAlias;
+  alias?: TableAlias | undefined;
   children: JoinTreeNode[] = [];
   join: JoinReference;
-  joinType?: JoinType;
+  joinType?: JoinType | undefined;
 
   constructor(join: JoinReference, joinType?: JoinType, alias?: TableAlias) {
     makeObservable(this, {
@@ -171,8 +171,8 @@ export const extractLine = (joinTreeNode: JoinTreeNode): JoinTreeNode[] =>
   );
 
 export class RelationalOperationElementWithJoin extends RelationalOperationElement {
-  relationalOperationElement?: RelationalOperationElement;
-  joinTreeNode?: JoinTreeNode;
+  relationalOperationElement?: RelationalOperationElement | undefined;
+  joinTreeNode?: JoinTreeNode | undefined;
 
   constructor() {
     super();
@@ -194,10 +194,10 @@ export class RelationalOperationElementWithJoin extends RelationalOperationEleme
 }
 
 export class TableAlias extends RelationalOperationElement implements Hashable {
-  // setMappingOwner?: PropertyMappingsImplementation;
+  // setMappingOwner?: PropertyMappingsImplementation | undefined;
   relation!: TableReference | ViewReference;
   name!: string;
-  database?: Database;
+  database?: Database | undefined;
   isSelfJoinTarget = false;
 
   constructor() {
@@ -217,10 +217,10 @@ export class TableAlias extends RelationalOperationElement implements Hashable {
 }
 
 export class TableAliasColumn extends RelationalOperationElement {
-  // setMappingOwner?: PropertyMappingsImplementation;
+  // setMappingOwner?: PropertyMappingsImplementation | undefined;
   alias!: TableAlias;
   column!: ColumnReference;
-  columnName?: string;
+  columnName?: string | undefined;
 
   constructor() {
     super();

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

@@ -33,9 +33,9 @@ export class View
   schema!: Schema;
   primaryKey: Column[] = [];
   columnMappings: ColumnMapping[] = [];
-  filter?: FilterMapping;
-  distinct?: boolean;
-  groupBy?: GroupByMapping;
+  filter?: FilterMapping | undefined;
+  distinct?: boolean | undefined;
+  groupBy?: GroupByMapping | undefined;
 
   constructor(name: string, schema: Schema) {
     super(name);

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

@@ -22,5 +22,5 @@ export abstract class Milestoning implements Hashable {
 }
 
 export abstract class TemporalMilestoning extends Milestoning {
-  infinityDate?: RawInstanceValue;
+  infinityDate?: RawInstanceValue | undefined;
 }

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

@@ -30,7 +30,7 @@ export class RawInstanceValue
 {
   type: PackageableElementReference<Type>;
   multiplicity: Multiplicity;
-  values?: (string | number)[];
+  values?: (string | number)[] | undefined;
 
   constructor(
     type: PackageableElementReference<Type>,

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

@@ -27,8 +27,8 @@ export class RawLambda
   extends RawValueSpecification
   implements Hashable, Stubable
 {
-  body?: object;
-  parameters?: object;
+  body?: object | undefined;
+  parameters?: object | undefined;
 
   constructor(parameters: object | undefined, body: object | undefined) {
     super();

package/src/models/metamodels/pure/valueSpecification/AlloySerializationConfig.ts

@@ -18,12 +18,12 @@ import { InstanceValue } from './InstanceValue';
 
 export class AlloySerializationConfig {
   typeKeyName: string;
-  includeType?: boolean;
-  includeEnumType?: boolean;
-  removePropertiesWithNullValues?: boolean;
-  removePropertiesWithEmptySets?: boolean;
-  fullyQualifiedTypePath?: boolean;
-  includeObjectReference?: boolean;
+  includeType?: boolean | undefined;
+  includeEnumType?: boolean | undefined;
+  removePropertiesWithNullValues?: boolean | undefined;
+  removePropertiesWithEmptySets?: boolean | undefined;
+  fullyQualifiedTypePath?: boolean | undefined;
+  includeObjectReference?: boolean | undefined;
 
   constructor(typeKeyName: string) {
     this.typeKeyName = typeKeyName;

package/src/models/metamodels/pure/valueSpecification/ExecutionContext.ts

@@ -17,8 +17,8 @@
 import type { LambdaFunction } from './LambdaFunction';
 
 export abstract class ExecutionContext {
-  queryTimeOutInSeconds?: number;
-  enableConstraints?: boolean;
+  queryTimeOutInSeconds?: number | undefined;
+  enableConstraints?: boolean | undefined;
 }
 
 export class AnalyticsExecutionContext extends ExecutionContext {

package/src/models/metamodels/pure/valueSpecification/GraphFetchTree.ts

@@ -63,7 +63,7 @@ export class RootGraphFetchTree extends GraphFetchTree {
 
 export class PropertyGraphFetchTree extends GraphFetchTree {
   property: PropertyReference;
-  alias?: string;
+  alias?: string | undefined;
   parameters: ValueSpecification[] = []; //TODO
   subType: OptionalPackageableElementReference<Class>;
 

package/src/models/metamodels/pure/valueSpecification/LambdaFunction.ts

@@ -24,7 +24,7 @@ import type {
 import type { Multiplicity } from '../packageableElements/domain/Multiplicity';
 
 export class FunctionType {
-  returnType?: Type;
+  returnType?: Type | undefined;
   parameters: VariableExpression[] = [];
   returnMultiplicity: Multiplicity;
 

package/src/models/metamodels/pure/valueSpecification/SimpleFunctionExpression.ts

@@ -25,7 +25,7 @@ import type { AbstractProperty } from '../packageableElements/domain/AbstractPro
 import { UnsupportedOperationError } from '@finos/legend-shared';
 
 export class Expression extends ValueSpecification {
-  classifierGenericType?: GenericTypeReference;
+  classifierGenericType?: GenericTypeReference | undefined;
 
   accept_ValueSpecificationVisitor<T>(
     visitor: ValueSpecificationVisitor<T>,
@@ -62,7 +62,7 @@ export class FunctionExpression extends Expression {
 }
 
 export class SimpleFunctionExpression extends FunctionExpression {
-  func?: PackageableElementReference<Function>;
+  func?: PackageableElementReference<Function> | undefined;
 
   override accept_ValueSpecificationVisitor<T>(
     visitor: ValueSpecificationVisitor<T>,

package/src/models/metamodels/pure/valueSpecification/ValueSpecification.ts

@@ -39,6 +39,7 @@ import type {
 } from './SimpleFunctionExpression';
 import type { INTERNAL__UnknownValueSpecification } from './INTERNAL__UnknownValueSpecification';
 import type { VariableExpression } from './VariableExpression';
+import { makeObservable, observable, action } from 'mobx';
 
 export interface ValueSpecificationVisitor<T> {
   visit_RootGraphFetchTreeInstanceValue(
@@ -76,17 +77,25 @@ export interface ValueSpecificationVisitor<T> {
 }
 
 export abstract class ValueSpecification {
-  genericType?: GenericTypeReference;
+  genericType?: GenericTypeReference | undefined;
   multiplicity!: Multiplicity;
 
   constructor(
     multiplicity: Multiplicity,
     genericTypeReference?: GenericTypeReference,
   ) {
+    makeObservable<ValueSpecification>(this, {
+      multiplicity: observable,
+      setMultiplicity: action,
+    });
     this.multiplicity = multiplicity;
     this.genericType = genericTypeReference;
   }
 
+  setMultiplicity(val: Multiplicity): void {
+    this.multiplicity = val;
+  }
+
   abstract accept_ValueSpecificationVisitor<T>(
     visitor: ValueSpecificationVisitor<T>,
   ): T;

package/src/models/metamodels/pure/valueSpecification/VariableExpression.ts

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { makeObservable, observable, action } from 'mobx';
+import type { GenericTypeReference } from '../packageableElements/domain/GenericTypeReference';
 import type { Multiplicity } from '../packageableElements/domain/Multiplicity';
 import type { ValueSpecificationVisitor } from './ValueSpecification';
 import { ValueSpecification } from './ValueSpecification';
@@ -21,9 +23,23 @@ import { ValueSpecification } from './ValueSpecification';
 export class VariableExpression extends ValueSpecification {
   name: string;
 
-  constructor(name: string, multiplicity: Multiplicity) {
+  constructor(
+    name: string,
+    multiplicity: Multiplicity,
+    genericType?: GenericTypeReference | undefined,
+  ) {
     super(multiplicity);
+    makeObservable<VariableExpression>(this, {
+      name: observable,
+      genericType: observable,
+      setName: action,
+    });
     this.name = name;
+    this.genericType = genericType;
+  }
+
+  setName(val: string): void {
+    this.name = val;
   }
 
   accept_ValueSpecificationVisitor<T>(

package/src/models/protocols/pure/DSLGenerationSpecification_PureProtocolProcessorPlugin_Extension.ts

@@ -14,18 +14,21 @@
  * limitations under the License.
  */
 
-import type { PackageableElement } from '../../metamodels/pure/packageableElements/PackageableElement';
+import type { ModelGenerationSpecification } from '../../metamodels/pure/packageableElements/generationSpecification/ModelGenerationSpecification';
 import type { PureProtocolProcessorPlugin } from './PureProtocolProcessorPlugin';
 import type { V1_Engine } from './v1/engine/V1_Engine';
 import type { V1_PureModelContextData } from './v1/model/context/V1_PureModelContextData';
 
 export type V1_ModelGenerator = (
-  generationElement: PackageableElement,
+  generationElement: ModelGenerationSpecification,
   model: V1_PureModelContextData,
   engine: V1_Engine,
 ) => Promise<V1_PureModelContextData | undefined>;
 
 export interface DSLGenerationSpecification_PureProtocolProcessorPlugin_Extension
   extends PureProtocolProcessorPlugin {
+  /**
+   * Get generators for model generation specification.
+   */
   V1_getExtraModelGenerators?(): V1_ModelGenerator[];
 }

package/src/models/protocols/pure/DSLMapping_PureProtocolProcessorPlugin_Extension.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 { PlainObject } from '@finos/legend-shared';
+import type { Connection } from '../../metamodels/pure/packageableElements/connection/Connection';
+import { PureProtocolProcessorPlugin } from './PureProtocolProcessorPlugin';
+import type { V1_Connection } from '../pure/v1/model/packageableElements/connection/V1_Connection';
+import type { V1_GraphTransformerContext } from './v1/transformation/pureGraph/from/V1_GraphTransformerContext';
+import type { V1_GraphBuilderContext } from './v1/transformation/pureGraph/to/V1_GraphBuilderContext';
+import type { Store } from '../../metamodels/pure/packageableElements/store/Store';
+import type { PackageableElementReference } from '../../metamodels/pure/packageableElements/PackageableElementReference';
+
+export type V1_ConnectionBuilder = (
+  connection: V1_Connection,
+  context: V1_GraphBuilderContext,
+  store?: PackageableElementReference<Store> | undefined,
+) => Connection | undefined;
+
+export type V1_ConnectionTransformer = (
+  metamodel: Connection,
+  context: V1_GraphTransformerContext,
+) => V1_Connection | undefined;
+
+export type V1_ConnectionProtocolSerializer = (
+  connection: V1_Connection,
+) => PlainObject<V1_Connection> | undefined;
+
+export type V1_ConnectionProtocolDeserializer = (
+  json: PlainObject<V1_Connection>,
+) => V1_Connection | undefined;
+
+export abstract class DSLMapping_PureProtocolProcessorPlugin_Extension extends PureProtocolProcessorPlugin {
+  V1_getExtraConnectionBuilders?(): V1_ConnectionBuilder[];
+
+  V1_getExtraConnectionTransformers?(): V1_ConnectionTransformer[];
+
+  V1_getExtraConnectionProtocolSerializers?(): V1_ConnectionProtocolSerializer[];
+
+  V1_getExtraConnectionProtocolDeserializers?(): V1_ConnectionProtocolDeserializer[];
+}

package/src/models/protocols/pure/PureProtocolProcessorPlugin.ts

@@ -62,30 +62,75 @@ export type V1_ExecutionInputGetter = (
   protocolGraph: V1_PureModelContextData,
 ) => V1_PackageableElement[];
 
+/**
+ * Plugins for protocol processors. Technically, this is a sub-part of `PureGraphManagerPlugin`
+ * but due to the way we encapsulate the protocol code and the way we organize graph managers,
+ * we want to keep `PureGraphManagerPlugin` to operate at metamodel level where as this allows
+ * extension mechanism on the protocol models.
+ *
+ * When we introduce another version of protocol models, e.g. v2_0_0, we would just add another set
+ * of plugin methods here without having to modify the abstract layer of graph manager.
+ */
 export abstract class PureProtocolProcessorPlugin extends AbstractPlugin {
   private readonly _$nominalTypeBrand!: 'PureProtocolProcessorPlugin';
 
+  /**
+   * Get the list of supported system element models.
+   *
+   * NOTE: since this set of element is meant to be kept small at the moment,
+   * we can store them as part of the codebase; however, when this set grows,
+   * we should consider having a backend exposed an end point to collect these models.
+   */
   V1_getExtraSystemModels?(): PlainObject<V1_PureModelContextData>[];
 
+  /**
+   * Get the list of builders for a packageable element: i.e. protocol model -> metamodel.
+   */
   V1_getExtraElementBuilders?(): V1_ElementBuilder<V1_PackageableElement>[];
 
+  /**
+   * Get the list of methods to derive the classifier path of a packageable element.
+   */
   V1_getExtraElementClassifierPathGetters?(): V1_ElementProtocolClassifierPathGetter[];
 
+  /**
+   * Get the list of serializers for a packageable element: i.e. protocol model -> JSON.
+   */
   V1_getExtraElementProtocolSerializers?(): V1_ElementProtocolSerializer[];
 
+  /**
+   * Get the list of de-serializers for a packageable element: i.e. JSON -> protocol model.
+   */
   V1_getExtraElementProtocolDeserializers?(): V1_ElementProtocolDeserializer[];
 
+  /**
+   * Get the list of transformers for a packageable element: i.e. metamodel -> protocol model.
+   */
   V1_getExtraElementTransformers?(): V1_ElementTransformer[];
 
+  /**
+   * Get the list of fields in element JSON which hold source information
+   * (a product of the grammar parsing process).
+   */
   V1_getExtraSourceInformationKeys?(): string[];
 
+  /**
+   * Get the list of builders for function expression.
+   *
+   * NOTE: this process is complicated, as it involes advanced procedures like type inferencing,
+   * function matching, handling generics, etc. so our graph manager never intends to even try to
+   * do this. However, occassionally, when there is needs to understand some particular lambda
+   * (such as while building a query), we would need this method.
+   */
   V1_getExtraFunctionExpressionBuilders?(): V1_FunctionExpressionBuilder[];
 
   /**
-   * Used to specify any additional packageable elements added to the graph that is
-   * used when executing a query against the engine server. We prune the graph to avoid
-   * sending the server additional elements not needed for execution. This would provide a mechanism
-   * to add more elements in this reduced graph.
+   * Get the list of collectors of graph elements to build execution input.
+   *
+   * In particular, such collector is used to specify any additional packageable elements
+   * added to the graph that is used when executing a query against the engine server.
+   * We prune the graph to avoid sending the server additional elements not needed for execution.
+   * This would provide a mechanism to add more elements in this reduced graph.
    */
   V1_getExtraExecutionInputGetters?(): V1_ExecutionInputGetter[];
 }