@finos/legend-graph 29.0.2 → 29.0.3

package/src/graph/PureModel.ts

@@ -37,7 +37,7 @@ import type { Mapping } from '../graph/metamodel/pure/packageableElements/mappin
 import type { Profile } from '../graph/metamodel/pure/packageableElements/domain/Profile.js';
 import type { Store } from '../graph/metamodel/pure/packageableElements/store/Store.js';
 import { DependencyManager } from '../graph/DependencyManager.js';
-import { ConcreteFunctionDefinition } from '../graph/metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import { ConcreteFunctionDefinition } from './metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import type { Service } from '../graph/metamodel/pure/packageableElements/service/Service.js';
 import { BasicModel } from './BasicModel.js';
 import { FlatData } from '../graph/metamodel/pure/packageableElements/store/flatData/model/FlatData.js';
@@ -59,6 +59,7 @@ import type { PackageableElement } from '../graph/metamodel/pure/packageableElem
 import type { SectionIndex } from '../graph/metamodel/pure/packageableElements/section/SectionIndex.js';
 import type { PropertyOwner } from './metamodel/pure/packageableElements/domain/AbstractProperty.js';
 import type { ExecutionEnvironmentInstance } from './metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import { FunctionActivator } from './metamodel/pure/packageableElements/function/FunctionActivator.js';
 
 /**
  * CoreModel holds meta models which are constant and basic building block of the graph. Since throughout the lifetime
@@ -104,6 +105,7 @@ export class CoreModel extends BasicModel {
       PrimitiveType.DATETIME,
       PrimitiveType.STRICTTIME,
       PrimitiveType.LATESTDATE,
+      PrimitiveType.BYTE,
     ].forEach((primitiveType) => {
       this.primitiveTypesIndex.set(primitiveType.path, primitiveType);
       this.setOwnType(primitiveType.path, primitiveType);
@@ -250,6 +252,15 @@ export class PureModel extends BasicModel {
       ...this.generationModel.ownFunctions,
     ];
   }
+  get functionActivators(): FunctionActivator[] {
+    return [
+      ...this.coreModel.ownFunctionActivators,
+      ...this.systemModel.ownFunctionActivators,
+      ...this.dependencyManager.functionActivators,
+      ...this.ownFunctionActivators,
+      ...this.generationModel.ownFunctionActivators,
+    ];
+  }
   get stores(): Store[] {
     return [
       ...this.coreModel.ownStores,
@@ -419,6 +430,15 @@ export class PureModel extends BasicModel {
       ConcreteFunctionDefinition,
       `Can't find function '${path}'`,
     );
+  getFunctionActivator = (path: string): FunctionActivator =>
+    guaranteeType(
+      this.getOwnNullableFunctionActivator(path) ??
+        this.generationModel.getOwnNullableFunctionActivator(path) ??
+        this.dependencyManager.getOwnNullableFunctionActivator(path) ??
+        this.systemModel.getOwnNullableFunctionActivator(path),
+      FunctionActivator,
+      `Can't find function activator '${path}'`,
+    );
   getStore = (path: string): Store =>
     guaranteeNonNullable(
       this.getOwnNullableStore(path) ??

package/src/graph/helpers/DomainHelper.ts

@@ -67,7 +67,7 @@ import type { Constraint } from '../metamodel/pure/packageableElements/domain/Co
 import type { GenericType } from '../metamodel/pure/packageableElements/domain/GenericType.js';
 import { Multiplicity } from '../metamodel/pure/packageableElements/domain/Multiplicity.js';
 import type { AnnotatedElement } from '../metamodel/pure/packageableElements/domain/AnnotatedElement.js';
-import type { ConcreteFunctionDefinition } from '../metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { ConcreteFunctionDefinition } from '../metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import { extractDependencyGACoordinateFromRootPackageName } from '../DependencyManager.js';
 
 export const addElementToPackage = (
@@ -713,3 +713,44 @@ export const getFunctionName = (
 export const getFunctionNameWithPath = (
   func: ConcreteFunctionDefinition,
 ): string => func.package?.path + ELEMENT_PATH_DELIMITER + func.functionName;
+
+const _classHasCycle = (
+  _class: Class,
+  __classesIndex: Set<string>,
+  options?: {
+    traverseNonRequiredProperties?: boolean | undefined;
+    excludedPaths?: Map<string, string[]> | undefined;
+  },
+): boolean => {
+  if (__classesIndex.has(_class.path)) {
+    return true;
+  }
+  const excludedProperties = options?.excludedPaths?.get(_class.path) ?? [];
+  const properties = options?.traverseNonRequiredProperties
+    ? getAllClassProperties(_class)
+    : getAllClassProperties(_class).filter(
+        (property) => property.multiplicity.lowerBound,
+      );
+  const complexPropertyTypes = properties
+    .filter((property) => !excludedProperties.includes(property.name))
+    .map((property) => property.genericType.value.rawType)
+    .filter(filterByType(Class));
+  if (complexPropertyTypes.length > 0) {
+    // we only count classes with complex properties in the cycle
+    __classesIndex.add(_class.path);
+  }
+  // we only check unique complex property classes; 2 same property classes on the same level do not count as a cycle
+  return Boolean(
+    Array.from(new Set(complexPropertyTypes)).find((type) =>
+      _classHasCycle(type, __classesIndex, options),
+    ),
+  );
+};
+
+export const classHasCycle = (
+  _class: Class,
+  options?: {
+    traverseNonRequiredProperties?: boolean | undefined;
+    excludedPaths?: Map<string, string[]> | undefined;
+  },
+): boolean => _classHasCycle(_class, new Set<string>(), options);

package/src/graph/helpers/PureLanguageHelper.ts

@@ -21,7 +21,7 @@ import {
   MULTIPLICITY_RANGE_OPERATOR,
   PRIMITIVE_TYPE,
 } from '../MetaModelConst.js';
-import type { ConcreteFunctionDefinition } from '../metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { ConcreteFunctionDefinition } from '../metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import type { Type } from '../metamodel/pure/packageableElements/domain/Type.js';
 import { PrimitiveType } from '../metamodel/pure/packageableElements/domain/PrimitiveType.js';
 import { Enumeration } from '../metamodel/pure/packageableElements/domain/Enumeration.js';
@@ -138,12 +138,14 @@ export const generateFunctionCallString = (
 
 export const generateFunctionPrettyName = (
   element: ConcreteFunctionDefinition,
-  fullPath: boolean,
+  options?: {
+    fullPath?: boolean;
+    spacing?: boolean;
+  },
 ): string =>
   `${
-    (fullPath ? element.package?.path + ELEMENT_PATH_DELIMITER : '') +
-    element.functionName
-  }(${element.parameters
+    options?.fullPath ? `${element.package?.path}${ELEMENT_PATH_DELIMITER}` : ''
+  }${element.functionName}(${element.parameters
     .map(
       (p) =>
         `${p.name}: ${p.type.value.name}[${generateMultiplicityString(
@@ -151,8 +153,14 @@ export const generateFunctionPrettyName = (
           p.multiplicity.upperBound,
         )}]`,
     )
-    .join(', ')})` +
-  `: ${element.returnType.value.name}[${generateMultiplicityString(
+    .join(', ')}): ${
+    element.returnType.value.name
+  }[${generateMultiplicityString(
     element.returnMultiplicity.lowerBound,
     element.returnMultiplicity.upperBound,
-  )}]`;
+  )}]`.replaceAll(/\s*/gu, (val) => {
+    if (options?.spacing) {
+      return val;
+    }
+    return '';
+  });

package/src/graph/metamodel/pure/packageableElements/PackageableElement.ts

@@ -27,7 +27,7 @@ import type { Profile } from './domain/Profile.js';
 import type { Enumeration } from './domain/Enumeration.js';
 import type { Class } from './domain/Class.js';
 import type { Association } from './domain/Association.js';
-import type { ConcreteFunctionDefinition } from './domain/ConcreteFunctionDefinition.js';
+import type { ConcreteFunctionDefinition } from './function/ConcreteFunctionDefinition.js';
 import type { FlatData } from './store/flatData/model/FlatData.js';
 import type { Mapping } from './mapping/Mapping.js';
 import type { Service } from './service/Service.js';
@@ -43,12 +43,16 @@ import type { DataElement } from './data/DataElement.js';
 import { AnnotatedElement } from './domain/AnnotatedElement.js';
 import type { ExecutionEnvironmentInstance } from './service/ExecutionEnvironmentInstance.js';
 import type { INTERNAL__UnknownPackageableElement } from './INTERNAL__UnknownPackageableElement.js';
+import type { INTERNAL__UnknownFunctionActivator } from './function/INTERNAL__UnknownFunctionActivator.js';
 
 export interface PackageableElementVisitor<T> {
   visit_PackageableElement(element: PackageableElement): T;
   visit_INTERNAL__UnknownPackageableElement(
     element: INTERNAL__UnknownPackageableElement,
   ): T;
+  visit_INTERNAL__UnknownFunctionActivator(
+    element: INTERNAL__UnknownFunctionActivator,
+  ): T;
 
   visit_SectionIndex(element: SectionIndex): T;
   visit_Package(element: Package): T;

package/src/graph/metamodel/pure/packageableElements/domain/PrimitiveType.ts

@@ -37,4 +37,5 @@ export class PrimitiveType extends DataType {
   static readonly DATETIME = new PrimitiveType(PRIMITIVE_TYPE.DATETIME);
   static readonly STRICTTIME = new PrimitiveType(PRIMITIVE_TYPE.STRICTTIME);
   static readonly LATESTDATE = new PrimitiveType(PRIMITIVE_TYPE.LATESTDATE);
+  static readonly BYTE = new PrimitiveType(PRIMITIVE_TYPE.BYTE);
 }

package/src/graph/metamodel/pure/packageableElements/{domain → function}/ConcreteFunctionDefinition.ts

@@ -18,13 +18,13 @@ import { type Hashable, hashArray } from '@finos/legend-shared';
 import {
   CORE_HASH_STRUCTURE,
   hashRawLambda,
-} from '../../../../../graph/Core_HashUtils.js';
+} from '../../../../Core_HashUtils.js';
 import type { PackageableElementVisitor } from '../PackageableElement.js';
 import type { RawVariableExpression } from '../../rawValueSpecification/RawVariableExpression.js';
-import type { Type } from './Type.js';
-import type { Multiplicity } from './Multiplicity.js';
+import type { Type } from '../domain/Type.js';
+import type { Multiplicity } from '../domain/Multiplicity.js';
 import type { PackageableElementReference } from '../PackageableElementReference.js';
-import { FunctionDefinition } from './Function.js';
+import { FunctionDefinition } from '../domain/Function.js';
 
 export class ConcreteFunctionDefinition
   extends FunctionDefinition

package/src/graph/metamodel/pure/packageableElements/function/FunctionActivator.ts

@@ -0,0 +1,33 @@
+/**
+ * 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 } from '@finos/legend-shared';
+import { PackageableElement } from '../PackageableElement.js';
+import type { PackageableElementReference } from '../PackageableElementReference.js';
+import type { ConcreteFunctionDefinition } from './ConcreteFunctionDefinition.js';
+
+export abstract class FunctionActivator
+  extends PackageableElement
+  implements Hashable
+{
+  /**
+   * This should be a reference to PackageableFunction but we haven't done that yet
+   * See https://github.com/finos/legend-studio/issues/1070
+   *
+   * @discrepancy model
+   */
+  function!: PackageableElementReference<ConcreteFunctionDefinition>;
+}

package/src/graph/metamodel/pure/packageableElements/function/INTERNAL__UnknownFunctionActivator.ts

@@ -0,0 +1,49 @@
+/**
+ * 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,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { FunctionActivator } from './FunctionActivator.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../Core_HashUtils.js';
+import type { PackageableElementVisitor } from '../PackageableElement.js';
+
+export class INTERNAL__UnknownFunctionActivator
+  extends FunctionActivator
+  implements Hashable
+{
+  content!: PlainObject;
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_FUNCTION_ACTIVATOR,
+      this.path,
+      this.function.valueForSerialization ?? '',
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_INTERNAL__UnknownFunctionActivator(this);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/mapping/INTERNAL__UnknownMappingInclude.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { hashArray, type PlainObject } from '@finos/legend-shared';
+import type { Mapping } from './Mapping.js';
+import { MappingInclude } from './MappingInclude.js';
+import { INTERNAL__PseudoMapping } from './INTERNAL__PseudoMapping.js';
+import { PackageableElementExplicitReference } from './../PackageableElementReference.js';
+import {
+  CORE_HASH_STRUCTURE,
+  hashObjectWithoutSourceInformation,
+} from '../../../../Core_HashUtils.js';
+
+export class INTERNAL__UnknownMappingInclude extends MappingInclude {
+  content!: PlainObject;
+
+  constructor(_OWNER: Mapping) {
+    const mappingReference = PackageableElementExplicitReference.create(
+      INTERNAL__PseudoMapping.INSTANCE,
+    );
+    super(_OWNER, mappingReference);
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.INTERNAL__UNKNOWN_MAPPING_INCLUDE,
+      hashObjectWithoutSourceInformation(this.content),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/mapping/MappingInclude.ts

@@ -14,31 +14,19 @@
  * limitations under the License.
  */
 
-import { hashArray, getNullableFirstEntry } from '@finos/legend-shared';
-import { CORE_HASH_STRUCTURE } from '../../../../../graph/Core_HashUtils.js';
+import { type Hashable } from '@finos/legend-shared';
 import type { PackageableElementReference } from '../PackageableElementReference.js';
 import type { Mapping } from './Mapping.js';
-import type { SubstituteStore } from './SubstituteStore.js';
 
-export class MappingInclude {
+export abstract class MappingInclude implements Hashable {
   readonly _OWNER: Mapping;
 
   included: PackageableElementReference<Mapping>;
-  storeSubstitutions: SubstituteStore[] = [];
 
-  constructor(owner: Mapping, included: PackageableElementReference<Mapping>) {
-    this._OWNER = owner;
+  constructor(_OWNER: Mapping, included: PackageableElementReference<Mapping>) {
+    this._OWNER = _OWNER;
     this.included = included;
   }
 
-  get hashCode(): string {
-    return hashArray([
-      CORE_HASH_STRUCTURE.MAPPING_INCLUDE,
-      this.included.valueForSerialization ?? '',
-      getNullableFirstEntry(this.storeSubstitutions)?.original
-        .valueForSerialization ?? '',
-      getNullableFirstEntry(this.storeSubstitutions)?.substitute
-        .valueForSerialization ?? '',
-    ]);
-  }
+  abstract get hashCode(): string;
 }

package/src/graph/metamodel/pure/packageableElements/mapping/MappingIncludeMapping.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { CORE_HASH_STRUCTURE } from '../../../../../graph/Core_HashUtils.js';
+import { hashArray, getNullableFirstEntry } from '@finos/legend-shared';
+import type { SubstituteStore } from './SubstituteStore.js';
+import { MappingInclude } from './MappingInclude.js';
+
+export class MappingIncludeMapping extends MappingInclude {
+  storeSubstitutions: SubstituteStore[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MAPPING_INCLUDE_MAPPING,
+      this.included.valueForSerialization ?? '',
+      getNullableFirstEntry(this.storeSubstitutions)?.original
+        .valueForSerialization ?? '',
+      getNullableFirstEntry(this.storeSubstitutions)?.substitute
+        .valueForSerialization ?? '',
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/mapping/SubstituteStore.ts

@@ -16,16 +16,16 @@
 
 import type { Store } from '../store/Store.js';
 import type { PackageableElementReference } from '../PackageableElementReference.js';
-import type { MappingInclude } from './MappingInclude.js';
+import type { MappingIncludeMapping } from './MappingIncludeMapping.js';
 
 export class SubstituteStore {
-  readonly _OWNER: MappingInclude;
+  readonly _OWNER: MappingIncludeMapping;
 
   original: PackageableElementReference<Store>;
   substitute: PackageableElementReference<Store>;
 
   constructor(
-    owner: MappingInclude,
+    owner: MappingIncludeMapping,
     original: PackageableElementReference<Store>,
     substitue: PackageableElementReference<Store>,
   ) {

package/src/graph/metamodel/pure/packageableElements/store/relational/connection/RelationalDatabaseConnection.ts

@@ -77,6 +77,12 @@ export class RelationalDatabaseConnection extends DatabaseConnection {
   authenticationStrategy: AuthenticationStrategy;
   postProcessors: PostProcessor[] = [];
 
+  /**
+   * HACKY: this is done to quickly add support for local connection
+   * See https://github.com/finos/legend-engine/pull/1807
+   */
+  localMode?: boolean | undefined;
+
   constructor(
     store: PackageableElementReference<Database>,
     type: string,
@@ -96,6 +102,7 @@ export class RelationalDatabaseConnection extends DatabaseConnection {
       this.quoteIdentifiers?.toString() ?? '',
       this.datasourceSpecification,
       this.authenticationStrategy,
+      this.localMode?.toString() ?? '',
       hashArray(this.postProcessors),
     ]);
   }

package/src/graph-manager/AbstractPureGraphManager.ts

@@ -98,6 +98,8 @@ import { EmbeddedFlatDataPropertyMapping } from '../graph/metamodel/pure/package
 import { EmbeddedRelationalInstanceSetImplementation } from '../graph/metamodel/pure/packageableElements/store/relational/mapping/EmbeddedRelationalInstanceSetImplementation.js';
 import type { SourceInformation } from './action/SourceInformation.js';
 import type { ClassifierPathMapping } from './action/protocol/ClassifierPathMapping.js';
+import type { FunctionActivatorConfiguration } from './action/functionActivator/FunctionActivatorConfiguration.js';
+import type { FunctionActivator } from '../graph/metamodel/pure/packageableElements/function/FunctionActivator.js';
 
 export interface TEMPORARY__EngineSetupConfig {
   env: string;
@@ -412,7 +414,7 @@ export abstract class AbstractPureGraphManager {
     graph: PureModel,
   ): Promise<SchemaSet[]>;
 
-  // ------------------------------------------- Import -------------------------------------------
+  // ------------------------------------------- Model Import -------------------------------------------
 
   abstract getExamplePureProtocolText(): string;
   abstract getExampleExternalFormatImportText(): string;
@@ -485,51 +487,6 @@ export abstract class AbstractPureGraphManager {
 
   abstract serializeExecutionNode(executionNode: ExecutionNode): object;
 
-  // ------------------------------------------- Service -------------------------------------------
-  /**
-   * @modularize
-   * See https://github.com/finos/legend-studio/issues/65
-   */
-
-  abstract registerService(
-    service: Service,
-    graph: PureModel,
-    groupId: string,
-    artifactId: string,
-    version: string | undefined,
-    server: string,
-    executionMode: ServiceExecutionMode,
-    options?: ServiceRegistrationOptions,
-  ): Promise<ServiceRegistrationSuccess>;
-  abstract bulkServiceRegistration(
-    service: Service[],
-    graph: PureModel,
-    groupId: string,
-    artifactId: string,
-    version: string | undefined,
-    server: string,
-    executionMode: ServiceExecutionMode,
-    options?: ServiceRegistrationOptions,
-  ): Promise<ServiceRegistrationResult[]>;
-  abstract activateService(
-    serviceUrl: string,
-    serviceId: string,
-  ): Promise<void>;
-  abstract TEMPORARY__deploySnowflakeService(
-    query: RawLambda,
-    graph: PureModel,
-  ): Promise<PlainObject>;
-
-  // ------------------------------------------- Database -------------------------------------------
-  /**
-   * @modularize
-   * See https://github.com/finos/legend-studio/issues/65
-   */
-
-  abstract buildDatabase(
-    databaseBuilderInput: DatabaseBuilderInput,
-  ): Promise<Entity[]>;
-
   // ------------------------------------------- Query -------------------------------------------
 
   abstract searchQueries(
@@ -571,6 +528,64 @@ export abstract class AbstractPureGraphManager {
     graphData: GraphData,
   ): Promise<DatasetEntitlementReport[]>;
 
+  /**
+   * TODO: Move this to store relational extension
+   *
+   * @modularize
+   * See https://github.com/finos/legend-studio/issues/65
+   */
+  abstract buildDatabase(
+    databaseBuilderInput: DatabaseBuilderInput,
+  ): Promise<Entity[]>;
+
+  // ------------------------------------------- Function -------------------------------------------
+
+  abstract getAvailableFunctionActivatorConfigurations(
+    coreModel: CoreModel,
+    systemModel: SystemModel,
+  ): Promise<FunctionActivatorConfiguration[]>;
+
+  abstract validateFunctionActivator(
+    functionActivator: FunctionActivator,
+    graphData: GraphData,
+  ): Promise<void>;
+
+  abstract publishFunctionActivatorToSandbox(
+    functionActivator: FunctionActivator,
+    graphData: GraphData,
+  ): Promise<void>;
+
+  // ------------------------------------------- Service -------------------------------------------
+  /**
+   * @modularize
+   * See https://github.com/finos/legend-studio/issues/65
+   */
+
+  abstract registerService(
+    service: Service,
+    graph: PureModel,
+    groupId: string,
+    artifactId: string,
+    version: string | undefined,
+    server: string,
+    executionMode: ServiceExecutionMode,
+    options?: ServiceRegistrationOptions,
+  ): Promise<ServiceRegistrationSuccess>;
+  abstract bulkServiceRegistration(
+    service: Service[],
+    graph: PureModel,
+    groupId: string,
+    artifactId: string,
+    version: string | undefined,
+    server: string,
+    executionMode: ServiceExecutionMode,
+    options?: ServiceRegistrationOptions,
+  ): Promise<ServiceRegistrationResult[]>;
+  abstract activateService(
+    serviceUrl: string,
+    serviceId: string,
+  ): Promise<void>;
+
   // ------------------------------------------- Change detection -------------------------------------------
 
   abstract buildHashesIndex(entities: Entity[]): Promise<Map<string, string>>;

package/src/graph-manager/GraphManagerState.ts

@@ -33,7 +33,7 @@ import type { Enumeration } from '../graph/metamodel/pure/packageableElements/do
 import type { Measure } from '../graph/metamodel/pure/packageableElements/domain/Measure.js';
 import type { Class } from '../graph/metamodel/pure/packageableElements/domain/Class.js';
 import type { Association } from '../graph/metamodel/pure/packageableElements/domain/Association.js';
-import type { ConcreteFunctionDefinition } from '../graph/metamodel/pure/packageableElements/domain/ConcreteFunctionDefinition.js';
+import type { ConcreteFunctionDefinition } from '../graph/metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import type { Store } from '../graph/metamodel/pure/packageableElements/store/Store.js';
 import type { Database } from '../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
 import type { Mapping } from '../graph/metamodel/pure/packageableElements/mapping/Mapping.js';

package/src/graph-manager/action/changeDetection/CoreObserverHelper.ts

@@ -74,7 +74,7 @@ export const observe_INTERNAL__UnknownPackageableElement = skipObserved(
     observe_Abstract_PackageableElement(metamodel);
 
     makeObservable(metamodel, {
-      content: observable,
+      content: observable.ref,
     });
 
     return metamodel;

package/src/graph-manager/action/changeDetection/DSL_Data_ObserverHelper.ts

@@ -99,7 +99,7 @@ const observe_RelationalCSVData = skipObserved(
 export const observe_INTERNAL__UnknownEmbeddedData = skipObserved(
   (metamodel: INTERNAL__UnknownEmbeddedData): INTERNAL__UnknownEmbeddedData => {
     makeObservable(metamodel, {
-      content: observable,
+      content: observable.ref,
     });
 
     return metamodel;