move to types package

update

lib/shared/types/src/index.ts

@@ -10,3 +10,4 @@ export * from './types/config/models'
 export * from './utils'
 export * from './types/ConfigSource'
 export * from './types/UserError'
+export * from './types/variableKeys'

lib/shared/types/src/types/variableKeys.ts

@@ -0,0 +1,44 @@
+import { VariableTypeAlias, VariableValue } from './config/models'
+
+/**
+ * Used to support strong typing of variable keys in the SDK.
+ * Usage;
+ * ```ts
+ * import '@devcycle/types';
+ * declare module '@devcycle/types' {
+ *   interface CustomVariableDefinitions {
+ *     'flag-one': boolean;
+ *   }
+ * }
+ * ```
+ * Or when using the cli generated types;
+ * ```ts
+ * import '@devcycle/types';
+ * declare module '@devcycle/types' {
+ *   interface CustomVariableDefinitions extends DVCVariableTypes {}
+ * }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface CustomVariableDefinitions {}
+type DynamicBaseVariableDefinitions =
+    keyof CustomVariableDefinitions extends never
+        ? {
+              [key: string]: VariableValue
+          }
+        : CustomVariableDefinitions
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface VariableDefinitions extends DynamicBaseVariableDefinitions {}
+export type VariableKey = string & keyof VariableDefinitions
+// type that determines whether the VariableDefinitions interface
+// extends the index signature, and thus does not have custom variable
+// types defined.
+export type CustomVariablesDefined =
+    keyof CustomVariableDefinitions extends never ? false : true
+
+export type InferredVariableType<
+    K extends VariableKey,
+    DefaultValue extends VariableDefinitions[K],
+> = CustomVariablesDefined extends true
+    ? VariableDefinitions[K]
+    : VariableTypeAlias<DefaultValue>

lib/shared/types/src/utils.ts

@@ -47,3 +47,7 @@ export function getVariableTypeFromValue(
         }
     }
 }
+
+export type NonIndexKey<T, K extends PropertyKey> = K extends keyof T
+    ? K
+    : never

sdk/js-cloud-server/src/cloudClient.ts

@@ -15,8 +15,9 @@ import {
     DevCycleServerSDKOptions,
     DVCLogger,
     getVariableTypeFromValue,
+    InferredVariableType,
+    VariableDefinitions,
     VariableTypeAlias,
-    type VariableValue,
 } from '@devcycle/types'
 import {
     getAllFeatures,
@@ -68,10 +69,6 @@ const throwIfUserError = (err: unknown) => {
     throw err
 }
 
-export interface VariableDefinitions {
-    [key: string]: VariableValue
-}
-
 export class DevCycleCloudClient<
     Variables extends VariableDefinitions = VariableDefinitions,
 > {
@@ -163,7 +160,7 @@ export class DevCycleCloudClient<
         user: DevCycleUser,
         key: K,
         defaultValue: T,
-    ): Promise<VariableTypeAlias<T>> {
+    ): Promise<InferredVariableType<K, T>> {
         return (await this.variable(user, key, defaultValue)).value
     }
 

sdk/js-cloud-server/src/models/variable.ts

@@ -1,4 +1,9 @@
-import { VariableType, VariableTypeAlias } from '@devcycle/types'
+import {
+    InferredVariableType,
+    VariableKey,
+    VariableType,
+    VariableTypeAlias,
+} from '@devcycle/types'
 import { DVCVariableInterface, DVCVariableValue } from '../types'
 import {
     checkParamDefined,
@@ -14,11 +19,13 @@ export type VariableParam<T extends DVCVariableValue> = {
     evalReason?: unknown
 }
 
-export class DVCVariable<T extends DVCVariableValue>
-    implements DVCVariableInterface
+export class DVCVariable<
+    T extends DVCVariableValue,
+    K extends VariableKey = VariableKey,
+> implements DVCVariableInterface
 {
-    key: string
-    value: VariableTypeAlias<T>
+    key: K
+    value: InferredVariableType<K, T>
     readonly defaultValue: T
     readonly isDefaulted: boolean
     readonly type: 'String' | 'Number' | 'Boolean' | 'JSON'
@@ -29,7 +36,9 @@ export class DVCVariable<T extends DVCVariableValue>
         checkParamDefined('key', key)
         checkParamDefined('defaultValue', defaultValue)
         checkParamType('key', key, typeEnum.string)
-        this.key = key.toLowerCase()
+        // kind of cheating here with the type assertion but we're basically assuming that all variable keys in
+        // generated types are lowercase since the system enforces that elsewhere
+        this.key = key.toLowerCase() as K
         this.isDefaulted = value === undefined || value === null
         this.value =
             value === undefined || value === null

sdk/js-cloud-server/src/request.ts

@@ -2,7 +2,6 @@ import { DVCPopulatedUser } from './models/populatedUser'
 import { DevCycleEvent } from './types'
 import { DevCycleServerSDKOptions } from '@devcycle/types'
 import { post } from '@devcycle/server-request'
-import { VariableKey } from '@devcycle/js-client-sdk'
 
 export const HOST = '.devcycle.com'
 
@@ -59,7 +58,7 @@ export async function getAllVariables(
 export async function getVariable(
     user: DVCPopulatedUser,
     sdkKey: string,
-    variableKey: VariableKey,
+    variableKey: string,
     options: DevCycleServerSDKOptions,
 ): Promise<Response> {
     const baseUrl = `${

sdk/js/src/Client.ts

@@ -8,7 +8,6 @@ import {
     DevCycleUser,
     ErrorCallback,
     DVCFeature,
-    VariableDefinitions,
     UserError,
 } from './types'
 
@@ -20,7 +19,12 @@ import { DVCPopulatedUser } from './User'
 import { EventQueue, EventTypes } from './EventQueue'
 import { checkParamDefined } from './utils'
 import { EventEmitter } from './EventEmitter'
-import type { BucketedUserConfig, VariableTypeAlias } from '@devcycle/types'
+import type {
+    BucketedUserConfig,
+    InferredVariableType,
+    VariableDefinitions,
+    VariableTypeAlias,
+} from '@devcycle/types'
 import { getVariableTypeFromValue } from '@devcycle/types'
 import { ConfigRequestConsolidator } from './ConfigRequestConsolidator'
 import { dvcDefaultLogger } from './logger'

sdk/js/src/EventQueue.ts

@@ -1,13 +1,9 @@
 import { DevCycleClient } from './Client'
-import {
-    DevCycleEvent,
-    DevCycleOptions,
-    VariableDefinitions,
-    DVCCustomDataJSON,
-} from './types'
+import { DevCycleEvent, DevCycleOptions, DVCCustomDataJSON } from './types'
 import { publishEvents } from './Request'
 import { checkParamDefined } from './utils'
 import chunk from 'lodash/chunk'
+import { VariableDefinitions } from '@devcycle/types'
 
 export const EventTypes = {
     variableEvaluated: 'variableEvaluated',

sdk/js/src/index.ts

@@ -2,7 +2,6 @@ import {
     DevCycleEvent,
     DevCycleOptions,
     DevCycleUser,
-    VariableDefinitions,
     UserError,
     DVCCustomDataJSON,
 } from './types'
@@ -15,6 +14,9 @@ import { checkIsServiceWorker } from './utils'
 export * from './types'
 export { dvcDefaultLogger } from './logger'
 
+import { VariableDefinitions } from '@devcycle/types'
+export { VariableDefinitions }
+
 /**
  * @deprecated Use DevCycleClient instead
  */

sdk/js/src/types.ts

@@ -7,6 +7,8 @@ import type {
     DevCycleJSON,
     DVCCustomDataJSON,
     BucketedUserConfig,
+    VariableKey,
+    InferredVariableType,
 } from '@devcycle/types'
 export { UserError } from '@devcycle/types'
 
@@ -193,38 +195,10 @@ export interface DevCycleUser<T extends DVCCustomDataJSON = DVCCustomDataJSON> {
     privateCustomData?: T
 }
 
-/**
- * Used to support strong typing of flag strings in the SDK.
- * Usage;
- * ```ts
- * import '@devcycle/js-client-sdk';
- * declare module '@devcycle/js-client-sdk' {
- *   interface CustomVariableDefinitions {
- *     'flag-one': boolean;
- *   }
- * }
- * ```
- * Or when using the cli generated types;
- * ```ts
- * import '@devcycle/js-client-sdk';
- * declare module '@devcycle/js-client-sdk' {
- *   interface CustomVariableDefinitions extends DVCVariableTypes {}
- * }
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface CustomVariableDefinitions {}
-type DynamicBaseVariableDefinitions =
-    keyof CustomVariableDefinitions extends never
-        ? {
-              [key: string]: VariableValue
-          }
-        : CustomVariableDefinitions
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface VariableDefinitions extends DynamicBaseVariableDefinitions {}
-export type VariableKey = string & keyof VariableDefinitions
-
-export interface DVCVariable<T extends DVCVariableValue> {
+export interface DVCVariable<
+    T extends DVCVariableValue,
+    K extends VariableKey = VariableKey,
+> {
     /**
      * Unique "key" by Project to use for this Dynamic Variable.
      */
@@ -234,7 +208,7 @@ export interface DVCVariable<T extends DVCVariableValue> {
      * The value for this Dynamic Variable which will be set to the `defaultValue`
      * if accessed before the SDK is fully Initialized
      */
-    readonly value: VariableTypeAlias<T>
+    readonly value: InferredVariableType<K, T>
 
     /**
      * Default value set when creating the variable

sdk/nestjs/src/DevCycleModule/DevCycleService.ts

@@ -1,10 +1,10 @@
 import { Injectable } from '@nestjs/common'
+import { DevCycleClient, DevCycleUser } from '@devcycle/nodejs-server-sdk'
 import {
-    DVCVariableValue,
-    DevCycleClient,
-    DevCycleUser,
-} from '@devcycle/nodejs-server-sdk'
-import { VariableTypeAlias } from '@devcycle/types'
+    InferredVariableType,
+    VariableDefinitions,
+    VariableKey,
+} from '@devcycle/types'
 import { ClsService } from 'nestjs-cls'
 
 @Injectable()
@@ -18,14 +18,14 @@ export class DevCycleService {
         return this.cls.get('dvc_user')
     }
 
-    isEnabled(key: string): boolean {
+    isEnabled(key: VariableKey): boolean {
         return this.devcycleClient.variableValue(this.getUser(), key, false)
     }
 
-    variableValue<T extends DVCVariableValue>(
-        key: string,
-        defaultValue: T,
-    ): VariableTypeAlias<T> {
+    variableValue<
+        K extends VariableKey,
+        ValueType extends VariableDefinitions[K],
+    >(key: K, defaultValue: ValueType): InferredVariableType<K, ValueType> {
         return this.devcycleClient.variableValue(
             this.getUser(),
             key,

sdk/nextjs/src/client/useVariableValue.ts

@@ -1,15 +1,18 @@
 'use client'
-import { DevCycleClient, DVCVariableValue } from '@devcycle/js-client-sdk'
+import { DevCycleClient } from '@devcycle/js-client-sdk'
 import { useContext, use } from 'react'
-import { VariableTypeAlias } from '@devcycle/types'
+import { VariableDefinitions, VariableKey } from '@devcycle/types'
 import { DVCVariable } from '@devcycle/js-client-sdk'
 import { DevCycleProviderContext } from './internal/context'
 import { useRerenderOnVariableChange } from './internal/useRerenderOnVariableChange'
 
-export const useVariable = <T extends DVCVariableValue>(
-    key: string,
-    defaultValue: T,
-): DVCVariable<T> => {
+export const useVariable = <
+    K extends VariableKey,
+    ValueType extends VariableDefinitions[K],
+>(
+    key: K,
+    defaultValue: ValueType,
+): DVCVariable<ValueType> => {
     const context = useContext(DevCycleProviderContext)
     useRerenderOnVariableChange(key)
 
@@ -21,10 +24,13 @@ export const useVariable = <T extends DVCVariableValue>(
     return context.client.variable(key, defaultValue)
 }
 
-export const useVariableValue = <T extends DVCVariableValue>(
-    key: string,
-    defaultValue: T,
-): VariableTypeAlias<T> => {
+export const useVariableValue = <
+    K extends VariableKey,
+    ValueType extends VariableDefinitions[K],
+>(
+    key: K,
+    defaultValue: ValueType,
+): DVCVariable<ValueType>['value'] => {
     return useVariable(key, defaultValue).value
 }
 

sdk/nextjs/src/server/getVariableValue.ts

@@ -1,17 +1,20 @@
 import { getClient } from './requestContext'
-import { DVCVariableValue } from '@devcycle/js-client-sdk'
-import { VariableTypeAlias } from '@devcycle/types'
+import {
+    VariableDefinitions,
+    VariableKey,
+    VariableTypeAlias,
+} from '@devcycle/types'
 
-export async function getVariableValue<T extends DVCVariableValue>(
-    key: string,
-    defaultValue: T,
-): Promise<VariableTypeAlias<T>> {
+export async function getVariableValue<
+    K extends VariableKey,
+    ValueType extends VariableDefinitions[K],
+>(key: K, defaultValue: ValueType): Promise<VariableTypeAlias<ValueType>> {
     const client = getClient()
     if (!client) {
         console.error(
             'React cache API is not working as expected. Please contact DevCycle support.',
         )
-        return defaultValue as VariableTypeAlias<T>
+        return defaultValue as VariableTypeAlias<ValueType>
     }
 
     const variable = client.variable(key, defaultValue)