@ninetailed/experience.js-utils-contentful 3.0.1-beta.4 → 3.0.2-beta.0

package/index.cjs

@@ -0,0 +1,233 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var zod = require('zod');
+var experience_jsShared = require('@ninetailed/experience.js-shared');
+var experience_jsUtils = require('@ninetailed/experience.js-utils');
+
+const EntryFields = zod.z.object({}).catchall(zod.z.unknown());
+
+const EntryLink = zod.z.object({
+  type: zod.z.string(),
+  linkType: zod.z.string(),
+  id: zod.z.string()
+});
+const EntrySchema = zod.z.object({
+  sys: zod.z.object({
+    type: zod.z.string().optional(),
+    id: zod.z.string(),
+    createdAt: zod.z.string().optional(),
+    updatedAt: zod.z.string().optional(),
+    locale: zod.z.string().optional(),
+    revision: zod.z.number().optional(),
+    space: zod.z.object({
+      sys: EntryLink.extend({
+        linkType: zod.z.string()
+      })
+    }).optional(),
+    environment: zod.z.object({
+      sys: EntryLink.extend({
+        linkType: zod.z.string()
+      })
+    }).optional(),
+    contentType: zod.z.object({
+      sys: EntryLink.extend({
+        linkType: zod.z.string()
+      })
+    }).optional()
+  }),
+  fields: EntryFields,
+  metadata: zod.z.object({
+    tags: zod.z.array(zod.z.object({
+      sys: EntryLink.extend({
+        linkType: zod.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 AudienceEntryFields = EntryFields.extend({
+  /**
+   * The name of the audience (Short Text)
+   */
+  nt_name: zod.z.string(),
+  /**
+   * The internal id of the audience (Short Text)
+   */
+  nt_audience_id: zod.z.string()
+});
+const AudienceEntry = EntrySchema.extend({
+  fields: AudienceEntryFields
+});
+
+class AudienceMapper {
+  static mapAudience(audience) {
+    return {
+      id: audience.fields.nt_audience_id
+    };
+  }
+}
+AudienceMapper.isAudienceEntry = entry => {
+  return AudienceEntry.safeParse(entry).success;
+};
+
+const ExperienceEntryFields = zod.z.object({
+  /**
+   * The name of the experience (Short Text)
+   */
+  nt_name: zod.z.string(),
+  /**
+   * The type if the experience (nt_experiment | nt_personalization)
+   */
+  nt_type: zod.z.union([zod.z.string(), zod.z.string()]),
+  /**
+   * The config of the experience (JSON)
+   */
+  nt_config: experience_jsUtils.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)
+   */
+  nt_audience: AudienceEntry.optional().nullable(),
+  /**
+   * All used variants of the experience (Contentful references to other Content Types)
+   */
+  nt_variants: zod.z.array(EntrySchema).optional()
+});
+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: ExperienceEntryFields.extend({
+    nt_type: zod.z.string().regex(/^nt_experiment$/g)
+  })
+});
+
+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) {
+    experience_jsShared.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;
+}
+class ExperienceMapper {
+  static isExperienceEntry(entry) {
+    return ExperienceEntry.safeParse(entry).success;
+  }
+  static mapExperience(ctfEntry) {
+    const {
+      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 experience_jsUtils.ExperienceMapper.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 experience_jsUtils.ExperienceMapper.mapExperience(experience);
+  }
+  static isExperiment(entry) {
+    return ExperimentEntry.safeParse(entry).success;
+  }
+  static mapExperiment(entry) {
+    return ExperienceMapper.mapCustomExperience(entry, () => ({
+      id: ''
+    }));
+  }
+  static mapBaselineWithExperiences(entry) {
+    return entry.fields.nt_experiences.filter(ExperienceMapper.isExperienceEntry).map(experience => ExperienceMapper.mapExperience(experience));
+  }
+}
+
+const isEntry = entry => {
+  return Entry.safeParse(entry).success;
+};
+
+exports.AudienceMapper = AudienceMapper;
+exports.ExperienceMapper = ExperienceMapper;
+exports.isEntry = isEntry;

package/index.d.ts

@@ -1,3 +1,9 @@
-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 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

@@ -0,0 +1,227 @@
+import { z } from 'zod';
+import { logger } from '@ninetailed/experience.js-shared';
+import { Config, ExperienceMapper as ExperienceMapper$1 } from '@ninetailed/experience.js-utils';
+
+const EntryFields = z.object({}).catchall(z.unknown());
+
+const EntryLink = z.object({
+  type: z.string(),
+  linkType: z.string(),
+  id: z.string()
+});
+const EntrySchema = z.object({
+  sys: z.object({
+    type: z.string().optional(),
+    id: z.string(),
+    createdAt: z.string().optional(),
+    updatedAt: z.string().optional(),
+    locale: z.string().optional(),
+    revision: z.number().optional(),
+    space: z.object({
+      sys: EntryLink.extend({
+        linkType: z.string()
+      })
+    }).optional(),
+    environment: z.object({
+      sys: EntryLink.extend({
+        linkType: z.string()
+      })
+    }).optional(),
+    contentType: z.object({
+      sys: EntryLink.extend({
+        linkType: z.string()
+      })
+    }).optional()
+  }),
+  fields: EntryFields,
+  metadata: z.object({
+    tags: z.array(z.object({
+      sys: EntryLink.extend({
+        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 AudienceEntryFields = EntryFields.extend({
+  /**
+   * The name of the audience (Short Text)
+   */
+  nt_name: z.string(),
+  /**
+   * The internal id of the audience (Short Text)
+   */
+  nt_audience_id: z.string()
+});
+const AudienceEntry = EntrySchema.extend({
+  fields: AudienceEntryFields
+});
+
+class AudienceMapper {
+  static mapAudience(audience) {
+    return {
+      id: audience.fields.nt_audience_id
+    };
+  }
+}
+AudienceMapper.isAudienceEntry = entry => {
+  return AudienceEntry.safeParse(entry).success;
+};
+
+const ExperienceEntryFields = z.object({
+  /**
+   * The name of the experience (Short Text)
+   */
+  nt_name: z.string(),
+  /**
+   * The type if the experience (nt_experiment | nt_personalization)
+   */
+  nt_type: z.union([z.string(), z.string()]),
+  /**
+   * The config of the experience (JSON)
+   */
+  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)
+   */
+  nt_audience: AudienceEntry.optional().nullable(),
+  /**
+   * All used variants of the experience (Contentful references to other Content Types)
+   */
+  nt_variants: z.array(EntrySchema).optional()
+});
+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: ExperienceEntryFields.extend({
+    nt_type: z.string().regex(/^nt_experiment$/g)
+  })
+});
+
+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;
+}
+class ExperienceMapper {
+  static isExperienceEntry(entry) {
+    return ExperienceEntry.safeParse(entry).success;
+  }
+  static mapExperience(ctfEntry) {
+    const {
+      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.mapCustomExperience(entry, () => ({
+      id: ''
+    }));
+  }
+  static mapBaselineWithExperiences(entry) {
+    return entry.fields.nt_experiences.filter(ExperienceMapper.isExperienceEntry).map(experience => ExperienceMapper.mapExperience(experience));
+  }
+}
+
+const isEntry = entry => {
+  return Entry.safeParse(entry).success;
+};
+
+export { AudienceMapper, ExperienceMapper, isEntry };

package/lib/AudienceMapper.d.ts

@@ -1,5 +1,51 @@
 import { Audience } from '@ninetailed/experience.js-utils';
 import { AudienceEntry } from '../types/AudienceEntry';
+import type { AudienceEntryLike } from '../types/AudienceEntry';
 export declare class AudienceMapper {
+    static isAudienceEntry: (entry: AudienceEntryLike) => entry is {
+        metadata?: {
+            tags: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            }[];
+        } | undefined;
+        sys: {
+            type?: string | undefined;
+            createdAt?: string | undefined;
+            updatedAt?: string | undefined;
+            locale?: string | undefined;
+            revision?: number | undefined;
+            space?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            environment?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            contentType?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            id: string;
+        };
+        fields: {
+            [x: string]: unknown;
+            nt_name: string;
+            nt_audience_id: string;
+        };
+    };
     static mapAudience(audience: AudienceEntry): Audience;
 }

package/lib/ExperienceMapper.d.ts

@@ -1,16 +1,101 @@
-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 type { EntryFields } from '../types/EntryFields';
+import { ExperienceEntry, ExperienceEntryLike } from '../types/ExperienceEntry';
+import { ExperimentEntry } 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<VariantFields extends EntryFields>(entry: ExperienceEntryLike<VariantFields>): entry is ExperienceEntry<VariantFields>;
+    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: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            environment?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            contentType?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            id: string;
+        };
+        metadata?: {
+            tags: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            }[];
+        } | 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: ExperienceEntryLike): entry is ExperimentEntry;
+    static mapExperiment(entry: ExperienceEntryLike): 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: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            environment?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            contentType?: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            } | undefined;
+            id: string;
+        };
+        metadata?: {
+            tags: {
+                sys: {
+                    type: string;
+                    id: string;
+                    linkType: string;
+                };
+            }[];
+        } | undefined;
+        fields: object;
+    }>[];
 }
-export {};