@ninetailed/experience.js-utils-contentful 2.1.2-beta.1 → 2.2.0

package/index.esm.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { Config, ExperienceMapper as ExperienceMapper$1 } from '@ninetailed/experience.js-utils';
 
 const EntryLink = z.object({
   type: z.literal('Link'),
@@ -29,7 +30,7 @@ const Entry = z.object({
       })
     }).optional()
   }),
-  fields: z.object({}),
+  fields: z.object({}).passthrough(),
   metadata: z.object({
     tags: z.array(z.object({
       sys: EntryLink.extend({
@@ -68,19 +69,7 @@ const ExperienceFields = z.object({
   /**
    * The config of the experience (JSON)
    */
-  nt_config: z.object({
-    distribution: z.array(z.number()),
-    traffic: z.number(),
-    components: z.array(z.object({
-      baseline: z.object({
-        id: z.string()
-      }),
-      variants: z.array(z.object({
-        id: z.string(),
-        hidden: z.boolean()
-      }))
-    }))
-  }).optional().nullable(),
+  nt_config: Config,
 
   /**
    * The audience of the experience (Audience)
@@ -96,6 +85,12 @@ const ExperienceEntry = Entry.extend({
   fields: ExperienceFields
 });
 
+const ExperimentEntry = ExperienceEntry.extend({
+  fields: ExperienceFields.extend({
+    nt_type: z.literal('nt_experiment')
+  })
+});
+
 class AudienceMapper {
   static mapAudience(audience) {
     return {
@@ -114,71 +109,54 @@ const isEntry = entry => {
   }
 };
 
-const defaultMapVariant = (variant, {
-  hidden
-}) => Object.assign(Object.assign({}, variant), {
-  id: variant.sys.id,
-  hidden: hidden
+const defaultMapVariant = variant => Object.assign(Object.assign({}, variant), {
+  id: variant.sys.id
 });
 
 class ExperienceMapper {
+  static isExperienceEntry(entry) {
+    return ExperienceEntry.safeParse(entry).success;
+  }
+
   static mapExperience(entry, options) {
     const _mapVariant = (options === null || options === void 0 ? void 0 : options.mapVariant) || defaultMapVariant;
 
-    const config = Object.assign({
-      traffic: 0,
-      distribution: [0.5, 0.5],
-      components: [{
-        baseline: {
-          id: ''
-        },
-        variants: [{
-          id: '',
-          hidden: false
-        }]
-      }]
-    }, entry.fields.nt_config);
-    const variantReferences = (entry.fields.nt_variants || []).filter(isEntry);
-    return Object.assign(Object.assign({
-      id: entry.sys.id,
-      type: entry.fields.nt_type
-    }, entry.fields.nt_audience ? {
-      audience: AudienceMapper.mapAudience(entry.fields.nt_audience)
-    } : {}), {
-      trafficAllocation: config.traffic,
-      distribution: config.distribution.map((percentage, index) => ({
-        index,
-        start: config.distribution.slice(0, index).reduce((a, b) => a + b, 0),
-        end: config.distribution.slice(0, index + 1).reduce((a, b) => a + b, 0)
-      })),
-      components: config.components.map(component => {
-        return {
-          baseline: component.baseline,
-          variants: component.variants.map(variant => {
-            if (variant.hidden) {
-              return variant;
-            }
-
-            const matchingVariant = variantReferences.find(variantReference => variantReference.sys.id === variant.id);
-
-            if (!matchingVariant) {
-              return null;
-            }
-
-            return _mapVariant(matchingVariant, {
-              hidden: variant.hidden
-            });
-          }).filter(variant => variant !== null)
-        };
-      })
-    });
+    const parsedExperience = ExperienceEntry.safeParse(entry);
+
+    if (!parsedExperience.success) {
+      throw new Error('The Experience Input is not valid. Please filter data first with `ExperienceMapper.isExperienceEntry`.');
+    }
+
+    const {
+      sys: {
+        id
+      },
+      fields: {
+        nt_type,
+        nt_name,
+        nt_config,
+        nt_audience,
+        nt_variants
+      }
+    } = parsedExperience.data;
+    return ExperienceMapper$1.mapExperience(Object.assign(Object.assign({
+      id,
+      type: nt_type,
+      name: nt_name
+    }, nt_audience ? AudienceMapper.mapAudience(nt_audience) : {}), {
+      config: nt_config,
+      variants: nt_variants.map(variant => _mapVariant(variant))
+    }));
+  }
+
+  static isExperiment(entry) {
+    return ExperimentEntry.safeParse(entry).success;
   }
 
   static mapExperiment(entry) {
     return ExperienceMapper.mapExperience(entry, {
       mapVariant: () => ({
-        id: '',
-        hidden: false
+        id: ''
       })
     });
   }
@@ -190,22 +168,11 @@ class ExperienceMapper {
 }
 
 const isAudienceEntry = entry => {
-  try {
-    AudienceEntry.parse(entry);
-    return true;
-  } catch (error) {
-    return false;
-  }
+  return AudienceEntry.safeParse(entry).success;
 };
 
 const isExperienceEntry = entry => {
-  try {
-    ExperienceEntry.parse(entry);
-    return true;
-  } catch (error) {
-    console.error(error);
-    return false;
-  }
+  return ExperienceEntry.safeParse(entry).success;
 };
 
-export { AudienceEntry, AudienceMapper, Entry, ExperienceEntry, ExperienceMapper, isAudienceEntry, isEntry, isExperienceEntry };
+export { AudienceEntry, AudienceMapper, Entry, ExperienceEntry, ExperienceMapper, ExperimentEntry, isAudienceEntry, isEntry, isExperienceEntry };

package/index.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('zod')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'zod'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsContentful = {}, global.zod));
-})(this, (function (exports, zod) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('zod'), require('@ninetailed/experience.js-utils')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'zod', '@ninetailed/experience.js-utils'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.UtilsContentful = {}, global.zod, global.experience_jsUtils));
+})(this, (function (exports, zod, experience_jsUtils) { 'use strict';
 
   var EntryLink = zod.z.object({
     type: zod.z.literal('Link'),
@@ -33,7 +33,7 @@
         })
       }).optional()
     }),
-    fields: zod.z.object({}),
+    fields: zod.z.object({}).passthrough(),
     metadata: zod.z.object({
       tags: zod.z.array(zod.z.object({
         sys: EntryLink.extend({
@@ -72,19 +72,7 @@
     /**
      * The config of the experience (JSON)
      */
-    nt_config: zod.z.object({
-      distribution: zod.z.array(zod.z.number()),
-      traffic: zod.z.number(),
-      components: zod.z.array(zod.z.object({
-        baseline: zod.z.object({
-          id: zod.z.string()
-        }),
-        variants: zod.z.array(zod.z.object({
-          id: zod.z.string(),
-          hidden: zod.z.boolean()
-        }))
-      }))
-    }).optional().nullable(),
+    nt_config: experience_jsUtils.Config,
 
     /**
      * The audience of the experience (Audience)
@@ -100,6 +88,12 @@
     fields: ExperienceFields
   });
 
+  var ExperimentEntry = ExperienceEntry.extend({
+    fields: ExperienceFields.extend({
+      nt_type: zod.z.literal('nt_experiment')
+    })
+  });
+
   var AudienceMapper =
   /** @class */
   function () {
@@ -149,11 +143,9 @@
     }
   };
 
-  var defaultMapVariant = function (variant, _a) {
-    var hidden = _a.hidden;
+  var defaultMapVariant = function (variant) {
     return __assign(__assign({}, variant), {
-      id: variant.sys.id,
-      hidden: hidden
+      id: variant.sys.id
     });
   };
 
@@ -162,75 +154,48 @@
   function () {
     function ExperienceMapper() {}
 
+    ExperienceMapper.isExperienceEntry = function (entry) {
+      return ExperienceEntry.safeParse(entry).success;
+    };
+
     ExperienceMapper.mapExperience = function (entry, options) {
       var _mapVariant = (options === null || options === void 0 ? void 0 : options.mapVariant) || defaultMapVariant;
 
-      var config = __assign({
-        traffic: 0,
-        distribution: [0.5, 0.5],
-        components: [{
-          baseline: {
-            id: ''
-          },
-          variants: [{
-            id: '',
-            hidden: false
-          }]
-        }]
-      }, entry.fields.nt_config);
-
-      var variantReferences = (entry.fields.nt_variants || []).filter(isEntry);
-      return __assign(__assign({
-        id: entry.sys.id,
-        type: entry.fields.nt_type
-      }, entry.fields.nt_audience ? {
-        audience: AudienceMapper.mapAudience(entry.fields.nt_audience)
-      } : {}), {
-        trafficAllocation: config.traffic,
-        distribution: config.distribution.map(function (percentage, index) {
-          return {
-            index: index,
-            start: config.distribution.slice(0, index).reduce(function (a, b) {
-              return a + b;
-            }, 0),
-            end: config.distribution.slice(0, index + 1).reduce(function (a, b) {
-              return a + b;
-            }, 0)
-          };
-        }),
-        components: config.components.map(function (component) {
-          return {
-            baseline: component.baseline,
-            variants: component.variants.map(function (variant) {
-              if (variant.hidden) {
-                return variant;
-              }
-
-              var matchingVariant = variantReferences.find(function (variantReference) {
-                return variantReference.sys.id === variant.id;
-              });
-
-              if (!matchingVariant) {
-                return null;
-              }
-
-              return _mapVariant(matchingVariant, {
-                hidden: variant.hidden
-              });
-            }).filter(function (variant) {
-              return variant !== null;
-            })
-          };
+      var parsedExperience = ExperienceEntry.safeParse(entry);
+
+      if (!parsedExperience.success) {
+        throw new Error('The Experience Input is not valid. Please filter data first with `ExperienceMapper.isExperienceEntry`.');
+      }
+
+      var _a = parsedExperience.data,
+          id = _a.sys.id,
+          _b = _a.fields,
+          nt_type = _b.nt_type,
+          nt_name = _b.nt_name,
+          nt_config = _b.nt_config,
+          nt_audience = _b.nt_audience,
+          nt_variants = _b.nt_variants;
+      return experience_jsUtils.ExperienceMapper.mapExperience(__assign(__assign({
+        id: id,
+        type: nt_type,
+        name: nt_name
+      }, nt_audience ? AudienceMapper.mapAudience(nt_audience) : {}), {
+        config: nt_config,
+        variants: nt_variants.map(function (variant) {
+          return _mapVariant(variant);
         })
-      });
+      }));
+    };
+
+    ExperienceMapper.isExperiment = function (entry) {
+      return ExperimentEntry.safeParse(entry).success;
     };
 
     ExperienceMapper.mapExperiment = function (entry) {
       return ExperienceMapper.mapExperience(entry, {
         mapVariant: function () {
           return {
-            id: '',
-            hidden: false
+            id: ''
           };
         }
       });
@@ -246,22 +211,11 @@
   }();
 
   var isAudienceEntry = function (entry) {
-    try {
-      AudienceEntry.parse(entry);
-      return true;
-    } catch (error) {
-      return false;
-    }
+    return AudienceEntry.safeParse(entry).success;
   };
 
   var isExperienceEntry = function (entry) {
-    try {
-      ExperienceEntry.parse(entry);
-      return true;
-    } catch (error) {
-      console.error(error);
-      return false;
-    }
+    return ExperienceEntry.safeParse(entry).success;
   };
 
   exports.AudienceEntry = AudienceEntry;
@@ -269,6 +223,7 @@
   exports.Entry = Entry;
   exports.ExperienceEntry = ExperienceEntry;
   exports.ExperienceMapper = ExperienceMapper;
+  exports.ExperimentEntry = ExperimentEntry;
   exports.isAudienceEntry = isAudienceEntry;
   exports.isEntry = isEntry;
   exports.isExperienceEntry = isExperienceEntry;

package/lib/AudienceMapper.d.ts

@@ -1,6 +1,5 @@
+import { Audience } from '@ninetailed/experience.js-utils';
 import { AudienceEntry } from '../types/AudienceEntry';
 export declare class AudienceMapper {
-    static mapAudience(audience: AudienceEntry): {
-        id: string;
-    };
+    static mapAudience(audience: AudienceEntry): Audience;
 }

package/lib/ExperienceMapper.d.ts

@@ -1,15 +1,15 @@
-import { Variant, ExperienceConfiguration } from '@ninetailed/experience.js';
-import { ExperienceEntry, Entry } from '../types';
+import { ExperienceConfiguration } from '@ninetailed/experience.js';
+import { Variant } from '@ninetailed/experience.js-utils';
+import { ExperienceEntry, Entry, ExperimentEntry } from '../types';
 import { BaselineWithExperiencesEntry } from '../types/BaselineWithExperiencesEntry';
-declare type MapVariantOptions = {
-    hidden: boolean;
-};
-declare type MapVariant<VariantType = Entry> = (variant: VariantType, options: MapVariantOptions) => Variant;
+declare type MapVariant<VariantType = Entry> = (variant: VariantType) => Variant;
 declare type MapExperienceOptions<VariantType = Entry> = {
     mapVariant?: MapVariant<VariantType>;
 };
 export declare class ExperienceMapper {
+    static isExperienceEntry(entry: Entry): entry is ExperienceEntry;
     static mapExperience(entry: ExperienceEntry, options?: MapExperienceOptions): ExperienceConfiguration;
+    static isExperiment(entry: Entry): entry is ExperimentEntry;
     static mapExperiment(entry: ExperienceEntry): ExperienceConfiguration;
     static mapBaselineWithExperiences(entry: BaselineWithExperiencesEntry): ExperienceConfiguration[];
 }

package/lib/isAudienceEntry.d.ts

@@ -1,5 +1,18 @@
 export declare const isAudienceEntry: (entry?: {
+    metadata?: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    } | undefined;
     sys: {
+        type?: string | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        locale?: string | undefined;
         revision?: number | undefined;
         space?: {
             sys: {
@@ -15,21 +28,18 @@ export declare const isAudienceEntry: (entry?: {
                 linkType: "Environment";
             };
         } | undefined;
-        type: string;
-        id: string;
-        createdAt: string;
-        updatedAt: string;
-        locale: string;
-        contentType: {
+        contentType?: {
             sys: {
                 type: "Link";
                 id: string;
                 linkType: "ContentType";
             };
-        };
+        } | undefined;
+        id: string;
     };
     fields: {};
-    metadata: {
+} | undefined) => entry is {
+    metadata?: {
         tags: {
             sys: {
                 type: "Link";
@@ -37,9 +47,12 @@ export declare const isAudienceEntry: (entry?: {
                 linkType: "Tag";
             };
         }[];
-    };
-} | undefined) => entry is {
+    } | undefined;
     sys: {
+        type?: string | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        locale?: string | undefined;
         revision?: number | undefined;
         space?: {
             sys: {
@@ -55,30 +68,17 @@ export declare const isAudienceEntry: (entry?: {
                 linkType: "Environment";
             };
         } | undefined;
-        type: string;
-        id: string;
-        createdAt: string;
-        updatedAt: string;
-        locale: string;
-        contentType: {
+        contentType?: {
             sys: {
                 type: "Link";
                 id: string;
                 linkType: "ContentType";
             };
-        };
+        } | undefined;
+        id: string;
     };
     fields: {
         nt_name: string;
         nt_audience_id: string;
     };
-    metadata: {
-        tags: {
-            sys: {
-                type: "Link";
-                id: string;
-                linkType: "Tag";
-            };
-        }[];
-    };
 };

package/lib/isEntry.d.ts

@@ -1,5 +1,18 @@
 export declare const isEntry: (entry?: {
+    metadata?: {
+        tags: {
+            sys: {
+                type: "Link";
+                id: string;
+                linkType: "Tag";
+            };
+        }[];
+    } | undefined;
     sys: {
+        type?: string | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        locale?: string | undefined;
         revision?: number | undefined;
         space?: {
             sys: {
@@ -15,21 +28,18 @@ export declare const isEntry: (entry?: {
                 linkType: "Environment";
             };
         } | undefined;
-        type: string;
-        id: string;
-        createdAt: string;
-        updatedAt: string;
-        locale: string;
-        contentType: {
+        contentType?: {
             sys: {
                 type: "Link";
                 id: string;
                 linkType: "ContentType";
             };
-        };
+        } | undefined;
+        id: string;
     };
     fields: {};
-    metadata: {
+} | undefined) => entry is {
+    metadata?: {
         tags: {
             sys: {
                 type: "Link";
@@ -37,9 +47,12 @@ export declare const isEntry: (entry?: {
                 linkType: "Tag";
             };
         }[];
-    };
-} | undefined) => entry is {
+    } | undefined;
     sys: {
+        type?: string | undefined;
+        createdAt?: string | undefined;
+        updatedAt?: string | undefined;
+        locale?: string | undefined;
         revision?: number | undefined;
         space?: {
             sys: {
@@ -55,27 +68,14 @@ export declare const isEntry: (entry?: {
                 linkType: "Environment";
             };
         } | undefined;
-        type: string;
-        id: string;
-        createdAt: string;
-        updatedAt: string;
-        locale: string;
-        contentType: {
+        contentType?: {
             sys: {
                 type: "Link";
                 id: string;
                 linkType: "ContentType";
             };
-        };
+        } | undefined;
+        id: string;
     };
     fields: {};
-    metadata: {
-        tags: {
-            sys: {
-                type: "Link";
-                id: string;
-                linkType: "Tag";
-            };
-        }[];
-    };
 };