@featurevisor/sdk 1.35.3 → 2.0.1

package/src/bucket.ts

@@ -1,139 +0,0 @@
-import * as murmurhash from "murmurhash";
-import { Feature, BucketKey, BucketValue, Context, AttributeValue } from "@featurevisor/types";
-
-import { Logger } from "./logger";
-
-/**
- * Generic hashing
- */
-const HASH_SEED = 1;
-const MAX_HASH_VALUE = Math.pow(2, 32);
-
-export const MAX_BUCKETED_NUMBER = 100000; // 100% * 1000 to include three decimal places in the same integer value
-
-export function getBucketedNumber(bucketKey: string): number {
-  const hashValue = murmurhash.v3(bucketKey, HASH_SEED);
-  const ratio = hashValue / MAX_HASH_VALUE;
-
-  return Math.floor(ratio * MAX_BUCKETED_NUMBER);
-}
-
-/**
- * Feature specific bucketing
- */
-export type ConfigureBucketKey = (
-  feature: Feature,
-  context: Context,
-  bucketKey: BucketKey,
-) => BucketKey;
-
-export interface BucketKeyOptions {
-  feature: Feature;
-  context: Context;
-  logger: Logger;
-  bucketKeySeparator?: string;
-  configureBucketKey?: ConfigureBucketKey;
-}
-
-export function getBucketKey(options: BucketKeyOptions): BucketKey {
-  const { feature, context, logger, bucketKeySeparator = ".", configureBucketKey } = options;
-
-  const featureKey = feature.key;
-
-  let type;
-  let attributeKeys;
-
-  if (typeof feature.bucketBy === "string") {
-    type = "plain";
-    attributeKeys = [feature.bucketBy];
-  } else if (Array.isArray(feature.bucketBy)) {
-    type = "and";
-    attributeKeys = feature.bucketBy;
-  } else if (typeof feature.bucketBy === "object" && Array.isArray(feature.bucketBy.or)) {
-    type = "or";
-    attributeKeys = feature.bucketBy.or;
-  } else {
-    logger.error("invalid bucketBy", { featureKey, bucketBy: feature.bucketBy });
-
-    throw new Error("invalid bucketBy");
-  }
-
-  const bucketKey: AttributeValue[] = [];
-
-  attributeKeys.forEach((attributeKey) => {
-    const attributeValue = context[attributeKey];
-
-    if (typeof attributeValue === "undefined") {
-      return;
-    }
-
-    if (type === "plain" || type === "and") {
-      bucketKey.push(attributeValue);
-    } else {
-      // or
-      if (bucketKey.length === 0) {
-        bucketKey.push(attributeValue);
-      }
-    }
-  });
-
-  bucketKey.push(featureKey);
-
-  const result = bucketKey.join(bucketKeySeparator);
-
-  if (configureBucketKey) {
-    return configureBucketKey(feature, context, result);
-  }
-
-  return result;
-}
-
-export interface Bucket {
-  bucketKey: BucketKey;
-  bucketValue: BucketValue;
-}
-
-export type ConfigureBucketValue = (
-  feature: Feature,
-  context: Context,
-  bucketValue: BucketValue,
-) => BucketValue;
-
-export interface BucketValueOptions {
-  // common with BucketKeyOptions
-  feature: Feature;
-  context: Context;
-  logger: Logger;
-  bucketKeySeparator?: string;
-  configureBucketKey?: ConfigureBucketKey;
-
-  // specific to BucketValueOptions
-  configureBucketValue?: ConfigureBucketValue;
-}
-
-export function getBucket(options: BucketValueOptions): Bucket {
-  const { feature, context, logger, bucketKeySeparator, configureBucketKey, configureBucketValue } =
-    options;
-  const bucketKey = getBucketKey({
-    feature,
-    context,
-    logger,
-    bucketKeySeparator,
-    configureBucketKey,
-  });
-  const value = getBucketedNumber(bucketKey);
-
-  if (configureBucketValue) {
-    const configuredValue = configureBucketValue(feature, context, value);
-
-    return {
-      bucketKey,
-      bucketValue: configuredValue,
-    };
-  }
-
-  return {
-    bucketKey,
-    bucketValue: value,
-  };
-}

package/src/feature.ts

@@ -1,141 +0,0 @@
-import { Allocation, Context, Traffic, Feature, Force } from "@featurevisor/types";
-import { DatafileReader } from "./datafileReader";
-import { allGroupSegmentsAreMatched } from "./segments";
-import { allConditionsAreMatched } from "./conditions";
-import { Logger } from "./logger";
-
-export function getMatchedAllocation(
-  traffic: Traffic,
-  bucketValue: number,
-): Allocation | undefined {
-  if (!traffic.allocation) {
-    return undefined;
-  }
-
-  for (const allocation of traffic.allocation) {
-    const [start, end] = allocation.range;
-
-    if (allocation.range && start <= bucketValue && end >= bucketValue) {
-      return allocation;
-    }
-  }
-
-  return undefined;
-}
-
-export function parseFromStringifiedSegments(value) {
-  if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
-    return JSON.parse(value);
-  }
-
-  return value;
-}
-
-export function getMatchedTraffic(
-  traffic: Traffic[],
-  context: Context,
-  datafileReader: DatafileReader,
-  logger: Logger,
-): Traffic | undefined {
-  const matchedTraffic = traffic.find((t) => {
-    if (
-      !allGroupSegmentsAreMatched(
-        parseFromStringifiedSegments(t.segments),
-        context,
-        datafileReader,
-        logger,
-      )
-    ) {
-      return false;
-    }
-
-    return true;
-  });
-
-  if (matchedTraffic && matchedTraffic.percentage > 0) {
-    return matchedTraffic;
-  }
-
-  return;
-}
-
-export interface MatchedTrafficAndAllocation {
-  matchedTraffic: Traffic | undefined;
-  matchedAllocation: Allocation | undefined;
-}
-
-export function getMatchedTrafficAndAllocation(
-  traffic: Traffic[],
-  context: Context,
-  bucketValue: number,
-  datafileReader: DatafileReader,
-  logger: Logger,
-): MatchedTrafficAndAllocation {
-  const matchedTraffic = traffic.find((t) => {
-    return allGroupSegmentsAreMatched(
-      parseFromStringifiedSegments(t.segments),
-      context,
-      datafileReader,
-      logger,
-    );
-  });
-
-  if (!matchedTraffic) {
-    return {
-      matchedTraffic: undefined,
-      matchedAllocation: undefined,
-    };
-  }
-
-  const matchedAllocation = getMatchedAllocation(matchedTraffic, bucketValue);
-
-  return {
-    matchedTraffic,
-    matchedAllocation,
-  };
-}
-
-export interface ForceResult {
-  force?: Force;
-  forceIndex?: number;
-}
-
-export function findForceFromFeature(
-  feature: Feature,
-  context: Context,
-  datafileReader: DatafileReader,
-  logger: Logger,
-): ForceResult {
-  const result: ForceResult = {
-    force: undefined,
-    forceIndex: undefined,
-  };
-
-  if (!feature.force) {
-    return result;
-  }
-
-  for (let i = 0; i < feature.force.length; i++) {
-    const currentForce = feature.force[i];
-
-    if (
-      currentForce.conditions &&
-      allConditionsAreMatched(currentForce.conditions, context, logger)
-    ) {
-      result.force = currentForce;
-      result.forceIndex = i;
-      break;
-    }
-
-    if (
-      currentForce.segments &&
-      allGroupSegmentsAreMatched(currentForce.segments, context, datafileReader, logger)
-    ) {
-      result.force = currentForce;
-      result.forceIndex = i;
-      break;
-    }
-  }
-
-  return result;
-}