@ninetailed/experience.js-utils-contentful 3.0.0-beta.33 → 3.0.0-beta.34

package/index.d.ts

@@ -1,3 +1,11 @@
-export * from './types';
-export { AudienceMapper, ExperienceMapper, isEntry, isAudienceEntry, isExperienceEntry, } from './lib';
-export type { MapVariant } from './lib';
+export { AudienceMapper } from './lib/AudienceMapper';
+export { ExperienceMapper } from './lib/ExperienceMapper';
+export { isEntry } from './lib/isEntry';
+export { isAudienceEntry } from './lib/isAudienceEntry';
+export { isExperienceEntry } from './lib/isExperienceEntry';
+export type { AudienceEntry, AudienceEntryLike, AudienceEntryFields, } from './types/AudienceEntry';
+export type { BaselineWithExperiencesEntry, BaselineWithExperiencesEntryLike, } from './types/BaselineWithExperiencesEntry';
+export type { Entry, EntryLike } from './types/Entry';
+export type { EntryFields } from './types/EntryFields';
+export type { ExperienceEntry, ExperienceEntryLike, ExperienceFields, } from './types/ExperienceEntry';
+export type { ExperimentEntry, ExperimentEntryLike, } from './types/ExperimentEntry';

package/index.js

@@ -1,13 +1,23 @@
-import { z } from 'zod';
-import { Config, ExperienceMapper as ExperienceMapper$1 } from '@ninetailed/experience.js-utils';
 import { logger } from '@ninetailed/experience.js-shared';
+import { Config, ExperienceMapper as ExperienceMapper$1 } from '@ninetailed/experience.js-utils';
+import { z } from 'zod';
+
+class AudienceMapper {
+  static mapAudience(audience) {
+    return {
+      id: audience.fields.nt_audience_id
+    };
+  }
+}
+
+const EntryFields = z.object({}).catchall(z.unknown());
 
 const EntryLink = z.object({
-  type: z.literal('Link'),
+  type: z.string(),
   linkType: z.string(),
   id: z.string()
 });
-const Entry = z.object({
+const EntrySchema = z.object({
   sys: z.object({
     type: z.string().optional(),
     id: z.string(),
@@ -17,31 +27,52 @@ const Entry = z.object({
     revision: z.number().optional(),
     space: z.object({
       sys: EntryLink.extend({
-        linkType: z.literal('Space')
+        linkType: z.string()
       })
     }).optional(),
     environment: z.object({
       sys: EntryLink.extend({
-        linkType: z.literal('Environment')
+        linkType: z.string()
       })
     }).optional(),
     contentType: z.object({
       sys: EntryLink.extend({
-        linkType: z.literal('ContentType')
+        linkType: z.string()
       })
     }).optional()
   }),
-  fields: z.object({}).passthrough(),
+  fields: EntryFields,
   metadata: z.object({
     tags: z.array(z.object({
       sys: EntryLink.extend({
-        linkType: z.literal('Tag')
+        linkType: z.string()
       })
     }))
   }).optional()
 });
+const parse$1 = input => {
+  const output = EntrySchema.parse(input);
+  return Object.assign(Object.assign({}, output), {
+    fields: input.fields
+  });
+};
+const safeParse$1 = input => {
+  const output = EntrySchema.safeParse(input);
+  if (!output.success) {
+    return output;
+  }
+  return Object.assign(Object.assign({}, output), {
+    data: Object.assign(Object.assign({}, output.data), {
+      fields: input.fields
+    })
+  });
+};
+const Entry = Object.assign(Object.assign({}, EntrySchema), {
+  parse: parse$1,
+  safeParse: safeParse$1
+});
 
-const AudienceFields = z.object({
+const AudienceEntryFields = EntryFields.extend({
   /**
    * The name of the audience (Short Text)
    */
@@ -51,11 +82,11 @@ const AudienceFields = z.object({
    */
   nt_audience_id: z.string()
 });
-const AudienceEntry = Entry.extend({
-  fields: AudienceFields
+const AudienceEntry = EntrySchema.extend({
+  fields: AudienceEntryFields
 });
 
-const ExperienceFields = z.object({
+const ExperienceEntryFields = z.object({
   /**
    * The name of the experience (Short Text)
    */
@@ -63,11 +94,17 @@ const ExperienceFields = z.object({
   /**
    * The type if the experience (nt_experiment | nt_personalization)
    */
-  nt_type: z.union([z.literal('nt_experiment'), z.literal('nt_personalization')]),
+  nt_type: z.union([z.string(), z.string()]),
   /**
    * The config of the experience (JSON)
    */
-  nt_config: Config.optional().nullable(),
+  nt_config: Config.optional().nullable().default(null).transform(val => {
+    return val !== null && val !== void 0 ? val : {
+      traffic: 0,
+      distribution: [0.5, 0.5],
+      components: []
+    };
+  }),
   /**
    * The audience of the experience (Audience)
    */
@@ -75,83 +112,115 @@ const ExperienceFields = z.object({
   /**
    * All used variants of the experience (Contentful references to other Content Types)
    */
-  nt_variants: z.array(Entry).default([])
+  nt_variants: z.array(EntrySchema).default([])
 });
-const ExperienceEntry = Entry.extend({
-  fields: ExperienceFields
+const ExperienceEntrySchema = EntrySchema.extend({
+  fields: ExperienceEntryFields
+});
+const parse = input => {
+  const output = ExperienceEntrySchema.parse(input);
+  return Object.assign(Object.assign({}, output), {
+    fields: Object.assign(Object.assign({}, output.fields), {
+      nt_variants: input.fields.nt_variants
+    })
+  });
+};
+const safeParse = input => {
+  const output = ExperienceEntrySchema.safeParse(input);
+  if (!output.success) {
+    return output;
+  }
+  return Object.assign(Object.assign({}, output), {
+    data: Object.assign(Object.assign({}, output.data), {
+      fields: Object.assign(Object.assign({}, output.data.fields), {
+        nt_variants: input.fields.nt_variants
+      })
+    })
+  });
+};
+const ExperienceEntry = Object.assign(Object.assign({}, ExperienceEntrySchema), {
+  parse,
+  safeParse
 });
 
 const ExperimentEntry = ExperienceEntry.extend({
-  fields: ExperienceFields.extend({
-    nt_type: z.literal('nt_experiment')
+  fields: ExperienceEntryFields.extend({
+    nt_type: z.string().regex(/^nt_experiment$/g)
   })
 });
 
-class AudienceMapper {
-  static mapAudience(audience) {
-    return {
-      id: audience.fields.nt_audience_id
-    };
+function mapAudience(ctfAudienceEntry) {
+  return {
+    id: ctfAudienceEntry.fields.nt_audience_id
+  };
+}
+function createExperience(id, fields, variants) {
+  const {
+    nt_name,
+    nt_type,
+    nt_audience,
+    nt_config
+  } = fields;
+  return Object.assign(Object.assign({
+    id,
+    name: nt_name,
+    type: nt_type
+  }, nt_audience ? {
+    audience: mapAudience(nt_audience)
+  } : {}), {
+    config: nt_config,
+    variants
+  });
+}
+function validateExperienceEntry(entry) {
+  const parsedExperience = ExperienceEntry.safeParse(entry);
+  if (!parsedExperience.success) {
+    logger.warn('[Ninetailed Contentful ExperienceMapper]', 'Error parsing experience', parsedExperience.error.format());
+    throw new Error(`[Ninetailed Contentful ExperienceMapper] The Experience Input is not valid. Please filter data first with "ExperienceMapper.isExperienceEntry".\n${JSON.stringify(parsedExperience.error.format(), null, 2)}`);
   }
+  return parsedExperience.data;
 }
-
-const isEntry = entry => {
-  return Entry.safeParse(entry).success;
-};
-
-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 parsedExperience = ExperienceEntry.safeParse(entry);
-    if (!parsedExperience.success) {
-      logger.warn('[Ninetailed Contentful ExperienceMapper]', 'Error parsing experience', parsedExperience.error.format());
-      throw new Error(`[Ninetailed Contentful ExperienceMapper] The Experience Input is not valid. Please filter data first with "ExperienceMapper.isExperienceEntry".\n${JSON.stringify(parsedExperience.error.format(), null, 2)}`);
-    }
+  static mapExperience(ctfEntry) {
     const {
-      sys: {
-        id
-      },
-      fields: {
-        nt_type,
-        nt_name,
-        nt_config,
-        nt_audience,
-        nt_variants
-      }
-    } = parsedExperience.data;
-    return ExperienceMapper$1.mapExperience(Object.assign(Object.assign(Object.assign({
-      id,
-      type: nt_type,
-      name: nt_name
-    }, nt_audience ? {
-      audience: AudienceMapper.mapAudience(nt_audience)
-    } : {}), nt_config ? {
-      config: nt_config
-    } : {}), {
-      variants: nt_variants.map(variant => _mapVariant(variant))
+      sys,
+      fields
+    } = validateExperienceEntry(ctfEntry);
+    const variants = fields.nt_variants.map(variant => Object.assign(Object.assign({}, variant), {
+      id: variant.sys.id
     }));
+    const experience = createExperience(sys.id, fields, variants);
+    return ExperienceMapper$1.mapExperience(experience);
+  }
+  static mapCustomExperience(ctfEntry, mapFn) {
+    const {
+      sys,
+      fields
+    } = validateExperienceEntry(ctfEntry);
+    const variants = fields.nt_variants.map(variantEntry => mapFn(variantEntry));
+    const experience = createExperience(sys.id, fields, variants);
+    return ExperienceMapper$1.mapExperience(experience);
   }
   static isExperiment(entry) {
     return ExperimentEntry.safeParse(entry).success;
   }
   static mapExperiment(entry) {
-    return ExperienceMapper.mapExperience(entry, {
-      mapVariant: () => ({
-        id: ''
-      })
-    });
+    return ExperienceMapper.mapCustomExperience(entry, () => ({
+      id: ''
+    }));
   }
   static mapBaselineWithExperiences(entry) {
-    return entry.fields.nt_experiences.filter(isEntry).map(experience => ExperienceMapper.mapExperience(experience));
+    return entry.fields.nt_experiences.filter(ExperienceMapper.isExperienceEntry).map(experience => ExperienceMapper.mapExperience(experience));
   }
 }
 
+const isEntry = entry => {
+  return Entry.safeParse(entry).success;
+};
+
 const isAudienceEntry = entry => {
   return AudienceEntry.safeParse(entry).success;
 };
@@ -160,4 +229,4 @@ const isExperienceEntry = entry => {
   return ExperienceEntry.safeParse(entry).success;
 };
 
-export { AudienceEntry, AudienceMapper, Entry, ExperienceEntry, ExperienceMapper, ExperimentEntry, isAudienceEntry, isEntry, isExperienceEntry };
+export { AudienceMapper, ExperienceMapper, isAudienceEntry, isEntry, isExperienceEntry };

package/lib/ExperienceMapper.d.ts

@@ -1,16 +1,103 @@
-import { ExperienceConfiguration } from '@ninetailed/experience.js';
-import { Variant } from '@ninetailed/experience.js-utils';
-import { ExperienceEntry, Entry, ExperimentEntry } from '../types';
+import { Reference } from '@ninetailed/experience.js';
 import { BaselineWithExperiencesEntry } from '../types/BaselineWithExperiencesEntry';
-export declare type MapVariant<VariantType extends Entry = Entry> = (variant: VariantType) => Variant;
-declare type MapExperienceOptions = {
-    mapVariant?: MapVariant;
-};
+import { EntryLike } from '../types/Entry';
+import { EntryFields } from '../types/EntryFields';
+import { ExperienceEntry, ExperienceEntryLike } from '../types/ExperienceEntry';
+import { ExperimentEntry, ExperimentEntryLike } from '../types/ExperimentEntry';
+export declare type MapVariantFunction<In extends EntryFields, Out extends Reference> = (input: EntryLike<In> & {
+    fields: In;
+}) => Out;
 export declare class ExperienceMapper {
-    static isExperienceEntry(entry: unknown): 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[];
+    static isExperienceEntry<Fields extends EntryFields>(entry: ExperienceEntryLike<Fields>): entry is ExperienceEntry<Fields>;
+    static mapExperience<VariantFields extends EntryFields>(ctfEntry: ExperienceEntryLike<VariantFields>): import("@ninetailed/experience.js").ExperienceConfiguration<{
+        id: string;
+        sys: {
+            type?: string | undefined;
+            createdAt?: string | undefined;
+            updatedAt?: string | undefined;
+            locale?: string | undefined;
+            revision?: number | undefined;
+            space?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Space";
+                };
+            } | undefined;
+            environment?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Environment";
+                };
+            } | undefined;
+            contentType?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "ContentType";
+                };
+            } | undefined;
+            id: string;
+        };
+        metadata?: {
+            tags: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Tag";
+                };
+            }[];
+        } | undefined;
+        fields: VariantFields;
+    }>;
+    static mapCustomExperience<Variant extends Reference, VariantFields extends EntryFields>(ctfEntry: ExperienceEntryLike<VariantFields>, mapFn: MapVariantFunction<VariantFields, Variant>): import("@ninetailed/experience.js").ExperienceConfiguration<Variant>;
+    static isExperiment(entry: ExperimentEntryLike): entry is ExperimentEntry;
+    static mapExperiment(entry: ExperienceEntry): import("@ninetailed/experience.js").ExperienceConfiguration<{
+        id: string;
+    }>;
+    static mapBaselineWithExperiences<Fields extends EntryFields>(entry: BaselineWithExperiencesEntry<Fields>): import("@ninetailed/experience.js").ExperienceConfiguration<{
+        id: string;
+        sys: {
+            type?: string | undefined;
+            createdAt?: string | undefined;
+            updatedAt?: string | undefined;
+            locale?: string | undefined;
+            revision?: number | undefined;
+            space?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Space";
+                };
+            } | undefined;
+            environment?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Environment";
+                };
+            } | undefined;
+            contentType?: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "ContentType";
+                };
+            } | undefined;
+            id: string;
+        };
+        metadata?: {
+            tags: {
+                sys: {
+                    type: "Link";
+                    id: string;
+                    linkType: "Tag";
+                };
+            }[];
+        } | undefined;
+        fields: {
+            [x: string]: unknown;
+        };
+    }>[];
 }
-export {};

package/lib/__test__/ntExperiences.d.ts

@@ -0,0 +1,229 @@
+export declare const EXPERIENCES: {
+    metadata: {
+        tags: never[];
+    };
+    sys: {
+        space: {
+            sys: {
+                type: "Link";
+                linkType: "Space";
+                id: string;
+            };
+        };
+        id: string;
+        type: "Entry";
+        createdAt: string;
+        updatedAt: string;
+        environment: {
+            sys: {
+                id: string;
+                type: "Link";
+                linkType: "Environment";
+            };
+        };
+        revision: number;
+        contentType: {
+            sys: {
+                type: "Link";
+                linkType: "ContentType";
+                id: string;
+            };
+        };
+        locale: string;
+    };
+    fields: {
+        nt_name: string;
+        nt_description: string;
+        nt_type: "nt_personalization";
+        nt_config: {
+            traffic: number;
+            components: {
+                baseline: {
+                    id: string;
+                    title: string;
+                };
+                variants: {
+                    id: string;
+                    hidden: boolean;
+                }[];
+            }[];
+            distribution: number[];
+        };
+        nt_audience: {
+            metadata: {
+                tags: never[];
+            };
+            sys: {
+                space: {
+                    sys: {
+                        type: "Link";
+                        linkType: "Space";
+                        id: string;
+                    };
+                };
+                id: string;
+                type: "Entry";
+                createdAt: string;
+                updatedAt: string;
+                environment: {
+                    sys: {
+                        id: string;
+                        type: "Link";
+                        linkType: "Environment";
+                    };
+                };
+                revision: number;
+                contentType: {
+                    sys: {
+                        type: "Link";
+                        linkType: "ContentType";
+                        id: string;
+                    };
+                };
+                locale: string;
+            };
+            fields: {
+                nt_name: string;
+                nt_rules: {
+                    any: {
+                        all: {
+                            type: string;
+                            operator: string;
+                            count: string;
+                            value: string;
+                            key: string;
+                            conditions: {
+                                key: {
+                                    id: string;
+                                    value: string;
+                                    key: string;
+                                    category: {
+                                        name: string;
+                                        label: string;
+                                        type: string;
+                                    };
+                                    label: string;
+                                    useOnce: boolean;
+                                };
+                                operator: string;
+                                value: string;
+                            }[];
+                        }[];
+                    }[];
+                };
+                nt_audience_id: string;
+            };
+        };
+        nt_variants: {
+            metadata: {
+                tags: never[];
+            };
+            sys: {
+                space: {
+                    sys: {
+                        type: "Link";
+                        linkType: "Space";
+                        id: string;
+                    };
+                };
+                id: string;
+                type: "Entry";
+                createdAt: string;
+                updatedAt: string;
+                environment: {
+                    sys: {
+                        id: string;
+                        type: "Link";
+                        linkType: "Environment";
+                    };
+                };
+                revision: number;
+                contentType: {
+                    sys: {
+                        type: "Link";
+                        linkType: "ContentType";
+                        id: string;
+                    };
+                };
+                locale: string;
+            };
+            fields: {
+                entryTitle: string;
+                variant: string;
+                description: {
+                    data: {};
+                    content: {
+                        data: {};
+                        content: {
+                            data: {};
+                            marks: {
+                                type: string;
+                            }[];
+                            value: string;
+                            nodeType: string;
+                        }[];
+                        nodeType: string;
+                    }[];
+                    nodeType: string;
+                };
+                desktopImage: {
+                    url: string;
+                    tags: never[];
+                    type: string;
+                    bytes: number;
+                    width: number;
+                    format: string;
+                    height: number;
+                    context: {
+                        custom: {
+                            alt: string;
+                        };
+                    };
+                    version: number;
+                    duration: null;
+                    metadata: never[];
+                    public_id: string;
+                    created_at: string;
+                    secure_url: string;
+                    original_url: string;
+                    resource_type: string;
+                    raw_transformation: string;
+                    original_secure_url: string;
+                }[];
+                mobileImage: {
+                    url: string;
+                    tags: never[];
+                    type: string;
+                    bytes: number;
+                    width: number;
+                    format: string;
+                    height: number;
+                    context: {
+                        custom: {
+                            alt: string;
+                        };
+                    };
+                    version: number;
+                    duration: null;
+                    metadata: never[];
+                    public_id: string;
+                    created_at: string;
+                    secure_url: string;
+                    original_url: string;
+                    resource_type: string;
+                    raw_transformation: string;
+                    original_secure_url: string;
+                }[];
+                ctaLink: {
+                    id: string;
+                    url: string;
+                    type: string;
+                    label: string;
+                }[];
+                theme: string;
+                headline: string;
+                headlineStyle: string;
+            };
+        }[];
+    };
+}[];

package/lib/isAudienceEntry.d.ts

@@ -1,5 +1,5 @@
-import { Entry } from '../types';
-export declare const isAudienceEntry: (entry?: Entry) => entry is {
+import { AudienceEntryLike } from '../types/AudienceEntry';
+export declare const isAudienceEntry: (entry: AudienceEntryLike) => entry is {
     metadata?: {
         tags: {
             sys: {
@@ -39,6 +39,7 @@ export declare const isAudienceEntry: (entry?: Entry) => entry is {
         id: string;
     };
     fields: {
+        [x: string]: unknown;
         nt_name: string;
         nt_audience_id: string;
     };