Add Optimizely adapter

.changeset/eighty-dingos-protect.md

@@ -0,0 +1,5 @@
+---
+'@flags-sdk/optimizely': minor
+---
+
+Implement adapter to resolve feature flags

package.json

@@ -55,7 +55,7 @@
     "publint": "0.2.7",
     "ts-jest": "29.1.2",
     "turbo": "2.3.3",
-    "typescript": "^5.3.3"
+    "typescript": "^5.9.2"
   },
   "packageManager": "pnpm@8.7.1",
   "engines": {

packages/adapter-optimizely/package.json

@@ -35,7 +35,11 @@
     "test:watch": "vitest",
     "type-check": "tsc --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "@optimizely/optimizely-sdk": "6.1.0",
+    "@vercel/edge-config": "1.4.0",
+    "@vercel/functions": "^1.5.2"
+  },
   "devDependencies": {
     "@types/node": "20.11.17",
     "eslint-config-custom": "workspace:*",
@@ -48,7 +52,6 @@
     "vite": "5.1.1",
     "vitest": "1.4.0"
   },
-  "peerDependencies": {},
   "publishConfig": {
     "access": "public"
   }

packages/adapter-optimizely/src/edge-runtime-hooks.ts

@@ -0,0 +1,31 @@
+import type { LogEvent } from '@optimizely/optimizely-sdk';
+
+/**
+ * Web standards friendly event dispatcher for Optimizely
+ * uses `waitUntil()` to avoid blocking the visitor's page load
+ *
+ * This does not send back the status code to the dispatcher as it runs in `waitUntil()`
+ */
+export async function dispatchEvent(event: LogEvent) {
+  // Non-POST requests not supported
+  if (event.httpVerb !== 'POST') {
+    throw new Error(
+      'Optimizely Event Dispatcher: Only POST requests are supported',
+    );
+  }
+
+  const url = new URL(event.url);
+  const data = JSON.stringify(event.params);
+
+  const dispatch = fetch(url, {
+    method: 'POST',
+    body: data,
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  });
+
+  import('@vercel/functions').then(({ waitUntil }) => {
+    waitUntil(dispatch);
+  });
+}

packages/adapter-optimizely/src/index.ts

@@ -1 +1,224 @@
 export { getProviderData } from './provider';
+import {
+  Client,
+  OpaqueConfigManager,
+  OptimizelyDecision,
+  UserAttributes,
+} from '@optimizely/optimizely-sdk';
+
+import type { Adapter, JsonValue } from 'flags';
+import { dispatchEvent } from './edge-runtime-hooks';
+import {
+  createForwardingEventProcessor,
+  createInstance,
+  createPollingProjectConfigManager,
+  createStaticProjectConfigManager,
+  RequestHandler,
+} from '@optimizely/optimizely-sdk/universal';
+import { createClient } from '@vercel/edge-config';
+
+let defaultOptimizelyAdapter:
+  | ReturnType<typeof createOptimizelyAdapter>
+  | undefined;
+
+/**
+ * The user context for the Optimizely adapter
+ */
+export type UserContext = {
+  userId: string;
+  attributes?: UserAttributes;
+};
+
+type AdapterResponse = {
+  decide: <T>(
+    getValue: (decision: OptimizelyDecision) => T,
+  ) => Adapter<T, UserContext>;
+  initialize: () => Promise<Client>;
+};
+
+/**
+ * The node instance has a hardcoded XHR request handler that will break in edge runtime,
+ * so we need to use a custom request handler that uses fetch.
+ */
+const requestHandler: RequestHandler = {
+  makeRequest(requestUrl, headers, method, data) {
+    const abortController = new AbortController();
+
+    const responsePromise = fetch(requestUrl, {
+      headers: headers as Record<string, string>,
+      method,
+      body: data,
+      signal: abortController.signal,
+    });
+    return {
+      abort: () => abortController.abort(),
+      responsePromise: responsePromise.then(async (response) => {
+        const headersObj: Record<string, string> = {};
+        response.headers.forEach((value, key) => {
+          headersObj[key] = value;
+        });
+        return {
+          statusCode: response.status,
+          body: (await response.text()) ?? '',
+          headers: headersObj,
+        };
+      }),
+    };
+  },
+};
+
+export function createOptimizelyAdapter({
+  sdkKey,
+  edgeConfig,
+}: {
+  sdkKey?: string;
+  edgeConfig?: {
+    connectionString: string;
+    itemKey: string;
+  };
+}): AdapterResponse {
+  let optimizelyInstance: Client | undefined;
+
+  const initializeOptimizely = async () => {
+    let projectConfigManager: OpaqueConfigManager | undefined;
+    if (edgeConfig) {
+      const edgeConfigClient = createClient(edgeConfig.connectionString);
+      const datafile = await edgeConfigClient.get<JsonValue>(
+        edgeConfig.itemKey,
+      );
+
+      if (!datafile) {
+        throw new Error(
+          'Optimizely Adapter: Could not get datafile from edge config',
+        );
+      }
+
+      projectConfigManager = createStaticProjectConfigManager({
+        datafile: JSON.stringify(datafile),
+      });
+    }
+
+    if (!projectConfigManager && sdkKey) {
+      projectConfigManager = createPollingProjectConfigManager({
+        sdkKey: sdkKey,
+        updateInterval: 10000,
+        requestHandler,
+      });
+    }
+
+    if (!projectConfigManager) {
+      throw new Error(
+        'Optimizely Adapter: Could not create project config manager, either edgeConfig or sdkKey must be provided',
+      );
+    }
+
+    try {
+      optimizelyInstance = createInstance({
+        clientEngine: 'javascript-sdk/flags-sdk',
+        projectConfigManager,
+        // @ts-expect-error - dispatchEvent runs in `waitUntil` so it's not going to return a response
+        eventProcessor: createForwardingEventProcessor({ dispatchEvent }),
+        requestHandler,
+      });
+    } catch (error) {
+      throw new Error(
+        `Optimizely Adapter: Error creating optimizely instance, ${
+          error instanceof Error ? error.message : error
+        }`,
+      );
+    }
+
+    // This resolves instantly when using the edge config, the timeout is just for fetching the datafile from the polling project config manager
+    await optimizelyInstance.onReady({ timeout: 500 });
+  };
+
+  let _initializePromise: Promise<void> | undefined;
+  const initialize = async () => {
+    if (!_initializePromise) {
+      _initializePromise = initializeOptimizely();
+    }
+    await _initializePromise;
+    if (!optimizelyInstance) {
+      throw new Error(
+        'Optimizely Adapter: Optimizely instance not initialized',
+      );
+    }
+    return optimizelyInstance;
+  };
+
+  function decide<T>(
+    getValue: (decision: OptimizelyDecision) => T,
+  ): Adapter<T, UserContext> {
+    return {
+      decide: async ({ key, entities }) => {
+        await initialize();
+        if (!optimizelyInstance) {
+          throw new Error(
+            'Optimizely Adapter: Optimizely instance not initialized',
+          );
+        }
+        if (!entities || !entities.userId) {
+          throw new Error('Optimizely Adapter: User ID not provided');
+        }
+        const context = optimizelyInstance.createUserContext(
+          entities?.userId,
+          entities?.attributes,
+        );
+        return getValue(context.decide(key));
+      },
+    };
+  }
+
+  return {
+    decide,
+    initialize,
+  };
+}
+
+function getOrCreateDefaultOptimizelyAdapter(): AdapterResponse {
+  const sdkKey = process.env.OPTIMIZELY_SDK_KEY;
+  const edgeConfigConnectionString = process.env.EDGE_CONFIG_CONNECTION_STRING;
+  const edgeConfigItemKey = process.env.OPTIMIZELY_DATAFILE_ITEM_KEY;
+
+  if (!defaultOptimizelyAdapter) {
+    if (edgeConfigConnectionString && edgeConfigItemKey) {
+      defaultOptimizelyAdapter = createOptimizelyAdapter({
+        sdkKey,
+        edgeConfig: {
+          connectionString: edgeConfigConnectionString,
+          itemKey: edgeConfigItemKey,
+        },
+      });
+    } else {
+      defaultOptimizelyAdapter = createOptimizelyAdapter({
+        sdkKey,
+      });
+    }
+  }
+  return defaultOptimizelyAdapter;
+}
+
+/**
+ * The default Optimizely adapter.
+ *
+ * This is a convenience object that pre-initializes the Optimizely SDK and provides
+ * the adapter functions for the Feature Flags.
+ *
+ * This is the recommended way to use the Optimizely adapter.
+ *
+ * ```ts
+ * // flags.ts
+ * import { flag } from 'flags/next';
+ * import { optimizelyAdapter } from '@flags-sdk/optimizely';
+ *
+ * const flag = flag({
+ *   key: 'my-flag',
+ *   defaultValue: false,
+ *   adapter: optimizelyAdapter.decide((decision) => decision.enabled),
+ * });
+ * ```
+ */
+export const optimizelyAdapter: AdapterResponse = {
+  decide: (...args) => getOrCreateDefaultOptimizelyAdapter().decide(...args),
+  initialize: () => getOrCreateDefaultOptimizelyAdapter().initialize(),
+};

packages/flags/src/sveltekit/index.ts

@@ -337,7 +337,7 @@ export function createHandle({
 }
 
 async function handleWellKnownFlagsRoute(
-  event: RequestEvent<Partial<Record<string, string>>, string | null>,
+  event: RequestEvent<Record<string, string>, string | null>,
   secret: string,
   flags: Record<string, Flag<any>>,
 ) {