@sanity/personalization-plugin 2.1.0-growthbook.1 → 2.1.0

package/src/types.ts

@@ -1,4 +1,3 @@
-import {Dispatch, SetStateAction} from 'react'
 import {
   ArrayOfObjectsInputProps,
   FieldDefinition,
@@ -21,35 +20,36 @@ 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
 }
 
 export type ExperimentContextProps = Required<FieldPluginConfig> & {
   experiments: ExperimentType[]
-  setSecret: Dispatch<SetStateAction<string | undefined>>
-  secret: string | undefined
 }
 
 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 +57,13 @@ export type ExperimentGeneric<T> = {
   _type: string
   default?: T
   experimentValue?: string
-  variants?: Array<
-    {
-      _key: string
-    } & VariantGeneric<T>
-  >
-}
-
-export type GrowthbookExperiment = {
-  id: string
-  dateCreated: string
-  dateUpdated: string
-  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: [
+  [key: string]:
+    | Array<
         {
-          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
-        }
-      },
-    ]
-    guardrails: [
-      {
-        metricId: string
-        overrides: {
-          delayHours: 0
-          windowHours: 0
-          window: string
-          winRiskThreshold: 0
-          loseRiskThreshold: 0
-        }
-      },
-    ]
-    activationMetric: {
-      metricId: string
-      overrides: {
-        delayHours: 0
-        windowHours: 0
-        window: string
-        winRiskThreshold: 0
-        loseRiskThreshold: 0
-      }
-    }
-  }
-  resultSummary: {
-    status: string
-    winner: string
-    conclusions: string
-    releasedVariationId: string
-    excludeFromPayload: boolean
-  }
-}
-
-export type GrowthbookFeature = {
-  id: string
-  dateCreated: string
-  dateUpdated: string
-  archived: boolean
-  description: string
-  owner: string
-  project: string
-  valueType: string
-  defaultValue: string
-  tags: string[]
-  environments: {
-    [key: string]: {
-      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
-      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
-      }
-    }
-  }
-  prerequisites: {
-    parentId: string
-    parentCondition: string
-  }[]
-  revision: {
-    version: number
-    comment: string
-    date: string
-    publishedBy: string
-  }
+          _key: string
+        } & VariantGeneric<T>
+      >
+    | string
+    | T
+    | undefined
 }

package/src/components/Secrets.tsx

@@ -1,47 +0,0 @@
-import {SettingsView, useSecrets} from '@sanity/studio-secrets'
-import {useEffect, useState} from 'react'
-import {ObjectInputProps} from 'sanity'
-
-import {useExperimentContext} from './ExperimentContext'
-
-const namespace = 'growthbook'
-
-const pluginConfigKeys = [
-  {
-    key: 'apiKey',
-    title: 'Your secret API key',
-  },
-]
-
-export const Secrets = (props: ObjectInputProps) => {
-  const {secrets, loading} = useSecrets(namespace) as {secrets: {apiKey: string}; loading: boolean}
-  const {setSecret} = useExperimentContext()
-  const [showSettings, setShowSettings] = useState<boolean>(false)
-
-  useEffect(() => {
-    if (loading) return undefined
-    if (!secrets && !loading) {
-      setSecret(undefined)
-      return setShowSettings(true)
-    }
-    setSecret(secrets.apiKey)
-    return setShowSettings(false)
-  }, [secrets, loading, setSecret])
-
-  if (!showSettings) {
-    return props.renderDefault(props)
-  }
-  return (
-    <>
-      <SettingsView
-        title={'Growthbook secret'}
-        namespace={namespace}
-        keys={pluginConfigKeys}
-        onClose={() => {
-          setShowSettings(false)
-        }}
-      />
-      {props.renderDefault(props)}
-    </>
-  )
-}

package/src/growthbookFieldExperiments.tsx

@@ -1,51 +0,0 @@
-import {definePlugin, FieldDefinition, isObjectInputProps} from 'sanity'
-
-import {Secrets} from './components/Secrets'
-import {fieldLevelExperiments} from './fieldExperiments'
-import {flattenSchemaType} from './utils/flattenSchemaType'
-import {getExperiments} from './utils/growthbook'
-
-export type GrowthbookABConfig = {
-  fields: (string | FieldDefinition)[]
-  environment: string
-  baseUrl?: string
-  project?: string
-  convertBooleans?: boolean
-}
-
-export const growthbookFieldLevel = definePlugin<GrowthbookABConfig>((config) => {
-  const {fields, environment, project, convertBooleans, baseUrl} = config
-  return {
-    name: 'sanity-growthbook-personalistaion-plugin-field-level-experiments',
-    plugins: [
-      fieldLevelExperiments({
-        fields,
-        experiments: (client) =>
-          getExperiments({client, environment, baseUrl, project, convertBooleans}),
-      }),
-    ],
-
-    form: {
-      components: {
-        input: (props) => {
-          const isRootInput = props.id === 'root' && isObjectInputProps(props)
-
-          if (!isRootInput) {
-            return props.renderDefault(props)
-          }
-
-          const flatFieldTypeNames = flattenSchemaType(props.schemaType).map(
-            (field) => field.type.name,
-          )
-
-          const hasExperiment = flatFieldTypeNames.some((name) => name.startsWith('experiment'))
-
-          if (!hasExperiment) {
-            return props.renderDefault(props)
-          }
-          return Secrets(props)
-        },
-      },
-    },
-  }
-})

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
-}