@finos/legend-graph 0.2.2 → 0.3.1

package/src/graphManager/action/SourceInformationHelper.ts

@@ -17,7 +17,9 @@
 import { assertTrue } from '@finos/legend-shared';
 import type { SourceInformation } from './SourceInformation';
 
-const COORDINATE_DELIMITER = '__';
+// NOTE: @ is chosen because it is not part of identifier token in Pure grammar
+// TODO: handle the case of quote identifier e.g. model::something::'I have an @ in me'
+const COORDINATE_DELIMITER = '@';
 
 export const extractSourceInformationCoordinates = (
   sourceInformation: SourceInformation | undefined,

package/src/graphManager/action/query/Query.ts

@@ -18,6 +18,17 @@ import type { Mapping } from '../../../models/metamodels/pure/packageableElement
 import type { PackageableElementReference } from '../../../models/metamodels/pure/packageableElements/PackageableElementReference';
 import type { PackageableRuntime } from '../../../models/metamodels/pure/packageableElements/runtime/PackageableRuntime';
 
+export class QueryTaggedValue {
+  profile!: string;
+  tag!: string;
+  value!: string;
+}
+
+export class QueryStereotype {
+  profile!: string;
+  stereotype!: string;
+}
+
 export class Query {
   name!: string;
   id!: string;
@@ -30,6 +41,10 @@ export class Query {
   // if not owner is specified, any user can own the query
   // NOTE: the owner is managed automatically by the backend
   owner?: string | undefined;
+  // NOTE: these are different from metamodel tagged values and stereotypes
+  // because we don't process them
+  taggedValues?: QueryTaggedValue[] | undefined;
+  stereotypes?: QueryStereotype[] | undefined;
   // Store query in text to be more compact and stable
   content!: string;
 

package/src/graphManager/action/query/QuerySearchSpecification.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { QueryStereotype, QueryTaggedValue } from './Query';
+
+export class QueryProjectCoordinates {
+  groupId!: string;
+  artifactId!: string;
+}
+
+export class QuerySearchSpecification {
+  searchTerm?: string | undefined;
+  projectCoordinates?: QueryProjectCoordinates[] | undefined;
+  taggedValues?: QueryTaggedValue[] | undefined;
+  stereotypes?: QueryStereotype[] | undefined;
+  limit?: number | undefined;
+  showCurrentUserQueriesOnly?: boolean | undefined;
+}

package/src/helpers/DomainHelper.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 { PureModel } from '../graph/PureModel';
+import { Class } from '../models/metamodels/pure/packageableElements/domain/Class';
+import { CORE_ELEMENT_PATH, MILESTONING_STEROTYPES } from '../MetaModelConst';
+
+export const getMilestoneTemporalStereotype = (
+  val: Class,
+  graph: PureModel,
+): MILESTONING_STEROTYPES | undefined => {
+  const milestonedProfile = graph.getProfile(
+    CORE_ELEMENT_PATH.PROFILE_TEMPORAL,
+  );
+  let stereotype;
+  const profile = val.stereotypes.find(
+    (e) => e.ownerReference.value === milestonedProfile,
+  );
+  stereotype = Object.values(MILESTONING_STEROTYPES).find(
+    (e) => e === profile?.value.value,
+  );
+  if (stereotype !== undefined) {
+    return stereotype;
+  }
+  val.generalizations.forEach((e) => {
+    const superType = e.value.rawType;
+    if (superType instanceof Class) {
+      const milestonedStereotype = getMilestoneTemporalStereotype(
+        superType,
+        graph,
+      );
+      if (milestonedStereotype !== undefined) {
+        stereotype = Object.values(MILESTONING_STEROTYPES).find(
+          (e) => e === milestonedStereotype,
+        );
+      }
+    }
+  });
+  return stereotype;
+};

package/src/index.ts

@@ -145,6 +145,7 @@ export * from './helpers/MappingHelper';
 export * from './helpers/MappingResolutionHelper';
 export * from './helpers/ValidationHelper';
 export * from './helpers/Stubable'; // TODO: to be removed
+export * from './helpers/DomainHelper';
 
 // --------------------------------------------- GRAPH --------------------------------------------------
 
@@ -179,6 +180,7 @@ export {
 export * from './graphManager/action/execution/ExecutionResultHelper';
 export * from './graphManager/PureGraphManagerPlugin';
 export * from './graphManager/action/query/Query';
+export * from './graphManager/action/query/QuerySearchSpecification';
 export * from './graphManager/action/EngineError';
 export * from './graphManager/action/SourceInformationHelper';
 export * from './graphManager/action/generation/ImportConfigurationDescription';
@@ -217,10 +219,7 @@ export { V1_rawLambdaModelSchema } from './models/protocols/pure/v1/transformati
 export { V1_transformPropertyReference } from './models/protocols/pure/v1/transformation/pureGraph/from/V1_MappingTransformer';
 export { V1_EngineServerClient } from './models/protocols/pure/v1/engine/V1_EngineServerClient';
 export { V1_Engine } from './models/protocols/pure/v1/engine/V1_Engine';
-export {
-  V1_pureModelContextDataPropSchema,
-  V1_deserializePureModelContextData as V1_jsonToPureModelContextData,
-} from './models/protocols/pure/v1/transformation/pureProtocol/V1_PureProtocolSerialization';
+export { V1_deserializePureModelContextData as V1_jsonToPureModelContextData } from './models/protocols/pure/v1/transformation/pureProtocol/V1_PureProtocolSerialization';
 export {
   V1_propertyPointerModelSchema,
   V1_stereotypePtrSchema,

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

@@ -174,6 +174,7 @@ export class SnowflakeDatasourceSpecification
   nonProxyHosts?: string | undefined;
   organization?: string | undefined;
   accountType?: string | undefined;
+  role?: string | undefined;
 
   constructor(
     accountName: string,
@@ -195,6 +196,7 @@ export class SnowflakeDatasourceSpecification
       nonProxyHosts: observable,
       organization: observable,
       accountType: observable,
+      role: observable,
       hashCode: computed,
       setAccountName: action,
       setRegion: action,
@@ -206,6 +208,7 @@ export class SnowflakeDatasourceSpecification
       setNonProxyHosts: action,
       setOrganization: action,
       setAccountType: action,
+      setRole: action,
       setQuotedIdentifiersIgnoreCase: action,
     });
 
@@ -259,6 +262,10 @@ export class SnowflakeDatasourceSpecification
     this.accountType = val;
   }
 
+  setRole(val: string | undefined): void {
+    this.role = val;
+  }
+
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.SNOWFLAKE_DATASOURCE_SPECIFICATION,
@@ -272,6 +279,7 @@ export class SnowflakeDatasourceSpecification
       this.nonProxyHosts ?? '',
       this.organization ?? '',
       this.accountType ?? '',
+      this.role ?? '',
       this.quotedIdentifiersIgnoreCase?.toString() ?? '',
     ]);
   }

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

@@ -29,6 +29,7 @@ import type { V1_GraphBuilderContext } from './v1/transformation/pureGraph/to/V1
 import type { V1_ProcessingContext } from './v1/transformation/pureGraph/to/helpers/V1_ProcessingContext';
 import type { SimpleFunctionExpression } from '../../metamodels/pure/valueSpecification/SimpleFunctionExpression';
 import type { ValueSpecification } from '../../metamodels/pure/valueSpecification/ValueSpecification';
+import type { GraphPluginManager } from '../../../GraphPluginManager';
 
 export type V1_ElementProtocolClassifierPathGetter = (
   protocol: V1_PackageableElement,
@@ -76,6 +77,10 @@ export type V1_ExecutionInputGetter = (
 export abstract class PureProtocolProcessorPlugin extends AbstractPlugin {
   private readonly _$nominalTypeBrand!: 'PureProtocolProcessorPlugin';
 
+  install(pluginManager: GraphPluginManager): void {
+    pluginManager.registerPureProtocolProcessorPlugin(this);
+  }
+
   /**
    * Get the list of supported system element models.
    *

package/src/models/protocols/pure/v1/V1_Core_SystemModels.json

@@ -19,6 +19,13 @@
       "name": "doc",
       "tags": ["doc", "todo"]
     },
+    {
+      "stereotypes": ["bitemporal", "businesstemporal", "processingtemporal"],
+      "package": "meta::pure::profiles",
+      "_type": "profile",
+      "name": "temporal",
+      "tags": []
+    },
     {
       "package": "meta::pure::metamodel::type",
       "_type": "class",

package/src/models/protocols/pure/v1/V1_PureGraphManager.ts

@@ -28,9 +28,9 @@ import type {
   Log,
   PlainObject,
   ServerClientConfig,
-  TracerServicePlugin,
 } from '@finos/legend-shared';
 import {
+  TracerService,
   LogEvent,
   getClass,
   guaranteeNonNullable,
@@ -192,6 +192,7 @@ import {
   V1_transformQuery,
   V1_buildGenerationOutput,
   V1_buildLightQuery,
+  V1_transformQuerySearchSpecification,
 } from './engine/V1_EngineHelper';
 import { V1_buildExecutionResult } from './engine/V1_ExecutionHelper';
 import type { Entity } from '@finos/legend-model-storage';
@@ -203,6 +204,7 @@ import {
 } from '../../../../graphManager/GraphManagerUtils';
 import { PackageableElementReference } from '../../../metamodels/pure/packageableElements/PackageableElementReference';
 import type { GraphPluginManager } from '../../../../GraphPluginManager';
+import type { QuerySearchSpecification } from '../../../../graphManager/action/query/QuerySearchSpecification';
 
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 
@@ -407,14 +409,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   *initialize(
     config: TEMP__EngineSetupConfig,
-    options: {
-      tracerServicePlugins?: TracerServicePlugin<unknown>[] | undefined;
+    options?: {
+      tracerService?: TracerService | undefined;
     },
   ): GeneratorFn<void> {
     this.engine = new V1_Engine(config.clientConfig, this.log);
     this.engine
       .getEngineServerClient()
-      .registerTracerServicePlugins(options.tracerServicePlugins ?? []);
+      .setTracerService(options?.tracerService ?? new TracerService());
     yield this.engine.setup(config);
   }
 
@@ -2039,13 +2041,14 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
 
   // --------------------------------------------- Query ---------------------------------------------
 
-  async getQueries(options?: {
-    search?: string | undefined;
-    projectCoordinates?: string[] | undefined;
-    showCurrentUserQueriesOnly?: boolean | undefined;
-    limit?: number | undefined;
-  }): Promise<LightQuery[]> {
-    return (await this.engine.getQueries(options)).map((protocol) =>
+  async searchQueries(
+    searchSpecification: QuerySearchSpecification,
+  ): Promise<LightQuery[]> {
+    return (
+      await this.engine.searchQueries(
+        V1_transformQuerySearchSpecification(searchSpecification),
+      )
+    ).map((protocol) =>
       V1_buildLightQuery(
         protocol,
         this.engine.getEngineServerClient().currentUserId,

package/src/models/protocols/pure/v1/engine/V1_Engine.ts

@@ -84,6 +84,8 @@ import type { V1_PureModelContext } from '../model/context/V1_PureModelContext';
 import { ServiceExecutionMode } from '../../../../../graphManager/action/service/ServiceExecutionMode';
 import { serialize } from 'serializr';
 import { V1_ExecutionError } from './execution/V1_ExecutionError';
+import { V1_PureModelContextText } from '../model/context/V1_PureModelContextText';
+import { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification';
 
 class V1_EngineConfig extends TEMP__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -471,12 +473,19 @@ export class V1_Engine {
     generationMode: GenerationMode,
     model: V1_PureModelContextData,
   ): Promise<V1_GenerationOutput[]> {
+    // NOTE: here instead of sending PureModelContextData, we send PureModelContextText so
+    // engine can convert that back to PureModelContextData to obtain source information
+    // as some generator uses that info. Sending PureModelContextData with source information
+    // from the front end to engine would take up a lot of bandwidth.
+    const textModel = new V1_PureModelContextText();
+    textModel.serializer = model.serializer;
+    textModel.code = await this.pureModelContextDataToPureCode(model);
     return (
       await this.engineServerClient.generateFile(
         generationMode,
         type,
         V1_GenerateFileInput.serialization.toJson(
-          new V1_GenerateFileInput(model, configs),
+          new V1_GenerateFileInput(textModel, configs),
         ),
       )
     ).map((output) => V1_GenerationOutput.serialization.fromJson(output));
@@ -573,15 +582,14 @@ export class V1_Engine {
 
   // ------------------------------------------- Query -------------------------------------------
 
-  async getQueries(options?: {
-    search?: string | undefined;
-    projectCoordinates?: string[] | undefined;
-    showCurrentUserQueriesOnly?: boolean | undefined;
-    limit?: number | undefined;
-  }): Promise<V1_LightQuery[]> {
-    return (await this.engineServerClient.getQueries(options)).map((query) =>
-      V1_LightQuery.serialization.fromJson(query),
-    );
+  async searchQueries(
+    searchSpecification: V1_QuerySearchSpecification,
+  ): Promise<V1_LightQuery[]> {
+    return (
+      await this.engineServerClient.searchQueries(
+        V1_QuerySearchSpecification.serialization.toJson(searchSpecification),
+      )
+    ).map((query) => V1_LightQuery.serialization.fromJson(query));
   }
 
   async getQuery(queryId: string): Promise<V1_Query> {
@@ -592,13 +600,18 @@ export class V1_Engine {
 
   async createQuery(query: V1_Query): Promise<V1_Query> {
     return V1_Query.serialization.fromJson(
-      await this.engineServerClient.createQuery(query),
+      await this.engineServerClient.createQuery(
+        V1_Query.serialization.toJson(query),
+      ),
     );
   }
 
   async updateQuery(query: V1_Query): Promise<V1_Query> {
     return V1_Query.serialization.fromJson(
-      await this.engineServerClient.updateQuery(query.id, query),
+      await this.engineServerClient.updateQuery(
+        query.id,
+        V1_Query.serialization.toJson(query),
+      ),
     );
   }
 

package/src/models/protocols/pure/v1/engine/V1_EngineHelper.ts

@@ -14,10 +14,15 @@
  * limitations under the License.
  */
 
-import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  guaranteeNonEmptyString,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
 import {
   LightQuery,
   Query,
+  QueryStereotype,
+  QueryTaggedValue,
 } from '../../../../../graphManager/action/query/Query';
 import type { V1_LightQuery } from './query/V1_Query';
 import { V1_Query } from './query/V1_Query';
@@ -52,6 +57,14 @@ import type { V1_SourceInformation } from '../model/V1_SourceInformation';
 import { SourceInformation } from '../../../../../graphManager/action/SourceInformation';
 import { ExecutionError } from '../../../../../graphManager/action/ExecutionError';
 import type { V1_ExecutionError } from './execution/V1_ExecutionError';
+import type { QuerySearchSpecification } from '../../../../../graphManager/action/query/QuerySearchSpecification';
+import {
+  V1_QueryProjectCoordinates,
+  V1_QuerySearchSpecification,
+} from './query/V1_QuerySearchSpecification';
+import { V1_TaggedValue } from '../model/packageableElements/domain/V1_TaggedValue';
+import { V1_TagPtr } from '../model/packageableElements/domain/V1_TagPtr';
+import { V1_StereotypePtr } from '../model/packageableElements/domain/V1_StereotypePtr';
 
 export const V1_buildLightQuery = (
   protocol: V1_LightQuery,
@@ -133,6 +146,38 @@ export const V1_buildQuery = (
   metamodel.owner = protocol.owner;
   metamodel.isCurrentUserQuery =
     currentUserId !== undefined && protocol.owner === currentUserId;
+
+  // NOTE: we don't properly process tagged values and stereotypes for query
+  // because these profiles/tags/stereotypes can come from external systems.
+  metamodel.taggedValues = protocol.taggedValues?.map((taggedValueProtocol) => {
+    const taggedValue = new QueryTaggedValue();
+    taggedValue.profile = guaranteeNonEmptyString(
+      taggedValueProtocol.tag.profile,
+      `Tagged value 'tag.profile' field is missing or empty`,
+    );
+    taggedValue.tag = guaranteeNonEmptyString(
+      taggedValueProtocol.tag.value,
+      `Tagged value 'tag.value' field is missing or empty`,
+    );
+    taggedValue.value = guaranteeNonEmptyString(
+      taggedValueProtocol.value,
+      `Tagged value 'value' field is missing or empty`,
+    );
+    return taggedValue;
+  });
+  metamodel.stereotypes = protocol.stereotypes?.map((stereotypeProtocol) => {
+    const stereotype = new QueryStereotype();
+    stereotype.profile = guaranteeNonEmptyString(
+      stereotypeProtocol.profile,
+      `Stereotype pointer 'profile' field is missing or empty`,
+    );
+    stereotype.stereotype = guaranteeNonEmptyString(
+      stereotypeProtocol.value,
+      `Stereotype pointer 'value' field is missing or empty`,
+    );
+    return stereotype;
+  });
+
   return metamodel;
 };
 
@@ -148,6 +193,52 @@ export const V1_transformQuery = (metamodel: Query): V1_Query => {
   protocol.runtime = metamodel.runtime.valueForSerialization ?? '';
   protocol.content = metamodel.content;
   protocol.owner = metamodel.owner;
+  protocol.taggedValues = metamodel.taggedValues?.map((_taggedValue) => {
+    const taggedValue = new V1_TaggedValue();
+    taggedValue.tag = new V1_TagPtr();
+    taggedValue.tag.profile = _taggedValue.profile;
+    taggedValue.tag.value = _taggedValue.tag;
+    taggedValue.value = _taggedValue.value;
+    return taggedValue;
+  });
+  protocol.stereotypes = metamodel.stereotypes?.map((_stereotype) => {
+    const stereotype = new V1_StereotypePtr();
+    stereotype.profile = _stereotype.profile;
+    stereotype.value = _stereotype.stereotype;
+    return stereotype;
+  });
+  return protocol;
+};
+
+export const V1_transformQuerySearchSpecification = (
+  metamodel: QuerySearchSpecification,
+): V1_QuerySearchSpecification => {
+  const protocol = new V1_QuerySearchSpecification();
+  protocol.searchTerm = metamodel.searchTerm;
+  protocol.limit = metamodel.limit;
+  protocol.showCurrentUserQueriesOnly = metamodel.showCurrentUserQueriesOnly;
+  protocol.projectCoordinates = metamodel.projectCoordinates?.map(
+    (_projectCoordinate) => {
+      const projectCoordinate = new V1_QueryProjectCoordinates();
+      projectCoordinate.groupId = _projectCoordinate.groupId;
+      projectCoordinate.artifactId = _projectCoordinate.artifactId;
+      return projectCoordinate;
+    },
+  );
+  protocol.taggedValues = metamodel.taggedValues?.map((_taggedValue) => {
+    const taggedValue = new V1_TaggedValue();
+    taggedValue.tag = new V1_TagPtr();
+    taggedValue.tag.profile = _taggedValue.profile;
+    taggedValue.tag.value = _taggedValue.tag;
+    taggedValue.value = _taggedValue.value;
+    return taggedValue;
+  });
+  protocol.stereotypes = metamodel.stereotypes?.map((_stereotype) => {
+    const stereotype = new V1_StereotypePtr();
+    stereotype.profile = _stereotype.profile;
+    stereotype.value = _stereotype.stereotype;
+    return stereotype;
+  });
   return protocol;
 };
 

package/src/models/protocols/pure/v1/engine/V1_EngineServerClient.ts

@@ -45,6 +45,7 @@ import type { V1_ExecutionPlan } from '../model/executionPlan/V1_ExecutionPlan';
 import type { V1_LightQuery, V1_Query } from './query/V1_Query';
 import type { V1_ServiceStorage } from './service/V1_ServiceStorage';
 import type { GenerationMode } from '../../../../../graphManager/action/generation/GenerationConfigurationDescription';
+import type { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification';
 
 enum CORE_ENGINE_TRACER_SPAN {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -393,21 +394,15 @@ export class V1_EngineServerClient extends AbstractServerClient {
     `${this.queryBaseUrl ?? this.networkClient.baseUrl}/pure/v1/query${
       queryId ? `/${encodeURIComponent(queryId)}` : ''
     }`;
-  getQueries = (options?: {
-    search?: string | undefined;
-    projectCoordinates?: string[] | undefined;
-    showCurrentUserQueriesOnly?: boolean | undefined;
-    limit?: number | undefined;
-  }): Promise<PlainObject<V1_LightQuery>[]> =>
-    this.get(this._query(), undefined, undefined, {
-      search: options?.search,
-      projectCoordinates: options?.projectCoordinates,
-      showCurrentUserQueriesOnly: options?.showCurrentUserQueriesOnly,
-      limit: options?.limit,
-    });
+  searchQueries = (
+    searchSpecification: PlainObject<V1_QuerySearchSpecification>,
+  ): Promise<PlainObject<V1_LightQuery>[]> =>
+    this.post(`${this._query()}/search`, searchSpecification, undefined);
   getQuery = (queryId: string): Promise<PlainObject<V1_Query>> =>
     this.get(this._query(queryId));
-  createQuery = (query: V1_Query): Promise<PlainObject<V1_Query>> =>
+  createQuery = (
+    query: PlainObject<V1_Query>,
+  ): Promise<PlainObject<V1_Query>> =>
     this.postWithTracing(
       this.getTraceData(CORE_ENGINE_TRACER_SPAN.CREATE_QUERY),
       this._query(),
@@ -415,7 +410,7 @@ export class V1_EngineServerClient extends AbstractServerClient {
     );
   updateQuery = (
     queryId: string,
-    query: V1_Query,
+    query: PlainObject<V1_Query>,
   ): Promise<PlainObject<V1_Query>> =>
     this.putWithTracing(
       this.getTraceData(CORE_ENGINE_TRACER_SPAN.UPDATE_QUERY),

package/src/models/protocols/pure/v1/engine/execution/V1_ExecuteInput.ts

@@ -17,16 +17,16 @@
 import {
   createModelSchema,
   custom,
+  object,
   optional,
   primitive,
   SKIP,
 } from 'serializr';
 import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
-import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData';
+import { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData';
 import type { V1_Runtime } from '../../model/packageableElements/runtime/V1_Runtime';
 import type { V1_RawExecutionContext } from '../../model/rawValueSpecification/V1_RawExecutionContext';
 import type { V1_RawLambda } from '../../model/rawValueSpecification/V1_RawLambda';
-import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization';
 import { V1_serializeRuntime } from '../../transformation/pureProtocol/serializationHelpers/V1_RuntimeSerializationHelper';
 import {
   V1_rawBaseExecutionContextModelSchema,
@@ -46,7 +46,7 @@ export class V1_ExecuteInput {
       clientVersion: optional(primitive()),
       function: usingModelSchema(V1_rawLambdaModelSchema),
       mapping: primitive(),
-      model: V1_pureModelContextDataPropSchema,
+      model: object(V1_PureModelContextData),
       runtime: custom(
         (val) => V1_serializeRuntime(val),
         () => SKIP,

package/src/models/protocols/pure/v1/engine/generation/V1_FileGenerationInput.ts

@@ -16,17 +16,17 @@
 
 import { createModelSchema, optional, primitive, raw } from 'serializr';
 import { SerializationFactory } from '@finos/legend-shared';
-import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData';
-import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization';
+import { V1_pureModelContextPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization';
 import { PureClientVersion } from '../../../../../../graphManager/GraphManagerUtils';
+import type { V1_PureModelContext } from '../../model/context/V1_PureModelContext';
 
 export class V1_GenerateFileInput {
   clientVersion?: string | undefined;
-  model: V1_PureModelContextData;
+  model: V1_PureModelContext;
   config?: Record<PropertyKey, unknown> | undefined;
 
   constructor(
-    model: V1_PureModelContextData,
+    model: V1_PureModelContext,
     config?: Record<PropertyKey, unknown>,
   ) {
     this.clientVersion = PureClientVersion.V1_0_0;
@@ -37,7 +37,7 @@ export class V1_GenerateFileInput {
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_GenerateFileInput, {
       clientVersion: optional(primitive()),
-      model: V1_pureModelContextDataPropSchema,
+      model: V1_pureModelContextPropSchema,
       config: raw(),
     }),
   );

package/src/models/protocols/pure/v1/engine/grammar/V1_JsonToGrammarInput.ts

@@ -14,12 +14,11 @@
  * limitations under the License.
  */
 
-import { createModelSchema, optional, primitive } from 'serializr';
+import { createModelSchema, object, optional, primitive } from 'serializr';
 import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
 import { V1_ParserError } from '../../engine/grammar/V1_ParserError';
 import { V1_LambdaInput } from './V1_LambdaInput';
-import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData';
-import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization';
+import { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData';
 
 export enum V1_RenderStyle {
   STANDARD = 'STANDARD',
@@ -35,7 +34,7 @@ export class V1_JsonToGrammarInput {
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_JsonToGrammarInput, {
-      modelDataContext: V1_pureModelContextDataPropSchema,
+      modelDataContext: optional(object(V1_PureModelContextData)),
       isolatedLambdas: usingModelSchema(V1_LambdaInput.serialization.schema),
       renderStyle: optional(primitive()),
       codeError: usingModelSchema(V1_ParserError.serialization.schema),