@reactionary/fake 0.9.0 → 0.9.1

package/capabilities/feature-flag.capability.js

@@ -0,0 +1,50 @@
+import {
+  FeatureFlagCapability,
+  success
+} from "@reactionary/core";
+class FakeFeatureFlagCapability extends FeatureFlagCapability {
+  config;
+  factory;
+  flagDefinitions;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+    this.flagDefinitions = new Map(config.featureFlags?.flags.map((f) => [f.key, f]) ?? []);
+  }
+  async getFlags(payload) {
+    const flags = payload.featureFlagIdentifiers.map((id) => {
+      const raw = this.evaluateFlag(id.key);
+      return this.factory.parseFeatureFlag(this.context, raw);
+    });
+    return success(flags);
+  }
+  evaluateFlag(key) {
+    const definition = this.flagDefinitions.get(key);
+    if (!definition) {
+      return {
+        identifier: { key },
+        type: "boolean",
+        enabled: false
+      };
+    }
+    if (definition.type === "boolean") {
+      return {
+        identifier: { key },
+        type: "boolean",
+        enabled: definition.enabled
+      };
+    }
+    return {
+      identifier: { key },
+      type: "multivariate",
+      variants: definition.variants.map((name) => ({
+        name,
+        enabled: name === definition.enabledVariant
+      }))
+    };
+  }
+}
+export {
+  FakeFeatureFlagCapability
+};

package/capabilities/index.js

@@ -2,8 +2,10 @@ export * from "./analytics.capability.js";
 export * from "./cart.capability.js";
 export * from "./category.capability.js";
 export * from "./checkout.capability.js";
+export * from "./feature-flag.capability.js";
 export * from "./identity.capability.js";
 export * from "./inventory.capability.js";
+export * from "./personalization-profile.capability.js";
 export * from "./order-search.capability.js";
 export * from "./order.capability.js";
 export * from "./price.capability.js";

package/capabilities/personalization-profile.capability.js

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  PersonalizationProfileCapability,
+  PersonalizationProfileQueryGetProfileSchema,
+  PersonalizationProfileSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import { calcSeed } from "../utilities/seed.js";
+const SEGMENTS = ["Big Spender", "Tech Head", "Newbie", "Gift Giver"];
+const BLURBS = [
+  "Loves hiking and outdoor gear but dislikes crowded malls and slow shipping times on weekend orders",
+  "Enjoys premium coffee and artisan food products while avoiding mass-produced snacks and cheap packaging materials",
+  "Passionate about smart home gadgets and wireless tech but frustrated by complicated setup processes and poor documentation",
+  "Prefers sustainable and eco-friendly brands over fast fashion and tends to research products thoroughly before buying",
+  "Avid reader who collects rare editions and dislikes digital-only content preferring tactile experiences with real pages",
+  "Fitness enthusiast who tracks every metric and avoids sugary supplements preferring clean ingredients and minimal branding",
+  "Enjoys cooking exotic cuisines at home and dislikes pre-packaged meal kits that lack authentic spices and herbs",
+  "Tech-savvy parent who values educational toys and screen-free activities but dislikes overly gendered product marketing campaigns"
+];
+class FakePersonalizationProfileCapability extends PersonalizationProfileCapability {
+  config;
+  factory;
+  constructor(config, cache, context, factory) {
+    super(cache, context);
+    this.config = config;
+    this.factory = factory;
+  }
+  async getPersonalizationProfile(payload) {
+    const identity = payload.identity;
+    if (identity.type === "Registered") {
+      const userId = identity.id.userId;
+      const seed = calcSeed(userId);
+      const profileKey = hashToHex(seed);
+      const segmentCount = 2 + Math.abs(seed) % 3;
+      const segments = pickDeterministic(SEGMENTS, segmentCount, seed);
+      const blurbIdx = Math.abs(seed) % BLURBS.length;
+      const blurb = BLURBS[blurbIdx];
+      return success(this.factory.parsePersonalizationProfile(this.context, {
+        identifier: { key: profileKey },
+        segments,
+        blurb
+      }));
+    }
+    const anonSeed = calcSeed(Date.now().toString() + Math.random().toString());
+    const anonKey = hashToHex(anonSeed);
+    return success(this.factory.parsePersonalizationProfile(this.context, {
+      identifier: { key: anonKey },
+      segments: [],
+      blurb: ""
+    }));
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: PersonalizationProfileQueryGetProfileSchema,
+    outputSchema: PersonalizationProfileSchema
+  })
+], FakePersonalizationProfileCapability.prototype, "getPersonalizationProfile", 1);
+function hashToHex(seed) {
+  const abs = Math.abs(seed) >>> 0;
+  return abs.toString(16).padStart(8, "0");
+}
+function pickDeterministic(items, count, seed) {
+  const picked = [];
+  const available = [...items];
+  let s = Math.abs(seed);
+  for (let i = 0; i < count && available.length > 0; i++) {
+    const idx = s % available.length;
+    picked.push(available[idx]);
+    available.splice(idx, 1);
+    s = Math.abs(calcSeed(s.toString()));
+  }
+  return picked;
+}
+export {
+  FakePersonalizationProfileCapability
+};

package/core/initialize.js

@@ -19,7 +19,9 @@ import {
   ProductSearchResultSchema as CoreProductSearchResultSchema,
   ProfileSchema as CoreProfileSchema,
   ShippingMethodSchema as CoreShippingMethodSchema,
-  StoreSchema as CoreStoreSchema
+  StoreSchema as CoreStoreSchema,
+  FeatureFlagSchema as CoreFeatureFlagSchema,
+  PersonalizationProfileSchema as CorePersonalizationProfileSchema
 } from "@reactionary/core";
 import { FakeProductCapability } from "../capabilities/product.capability.js";
 import { FakeProductSearchCapability } from "../capabilities/product-search.capability.js";
@@ -38,12 +40,16 @@ import { FakeOrderCapability } from "../capabilities/order.capability.js";
 import { FakeProfileCapability } from "../capabilities/profile.capability.js";
 import { FakeProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
 import { FakeProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import { FakeFeatureFlagCapability } from "../capabilities/feature-flag.capability.js";
+import { FakePersonalizationProfileCapability } from "../capabilities/personalization-profile.capability.js";
 import {
   FakeCartFactory,
   FakeCategoryFactory,
   FakeCheckoutFactory,
+  FakeFeatureFlagFactory,
   FakeIdentityFactory,
   FakeInventoryFactory,
+  FakePersonalizationProfileFactory,
   FakeOrderFactory,
   FakeOrderSearchFactory,
   FakePriceFactory,
@@ -232,6 +238,26 @@ function withFakeCapabilities(configuration, capabilities) {
         buildCapabilityArgs
       );
     }
+    if (caps.featureFlag?.enabled) {
+      client.featureFlag = resolveCapabilityWithFactory(
+        capabilities.featureFlag,
+        {
+          factory: new FakeFeatureFlagFactory(CoreFeatureFlagSchema),
+          capability: (args) => new FakeFeatureFlagCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
+    if (caps.personalizationProfile?.enabled) {
+      client.personalizationProfile = resolveCapabilityWithFactory(
+        capabilities.personalizationProfile,
+        {
+          factory: new FakePersonalizationProfileFactory(CorePersonalizationProfileSchema),
+          capability: (args) => new FakePersonalizationProfileCapability(args.config, args.cache, args.context, args.factory)
+        },
+        buildCapabilityArgs
+      );
+    }
     return client;
   };
 }

package/factories/feature-flag/feature-flag.factory.js

@@ -0,0 +1,12 @@
+class FakeFeatureFlagFactory {
+  featureFlagSchema;
+  constructor(featureFlagSchema) {
+    this.featureFlagSchema = featureFlagSchema;
+  }
+  parseFeatureFlag(_context, data) {
+    return this.featureFlagSchema.parse(data);
+  }
+}
+export {
+  FakeFeatureFlagFactory
+};

package/factories/index.js

@@ -1,8 +1,10 @@
 export * from "./cart/cart.factory.js";
 export * from "./category/category.factory.js";
 export * from "./checkout/checkout.factory.js";
+export * from "./feature-flag/feature-flag.factory.js";
 export * from "./identity/identity.factory.js";
 export * from "./inventory/inventory.factory.js";
+export * from "./personalization-profile/personalization-profile.factory.js";
 export * from "./order-search/order-search.factory.js";
 export * from "./order/order.factory.js";
 export * from "./price/price.factory.js";

package/factories/personalization-profile/personalization-profile.factory.js

@@ -0,0 +1,12 @@
+class FakePersonalizationProfileFactory {
+  personalizationProfileSchema;
+  constructor(personalizationProfileSchema) {
+    this.personalizationProfileSchema = personalizationProfileSchema;
+  }
+  parsePersonalizationProfile(_context, data) {
+    return this.personalizationProfileSchema.parse(data);
+  }
+}
+export {
+  FakePersonalizationProfileFactory
+};

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@reactionary/fake",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
   "dependencies": {
     "vitest": "^4.0.9",
     "@nx/vite": "22.4.5",
-    "@reactionary/core": "0.9.0",
+    "@reactionary/core": "0.9.1",
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
   },

package/schema/capabilities.schema.js

@@ -19,7 +19,9 @@ const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   orderSearch: true,
   profile: true,
   productReviews: true,
-  productAssociations: true
+  productAssociations: true,
+  featureFlag: true,
+  personalizationProfile: true
 }).extend({
   product: OverridableCapabilitySchema.optional(),
   productSearch: OverridableCapabilitySchema.optional(),
@@ -34,7 +36,9 @@ const FakeCapabilitiesSchema = CapabilitiesSchema.pick({
   orderSearch: OverridableCapabilitySchema.optional(),
   profile: OverridableCapabilitySchema.optional(),
   productReviews: OverridableCapabilitySchema.optional(),
-  productAssociations: OverridableCapabilitySchema.optional()
+  productAssociations: OverridableCapabilitySchema.optional(),
+  featureFlag: OverridableCapabilitySchema.optional(),
+  personalizationProfile: OverridableCapabilitySchema.optional()
 }).partial();
 export {
   FakeCapabilitiesSchema

package/schema/configuration.schema.js

@@ -1,4 +1,22 @@
 import * as z from "zod";
+const BooleanFeatureFlagDefinitionSchema = z.looseObject({
+  key: z.string(),
+  type: z.literal("boolean"),
+  enabled: z.boolean()
+});
+const MultivariateFeatureFlagDefinitionSchema = z.looseObject({
+  key: z.string(),
+  type: z.literal("multivariate"),
+  variants: z.array(z.string()),
+  enabledVariant: z.string()
+});
+const FakeFeatureFlagDefinitionSchema = z.discriminatedUnion("type", [
+  BooleanFeatureFlagDefinitionSchema,
+  MultivariateFeatureFlagDefinitionSchema
+]);
+const FakeConfigurationFeatureFlagsSchema = z.looseObject({
+  flags: z.array(FakeFeatureFlagDefinitionSchema).default([])
+});
 const FakeConfigurationSchema = z.looseObject({
   jitter: z.looseObject({
     mean: z.number().min(0).max(1e4),
@@ -11,7 +29,8 @@ const FakeConfigurationSchema = z.looseObject({
     product: z.number().min(0).max(1e4).default(1),
     search: z.number().min(0).max(1e4).default(1),
     category: z.number().min(0).max(1e4).default(1)
-  })
+  }),
+  featureFlags: FakeConfigurationFeatureFlagsSchema.optional()
 });
 export {
   FakeConfigurationSchema

package/src/capabilities/feature-flag.capability.d.ts

@@ -0,0 +1,12 @@
+import type { Cache, FeatureFlagFactory, FeatureFlagFactoryOutput, FeatureFlagFactoryWithOutput, FeatureFlagQueryGetFlags, RequestContext, Result } from '@reactionary/core';
+import { FeatureFlagCapability } from '@reactionary/core';
+import type { FakeConfiguration, FakeFeatureFlagDefinition } from '../schema/configuration.schema.js';
+import type { FakeFeatureFlagFactory } from '../factories/feature-flag/feature-flag.factory.js';
+export declare class FakeFeatureFlagCapability<TFactory extends FeatureFlagFactory = FakeFeatureFlagFactory> extends FeatureFlagCapability<FeatureFlagFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: FeatureFlagFactoryWithOutput<TFactory>;
+    protected flagDefinitions: Map<string, FakeFeatureFlagDefinition>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: FeatureFlagFactoryWithOutput<TFactory>);
+    getFlags(payload: FeatureFlagQueryGetFlags): Promise<Result<FeatureFlagFactoryOutput<TFactory>[]>>;
+    private evaluateFlag;
+}

package/src/capabilities/index.d.ts

@@ -2,8 +2,10 @@ export * from './analytics.capability.js';
 export * from './cart.capability.js';
 export * from './category.capability.js';
 export * from './checkout.capability.js';
+export * from './feature-flag.capability.js';
 export * from './identity.capability.js';
 export * from './inventory.capability.js';
+export * from './personalization-profile.capability.js';
 export * from './order-search.capability.js';
 export * from './order.capability.js';
 export * from './price.capability.js';

package/src/capabilities/personalization-profile.capability.d.ts

@@ -0,0 +1,10 @@
+import type { Cache, PersonalizationProfileFactory, PersonalizationProfileFactoryOutput, PersonalizationProfileFactoryWithOutput, PersonalizationProfileQueryGetProfile, NotFoundError, RequestContext, Result } from '@reactionary/core';
+import { PersonalizationProfileCapability } from '@reactionary/core';
+import type { FakeConfiguration } from '../schema/configuration.schema.js';
+import type { FakePersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
+export declare class FakePersonalizationProfileCapability<TFactory extends PersonalizationProfileFactory = FakePersonalizationProfileFactory> extends PersonalizationProfileCapability<PersonalizationProfileFactoryOutput<TFactory>> {
+    protected config: FakeConfiguration;
+    protected factory: PersonalizationProfileFactoryWithOutput<TFactory>;
+    constructor(config: FakeConfiguration, cache: Cache, context: RequestContext, factory: PersonalizationProfileFactoryWithOutput<TFactory>);
+    getPersonalizationProfile(payload: PersonalizationProfileQueryGetProfile): Promise<Result<PersonalizationProfileFactoryOutput<TFactory>, NotFoundError>>;
+}

package/src/core/initialize.types.d.ts

@@ -1,4 +1,4 @@
-import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, IdentityFactory, InventoryFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductReviewsFactory, ProductSearchFactory, ProfileFactory, StoreFactory } from '@reactionary/core';
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, FeatureFlagFactory, IdentityFactory, InventoryFactory, PersonalizationProfileFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, ProductReviewsFactory, ProductSearchFactory, ProfileFactory, StoreFactory } from '@reactionary/core';
 import type { FakeCapabilities } from '../schema/capabilities.schema.js';
 import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
 import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
@@ -14,6 +14,8 @@ import type { FakeProductReviewsFactory } from '../factories/product-reviews/pro
 import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
 import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
 import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+import type { FakeFeatureFlagFactory } from '../factories/feature-flag/feature-flag.factory.js';
+import type { FakePersonalizationProfileFactory } from '../factories/personalization-profile/personalization-profile.factory.js';
 import type { FakeCartCapability } from '../capabilities/cart.capability.js';
 import type { FakeCategoryCapability } from '../capabilities/category.capability.js';
 import type { FakeCheckoutCapability } from '../capabilities/checkout.capability.js';
@@ -28,6 +30,8 @@ import type { FakeProductReviewsCapability } from '../capabilities/product-revie
 import type { FakeProductSearchCapability } from '../capabilities/product-search.capability.js';
 import type { FakeProfileCapability } from '../capabilities/profile.capability.js';
 import type { FakeStoreCapability } from '../capabilities/store.capability.js';
+import type { FakeFeatureFlagCapability } from '../capabilities/feature-flag.capability.js';
+import type { FakePersonalizationProfileCapability } from '../capabilities/personalization-profile.capability.js';
 type FakeCapabilityKey = keyof FakeCapabilities;
 type EnabledCapability<TCapability> = TCapability extends {
     enabled: true;
@@ -58,6 +62,8 @@ type FactoryContractMap = {
     profile: ProfileFactory;
     productReviews: ProductReviewsFactory;
     productAssociations: ProductAssociationsFactory;
+    featureFlag: FeatureFlagFactory;
+    personalizationProfile: PersonalizationProfileFactory;
 };
 type DefaultFactoryMap = {
     product: FakeProductFactory;
@@ -74,6 +80,8 @@ type DefaultFactoryMap = {
     profile: FakeProfileFactory;
     productReviews: FakeProductReviewsFactory;
     productAssociations: FakeProductAssociationsFactory;
+    featureFlag: FakeFeatureFlagFactory;
+    personalizationProfile: FakePersonalizationProfileFactory;
 };
 type ResolvedFactoryMap<T extends FakeCapabilities> = {
     [K in FakeCapabilityKey]: ExtractCapabilityFactory<T[K], FactoryContractMap[K], DefaultFactoryMap[K]>;
@@ -93,6 +101,8 @@ type DefaultCapabilityMap<T extends FakeCapabilities> = {
     profile: FakeProfileCapability<ResolvedFactoryMap<T>['profile']>;
     productReviews: FakeProductReviewsCapability<ResolvedFactoryMap<T>['productReviews']>;
     productAssociations: FakeProductAssociationsCapability<ResolvedFactoryMap<T>['productAssociations']>;
+    featureFlag: FakeFeatureFlagCapability<ResolvedFactoryMap<T>['featureFlag']>;
+    personalizationProfile: FakePersonalizationProfileCapability<ResolvedFactoryMap<T>['personalizationProfile']>;
 };
 type CapabilityImplementationMap<T extends FakeCapabilities> = {
     [K in FakeCapabilityKey]: ExtractCapabilityImplementation<T[K], DefaultCapabilityMap<T>[K]>;

package/src/factories/feature-flag/feature-flag.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyFeatureFlagSchema, FeatureFlagFactory, FeatureFlagSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakeFeatureFlagFactory<TFeatureFlagSchema extends AnyFeatureFlagSchema = typeof FeatureFlagSchema> implements FeatureFlagFactory<TFeatureFlagSchema> {
+    readonly featureFlagSchema: TFeatureFlagSchema;
+    constructor(featureFlagSchema: TFeatureFlagSchema);
+    parseFeatureFlag(_context: RequestContext, data: unknown): z.output<TFeatureFlagSchema>;
+}

package/src/factories/index.d.ts

@@ -1,8 +1,10 @@
 export * from './cart/cart.factory.js';
 export * from './category/category.factory.js';
 export * from './checkout/checkout.factory.js';
+export * from './feature-flag/feature-flag.factory.js';
 export * from './identity/identity.factory.js';
 export * from './inventory/inventory.factory.js';
+export * from './personalization-profile/personalization-profile.factory.js';
 export * from './order-search/order-search.factory.js';
 export * from './order/order.factory.js';
 export * from './price/price.factory.js';

package/src/factories/personalization-profile/personalization-profile.factory.d.ts

@@ -0,0 +1,7 @@
+import type { AnyPersonalizationProfileSchema, PersonalizationProfileFactory, PersonalizationProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class FakePersonalizationProfileFactory<TPersonalizationProfileSchema extends AnyPersonalizationProfileSchema = typeof PersonalizationProfileSchema> implements PersonalizationProfileFactory<TPersonalizationProfileSchema> {
+    readonly personalizationProfileSchema: TPersonalizationProfileSchema;
+    constructor(personalizationProfileSchema: TPersonalizationProfileSchema);
+    parsePersonalizationProfile(_context: RequestContext, data: unknown): z.output<TPersonalizationProfileSchema>;
+}

package/src/schema/capabilities.schema.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, ProductReviewsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, StoreFactory, StoreFactoryWithOutput, StoreCapability } from '@reactionary/core';
+import type { Cache, CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, FeatureFlagFactory, FeatureFlagFactoryWithOutput, FeatureFlagCapability, IdentityFactory, IdentityFactoryWithOutput, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, PersonalizationProfileFactory, PersonalizationProfileFactoryWithOutput, PersonalizationProfileCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductReviewsFactory, ProductReviewsFactoryWithOutput, ProductReviewsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, StoreFactory, StoreFactoryWithOutput, StoreCapability } from '@reactionary/core';
 import type { FakeConfiguration } from './configuration.schema.js';
 import * as z from 'zod';
 export declare const FakeCapabilitiesSchema: z.ZodObject<{
@@ -72,6 +72,16 @@ export declare const FakeCapabilitiesSchema: z.ZodObject<{
         factory: z.ZodOptional<z.ZodUnknown>;
         capability: z.ZodOptional<z.ZodUnknown>;
     }, z.core.$loose>>>;
+    featureFlag: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    personalizationProfile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
 }, z.core.$loose>;
 export interface FakeCapabilityFactoryArgs<TFactory> {
     cache: Cache;
@@ -98,6 +108,8 @@ export type FakeOrderSearchCapabilityConfig = FakeCapabilityConfig<OrderSearchFa
 export type FakeProfileCapabilityConfig = FakeCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
 export type FakeProductReviewsCapabilityConfig = FakeCapabilityConfig<ProductReviewsFactoryWithOutput<ProductReviewsFactory>, ProductReviewsCapability>;
 export type FakeProductAssociationsCapabilityConfig = FakeCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+export type FakeFeatureFlagCapabilityConfig = FakeCapabilityConfig<FeatureFlagFactoryWithOutput<FeatureFlagFactory>, FeatureFlagCapability>;
+export type FakePersonalizationProfileCapabilityConfig = FakeCapabilityConfig<PersonalizationProfileFactoryWithOutput<PersonalizationProfileFactory>, PersonalizationProfileCapability>;
 export type FakeCapabilities = {
     product?: FakeProductCapabilityConfig;
     productSearch?: FakeProductSearchCapabilityConfig;
@@ -113,5 +125,7 @@ export type FakeCapabilities = {
     profile?: FakeProfileCapabilityConfig;
     productReviews?: FakeProductReviewsCapabilityConfig;
     productAssociations?: FakeProductAssociationsCapabilityConfig;
+    featureFlag?: FakeFeatureFlagCapabilityConfig;
+    personalizationProfile?: FakePersonalizationProfileCapabilityConfig;
 };
 export type ParsedFakeCapabilities = z.infer<typeof FakeCapabilitiesSchema>;

package/src/schema/configuration.schema.d.ts

@@ -1,4 +1,14 @@
 import * as z from 'zod';
+declare const FakeFeatureFlagDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"boolean">;
+    enabled: z.ZodBoolean;
+}, z.core.$loose>, z.ZodObject<{
+    key: z.ZodString;
+    type: z.ZodLiteral<"multivariate">;
+    variants: z.ZodArray<z.ZodString>;
+    enabledVariant: z.ZodString;
+}, z.core.$loose>], "type">;
 export declare const FakeConfigurationSchema: z.ZodObject<{
     jitter: z.ZodDefault<z.ZodObject<{
         mean: z.ZodNumber;
@@ -9,5 +19,19 @@ export declare const FakeConfigurationSchema: z.ZodObject<{
         search: z.ZodDefault<z.ZodNumber>;
         category: z.ZodDefault<z.ZodNumber>;
     }, z.core.$loose>;
+    featureFlags: z.ZodOptional<z.ZodObject<{
+        flags: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodLiteral<"boolean">;
+            enabled: z.ZodBoolean;
+        }, z.core.$loose>, z.ZodObject<{
+            key: z.ZodString;
+            type: z.ZodLiteral<"multivariate">;
+            variants: z.ZodArray<z.ZodString>;
+            enabledVariant: z.ZodString;
+        }, z.core.$loose>], "type">>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type FakeConfiguration = z.infer<typeof FakeConfigurationSchema>;
+export type FakeFeatureFlagDefinition = z.infer<typeof FakeFeatureFlagDefinitionSchema>;
+export {};