chore: update LD importer to use v2 endpoints

.gitignore

@@ -129,4 +129,5 @@ dist
 .yarn/install-state.gz
 .pnp.*
 
-config.json
+config.json
+.idea/*

README.md

@@ -54,7 +54,7 @@ Note: This feature importer only supports LaunchDarkly API Version `20220603`. P
   - Equivalent env var: OVERWRITE_DUPLICATES
 - <b>operationMap</b>: <i>Map<string, string></i>
   - A map of LD operations to map to DevCycle operations
-  - DevCycle operations: `=`, `!=`, `>`, `<`, `>=`, `<=`, `contain`, `!contain`, `exist`, `!exist`
+  - DevCycle operations: `=`, `!=`, `>`, `<`, `>=`, `<=`, `contain`, `!contain`, `exist`, `!exist`, `startWith`, `!startWith`, `endWith`, `!endWith`
   - Equivalent env var: OPERATION_MAP
 - <b>provider</b>: <i>string</i>
   - The provider to import the feature flags from.
@@ -99,4 +99,4 @@ PROVIDER='launchdarkly'
 - DVC supports the following top-level properties on the user object: see [DVC User Object](https://docs.devcycle.com/docs/sdk/client-side-sdks/javascript#dvc-user-object).
   Any other properties used for targeting should be passed within the `customData` map.
 - If you are passing a date to be used with LD's before/after operators, the value should to be converted to a long when passed to DVC. The importer will convert `before` & `after` operators to `<` & `>` in DVC.
-- DVC doesn't support targeting by the top-level `isAnonymous` property. If you are using LD's targeting with the `anonymous` attribute, make sure to include an `anonymous` property in the user's `customData`
+- DVC doesn't support targeting by the top-level `isAnonymous` property. If you are using LD's targeting with the `anonymous` attribute, make sure to include an `anonymous` property in the user's `customData`

src/api/DevCycleApiWrapper.ts

@@ -13,6 +13,7 @@
 import { FeatureConfiguration } from '../types/DevCycle/targeting'
 
 const DVC_BASE_URL = process.env.DVC_BASE_URL || 'https://api.devcycle.com/v1'
+const DVC_BASE_URL_V2 = process.env.DVC_BASE_URL_V2 || 'https://api.devcycle.com/v2'
 
 export default class DevCycleApiWrapper {
     constructor(dvcClientId: string, dvcClientSecret: string, provider?: string) {
@@ -23,7 +24,7 @@
     dvcClientId: string
     dvcClientSecret: string
     apiToken: string
-    provider: string 
+    provider: string
 
     private async getApiToken(): Promise<string> {
         if (this.apiToken) return this.apiToken
@@ -140,7 +141,7 @@
 
     async createFeature(projectKey: string, feature: Feature): Promise<Feature> {
         const headers = await this.getHeaders()
-        const response = await fetch(`${DVC_BASE_URL}/projects/${projectKey}/features`, {
+        const response = await fetch(`${DVC_BASE_URL_V2}/projects/${projectKey}/features`, {
             method: 'POST',
             body: JSON.stringify(feature),
             headers,
@@ -151,7 +152,7 @@
 
     async updateFeature(projectKey: string, feature: Feature): Promise<Feature> {
         const headers = await this.getHeaders()
-        const response = await fetch(`${DVC_BASE_URL}/projects/${projectKey}/features/${feature.key}`, {
+        const response = await fetch(`${DVC_BASE_URL_V2}/projects/${projectKey}/features/${feature.key}`, {
             method: 'PATCH',
             body: JSON.stringify(feature),
             headers,
@@ -162,7 +163,7 @@
 
     async getFeaturesForProject(projectKey: string): Promise<Feature[]> {
         const headers = await this.getHeaders()
-        const response = await fetch(`${DVC_BASE_URL}/projects/${projectKey}/features?perPage=1000`, {
+        const response = await fetch(`${DVC_BASE_URL_V2}/projects/${projectKey}/features?perPage=1000`, {
             headers,
         })
         await this.handleErrors(response)
@@ -210,17 +211,19 @@
 
     async updateFeatureConfigurations(
         projectKey: string,
-        featureKey: string,
-        environment: string,
-        configurations: FeatureConfiguration,
+        feature: Feature,
+        configurations: Record<string, FeatureConfiguration>,
         options: { throwOnError: boolean } = { throwOnError: true }
     ): Promise<FeatureConfiguration> {
         const headers = await this.getHeaders()
         const response = await fetch(
-            `${DVC_BASE_URL}/projects/${projectKey}/features/${featureKey}/configurations?environment=${environment}`,
+            `${DVC_BASE_URL_V2}/projects/${projectKey}/features/${feature.key}`,
             {
                 method: 'PATCH',
-                body: JSON.stringify(configurations),
+                body: JSON.stringify({
+                    ...feature,
+                    configurations
+                }),
                 headers,
             })
         if (options.throwOnError) await this.handleErrors(response)

src/resources/environments/LDEnvironmentImporter.ts

@@ -66,4 +66,4 @@ export class LDEnvironmentImporter {
 
         return this.environmentsByKey
     }
-}
+}

src/resources/features/LDFeatureImporter.ts

@@ -149,18 +149,19 @@ export class LDFeatureImporter {
             const { action, feature, configs = [] } = this.featuresToImport[featureKey]
             if (this.errors[feature.key]) continue
             if (action === FeatureImportAction.Skip) continue
-
-            for (const config of configs) {
-                try {
-                    if ((action === FeatureImportAction.Create) ||
-                        (action === FeatureImportAction.Update && overwriteDuplicates)) {
-                        await DVC.updateFeatureConfigurations(
-                            targetProjectKey, feature.key, config.environment, config.targetingRules
-                        )
-                    }
-                } catch (e) {
-                    this.errors[feature.key] = e instanceof Error ? e.message : 'unknown error'
+            const configurations: Record<string, FeatureConfiguration> = {}
+            configs.forEach((config) => {
+                configurations[config.environment] = config.targetingRules
+            })
+            try {
+                if ((action === FeatureImportAction.Create) ||
+                    (action === FeatureImportAction.Update && overwriteDuplicates)) {
+                    await DVC.updateFeatureConfigurations(
+                        targetProjectKey, feature, configurations
+                    )
                 }
+            } catch (e) {
+                this.errors[feature.key] = e instanceof Error ? e.message : 'unknown error'
             }
         }
     }
@@ -177,4 +178,4 @@ export class LDFeatureImporter {
             errored: this.errors,
         }
     }
-}
+}

src/types/DevCycle/feature.ts

@@ -1,3 +1,5 @@
+import { FeatureConfiguration } from './targeting'
+
 export type Feature = {
     _id?: string
     _project?: string
@@ -9,6 +11,7 @@ export type Feature = {
     variables?: Variable[]
     tags?: string[]
     sdkVisibility?: SDKVisibility
+    configurations?: FeatureConfiguration[]
 }
 
 export type Variable = {
@@ -46,4 +49,4 @@ type SDKVisibility = {
     mobile: boolean
     client: boolean
     server: boolean
-}
+}

src/utils/DevCycle/targeting.ts

@@ -15,7 +15,7 @@ export function createUserFilter(subType: string, comparator: string, values: an
         }
         normalizedValues = normalizedValues.map((value) => value.toUpperCase())
     }
-    
+
     return {
         type: 'user',
         subType,
@@ -75,6 +75,10 @@ export function getNegatedComparator(operator: string) {
         '!contain': 'contain',
         'exist': '!exist',
         '!exist': 'exist',
+        'startWith': '!startWith',
+        '!startWith': 'startWith',
+        '!endWith': 'endWith',
+        'endWith': '!endWith',
     }
     if (!(operator in negateComparatorMap)) {
         throw new Error(`Unsupported operator: ${operator}`)

src/utils/LaunchDarkly/targeting.test.ts

@@ -57,7 +57,7 @@ const mockUnsupportedOpRule = {
             _id: 'abc',
             attribute: 'email',
             negate: false,
-            op: 'endsWith',
+            op: 'rhymesWith',
             values: ['email.com']
         }
     ],
@@ -244,7 +244,7 @@ describe('buildTargetingRuleFromRule', () => {
     test('builds targeting rule with an op overrided in operationMap', () => {
         const audienceImport = new LDAudienceImporter(mockConfig)
         const operationMap = {
-            endsWith: 'contain',
+            rhymesWith: 'contain',
         }
 
         const result = buildTargetingRuleFromRule(
@@ -274,10 +274,53 @@ describe('buildTargetingRuleFromRule', () => {
         })
     })
 
+    test('builds targeting rule with endsWith', () => {
+        const audienceImport = new LDAudienceImporter(mockConfig)
+        const operationMap = {}
+        const mockUnsupportedNegatedOpRule = {
+            ...mockUnsupportedOpRule,
+            clauses: [
+                {
+                    _id: 'abc',
+                    attribute: 'email',
+                    negate: true,
+                    op: 'endsWith',
+                    values: ['email.com']
+                }
+            ]
+        }
+
+        const result = buildTargetingRuleFromRule(
+            mockUnsupportedNegatedOpRule,
+            mockFeature,
+            'prod',
+            audienceImport,
+            operationMap,
+        )
+        expect(result).toEqual({
+            audience: {
+                name: 'Imported Rule',
+                filters: {
+                    filters: [{
+                        comparator: '!endWith',
+                        type: 'user',
+                        subType: 'email',
+                        values: ['email.com']
+                    }],
+                    operator: OperatorType.and
+                }
+            },
+            distribution: [{
+                _variation: 'variation-2',
+                percentage: 1
+            }]
+        })
+    })
+
     test('builds targeting rule with a negated op overrided in operationMap', () => {
         const audienceImport = new LDAudienceImporter(mockConfig)
         const operationMap = {
-            endsWith: 'contain',
+            rhymesWith: 'contain',
         }
         const mockUnsupportedNegatedOpRule = {
             ...mockUnsupportedOpRule,
@@ -286,7 +329,7 @@ describe('buildTargetingRuleFromRule', () => {
                     _id: 'abc',
                     attribute: 'email',
                     negate: true,
-                    op: 'endsWith',
+                    op: 'rhymesWith',
                     values: ['email.com']
                 }
             ]
@@ -332,7 +375,7 @@ describe('buildTargetingRuleFromRule', () => {
             audienceImport,
             operationMap,
         )
-        expect(methodCall).toThrowError('Unsupported operation: endsWith')
+        expect(methodCall).toThrowError('Unsupported operation: rhymesWith')
     })
 })
 
@@ -396,4 +439,4 @@ describe('buildTargetingRulesFromFallthrough', () => {
             ]
         })
     })
-})
+})

src/utils/LaunchDarkly/targeting.ts

@@ -41,6 +41,8 @@ export function getComparator(clause: Clause, customOperationMap: { [key: string
     const operationMap = {
         in: (neg: boolean) => neg ? '!=' : '=',
         contains: (neg: boolean) => neg ? '!contain' : 'contain',
+        startsWith: (neg: boolean) => neg ? '!startWith' : 'startWith',
+        endsWith: (neg: boolean) => neg ? '!endWith' : 'endWith',
         lessThan: (neg: boolean) => '<',
         lessThanOrEqual: (neg: boolean) => '<=',
         greaterThan: (neg: boolean) => '>',