Merge main into FFL-2835 configuration parsing

Author: sameerank

packages/browser/src/domain/configuration.ts

@@ -1,5 +1,5 @@
 import type { Configuration, EndpointBuilder, InitConfiguration } from '@datadog/browser-core'
-import { display, validateAndBuildConfiguration } from '@datadog/browser-core'
+import { validateAndBuildConfiguration } from '@datadog/browser-core'
 import type { FlagsConfiguration } from '@datadog/flagging-core'
 import type { EvaluationContext } from '@openfeature/web-sdk'
 import type { DDRum } from '../openfeature/rumIntegration'
@@ -90,11 +90,6 @@ export interface FlaggingConfiguration extends Configuration {
 export function validateAndBuildFlaggingConfiguration(
   initConfiguration: FlaggingInitConfiguration
 ): FlaggingConfiguration | undefined {
-  if (!initConfiguration.applicationId) {
-    display.error('Application ID is not configured, no flagging data will be collected.')
-    return
-  }
-
   const baseConfiguration = validateAndBuildConfiguration(initConfiguration)
   if (!baseConfiguration) {
     return

packages/browser/test/openfeature/exposures.spec.ts

@@ -298,6 +298,39 @@ describe('Exposures End-to-End', () => {
     })
   })
 
+  it('should send exposure events without RUM application attribution when applicationId is not provided', async () => {
+    fetchMock.mockImplementation((url: string) => {
+      if (url.includes('exposures')) {
+        return Promise.resolve({ ok: true, status: 200 })
+      }
+      if (url.includes('precompute-assignments')) {
+        return Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve(precomputedServerResponse),
+        })
+      }
+      return Promise.resolve({ ok: true, json: () => Promise.resolve({}) })
+    })
+
+    await OpenFeature.setContext({ targetingKey: 'test-user-123' })
+    const provider = new DatadogProvider({
+      clientToken: 'test-client-token',
+      env: 'test',
+      site: INTAKE_SITE_STAGING,
+      enableExposureLogging: true,
+    })
+    await OpenFeature.setProviderAndWait(provider)
+
+    OpenFeature.getClient().getStringValue('string-flag', 'default')
+    triggerBatch()
+
+    const exposuresCalls = getExposuresCalls()
+    expect(exposuresCalls).toHaveLength(1)
+
+    const [event] = parseExposureEvents(exposuresCalls[0][1].body)
+    expect(event.rum).toEqual({ view: { url: 'http://localhost/' } })
+  })
+
   it('should not send exposure events when exposure logging is disabled', async () => {
     // Mock server response
     fetchMock.mockImplementation((url: string) => {

packages/browser/test/openfeature/provider.spec.ts

@@ -517,6 +517,31 @@ describe('DatadogProvider', () => {
     })
   })
 
+  describe('initialization without applicationId', () => {
+    it('should initialize successfully', async () => {
+      const originalFetch = global.fetch
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => precomputedResponse,
+      })
+      const testProvider = new DatadogProvider({
+        clientToken: 'xxx',
+        env: 'test',
+        site: INTAKE_SITE_STAGING,
+        enableExposureLogging: false,
+        enableFlagEvaluationTracking: false,
+        enableRumFeatureFlagTracking: false,
+      })
+
+      try {
+        await expect(testProvider.initialize()).resolves.toBeUndefined()
+        expect(testProvider.status).toBe(ProviderStatus.READY)
+      } finally {
+        global.fetch = originalFetch
+      }
+    })
+  })
+
   describe('error handling integration', () => {
     let originalFetch: (input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>
     let isolatedFetchMock: jest.Mock

packages/core/src/evaluation/evaluateForSubject.ts

@@ -4,7 +4,7 @@ import { type TimeStamp, timeStampNow } from '../time'
 import { TargetingKeyMissingError } from './errors'
 import { createEvaluationTimestampMetadata } from './evaluationMetadata'
 import { matchesShard } from './matchesShard'
-import { isValidRule, matchesRule, type Rule } from './rules'
+import { hasInvalidSemverComparand, isValidRule, matchesRule, type Rule } from './rules'
 import { type Flag, type Split, type VariantType, variantTypeToFlagValueType } from './ufc-v1'
 
 export function evaluateForSubject<T extends FlagValueType>(
@@ -157,15 +157,25 @@ function validateTypeMatch(expectedType: FlagValueType, variantType: VariantType
 }
 
 function isValidFlag(flag: Flag): boolean {
-  return (
-    Array.isArray(flag.allocations) &&
-    flag.allocations.every(
+  if (!Array.isArray(flag.allocations)) {
+    return false
+  }
+
+  if (
+    flag.allocations.some(
       (allocation) =>
-        Array.isArray(allocation.splits) &&
-        allocation.splits.every((split) => Array.isArray(split.shards)) &&
-        (allocation.rules === undefined ||
-          (Array.isArray(allocation.rules) && allocation.rules.every((rule) => isValidRule(rule))))
+        Array.isArray(allocation.rules) && allocation.rules.some((rule) => hasInvalidSemverComparand(rule))
     )
+  ) {
+    throw new Error('invalid semantic version comparand')
+  }
+
+  return flag.allocations.every(
+    (allocation) =>
+      Array.isArray(allocation.splits) &&
+      allocation.splits.every((split) => Array.isArray(split.shards)) &&
+      (allocation.rules === undefined ||
+        (Array.isArray(allocation.rules) && allocation.rules.every((rule) => isValidRule(rule))))
   )
 }
 

packages/core/src/evaluation/rules.test.ts

@@ -1,28 +1,5 @@
 import { isValidRule, matchesRule, OperatorType, type Rule } from './rules'
 
-describe('SemVer conditions', () => {
-  it.each([
-    [OperatorType.SEMVER_EQUAL, '1.2.3+build.9', '1.2.3+other', true],
-    [OperatorType.SEMVER_NOT_EQUAL, '1.2.3-alpha', '1.2.3', true],
-    [OperatorType.SEMVER_LT, '1.2.3-alpha.2', '1.2.3-alpha.10', true],
-    [OperatorType.SEMVER_LTE, '1.2.3', '1.2.3', true],
-    [OperatorType.SEMVER_GT, '2.0.0', '1.999999999999999999999.0', true],
-    [OperatorType.SEMVER_GTE, '1.2.3', '2.0.0', false],
-  ] as const)('%s compares %s against %s', (operator, actual, expected, matches) => {
-    expect(
-      matchesRule({ conditions: [{ operator, attribute: 'version', value: expected }] }, { version: actual })
-    ).toBe(matches)
-  })
-
-  it.each(['1.2', '01.2.3', '1.2.3-01', '1.2.3+'])('rejects invalid strict SemVer value %s', (value) => {
-    const rule: Rule = {
-      conditions: [{ operator: OperatorType.SEMVER_EQUAL, attribute: 'version', value: '1.2.3' }],
-    }
-
-    expect(matchesRule(rule, { version: value })).toBe(false)
-  })
-})
-
 describe('SHA-256 membership conditions', () => {
   const hash = 'c0e551d80aa1e2cb1eaf5be7edbb04e51eb1823e562e2ce5dfeda0ecba76c744'
 

packages/core/src/evaluation/rules.ts

@@ -1,6 +1,7 @@
 import type { EvaluationContext, EvaluationContextValue } from '@openfeature/core'
 import { encodeUtf8 } from '../utf8'
-import { compareSemver, compileRegex, isValidSemver } from './condition-helpers'
+import { compileRegex } from './condition-helpers'
+import { compareSemver, parseSemver } from './semver'
 import { sha256Hex } from './sha256'
 
 export type ConditionValueType = EvaluationContextValue | EvaluationContextValue[]
@@ -17,8 +18,8 @@ export enum OperatorType {
   ONE_OF_SHA256 = 'ONE_OF_SHA256',
   NOT_ONE_OF_SHA256 = 'NOT_ONE_OF_SHA256',
   IS_NULL = 'IS_NULL',
-  SEMVER_EQUAL = 'SEMVER_EQUAL',
-  SEMVER_NOT_EQUAL = 'SEMVER_NOT_EQUAL',
+  SEMVER_EQ = 'SEMVER_EQ',
+  SEMVER_NEQ = 'SEMVER_NEQ',
   SEMVER_LT = 'SEMVER_LT',
   SEMVER_LTE = 'SEMVER_LTE',
   SEMVER_GT = 'SEMVER_GT',
@@ -74,14 +75,16 @@ type Sha256Condition = {
   }
 }
 
+type SemverOperator =
+  | OperatorType.SEMVER_EQ
+  | OperatorType.SEMVER_NEQ
+  | OperatorType.SEMVER_LT
+  | OperatorType.SEMVER_LTE
+  | OperatorType.SEMVER_GT
+  | OperatorType.SEMVER_GTE
+
 type SemverCondition = {
-  operator:
-    | OperatorType.SEMVER_EQUAL
-    | OperatorType.SEMVER_NOT_EQUAL
-    | OperatorType.SEMVER_LT
-    | OperatorType.SEMVER_LTE
-    | OperatorType.SEMVER_GT
-    | OperatorType.SEMVER_GTE
+  operator: SemverOperator
   attribute: string
   value: string
 }
@@ -109,13 +112,8 @@ export function isValidRule(rule: Rule): boolean {
     if (!supportedOperators.has(condition.operator)) {
       return false
     }
-    if (condition.operator === OperatorType.MATCHES || condition.operator === OperatorType.NOT_MATCHES) {
-      try {
-        compileRegex(condition.value)
-        return true
-      } catch {
-        return false
-      }
+    if (isSemverOperator(condition.operator)) {
+      return parseSemver(condition.value) !== null
     }
     if (condition.operator === OperatorType.ONE_OF_SHA256 || condition.operator === OperatorType.NOT_ONE_OF_SHA256) {
       return (
@@ -124,8 +122,13 @@ export function isValidRule(rule: Rule): boolean {
         condition.value.hashes.every((hash) => /^[0-9a-f]{64}$/.test(hash))
       )
     }
-    if (condition.operator.startsWith('SEMVER_')) {
-      return isValidSemver(condition.value as string)
+    if (condition.operator === OperatorType.MATCHES || condition.operator === OperatorType.NOT_MATCHES) {
+      try {
+        compileRegex(condition.value)
+        return true
+      } catch {
+        return false
+      }
     }
     return true
   })
@@ -185,26 +188,66 @@ function evaluateCondition(subjectAttributes: EvaluationContext, condition: Cond
         const included = condition.value.hashes.includes(sha256Hex(input))
         return condition.operator === OperatorType.ONE_OF_SHA256 ? included : !included
       }
-      case OperatorType.SEMVER_EQUAL:
-      case OperatorType.SEMVER_NOT_EQUAL:
+      case OperatorType.SEMVER_EQ:
+      case OperatorType.SEMVER_NEQ:
       case OperatorType.SEMVER_LT:
       case OperatorType.SEMVER_LTE:
       case OperatorType.SEMVER_GT:
-      case OperatorType.SEMVER_GTE: {
-        const comparison = compareSemver(String(value), condition.value)
-        if (comparison === undefined) return false
-        if (condition.operator === OperatorType.SEMVER_EQUAL) return comparison === 0
-        if (condition.operator === OperatorType.SEMVER_NOT_EQUAL) return comparison !== 0
-        if (condition.operator === OperatorType.SEMVER_LT) return comparison < 0
-        if (condition.operator === OperatorType.SEMVER_LTE) return comparison <= 0
-        if (condition.operator === OperatorType.SEMVER_GT) return comparison > 0
-        return comparison >= 0
-      }
+      case OperatorType.SEMVER_GTE:
+        return evaluateSemverCondition(value, condition.value, condition.operator)
     }
   }
   return false
 }
 
+export function isSemverOperator(operator: string): operator is SemverOperator {
+  return (
+    operator === OperatorType.SEMVER_EQ ||
+    operator === OperatorType.SEMVER_NEQ ||
+    operator === OperatorType.SEMVER_LT ||
+    operator === OperatorType.SEMVER_LTE ||
+    operator === OperatorType.SEMVER_GT ||
+    operator === OperatorType.SEMVER_GTE
+  )
+}
+
+export function hasInvalidSemverComparand(rule: Rule): boolean {
+  return rule.conditions.some(
+    (condition) => isSemverOperator(condition.operator) && parseSemver(condition.value) === null
+  )
+}
+
+function evaluateSemverCondition(
+  attributeValue: EvaluationContextValue,
+  comparandValue: string,
+  operator: SemverOperator
+): boolean {
+  if (typeof attributeValue !== 'string') {
+    return false
+  }
+
+  const attribute = parseSemver(attributeValue)
+  const comparand = parseSemver(comparandValue)
+  if (!attribute || !comparand) {
+    return false
+  }
+
+  const ordering = compareSemver(attribute, comparand)
+  switch (operator) {
+    case OperatorType.SEMVER_EQ:
+      return ordering === 0
+    case OperatorType.SEMVER_NEQ:
+      return ordering !== 0
+    case OperatorType.SEMVER_LT:
+      return ordering < 0
+    case OperatorType.SEMVER_LTE:
+      return ordering <= 0
+    case OperatorType.SEMVER_GT:
+      return ordering > 0
+    case OperatorType.SEMVER_GTE:
+      return ordering >= 0
+  }
+}
 function isOneOf(attributeValue: string, conditionValues: string[]) {
   return conditionValues.includes(attributeValue)
 }