@statsig/serverless-client 3.29.0 → 3.30.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@statsig/serverless-client",
-  "version": "3.29.0",
+  "version": "3.30.0",
   "license": "ISC",
   "homepage": "https://github.com/statsig-io/js-client-monorepo",
   "repository": {
@@ -9,8 +9,8 @@
     "directory": "packages/serverless"
   },
   "dependencies": {
-    "@statsig/client-core": "3.29.0",
-    "@statsig/js-on-device-eval-client": "3.29.0"
+    "@statsig/client-core": "3.30.0",
+    "@statsig/js-on-device-eval-client": "3.30.0"
   },
   "type": "commonjs",
   "main": "./src/index.js",
@@ -19,6 +19,10 @@
     "./cloudflare": {
       "types": "./src/provider/cloudflare.d.ts",
       "default": "./src/provider/cloudflare.js"
+    },
+    "./fastly": {
+      "types": "./src/provider/fastly.d.ts",
+      "default": "./src/provider/fastly.js"
     }
   },
   "devDependencies": {

package/src/provider/fastly.d.ts

@@ -0,0 +1,28 @@
+import { StatsigUpdateDetails } from '@statsig/client-core';
+import { StatsigOptions } from '@statsig/js-on-device-eval-client';
+import { StatsigServerlessClient } from '../StatsigServerlessClient';
+export declare class StatsigFastlyClient extends StatsigServerlessClient {
+    constructor(sdkKey: string, options?: StatsigOptions | null);
+    initializeFromFastly(FastlyStoreType: 'kv' | 'config', storeId: string, keyId: string, apiToken: string): Promise<StatsigUpdateDetails>;
+}
+interface FetchEvent {
+    request: Request;
+    respondWith(response: Response | Promise<Response>): void;
+    waitUntil(promise: Promise<any>): void;
+}
+export interface StatsigFastlyHandler {
+    (event: FetchEvent, client: StatsigFastlyClient): Promise<Response> | Response;
+}
+export interface StatsigFastlyHandlerParams {
+    statsigSdkKey: string;
+    fastlyStoreType: 'kv' | 'config';
+    storeId: string;
+    keyId: string;
+    apiToken: string;
+    statsigOptions?: StatsigOptions;
+}
+interface FastlyHandlerExport {
+    (event: FetchEvent): Promise<Response>;
+}
+export declare function handleWithStatsig(handler: StatsigFastlyHandler, params: StatsigFastlyHandlerParams): FastlyHandlerExport;
+export {};

package/src/provider/fastly.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleWithStatsig = exports.StatsigFastlyClient = void 0;
+const client_core_1 = require("@statsig/client-core");
+const StatsigServerlessClient_1 = require("../StatsigServerlessClient");
+class StatsigFastlyClient extends StatsigServerlessClient_1.StatsigServerlessClient {
+    constructor(sdkKey, options = null) {
+        var _a;
+        const userOverride = (_a = options === null || options === void 0 ? void 0 : options.networkConfig) === null || _a === void 0 ? void 0 : _a.networkOverrideFunc;
+        const fastlyNetworkOverride = (url, args) => __awaiter(this, void 0, void 0, function* () {
+            if (userOverride) {
+                return userOverride(url, args);
+            }
+            let backend;
+            if (url.startsWith(`${client_core_1.NetworkDefault[client_core_1.Endpoint._rgstr]}/${client_core_1.Endpoint._rgstr}`)) {
+                backend = 'statsig_flush';
+            }
+            else if (url.startsWith(`${client_core_1.NetworkDefault[client_core_1.Endpoint._download_config_specs]}/${client_core_1.Endpoint._download_config_specs}`)) {
+                backend = 'async_initialize';
+            }
+            return fetch(url, Object.assign(Object.assign({}, args), { backend }));
+        });
+        const fastlyOptions = Object.assign(Object.assign({}, options), { networkConfig: Object.assign(Object.assign({}, options === null || options === void 0 ? void 0 : options.networkConfig), { networkOverrideFunc: fastlyNetworkOverride }) });
+        super(sdkKey, fastlyOptions);
+    }
+    initializeFromFastly(FastlyStoreType, storeId, keyId, apiToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startTime = performance.now();
+            let url;
+            if (FastlyStoreType === 'kv') {
+                url = `https://api.fastly.com/resources/stores/kv/${storeId}/keys/${keyId}`;
+            }
+            else if (FastlyStoreType === 'config') {
+                url = `https://api.fastly.com/resources/stores/config/${storeId}/item/${keyId}`;
+            }
+            else {
+                return {
+                    duration: performance.now() - startTime,
+                    source: 'Bootstrap',
+                    success: false,
+                    error: { message: 'Invalid Fastly store type' },
+                    sourceUrl: 'Invalid Fastly store type',
+                };
+            }
+            try {
+                const response = yield fetch(url, {
+                    method: 'GET',
+                    headers: {
+                        'Fastly-Key': apiToken,
+                        Accept: 'application/json',
+                    },
+                    backend: 'fastly_api',
+                });
+                const res = yield response.text();
+                if (res) {
+                    let configData;
+                    if (FastlyStoreType === 'config') {
+                        const parsedRes = JSON.parse(res);
+                        configData = parsedRes.item_value;
+                    }
+                    else {
+                        configData = res;
+                    }
+                    this.dataAdapter.setData(configData);
+                    return this.initializeSync({
+                        disableBackgroundCacheRefresh: true,
+                    });
+                }
+                return {
+                    duration: performance.now() - startTime,
+                    source: 'Bootstrap',
+                    success: false,
+                    error: {
+                        message: 'Config specs were not parsed successfully',
+                    },
+                    sourceUrl: url,
+                };
+            }
+            catch (error) {
+                return {
+                    duration: performance.now() - startTime,
+                    source: 'Bootstrap',
+                    success: false,
+                    error: {
+                        message: 'Failed to retrieve config specs from Fastly',
+                    },
+                    sourceUrl: url,
+                };
+            }
+        });
+    }
+}
+exports.StatsigFastlyClient = StatsigFastlyClient;
+function handleWithStatsig(handler, params) {
+    return (event) => __awaiter(this, void 0, void 0, function* () {
+        if (!params.statsigSdkKey || typeof params.statsigSdkKey !== 'string') {
+            client_core_1.Log.error(`Invalid statsigSdkKey`);
+        }
+        if (!params.storeId || typeof params.storeId !== 'string') {
+            client_core_1.Log.error(`Invalid storeId`);
+        }
+        if (!params.keyId || typeof params.keyId !== 'string') {
+            client_core_1.Log.error(`Invalid keyId`);
+        }
+        if (!params.apiToken || typeof params.apiToken !== 'string') {
+            client_core_1.Log.error(`Invalid apiToken`);
+        }
+        const client = new StatsigFastlyClient(params.statsigSdkKey, params.statsigOptions);
+        yield client.initializeFromFastly(params.fastlyStoreType, params.storeId, params.keyId, params.apiToken);
+        const response = yield handler(event, client);
+        event.waitUntil(client.flush());
+        return response;
+    });
+}
+exports.handleWithStatsig = handleWithStatsig;