Decide methods for the JavaScript SDK v6+

// create the user and decide which flag rule and variation they bucket into 
const attributes = {
  logged_in: true
};
const user = optimizely.createUserContext('user123', attributes);
const decision = user.decide('product_sort');

// The variation key. if null, decision failed with a critical error
const variationKey = decision['variationKey'];
if (variationKey === null) {
  console.log(' decision error: ', decision['reasons']);
}

// The flag enabled state.
const enabled = decision['enabled'];

// String variable value.
const value = decision.variables['sort_method'];

// All variable values.
const allVarValues = decision['variables'];

// Flag decision reasons.
const reasons = decision['reasons'];

// User for which the decision was made.
const userContext = decision['userContext'];

import {
  createInstance,
  createPollingProjectConfigManager,
  createBatchEventProcessor,
  createOdpManager,
  createVuidManager,
  UserProfile,
  Client,
} from "@optimizely/optimizely-sdk";

const pollingConfigManager = createPollingProjectConfigManager({
  sdkKey: "YOUR_SDK_KEY", // Replace with your SDK key
});

const batchEventProcessor = createBatchEventProcessor();

const odpManager = createOdpManager();

const vuidManager = createVuidManager({
  enableVuid: true,
});

// Simulated async implementation of UserProfileServiceAsync using timeouts
export class InMemoryUserProfileServiceAsync {
  private store = new Map();

  async lookup(userId: string): Promise<UserProfile> {
    return new Promise((resolve) => {
      setTimeout(() => {
        const profile = this.store.get(userId);
        resolve(profile ?? { user_id: userId, experimentBucketMap: {} });
      }, 10); // simulate async delay
    });
  }

  async save(profile: UserProfile): Promise<void> {
    return new Promise((resolve) => {
      setTimeout(() => {
        this.store.set(profile.user_id, profile);
        resolve();
      }, 10); // simulate async delay
    });
  }
}

const optimizelyClient = createInstance({
  projectConfigManager: pollingConfigManager,
  eventProcessor: batchEventProcessor,
  odpManager: odpManager,
  vuidManager: vuidManager,
  userProfileServiceAsync: new InMemoryUserProfileServiceAsync(),
});

const getDecision = async (client: Client, userId: string, flagKey: string) => {
  try {
    await client.onReady();
    const user = client.createUserContext(userId);
    if (!user) {
      throw new Error("Failed to create user context");
    }
    try {
      const res = await user.decideAsync(flagKey);
      return res;
    } catch (err) {
      console.error("Error in decideAsync:", err);
    }
  } catch (err) {
    console.error("Error initializing client", err);
  }
};

if(optimizelyClient) {
  getDecision(optimizelyClient, "user123", "flag_key").then((decision) => {
    console.log("Decision:", decision);
  });
}

const attributes = {
  logged_in: true
};

const user = optimizely.createUserContext('user123', attributes);
// make decisions for all active (unarchived) flags in the project for a user
let decisions = user.decideAll();
// or only for enabled flags
decisions = user.decideAll([OptimizelyDecideOption.ENABLED_FLAGS_ONLY]);

const flagKeys = Object.keys(decisions);
const decisionForFlag1 = decisions['flag_1'];

const getDecisions = async (client: Client, userId: string) => {
  try {
    await client.onReady();
    const user = client.createUserContext(userId);
    if (!user) {
      throw new Error("Failed to create user context");
    }
    try {
      const res = await user.decideAllAsync();
      return res;
    } catch (err) {
      console.error("Error in decideAllAsync", err);
    }
  } catch (err) {
    console.error("Error in client onReady", err);
  }
};

// make decisions for specific flags
const keys = ['flag_1', 'flag_2'];
const decisions = user.decideForKeys(keys);
const decision1 = decisions['flag_1'];
const decision2 = decisions['flag_2'];

const getDecisions = async (client: Client, userId: string, keys: string[]) => {
  try {
    await client.onReady();
    const user = client.createUserContext(userId);
    if (!user) {
      throw new Error("Failed to create user context");
    }
    try {
      const res = await user.decideForKeysAsync(keys);
      return res;
    } catch (err) {
      console.error("Error in decideForKeysAsync", err);
    }
  } catch (err) {
    console.error("Error in client onReady", err);
  }
};

import {
  createBatchEventProcessor,
  createInstance,
  createOdpManager,
  createPollingProjectConfigManager,
  OptimizelyDecideOption
} from "@optimizely/optimizely-sdk";

const SDK_KEY="YOUR_SDK_KEY";

const pollingConfigManager = createPollingProjectConfigManager({
  sdkKey: SDK_KEY,
  autoUpdate: true,
  updateInterval: 60000, // 1 minute
});

const batchEventProcessor = createBatchEventProcessor();
const odpManager = createOdpManager();

const optimizelyClient = createInstance({
  projectConfigManager: pollingConfigManager,
  eventProcessor: batchEventProcessor,
  odpManager: odpManager,
  defaultDecideOptions: [OptimizelyDecideOption.DISABLE_DECISION_EVENT]
});


optimizelyClient.onReady().then(() => {
  const user = optimizelyClient.createUserContext('user123');
  if (!user) {
    throw new Error('failed to create user context');
  }

  // set additional options in a decide call
  const decisionResults = user.decideAll(
    [
      OptimizelyDecideOption.ENABLED_FLAGS_ONLY,
      OptimizelyDecideOption.IGNORE_USER_PROFILE_SERVICE,
    ]
  );

  console.log(decisionResults);
}).catch((err) => {
  // handle error
});