@sanity/personalization-plugin 2.5.0-launch-darkly.1 → 3.0.0

package/src/launchDarkly/launchdarkly.md

@@ -1,76 +0,0 @@
-# @sanity/personalization-plugin - launchDarklyFieldLevel
-
-## Previously know as @sanity/personalisation-plugin
-
-> This is a **Sanity Studio v3** plugin.
-
-This plugin allows users to add a/b/n testing experiments to individual fields connecting to the [LaunchDarkly](https://launchdarkly.com//) A/B testing service.
-
-- [@sanity/personalization-plugin - launchDarklyFieldLevel](#sanitypersonalization-plugin---launchDarklyFieldLevel)
-  - [Installation](#installation)
-  - [Usage](#usage)
-  - [Loading Experiments](#loading-experiments)
-
-This plugin is built on top of the `fieldLevelExperiments` export so see the main readme for details of:
-
-- [Using complex field configurations](/#using-complex-field-configurations)
-- [Validation of individual array items](/#validation-of-individual-array-items)
-- [Shape of stored data](/#shape-of-stored-data)
-- [Querying data](/#querying-data)
-- [License](#license)
-- [Develop \& test](#develop--test)
-  - [Release new version](#release-new-version)
-- [License](#license-1)
-
-## Installation
-
-```sh
-npm install @sanity/personalization-plugin
-```
-
-## Usage
-
-Add it as a plugin in `sanity.config.ts` (or .js):
-
-```ts
-import {defineConfig} from 'sanity'
-import {fieldLevelExperiments} from '@sanity/personalization-plugin/launchDarkly'
-
-export default defineConfig({
-  //...
-  plugins: [
-    //...
-    launchDarklyFieldLevel({
-      fields: ['string'],
-      projectKey: 'string', // required filter parameter for fetching features/variants
-      tags: ['string'] //optional parameter that filters the list to flags that have all of the tags in the list
-    }),
-  ],
-})
-```
-
-This will register two new fields to the schema., based on the setting passed into `fields:`
-
-- `flagString` an Object field with `string` field called `default`, a `string` field called `flagId` and an array field of type:
-- `variantsString` an object field with a `string` field called `value`, a string field called `variantId`, a `string` field called `flagId`.
-
-Use the flag field in your schema like this:
-
-```ts
-//for Example in post.ts
-
-fields: [
-  defineField({
-    name: 'title',
-    type: 'flagString',
-  }),
-]
-```
-
-## Loading Experiments
-
-This plugin uses [@sanity/studio-secrets](https://www.npmjs.com/package/@sanity/studio-secrets) for storing your Launch Darkly API key. The first time you open a document that has an experiment you will be asked to provide your API key. This is stored in a private document on the dataset.
-
-Once you have entered you API key the plugin will fetch feature flags and variants flags. If features/variants are updated on LaunchDarkly you will need to refresh the page.
-
-The values stored for an flag will be the Feature Key amd the variants will stored the variation value.

package/src/launchDarkly/types.ts

@@ -1,193 +0,0 @@
-import {FieldDefinition} from 'sanity'
-
-export type LaunchDarklyFieldLevelConfig = {
-  fields: (string | FieldDefinition)[]
-  projectKey: string
-  tags?: string[]
-}
-export type LaunchDarklyContextProps = {
-  setSecret: (secret: string | undefined) => void
-  secret: string | undefined
-}
-
-export type LaunchDarklyFlagItem = {
-  name: string
-  kind: string
-  key: string
-  _version: number
-  creationDate: number
-  variations: Array<{
-    value: boolean | string | number
-    _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
-          }
-        }
-        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
-        }
-        category: string
-        isNumeric: boolean
-        percentileValue: number
-      }
-    }>
-  }
-  customProperties: {
-    key: {
-      name: string
-      value: string[]
-    }
-  }
-  archived: boolean
-  description: 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]: {
-      on: boolean
-      archived: boolean
-      salt: string
-      sel: string
-      lastModified: number
-      version: number
-      _site: {
-        href: string
-        type: 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
-      }
-    }
-  }
-  includeInSnippet: boolean
-  goalIds: string[]
-}

package/src/launchDarkly/utils.ts

@@ -1,54 +0,0 @@
-import {SanityClient} from 'sanity'
-
-import {ExperimentType} from '../types'
-import {LaunchDarklyFieldLevelConfig, 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.toString(),
-        label: variation.name ?? variation.value.toString(),
-      })),
-    }))
-    featureExperiments.push(...experiments)
-    if (items.length !== limit) {
-      hasMore = false
-    }
-  }
-
-  return featureExperiments
-}

package/src/types.ts

@@ -1,245 +0,0 @@
-import {
-  ArrayOfObjectsInputProps,
-  FieldDefinition,
-  ObjectField,
-  Path,
-  PreviewProps,
-  SanityClient,
-  SchemaType,
-} from 'sanity'
-
-export type VariantType = {
-  id: string
-  label: string
-}
-export type ExperimentType = {
-  id: string
-  label: string
-  variants: VariantType[]
-}
-
-export type FieldPluginConfig = {
-  fields: (string | FieldDefinition)[]
-  experiments: ExperimentType[] | ((client: SanityClient) => Promise<ExperimentType[]>)
-  apiVersion?: string
-  experimentNameOverride?: string
-  variantNameOverride?: string
-  variantId?: string
-  variantArrayName?: string
-  experimentId?: string
-}
-
-export type VariantPreviewProps = Omit<PreviewProps, 'SchemaType'> & {
-  [key: string]: string
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  value: any
-}
-
-export type ExperimentContextProps = Required<FieldPluginConfig> & {
-  experiments: ExperimentType[]
-}
-
-export type ArrayInputProps = ArrayOfObjectsInputProps & {
-  variantName: string
-  variantId: string
-  experimentId: string
-}
-
-export type ObjectFieldWithPath = ObjectField<SchemaType> & {path: Path}
-
-export type VariantGeneric<T> = {
-  [key: string]: string | T | undefined
-  _type: string
-  value?: T
-}
-
-export type ExperimentGeneric<T> = {
-  _type: string
-  default?: T
-  experimentValue?: string
-  [key: string]:
-    | Array<
-        {
-          _key: string
-        } & VariantGeneric<T>
-      >
-    | string
-    | T
-    | undefined
-}
-
-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: [
-        {
-          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
-  }
-}

package/src/utils/flattenSchemaType.ts

@@ -1,47 +0,0 @@
-import {isDocumentSchemaType, type ObjectField, type Path, type SchemaType} from 'sanity'
-
-import {ObjectFieldWithPath} from '../types'
-
-/**
- * Flattens a document's schema type into a flat array of fields and includes their path
- */
-export function flattenSchemaType(schemaType: SchemaType): ObjectFieldWithPath[] {
-  if (!isDocumentSchemaType(schemaType)) {
-    console.error(`Schema type is not a document`)
-    return []
-  }
-
-  return extractInnerFields(schemaType.fields, [], 5)
-}
-
-function extractInnerFields(
-  fields: ObjectField<SchemaType>[],
-  path: Path,
-  maxDepth: number,
-): ObjectFieldWithPath[] {
-  if (path.length >= maxDepth) {
-    return []
-  }
-
-  return fields.reduce<ObjectFieldWithPath[]>((acc, field) => {
-    const thisFieldWithPath = {path: [...path, field.name], ...field}
-
-    if (field.type.jsonType === 'object') {
-      const innerFields = extractInnerFields(field.type.fields, [...path, field.name], maxDepth)
-      return [...acc, thisFieldWithPath, ...innerFields]
-    } else if (field.type.jsonType === 'array') {
-      // Handle array types by checking each possible type in the array
-      const arrayTypes = field.type.of || []
-      const innerFields = arrayTypes.reduce<ObjectFieldWithPath[]>((arrayAcc, arrayType) => {
-        if ('fields' in arrayType) {
-          const typeFields = extractInnerFields(arrayType.fields, [...path, field.name], maxDepth)
-          return [...arrayAcc, ...typeFields]
-        }
-        return arrayAcc
-      }, [])
-      return [...acc, thisFieldWithPath, ...innerFields]
-    }
-
-    return [...acc, thisFieldWithPath]
-  }, [])
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version, sanityExchangeUrl} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: undefined,
-  },
-  sanityExchangeUrl,
-})