@sanity/personalization-plugin 2.1.0-growthbook.1 → 2.2.0-launch-darkly.1

package/src/types.ts

@@ -21,15 +21,17 @@ export type ExperimentType = {
 
 export type FieldPluginConfig = {
   fields: (string | FieldDefinition)[]
-  experiments:
-    | ExperimentType[]
-    | ((client: SanityClient, secret?: string) => Promise<ExperimentType[]>)
+  experiments: ExperimentType[] | ((client: SanityClient) => Promise<ExperimentType[]>)
   apiVersion?: string
+  experimentNameOverride?: string
+  variantNameOverride?: string
+  variantId?: string
+  variantArrayName?: string
+  experimentId?: string
 }
 
 export type VariantPreviewProps = Omit<PreviewProps, 'SchemaType'> & {
-  experiment: string
-  variant: string
+  [key: string]: string
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   value: any
 }
@@ -41,15 +43,16 @@ export type ExperimentContextProps = Required<FieldPluginConfig> & {
 }
 
 export type ArrayInputProps = ArrayOfObjectsInputProps & {
-  objectName: string
+  variantName: string
+  variantId: string
+  experimentId: string
 }
 
 export type ObjectFieldWithPath = ObjectField<SchemaType> & {path: Path}
 
 export type VariantGeneric<T> = {
+  [key: string]: string | T | undefined
   _type: string
-  variantId?: string
-  experimentId?: string
   value?: T
 }
 
@@ -57,185 +60,195 @@ export type ExperimentGeneric<T> = {
   _type: string
   default?: T
   experimentValue?: string
-  variants?: Array<
-    {
-      _key: string
-    } & VariantGeneric<T>
-  >
+  [key: string]:
+    | Array<
+        {
+          _key: string
+        } & VariantGeneric<T>
+      >
+    | string
+    | T
+    | undefined
 }
 
-export type GrowthbookExperiment = {
-  id: string
-  dateCreated: string
-  dateUpdated: string
+export type LaunchDarklyFlagItem = {
   name: string
-  project: string
-  hypothesis: string
-  description: string
-  tags: [string]
-  owner: string
-  archived: boolean
-  status: string
-  autoRefresh: boolean
-  hashAttribute: string
-  fallbackAttribute: string
-  hashVersion: number
-  disableStickyBucketing: boolean
-  bucketVersion: number
-  minBucketVersion: number
-  variations: [
-    {
-      variationId: string
-      key: string
-      name: string
-      description: string
-      screenshots: [string]
-    },
-  ]
-  phases: [
-    {
-      name: string
-      dateStarted: string
-      dateEnded: string
-      reasonForStopping: string
-      seed: string
-      coverage: 0
-      trafficSplit: [
-        {
-          variationId: string
-          weight: 0
-        },
-      ]
-      namespace: {
-        namespaceId: string
-        range: []
-      }
-      targetingCondition: string
-      savedGroupTargeting: [
-        {
-          matchType: string
-          savedGroups: [string]
-        },
-      ]
-    },
-  ]
-  settings: {
-    datasourceId: string
-    assignmentQueryId: string
-    experimentId: string
-    segmentId: string
-    queryFilter: string
-    inProgressConversions: string
-    attributionModel: string
-    statsEngine: string
-    regressionAdjustmentEnabled: boolean
-    goals: [
-      {
-        metricId: string
-        overrides: {
-          delayHours: 0
-          windowHours: 0
-          window: string
-          winRiskThreshold: 0
-          loseRiskThreshold: 0
-        }
-      },
-    ]
-    secondaryMetrics: [
-      {
-        metricId: string
-        overrides: {
-          delayHours: 0
-          windowHours: 0
-          window: string
-          winRiskThreshold: 0
-          loseRiskThreshold: 0
+  kind: string
+  key: string
+  _version: number
+  creationDate: number
+  variations: Array<{
+    value: boolean
+    _id: string
+    name: string
+  }>
+  temporary: boolean
+  tags: string[]
+  _links: {
+    parent: {
+      href: string
+      type: string
+    }
+    self: {
+      href: string
+      type: string
+    }
+  }
+  experiments: {
+    baselineIdx: number
+    items: Array<{
+      metricKey: string
+      _metric: {
+        _id: string
+        _versionId: string
+        key: string
+        name: string
+        kind: string
+        _links: {
+          parent: {
+            href: string
+            type: string
+          }
+          self: {
+            href: string
+            type: string
+          }
         }
-      },
-    ]
-    guardrails: [
-      {
-        metricId: string
-        overrides: {
-          delayHours: 0
-          windowHours: 0
-          window: string
-          winRiskThreshold: 0
-          loseRiskThreshold: 0
+        tags: string[]
+        _creationDate: number
+        experimentCount: number
+        metricGroupCount: number
+        _attachedFlagCount: number
+        maintainerId: string
+        _maintainer: {
+          _links: {
+            self: {
+              href: string
+              type: string
+            }
+          }
+          _id: string
+          role: string
+          email: string
+          firstName: string
+          lastName: string
         }
-      },
-    ]
-    activationMetric: {
-      metricId: string
-      overrides: {
-        delayHours: 0
-        windowHours: 0
-        window: string
-        winRiskThreshold: 0
-        loseRiskThreshold: 0
+        category: string
+        isNumeric: boolean
+        percentileValue: number
       }
-    }
+    }>
   }
-  resultSummary: {
-    status: string
-    winner: string
-    conclusions: string
-    releasedVariationId: string
-    excludeFromPayload: boolean
+  customProperties: {
+    key: {
+      name: string
+      value: string[]
+    }
   }
-}
-
-export type GrowthbookFeature = {
-  id: string
-  dateCreated: string
-  dateUpdated: string
   archived: boolean
   description: string
-  owner: string
-  project: string
-  valueType: string
-  defaultValue: string
-  tags: string[]
+  maintainerId: string
+  _maintainer: {
+    _links: {
+      self: {
+        href: string
+        type: string
+      }
+    }
+    _id: string
+    role: string
+    email: string
+    firstName: string
+    lastName: string
+  }
+  maintainerTeamKey: string
+  _maintainerTeam: {
+    key: string
+    name: string
+    _links: {
+      parent: {
+        href: string
+        type: string
+      }
+      roles: {
+        href: string
+        type: string
+      }
+      self: {
+        href: string
+        type: string
+      }
+    }
+  }
+  archivedDate: number
+  deprecated: boolean
+  deprecatedDate: number
+  defaults: {
+    onVariation: number
+    offVariation: number
+  }
+  _purpose: string
+  migrationSettings: {
+    contextKind: string
+    stageCount: number
+  }
   environments: {
     [key: string]: {
-      enabled: boolean
-      defaultValue: string
-      rules: {
-        description: string
-        condition: string
-        savedGroupTargeting: {matchType: string; savedGroups: string[]}[]
-        id: string
-        enabled: boolean
+      on: boolean
+      archived: boolean
+      salt: string
+      sel: string
+      lastModified: number
+      version: number
+      _site: {
+        href: string
         type: string
-        value: string
-        variations: {value: string; variationId: string}[]
-      }[]
-      definition: string
-      draft: {
-        enabled: boolean
-        defaultValue: string
-        rules: {
-          description: string
-          condition: string
-          savedGroupTargeting: {matchType: string; savedGroups: string[]}[]
-          id: string
-          enabled: boolean
-          type: string
-          value: string
-          variations: {value: string; variationId: string}[]
-        }[]
-        definition: string
+      }
+      _environmentName: string
+      trackEvents: boolean
+      trackEventsFallthrough: boolean
+      targets: Array<{
+        values: string[]
+        variation: number
+        contextKind: string
+      }>
+      contextTargets: Array<{
+        values: string[]
+        variation: number
+        contextKind: string
+      }>
+      rules: Array<{
+        clauses: Array<{
+          attribute: string
+          op: string
+          values: unknown[]
+          negate: boolean
+        }>
+        trackEvents: boolean
+      }>
+      fallthrough: {
+        variation: number
+      }
+      offVariation: number
+      prerequisites: Array<{
+        key: string
+        variation: number
+      }>
+      _summary: {
+        variations: {
+          [key: string]: {
+            rules: number
+            nullRules: number
+            targets: number
+            contextTargets: number
+            isFallthrough?: boolean
+            isOff?: boolean
+          }
+        }
+        prerequisites: number
       }
     }
   }
-  prerequisites: {
-    parentId: string
-    parentCondition: string
-  }[]
-  revision: {
-    version: number
-    comment: string
-    date: string
-    publishedBy: string
-  }
+  includeInSnippet: boolean
+  goalIds: string[]
 }

package/src/utils/launchDarkly.ts

@@ -0,0 +1,54 @@
+import {SanityClient} from 'sanity'
+
+import {LaunchDarklyFieldLevelConfig} from '../launchDarklyExperiments'
+import {ExperimentType, LaunchDarklyFlagItem} from '../types'
+
+export const getExperiments = async ({
+  client,
+  projectKey,
+  tags,
+}: Omit<LaunchDarklyFieldLevelConfig, 'fields'> & {client: SanityClient}): Promise<
+  ExperimentType[]
+> => {
+  const query = `*[_id == 'secrets.launchdarkly'][0].secrets.apiKey`
+
+  const secret = await client.fetch(query) // secret is stored in the content lake using @sanity/studio-secrets
+  if (!secret) return []
+
+  const url = new URL(`https://app.launchdarkly.com/api/v2/flags/${projectKey}`)
+
+  if (tags) {
+    url.searchParams.set('filter', `tags:${tags.join('+')}`)
+  }
+
+  const featureExperiments: ExperimentType[] = []
+  let hasMore = true
+  const offset = 0
+  const limit = 10
+
+  while (hasMore) {
+    url.searchParams.set('offset', offset.toString())
+    url.searchParams.set('limit', limit.toString())
+    const responseFlags = await fetch(url, {
+      headers: {
+        Authorization: secret,
+      },
+    })
+
+    const {items} = await responseFlags.json()
+    const experiments = items.map((flag: LaunchDarklyFlagItem) => ({
+      id: flag.key,
+      label: flag.name,
+      variants: flag.variations.map((variation) => ({
+        id: variation.value,
+        label: variation.name,
+      })),
+    }))
+    featureExperiments.push(...experiments)
+    if (items.length !== limit) {
+      hasMore = false
+    }
+  }
+
+  return featureExperiments
+}

package/src/utils/growthbook.ts

@@ -1,78 +0,0 @@
-import {SanityClient} from 'sanity'
-
-import {GrowthbookABConfig} from '../growthbookFieldExperiments'
-import {ExperimentType, GrowthbookFeature, VariantType} from '../types'
-
-const getBooleanConversion = (value: string) => {
-  // this way or the other way around?
-  if (value === 'true') {
-    return 'variant'
-  } else if (value === 'false') {
-    return 'control'
-  }
-  return value
-}
-
-export const getExperiments = async ({
-  client,
-  environment,
-  baseUrl,
-  project,
-  convertBooleans,
-}: Omit<GrowthbookABConfig, 'fields'> & {client: SanityClient}): Promise<ExperimentType[]> => {
-  const query = `*[_id == 'secrets.growthbook'][0].secrets.apiKey`
-
-  const secret = await client.fetch(query) // secret is stored in the content lake using @sanity/studio-secrets
-  if (!secret) return []
-
-  const featureExperiments: ExperimentType[] = []
-  let hasMore = true
-  let offset = 0
-  const url = new URL(baseUrl ?? 'https://api.growthbook.io/api/v1/features')
-  if (project) {
-    url.searchParams.set('projectId', project)
-  }
-
-  while (hasMore) {
-    url.searchParams.set('offset', offset.toString())
-    const response = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${secret}`,
-      },
-    })
-
-    const {features, hasMore: responseHasMore, nextOffset} = await response.json()
-
-    hasMore = responseHasMore
-    offset = nextOffset
-    if (!features) continue
-
-    features.forEach((feature: GrowthbookFeature) => {
-      if (feature.archived) {
-        return undefined
-      }
-      const experiments = feature.environments[environment]?.rules.filter(
-        (experiment) => experiment.type === 'experiment-ref' || experiment.type === 'experiment',
-      )
-
-      if (!experiments) {
-        return undefined
-      }
-
-      const variations = new Set<VariantType>()
-      experiments.forEach((experiment) => {
-        experiment?.variations.forEach((variant) => {
-          variations.add({
-            id: convertBooleans ? getBooleanConversion(variant.value) : variant.value,
-            label: convertBooleans ? getBooleanConversion(variant.value) : variant.value,
-          })
-        })
-      })
-      const value = {id: feature.id, label: feature.id, variants: [...variations]}
-
-      featureExperiments.push(value)
-      return undefined
-    })
-  }
-  return featureExperiments
-}