[FEC-38] Fix ProductProjection model reference properties

models/business-unit/src/associate/builder.spec.ts

@@ -40,6 +40,10 @@ describe('builder', () => {
         ]),
         customer: expect.objectContaining({
           id: expect.any(String),
+          typeId: 'customer',
+          obj: expect.objectContaining({
+            id: expect.any(String),
+          }),
         }),
       })
     )
@@ -66,10 +70,10 @@ describe('builder', () => {
         ]),
         customer: expect.objectContaining({
           id: expect.any(String),
-          typeId: 'customer',
-          __typename: 'Reference',
+          email: expect.any(String),
         }),
         customerRef: expect.objectContaining({
+          id: expect.any(String),
           typeId: 'customer',
           __typename: 'Reference',
         }),

models/business-unit/src/associate/transformers.ts

@@ -1,9 +1,9 @@
 import {
-  type TReference,
   type TReferenceGraphql,
   Reference,
 } from '@commercetools-test-data/commons';
-import { Transformer } from '@commercetools-test-data/core';
+import { buildField, Transformer } from '@commercetools-test-data/core';
+import { Customer, TCustomerGraphql } from '@commercetools-test-data/customer';
 import type {
   TAssociateDefault,
   TAssociateRest,
@@ -16,26 +16,30 @@ const transformers = {
   }),
   rest: Transformer<TAssociateDefault, TAssociateRest>('rest', {
     buildFields: ['associateRoleAssignments', 'customer'],
-    replaceFields: ({ fields }) => {
-      const customer: TReference<'customer'> = Reference.presets
-        .customerReference()
-        .id(fields.customer.id)
-        .build();
-      return {
-        ...fields,
-        customer,
-      };
-    },
   }),
   graphql: Transformer<TAssociateDefault, TAssociateGraphql>('graphql', {
-    buildFields: ['associateRoleAssignments', 'customer'],
+    buildFields: ['associateRoleAssignments'],
     replaceFields: ({ fields }) => {
-      const customerRef: TReferenceGraphql = Reference.presets
+      const restCustomerRef = buildField(fields.customer, 'rest');
+
+      const customerRef = Reference.presets
         .customerReference()
-        .id(fields.customer.id)
-        .buildGraphql();
+        .id(restCustomerRef.id)
+        .buildGraphql<TReferenceGraphql>();
+
+      const customer = Customer.random()
+        .id(restCustomerRef.id)
+        .firstName(restCustomerRef.obj?.firstName)
+        .lastName(restCustomerRef.obj?.lastName)
+        .key(restCustomerRef.obj?.key)
+        .customerNumber(restCustomerRef.obj?.customerNumber)
+        .externalId(restCustomerRef.obj?.externalId)
+        .email(restCustomerRef.obj?.email || '')
+        .buildGraphql<TCustomerGraphql>();
+
       return {
         ...fields,
+        customer,
         customerRef,
         __typename: 'Associate',
       };

models/business-unit/src/associate/types.ts

@@ -1,19 +1,17 @@
-import type {
-  Associate,
-  AssociateDraft,
-  Customer,
-} from '@commercetools/platform-sdk';
+import type { Associate, AssociateDraft } from '@commercetools/platform-sdk';
 import { TReferenceGraphql } from '@commercetools-test-data/commons';
 import type { TBuilder } from '@commercetools-test-data/core';
+import { TCustomerGraphql } from '@commercetools-test-data/customer';
+
+export type TAssociateDefault = Associate;
 
 export type TAssociateDraft = AssociateDraft;
 export type TAssociateDraftGraphql = TAssociateDraft;
 
-export type TAssociateDefault = Omit<Associate, 'customer'> & {
-  customer: Customer;
-};
 export type TAssociateRest = Associate;
-export type TAssociateGraphql = TAssociateDefault & {
+
+export type TAssociateGraphql = Omit<TAssociateDefault, 'customer'> & {
+  customer: TCustomerGraphql;
   customerRef: TReferenceGraphql | null;
   __typename: 'Associate';
 };

models/channel/src/builder.spec.ts

@@ -83,6 +83,7 @@ describe('builder', () => {
       ),
       expect.objectContaining({
         __typename: 'Channel',
+        name: 'Food Store',
         nameAllLocales: expect.arrayContaining([
           expect.objectContaining({
             __typename: 'LocalizedString',

models/channel/src/transformers.ts

@@ -1,4 +1,7 @@
-import { LocalizedString } from '@commercetools-test-data/commons';
+import {
+  LocalizedString,
+  TClientLoggingGraphql,
+} from '@commercetools-test-data/commons';
 import { Transformer } from '@commercetools-test-data/core';
 import type { TChannel, TChannelGraphql } from './types';
 
@@ -23,16 +26,25 @@ const transformers = {
   }),
   graphql: Transformer<TChannel, TChannelGraphql>('graphql', {
     buildFields: ['address', 'createdBy', 'lastModifiedBy'],
-    addFields: ({ fields }) => {
+    replaceFields: ({ fields }) => {
       const nameAllLocales = LocalizedString.toLocalizedField(fields.name);
       const descriptionAllLocales = LocalizedString.toLocalizedField(
         fields.description
       );
 
       return {
+        ...fields,
         __typename: 'Channel',
+        createdBy: fields.createdBy as TClientLoggingGraphql | undefined,
+        lastModifiedBy: fields.lastModifiedBy as
+          | TClientLoggingGraphql
+          | undefined,
         nameAllLocales,
+        name: LocalizedString.resolveGraphqlDefaultLocaleValue(nameAllLocales),
         descriptionAllLocales,
+        description: LocalizedString.resolveGraphqlDefaultLocaleValue(
+          descriptionAllLocales
+        ),
       };
     },
   }),

models/channel/src/types.ts

@@ -19,19 +19,15 @@ export type TChannelDraftGraphql = Omit<
 
 export type TChannelGraphql = Omit<
   TChannel,
-  // In GraphQL, we prefer to use `nameAllLocales` instead of `name`.
-  | 'name'
-  // In GraphQL, we prefer to use `descriptionAllLocales` instead of `description`.
-  | 'description'
-  // In GraphQL, the object shape is different.
-  | 'createdBy'
-  // In GraphQL, the object shape is different.
-  | 'lastModifiedBy'
+  // In GraphQL, these properties have different shapes.
+  'name' | 'description' | 'createdBy' | 'lastModifiedBy'
 > & {
   __typename: 'Channel';
-  createdBy: TClientLoggingGraphql;
-  lastModifiedBy: TClientLoggingGraphql;
+  createdBy?: TClientLoggingGraphql;
+  lastModifiedBy?: TClientLoggingGraphql;
+  name?: string;
   nameAllLocales?: TLocalizedStringGraphql | null;
+  description?: string;
   descriptionAllLocales?: TLocalizedStringGraphql | null;
 };
 

models/commons/src/localized-string/helpers.ts

@@ -24,7 +24,7 @@ const resolveGraphqlDefaultLocaleValue = (
   const defaultLocaleName = allLocales.find(
     (name) => name.locale === DEFAULT_LOCALE
   );
-  return defaultLocaleName ? defaultLocaleName.value : allLocales[0].value;
+  return defaultLocaleName ? defaultLocaleName.value : allLocales[0]?.value;
 };
 
 export { resolveGraphqlDefaultLocaleValue, toLocalizedField };

models/commons/src/reference/builder.spec.ts

@@ -1,9 +1,32 @@
 /* eslint-disable jest/no-disabled-tests */
 /* eslint-disable jest/valid-title */
+import {
+  Builder,
+  fake,
+  Generator,
+  Transformer,
+} from '@commercetools-test-data/core';
 import { createBuilderSpec } from '@commercetools-test-data/core/test-utils';
 import type { TReference, TReferenceGraphql, TReferenceRest } from './types';
 import * as Reference from './index';
 
+// We use this dummy model in the customization tests.
+// It is a simple model so we don't need to depend on other models.
+const DummyModel = () =>
+  Builder<{ id: string; name: string }>({
+    generator: Generator<{ id: string; name: string }>({
+      fields: {
+        id: fake((f) => f.string.uuid()),
+        name: fake((f) => f.person.fullName()),
+      },
+    }),
+    transformers: {
+      default: Transformer('default', {}),
+      rest: Transformer('rest', {}),
+      graphql: Transformer('graphql', {}),
+    },
+  });
+
 describe('builder', () => {
   it(
     ...createBuilderSpec<TReference, TReference>(
@@ -39,4 +62,39 @@ describe('builder', () => {
       }
     )
   );
+
+  describe('when customizing the model', () => {
+    const referenceMock = Reference.random()
+      .typeId('dummy-type')
+      .obj(DummyModel().id('dummy-id').name('dummy-name'));
+
+    it('should build the right rest model', () => {
+      const restReference = referenceMock.buildRest<TReferenceRest>();
+
+      expect(restReference).toEqual(
+        expect.objectContaining({
+          id: 'dummy-id',
+          typeId: 'dummy-type',
+          obj: {
+            id: 'dummy-id',
+            name: 'dummy-name',
+          },
+        })
+      );
+    });
+    it('should build the right graphql model', () => {
+      const graphqlReference = referenceMock.buildGraphql<TReferenceGraphql>();
+
+      expect(graphqlReference).toEqual(
+        expect.objectContaining({
+          __typename: 'Reference',
+          id: 'dummy-id',
+          typeId: 'dummy-type',
+        })
+      );
+      // @ts-expect-error "obj" is not defined in the graphql model
+      // but we want to make sure the built model does not include it
+      expect(graphqlReference.obj).toBeUndefined();
+    });
+  });
 });

models/commons/src/reference/generator.ts

@@ -6,6 +6,7 @@ const generator = Generator<TReference>({
   fields: {
     id: fake((f) => f.string.uuid()),
     typeId: null,
+    obj: undefined,
   },
 });
 

models/commons/src/reference/transformers.ts

@@ -1,22 +1,45 @@
 import { Transformer } from '@commercetools-test-data/core';
-import omit from 'lodash/omit';
-import type { TReference, TReferenceGraphql, TReferenceRest } from './types';
+import type {
+  TExpandedReferenceObject,
+  TReference,
+  TReferenceGraphql,
+  TReferenceRest,
+} from './types';
 
 const transformers = {
-  default: Transformer<TReference, TReference>('default', {}),
+  default: Transformer<TReference, TReference>('default', {
+    buildFields: ['obj'],
+  }),
   rest: Transformer<TReference, TReferenceRest>('rest', {
-    replaceFields: ({ fields }) => ({
-      ...fields,
-      obj: omit(fields, ['typeId']),
-    }),
+    replaceFields: ({ fields }) => {
+      const obj = fields.obj
+        ? fields.obj.buildRest<TExpandedReferenceObject>()
+        : {
+            id: fields.id,
+          };
+
+      return {
+        ...fields,
+        id: obj.id,
+        obj,
+      };
+    },
   }),
   // we do not add the expanded object ourselves
   // since some fields are pure `*Ref`, e.g `channelsRef`
   // with no option to expand.
   graphql: Transformer<TReference, TReferenceGraphql>('graphql', {
-    addFields: () => ({
-      __typename: 'Reference',
-    }),
+    replaceFields: ({ fields }) => {
+      const id = fields.obj
+        ? fields.obj.buildGraphql<TExpandedReferenceObject>().id
+        : fields.id;
+
+      return {
+        id,
+        typeId: fields.typeId,
+        __typename: 'Reference',
+      };
+    },
   }),
 };
 

models/commons/src/reference/types.ts

@@ -1,40 +1,37 @@
 import type { TBuilder } from '@commercetools-test-data/core';
 
-export type TReferenceBuilder<TypeId = string> = TBuilder<TReference<TypeId>>;
+export type TExpandedReferenceObject = {
+  id: string;
+  version?: number;
+};
 
 export interface TReference<TypeId = string> {
   typeId: TypeId;
   id: string;
+  obj?: TBuilder<TExpandedReferenceObject>;
 }
 
-export type TExpandedReferenceObject<TypeId = string> = {
-  id: TReference<TypeId>['id'];
-  version?: number;
-};
-
-export type TCreateReferenceBuilder<TypeId = string> =
-  () => TReferenceBuilder<TypeId>;
-
 export type TReferenceRest<
-  TypeId = string,
-  ExpandedObject extends TExpandedReferenceObject<TypeId> = TExpandedReferenceObject<TypeId>
-> = TReference<TypeId> & {
-  obj: ExpandedObject;
+  ExpandedObject extends TExpandedReferenceObject = TExpandedReferenceObject,
+> = Omit<TReference, 'obj'> & {
+  obj?: ExpandedObject;
 };
 
-export type TReferenceGraphql<TypeId = string> =
-  TExpandedReferenceObject<TypeId> & {
-    __typename: 'Reference';
-  };
+export type TReferenceGraphql = Omit<TReference, 'obj'> & {
+  __typename: 'Reference';
+};
 
 // Draft representation
 export interface TReferenceDraft<TypeId = string> {
   typeId: TypeId;
   id: string;
 }
 
-export type TReferenceDraftGraphql<TypeId = string> =
-  TExpandedReferenceObject<TypeId>;
+export type TReferenceDraftGraphql = TExpandedReferenceObject;
+
+export type TReferenceBuilder<TypeId = string> = TBuilder<TReference<TypeId>>;
+export type TCreateReferenceBuilder<TypeId = string> =
+  () => TReferenceBuilder<TypeId>;
 
 export type TReferenceDraftBuilder<TypeId = string> = TBuilder<
   TReferenceDraft<TypeId>