Dev 3831 experience js experience mapper wont default a null or missing variants array correctly

packages/utils/contentful/src/types/ExperienceEntry.spec.ts

@@ -11,11 +11,44 @@ describe('ExperienceEntry', () => {
     ).toEqual([]);
   });
 
+  it('Should not accept a null value as variants', () => {
+    expect(
+      () =>
+        ExperienceEntry.parse({
+          sys: { id: 'experience' },
+          fields: {
+            ...experienceEntryWithoutVariants.fields,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            nt_variants: null,
+          },
+        }).fields.nt_variants
+    ).toThrow();
+  });
+
   it('should parse an ExperienceEntry without linkType', () => {
     experienceEntryWithoutLinkType.map((entry) => {
       expect(
         ExperienceEntry.parse(entry as unknown as ExperienceEntryLike)
       ).toMatchSnapshot();
     });
   });
+
+  it('Should not accept invalid variants', () => {
+    expect(() =>
+      ExperienceEntry.parse({
+        sys: { id: 'experience' },
+        fields: {
+          ...experienceEntryWithoutVariants.fields,
+          nt_variants: [
+            {
+              // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+              // @ts-expect-error
+              key: 'invalid-variant',
+            },
+          ],
+        },
+      })
+    ).toThrow();
+  });
 });

packages/utils/javascript/src/lib/ExperienceMapper.spec.ts

@@ -83,4 +83,21 @@ describe('Experience Mapper', () => {
       { id: 'variant', hidden: true },
     ]);
   });
+
+  it('should preserve the type of the variants', () => {
+    const mapped = ExperienceMapper.mapExperience({
+      ...defaultExperience,
+      variants: [{ id: 'variant', foo: 'bar' }],
+    });
+
+    const variant = mapped.components[0].variants[0];
+    if (!('hidden' in variant)) {
+      // Yeay! It correctly inferred the type of the property "foo" on the variant
+      expect(variant.foo).toBe('bar');
+    }
+
+    expect(mapped.components[0].variants).toStrictEqual([
+      { id: 'variant', foo: 'bar' },
+    ]);
+  });
 });

packages/utils/javascript/src/types/Experiement.spec.ts

@@ -0,0 +1,43 @@
+import { Reference } from '@ninetailed/experience.js-shared';
+import { Experiment } from './Experiment';
+
+describe('Experiment Schema Validation', () => {
+  it('Should default missing variants to an empty array', () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const experiment = Experiment.parse({
+      id: 'experience-without-variants',
+      name: 'Experience without variants',
+      type: 'nt_experiment',
+    });
+
+    expect(experiment.variants).toEqual([]);
+  });
+
+  it('Should default null variants to an empty array', () => {
+    const experiment = Experiment.parse({
+      id: 'experience-with-null-variants',
+      name: 'Experience with null variants',
+      type: 'nt_experiment',
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      variants: null,
+    });
+
+    expect(experiment.variants).toEqual([]);
+  });
+
+  it('Should validate the variants array to contain only element with an id', () => {
+    const experiment = Experiment.parse({
+      id: 'experience-with-invalid-variants',
+      name: 'Experience with invalid variants',
+      type: 'nt_experiment',
+      variants: [
+        { id: 'valid-variant', foo: 'bar' },
+        { key: 'invalid-variant' } as unknown as Reference,
+      ],
+    });
+
+    expect(experiment.variants).toEqual([{ id: 'valid-variant', foo: 'bar' }]);
+  });
+});

packages/utils/javascript/src/types/Experience.spec.ts

@@ -0,0 +1,43 @@
+import { Reference } from '@ninetailed/experience.js-shared';
+import { Experience } from './Experience';
+
+describe('Experience Schema Validation', () => {
+  it('Should default missing variants to an empty array', () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const experience = Experience.parse({
+      id: 'experience-without-variants',
+      name: 'Experience without variants',
+      type: 'nt_experiment',
+    });
+
+    expect(experience.variants).toEqual([]);
+  });
+
+  it('Should default null variants to an empty array', () => {
+    const experience = Experience.parse({
+      id: 'experience-with-null-variants',
+      name: 'Experience with null variants',
+      type: 'nt_experiment',
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      variants: null,
+    });
+
+    expect(experience.variants).toEqual([]);
+  });
+
+  it('Should validate the variants array to contain only element with an id', () => {
+    const experience = Experience.parse({
+      id: 'experience-with-invalid-variants',
+      name: 'Experience with invalid variants',
+      type: 'nt_experiment',
+      variants: [
+        { id: 'valid-variant', foo: 'bar' },
+        { key: 'invalid-variant' } as unknown as Reference,
+      ],
+    });
+
+    expect(experience.variants).toEqual([{ id: 'valid-variant', foo: 'bar' }]);
+  });
+});

packages/utils/javascript/src/types/Experience.ts

@@ -64,7 +64,7 @@ const parse = <T extends Reference>(
 
   return {
     ...output,
-    variants: input.variants,
+    variants: output.variants as T[],
   };
 };
 
@@ -79,7 +79,7 @@ const safeParse = <T extends Reference>(input: ExperienceLike<T>) => {
     ...output,
     data: {
       ...output.data,
-      variants: input.variants,
+      variants: output.data.variants as T[],
     },
   };
 };

packages/utils/javascript/src/types/Experiment.ts

@@ -30,7 +30,7 @@ const parse = <T extends Reference>(
 
   return {
     ...output,
-    variants: input.variants,
+    variants: output.variants as T[],
   };
 };
 
@@ -45,7 +45,7 @@ const safeParse = <T extends Reference>(input: ExperimentLike<T>) => {
     ...output,
     data: {
       ...output.data,
-      variants: input.variants,
+      variants: output.data.variants as T[],
     },
   };
 };