@finos/legend-graph 32.3.37 → 32.3.39

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/lakehouse/V1_ConsumerEntitlementsSerializationHelper.ts

@@ -0,0 +1,394 @@
+/**
+ * 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 {
+  customListWithSchema,
+  optionalCustomListWithSchema,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  optional,
+  primitive,
+  serialize,
+} from 'serializr';
+import {
+  type V1_ContractUserEventPayload,
+  V1_ContractEventPayloadType,
+  V1_ContractUserEventDataProducerPayload,
+  V1_ContractUserEventPrivilegeManagerPayload,
+  V1_ContractUserEventRecord,
+  V1_CreateContractPayload,
+  V1_DataContract,
+  V1_DataContractSubscriptions,
+  V1_DataContractsResponse,
+  V1_PendingTasksResponse,
+  V1_TaskMetadata,
+  V1_TaskResponse,
+  V1_TaskStatusChangeResponse,
+  V1_ContractUserStatusResponse,
+  V1_LiteDataContractsResponse,
+  V1_LiteDataContract,
+  V1_DataContractApprovedUsersResponse,
+  V1_TerminalOrderItem,
+  V1_TerminalProvisionPayload,
+  V1_LiteDataContractWithUserStatus,
+  V1_LiteDataContractsPaginatedResponse,
+} from '../../../../lakehouse/entitlements/V1_ConsumerEntitlements.js';
+import type { PureProtocolProcessorPlugin } from '../../../../../PureProtocolProcessorPlugin.js';
+import {
+  V1_UserModelSchema,
+  V1_paginationMetadataRecordModelSchema,
+  V1_serializeOrganizationalScope,
+  V1_deserializeOrganizationalScope,
+  V1_contractUserMembershipModelSchema,
+  V1_deseralizeConsumerEntitlementResource,
+  V1_seralizeConsumerEntitlementResource,
+} from './V1_CoreEntitlementsSerializationHelper.js';
+import { V1_pendingTaskWithAssigneesModelSchema } from './V1_EntitlementsTasksSerializationHelper.js';
+import { V1_dataSubscriptionModelSchema } from './V1_SubscriptionSerializationHelper.js';
+
+export const V1_dataContractModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_DataContract, {
+    description: primitive(),
+    guid: primitive(),
+    version: primitive(),
+    state: primitive(),
+    resource: custom(
+      V1_seralizeConsumerEntitlementResource,
+      V1_deseralizeConsumerEntitlementResource,
+    ),
+    members: optional(
+      list(usingModelSchema(V1_contractUserMembershipModelSchema)),
+    ),
+    consumer: custom(
+      (val) => V1_serializeOrganizationalScope(val, plugins),
+      (val) => V1_deserializeOrganizationalScope(val, plugins),
+    ),
+    createdBy: primitive(),
+    createdAt: primitive(),
+  });
+
+export const V1_dataContractSubscriptionsModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_DataContractSubscriptions, {
+    dataContract: usingModelSchema(V1_dataContractModelSchema(plugins)),
+    subscriptions: optional(
+      list(usingModelSchema(V1_dataSubscriptionModelSchema)),
+    ),
+  });
+
+export const V1_liteDataContractModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_LiteDataContract, {
+    description: primitive(),
+    guid: primitive(),
+    version: primitive(),
+    state: primitive(),
+    members: optional(
+      list(usingModelSchema(V1_contractUserMembershipModelSchema)),
+    ),
+    consumer: custom(
+      (val) => V1_serializeOrganizationalScope(val, plugins),
+      (val) => V1_deserializeOrganizationalScope(val, plugins),
+    ),
+    createdAt: primitive(),
+    createdBy: primitive(),
+    resourceId: primitive(),
+    resourceType: primitive(),
+    deploymentId: primitive(),
+    accessPointGroup: optional(primitive()),
+  });
+
+export const V1_dataContractsResponseModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_DataContractsResponse, {
+    dataContracts: optional(
+      customListWithSchema(V1_dataContractSubscriptionsModelSchema(plugins)),
+    ),
+    subscriptions: optional(
+      customListWithSchema(V1_dataSubscriptionModelSchema),
+    ),
+  });
+
+const V1_liteDataContractsResponseModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_LiteDataContractsResponse, {
+    dataContracts: optional(
+      customListWithSchema(V1_liteDataContractModelSchema(plugins)),
+    ),
+  });
+
+export const V1_liteDataContractsPaginatedResponseModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_LiteDataContractsPaginatedResponse, {
+    liteDataContractsResponse: usingModelSchema(
+      V1_liteDataContractsResponseModelSchema(plugins),
+    ),
+    paginationMetadataRecord: usingModelSchema(
+      V1_paginationMetadataRecordModelSchema,
+    ),
+  });
+
+export const V1_liteDataContractWithUserStatusModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_LiteDataContractWithUserStatus, {
+    contractResultLite: usingModelSchema(
+      V1_liteDataContractModelSchema(plugins),
+    ),
+    status: primitive(),
+    pendingTaskWithAssignees: optional(
+      usingModelSchema(V1_pendingTaskWithAssigneesModelSchema),
+    ),
+    user: primitive(),
+  });
+
+export const V1_contractUserEventPrivilegeManagerPayloadModelSchema =
+  createModelSchema(V1_ContractUserEventPrivilegeManagerPayload, {
+    type: primitive(),
+    managerIdentity: primitive(),
+    candidateIdentity: primitive(),
+    taskId: primitive(),
+    eventTimestamp: primitive(),
+  });
+
+export const V1_contractUserEventDataProducerPayloadModelSchema =
+  createModelSchema(V1_ContractUserEventDataProducerPayload, {
+    type: primitive(),
+    dataProducerIdentity: primitive(),
+    candidateIdentity: primitive(),
+    taskId: primitive(),
+    eventTimestamp: primitive(),
+  });
+
+const V1_deserializeContractUserEventPayload = (
+  json: PlainObject<V1_ContractUserEventPayload>,
+): V1_ContractUserEventPayload => {
+  if (
+    [
+      V1_ContractEventPayloadType.DATA_PRODUCER_APPROVED,
+      V1_ContractEventPayloadType.DATA_PRODUCER_REJECTED,
+    ].includes((json as unknown as V1_ContractUserEventPayload).type)
+  ) {
+    return deserialize(
+      V1_contractUserEventDataProducerPayloadModelSchema,
+      json,
+    );
+  } else {
+    return deserialize(
+      V1_contractUserEventPrivilegeManagerPayloadModelSchema,
+      json,
+    );
+  }
+};
+
+const V1_serializeContractUserEventPayload = (
+  payload: V1_ContractUserEventPayload,
+): PlainObject<V1_ContractUserEventPayload> => {
+  if (payload instanceof V1_ContractUserEventDataProducerPayload) {
+    return serialize(
+      V1_contractUserEventDataProducerPayloadModelSchema,
+      payload,
+    );
+  } else {
+    return serialize(
+      V1_contractUserEventPrivilegeManagerPayloadModelSchema,
+      payload,
+    );
+  }
+};
+
+export const V1_contractUserEventRecordModelSchema = createModelSchema(
+  V1_ContractUserEventRecord,
+  {
+    taskId: primitive(),
+    dataContractId: primitive(),
+    status: primitive(),
+    consumer: primitive(),
+    eventPayload: custom(
+      V1_serializeContractUserEventPayload,
+      V1_deserializeContractUserEventPayload,
+    ),
+    type: primitive(),
+    effectiveFrom: primitive(),
+    effectiveTo: primitive(),
+    isEscalated: primitive(),
+  },
+);
+export const V1_taskMetadataModelSchema = createModelSchema(V1_TaskMetadata, {
+  rec: usingModelSchema(V1_contractUserEventRecordModelSchema),
+  assignees: list(primitive()),
+});
+
+export const V1_taskResponseModelSchema = createModelSchema(V1_TaskResponse, {
+  tasks: customListWithSchema(V1_taskMetadataModelSchema),
+});
+
+export const V1_pendingTasksResponseModelSchema = createModelSchema(
+  V1_PendingTasksResponse,
+  {
+    privilegeManager: customListWithSchema(
+      V1_contractUserEventRecordModelSchema,
+    ),
+    dataOwner: customListWithSchema(V1_contractUserEventRecordModelSchema),
+  },
+);
+
+export const V1_TaskStatusChangeResponseModelSchema = createModelSchema(
+  V1_TaskStatusChangeResponse,
+  {
+    status: primitive(),
+    errorType: primitive(),
+    errorMessage: primitive(),
+  },
+);
+
+export const V1_deserializeDataContractResponse = (
+  json: PlainObject<V1_DataContractsResponse>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_DataContractSubscriptions[] => {
+  const contracts = deserialize(
+    V1_dataContractsResponseModelSchema(plugins),
+    json,
+  );
+  return contracts.dataContracts ?? [];
+};
+
+export const V1_deserializeLiteDataContractsPaginatedResponse = (
+  json: PlainObject<V1_LiteDataContractsResponse>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_LiteDataContractsPaginatedResponse => {
+  return deserialize(
+    V1_liteDataContractsPaginatedResponseModelSchema(plugins),
+    json,
+  );
+};
+
+export const V1_liteDataContractsResponseModelSchemaToContracts = (
+  json: PlainObject<V1_LiteDataContractsResponse>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_LiteDataContract[] => {
+  const contracts = deserialize(
+    V1_liteDataContractsResponseModelSchema(plugins),
+    json,
+  );
+  return contracts.dataContracts ?? [];
+};
+
+export const V1_deserializeTaskResponse = (
+  json: PlainObject<V1_TaskResponse>,
+): V1_TaskMetadata[] => {
+  return deserialize(V1_taskResponseModelSchema, json).tasks ?? [];
+};
+
+export const V1_createContractPayloadModelSchema = (
+  plugins: PureProtocolProcessorPlugin[],
+) =>
+  createModelSchema(V1_CreateContractPayload, {
+    description: primitive(),
+    resourceId: primitive(),
+    resourceType: primitive(),
+    deploymentId: primitive(),
+    accessPointGroup: optional(primitive()),
+    consumer: custom(
+      (val) => V1_serializeOrganizationalScope(val, plugins),
+      (val) => V1_deserializeOrganizationalScope(val, plugins),
+    ),
+  });
+
+export const V1_terminalOrderItemModelSchema = createModelSchema(
+  V1_TerminalOrderItem,
+  {
+    providerName: primitive(),
+    productName: primitive(),
+    category: primitive(),
+    price: primitive(),
+    id: primitive(),
+    perm_id: optional(primitive()),
+  },
+);
+
+export const V1_serializeOrderItems = (
+  val: Record<number, V1_TerminalOrderItem[]>,
+): Record<number, PlainObject<V1_TerminalOrderItem>[]> => {
+  const result: Record<number, PlainObject<V1_TerminalOrderItem>[]> = {};
+  for (const [key, items] of Object.entries(val)) {
+    result[Number(key)] = items.map(
+      (item: V1_TerminalOrderItem): PlainObject<V1_TerminalOrderItem> =>
+        serialize(V1_terminalOrderItemModelSchema, item),
+    );
+  }
+  return result;
+};
+
+export const V1_deserializeOrderItems = (
+  val: Record<string, PlainObject<V1_TerminalOrderItem>[]>,
+): Record<number, V1_TerminalOrderItem[]> => {
+  const result: Record<number, V1_TerminalOrderItem[]> = {};
+  for (const [key, items] of Object.entries(val)) {
+    result[Number(key)] = items.map(
+      (item: PlainObject<V1_TerminalOrderItem>): V1_TerminalOrderItem =>
+        deserialize(V1_terminalOrderItemModelSchema, item),
+    );
+  }
+  return result;
+};
+
+export const V1_terminalProvisionPayloadModelSchema = createModelSchema(
+  V1_TerminalProvisionPayload,
+  {
+    ordered_by: primitive(),
+    kerberos: primitive(),
+    order_items: custom(V1_serializeOrderItems, V1_deserializeOrderItems),
+    business_justification: primitive(),
+  },
+);
+
+export const V1_serializeTerminalProvisionPayload = (
+  payload: V1_TerminalProvisionPayload,
+): PlainObject<V1_TerminalProvisionPayload> => {
+  return serialize(V1_terminalProvisionPayloadModelSchema, payload);
+};
+
+export const V1_deserializeTerminalProvisionPayload = (
+  json: PlainObject<V1_TerminalProvisionPayload>,
+): V1_TerminalProvisionPayload => {
+  return deserialize(V1_terminalProvisionPayloadModelSchema, json);
+};
+
+export const V1_ContractUserStatusResponseModelSchema = createModelSchema(
+  V1_ContractUserStatusResponse,
+  {
+    status: primitive(),
+  },
+);
+
+export const V1_DataContractApprovedUsersResponseModelSchema =
+  createModelSchema(V1_DataContractApprovedUsersResponse, {
+    approvedUsers: optionalCustomListWithSchema(V1_UserModelSchema),
+  });

package/src/graph-manager/protocol/pure/v1/transformation/pureProtocol/serializationHelpers/lakehouse/V1_CoreEntitlementsSerializationHelper.ts

@@ -0,0 +1,238 @@
+/**
+ * Copyright (c) 2026-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 {
+  customListWithSchema,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  deserialize,
+  list,
+  primitive,
+  raw,
+  serialize,
+} from 'serializr';
+import {
+  type V1_ConsumerEntitlementResource,
+  type V1_OrganizationalScope,
+  V1_AccessPointGroupReference,
+  V1_AccessPointGroupStereotypeMapping,
+  V1_AdhocTeam,
+  V1_AppDirNode,
+  V1_ContractUserMembership,
+  V1_DataBundle,
+  V1_EntitlementsAccessPoint,
+  V1_EntitlementsDataProduct,
+  V1_PaginationMetadataRecord,
+  V1_ProducerScope,
+  V1_UnknownOrganizationalScopeType,
+  V1_User,
+} from '../../../../lakehouse/entitlements/V1_CoreEntitlements.js';
+import type { PureProtocolProcessorPlugin } from '../../../../../PureProtocolProcessorPlugin.js';
+import type { DSL_Lakehouse_PureProtocolProcessorPlugin_Extension } from '../../../../../extensions/DSL_Lakehouse_PureProtocolProcessorPlugin_Extension.js';
+import { V1_stereotypePtrModelSchema } from '../V1_CoreSerializationHelper.js';
+
+// ---------------------------------------- Users & App Directory --------------------------------------
+
+export const V1_UserModelSchema = createModelSchema(V1_User, {
+  name: primitive(),
+  userType: primitive(),
+});
+
+export const V1_AppDirNodeModelSchema = createModelSchema(V1_AppDirNode, {
+  appDirId: primitive(),
+  level: primitive(),
+});
+
+// -------------------------------------------- Pagination ---------------------------------------------
+
+export const V1_paginationMetadataRecordModelSchema = createModelSchema(
+  V1_PaginationMetadataRecord,
+  {
+    hasNextPage: primitive(),
+    lastValuesMap: raw(),
+    size: primitive(),
+  },
+);
+
+// ---------------------------------------- Organizational Scopes --------------------------------------
+
+export enum V1_OrganizationalScopeType {
+  AdHocTeam = 'AdHocTeam',
+  Producer = 'Producer',
+}
+
+export const V1_AdhocTeamModelSchema = createModelSchema(V1_AdhocTeam, {
+  _type: usingConstantValueSchema(V1_OrganizationalScopeType.AdHocTeam),
+  users: customListWithSchema(V1_UserModelSchema),
+});
+
+export const V1_ProducerScopeModelSchema = createModelSchema(V1_ProducerScope, {
+  _type: usingConstantValueSchema(V1_OrganizationalScopeType.Producer),
+  did: primitive(),
+});
+
+export const V1_deserializeOrganizationalScope = (
+  json: PlainObject<V1_OrganizationalScope>,
+  plugins: PureProtocolProcessorPlugin[],
+): V1_OrganizationalScope => {
+  switch (json._type) {
+    case V1_OrganizationalScopeType.AdHocTeam:
+      return deserialize(V1_AdhocTeamModelSchema, json);
+    case V1_OrganizationalScopeType.Producer:
+      return deserialize(V1_ProducerScopeModelSchema, json);
+    default: {
+      const extraOrganizationalScopeDeserializers = plugins.flatMap(
+        (plugin) =>
+          (
+            plugin as DSL_Lakehouse_PureProtocolProcessorPlugin_Extension
+          ).V1_getExtraOrganizationalScopeDeserializers?.() ?? [],
+      );
+      for (const deserializer of extraOrganizationalScopeDeserializers) {
+        const protocol = deserializer(json);
+        if (protocol) {
+          return protocol;
+        }
+      }
+
+      // Fall back to create unknown stub if not supported
+      const org = new V1_UnknownOrganizationalScopeType();
+      org.content = json;
+      return org;
+    }
+  }
+};
+
+export const V1_serializeOrganizationalScope = (
+  organizationalScope: V1_OrganizationalScope,
+  plugins: PureProtocolProcessorPlugin[],
+): PlainObject<V1_OrganizationalScope> => {
+  if (organizationalScope instanceof V1_AdhocTeam) {
+    return serialize(V1_AdhocTeamModelSchema, organizationalScope);
+  }
+  if (organizationalScope instanceof V1_ProducerScope) {
+    return serialize(V1_ProducerScopeModelSchema, organizationalScope);
+  }
+  const extraOrganizationalScopeSerializers = plugins.flatMap(
+    (plugin) =>
+      (
+        plugin as DSL_Lakehouse_PureProtocolProcessorPlugin_Extension
+      ).V1_getExtraOrganizationalScopeSerializers?.() ?? [],
+  );
+  for (const serializer of extraOrganizationalScopeSerializers) {
+    const result = serializer(organizationalScope);
+    if (result) {
+      return result;
+    }
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize unsupported organizational scope type: ${organizationalScope.constructor.name}`,
+  );
+};
+
+// -------------------------------- Entitlements Data Products & Access Points --------------------------
+
+export const V1_EntitlementsAccessPointModelSchema = createModelSchema(
+  V1_EntitlementsAccessPoint,
+  {
+    name: primitive(),
+    groups: list(primitive()),
+  },
+);
+
+export const V1_AccessPointGroupStereotypeMappingModelSchema =
+  createModelSchema(V1_AccessPointGroupStereotypeMapping, {
+    accessPointGroup: primitive(),
+    stereotypes: customListWithSchema(V1_stereotypePtrModelSchema),
+  });
+
+export const V1_EntitlementsDataProductModelSchema = createModelSchema(
+  V1_EntitlementsDataProduct,
+  {
+    name: primitive(),
+    accessPoints: customListWithSchema(V1_EntitlementsAccessPointModelSchema),
+    accessPointGroupStereotypeMappings: customListWithSchema(
+      V1_AccessPointGroupStereotypeMappingModelSchema,
+    ),
+    owner: usingModelSchema(V1_AppDirNodeModelSchema),
+  },
+);
+
+// ------------------------------------- Consumer Entitlement Resources --------------------------------
+
+export enum V1_AccessPointGroupReferenceType {
+  AccessPointGroupReference = 'AccessPointGroupReference',
+}
+
+export const V1_AccessPointGroupReferenceModelSchema = createModelSchema(
+  V1_AccessPointGroupReference,
+  {
+    _type: usingConstantValueSchema(
+      V1_AccessPointGroupReferenceType.AccessPointGroupReference,
+    ),
+    dataProduct: usingModelSchema(V1_EntitlementsDataProductModelSchema),
+    accessPointGroup: primitive(),
+  },
+);
+
+export const V1_DataBundleModelSchema = createModelSchema(V1_DataBundle, {
+  content: raw(),
+});
+
+export const V1_seralizeConsumerEntitlementResource = (
+  consumerEntitlementResource: V1_ConsumerEntitlementResource,
+): PlainObject<V1_ConsumerEntitlementResource> => {
+  if (consumerEntitlementResource instanceof V1_AccessPointGroupReference) {
+    return serialize(
+      V1_AccessPointGroupReferenceModelSchema,
+      consumerEntitlementResource,
+    );
+  } else if (consumerEntitlementResource instanceof V1_DataBundle) {
+    return serialize(V1_DataBundleModelSchema, consumerEntitlementResource);
+  } else {
+    throw new UnsupportedOperationError(
+      `Can't serialize unsupported consumer entitlement resource type: ${consumerEntitlementResource.constructor.name}`,
+    );
+  }
+};
+
+export const V1_deseralizeConsumerEntitlementResource = (
+  json: PlainObject<V1_ConsumerEntitlementResource>,
+): V1_ConsumerEntitlementResource => {
+  switch (json._type) {
+    case V1_AccessPointGroupReferenceType.AccessPointGroupReference:
+      return deserialize(V1_AccessPointGroupReferenceModelSchema, json);
+    default:
+      const bundle = new V1_DataBundle();
+      bundle.content = json;
+      return bundle;
+  }
+};
+
+// -------------------------------------- Contract User Membership -------------------------------------
+
+export const V1_contractUserMembershipModelSchema = createModelSchema(
+  V1_ContractUserMembership,
+  {
+    guid: primitive(),
+    user: usingModelSchema(V1_UserModelSchema),
+    status: primitive(),
+  },
+);