@flipt-io/flipt-client-js 0.0.1 → 0.0.3

package/dist/{browser/flipt_engine_wasm_js.js → slim/index.cjs}

@@ -1,3 +1,6 @@
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 let wasm;
 
 let WASM_VECTOR_LEN = 0;
@@ -91,8 +94,7 @@ function handleError(f, args) {
 
 const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
 
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
-
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
 function getStringFromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
@@ -177,7 +179,7 @@ const EngineFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_engine_free(ptr >>> 0, 1));
 
-export class Engine {
+class Engine {
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -479,7 +481,6 @@ function __wbg_get_imports() {
         table.set(offset + 1, null);
         table.set(offset + 2, true);
         table.set(offset + 3, false);
-        ;
     };
     imports.wbg.__wbindgen_is_function = function(arg0) {
         const ret = typeof(arg0) === 'function';
@@ -535,10 +536,6 @@ function __wbg_get_imports() {
     return imports;
 }
 
-function __wbg_init_memory(imports, memory) {
-
-}
-
 function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
@@ -550,45 +547,20 @@ function __wbg_finalize_init(instance, module) {
     return wasm;
 }
 
-function initSync(module) {
-    if (wasm !== undefined) return wasm;
-
-
-    if (typeof module !== 'undefined') {
-        if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module} = module)
-        } else {
-            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
-        }
-    }
-
-    const imports = __wbg_get_imports();
-
-    __wbg_init_memory(imports);
-
-    if (!(module instanceof WebAssembly.Module)) {
-        module = new WebAssembly.Module(module);
-    }
-
-    const instance = new WebAssembly.Instance(module, imports);
-
-    return __wbg_finalize_init(instance, module);
-}
-
 async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
 
     if (typeof module_or_path !== 'undefined') {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path} = module_or_path)
+            ({module_or_path} = module_or_path);
         } else {
-            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead');
         }
     }
 
     if (typeof module_or_path === 'undefined') {
-        module_or_path = new URL('flipt_engine_wasm_js_bg.wasm', import.meta.url);
+        module_or_path = new URL('flipt_engine_wasm_js_bg.wasm', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
     }
     const imports = __wbg_get_imports();
 
@@ -596,12 +568,284 @@ async function __wbg_init(module_or_path) {
         module_or_path = fetch(module_or_path);
     }
 
-    __wbg_init_memory(imports);
-
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync };
-export default __wbg_init;
+/**
+ * Defines the strategy to handle errors during the flags snapshot update calls.
+ */
+exports.ErrorStrategy = void 0;
+(function (ErrorStrategy) {
+    /** The client will throw an error if the flag state cannot be fetched. This is the default behavior. */
+    ErrorStrategy["Fail"] = "fail";
+    /** The client will maintain the last known good state and use that state for evaluation in case of an error. */
+    ErrorStrategy["Fallback"] = "fallback";
+})(exports.ErrorStrategy || (exports.ErrorStrategy = {}));
+
+function snakeToCamel(str) {
+    return str.replace(/([-_][a-z])/g, (group) => group.toUpperCase().replace('-', '').replace('_', ''));
+}
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+function deserialize(data) {
+    const result = {};
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            const camelKey = snakeToCamel(key);
+            result[camelKey] = data[key];
+        }
+    }
+    return result;
+}
+function serialize(data) {
+    const result = {};
+    for (const key in data) {
+        if (Object.prototype.hasOwnProperty.call(data, key)) {
+            const snakeKey = camelToSnake(key);
+            result[snakeKey] = data[key];
+        }
+    }
+    return result;
+}
+
+class BaseFliptClient {
+    constructor(engine, fetcher) {
+        this.engine = engine;
+        this.fetcher = fetcher;
+    }
+    /**
+     * Store etag from response for next requests
+     */
+    storeEtag(resp) {
+        const etag = resp.headers.get('etag');
+        if (etag) {
+            this.etag = etag;
+        }
+    }
+    /**
+     * Refresh the flags snapshot
+     * @returns true if snapshot changed
+     */
+    async refresh() {
+        try {
+            const opts = { etag: this.etag };
+            const resp = await this.fetcher(opts);
+            const etag = resp.headers.get('etag');
+            if (this.etag && this.etag === etag) {
+                return false;
+            }
+            this.storeEtag(resp);
+            const data = await resp.json();
+            this.engine.snapshot(data);
+            return true;
+        }
+        catch (error) {
+            if (this.errorStrategy === exports.ErrorStrategy.Fail) {
+                throw error;
+            }
+        }
+        return false;
+    }
+    /**
+     * Evaluate a variant flag
+     */
+    evaluateVariant({ flagKey, entityId, context }) {
+        if (!flagKey || flagKey.trim() === '') {
+            throw new Error('flagKey cannot be empty');
+        }
+        if (!entityId || entityId.trim() === '') {
+            throw new Error('entityId cannot be empty');
+        }
+        const evaluationRequest = {
+            flagKey,
+            entityId,
+            context
+        };
+        const result = this.engine.evaluate_variant(serialize(evaluationRequest));
+        if (result === null) {
+            throw new Error('Failed to evaluate variant');
+        }
+        const variantResult = deserialize(result);
+        if (variantResult.status === 'failure') {
+            throw new Error(variantResult.errorMessage);
+        }
+        if (!variantResult.result) {
+            throw new Error('Failed to evaluate variant');
+        }
+        return deserialize(variantResult.result);
+    }
+    /**
+     * Evaluate a boolean flag
+     */
+    evaluateBoolean({ flagKey, entityId, context }) {
+        if (!flagKey || flagKey.trim() === '') {
+            throw new Error('flagKey cannot be empty');
+        }
+        if (!entityId || entityId.trim() === '') {
+            throw new Error('entityId cannot be empty');
+        }
+        const evaluationRequest = {
+            flagKey,
+            entityId,
+            context
+        };
+        const result = this.engine.evaluate_boolean(serialize(evaluationRequest));
+        if (result === null) {
+            throw new Error('Failed to evaluate boolean');
+        }
+        const booleanResult = deserialize(result);
+        if (booleanResult.status === 'failure') {
+            throw new Error(booleanResult.errorMessage);
+        }
+        if (!booleanResult.result) {
+            throw new Error('Failed to evaluate boolean');
+        }
+        return deserialize(booleanResult.result);
+    }
+    /**
+     * Evaluate a batch of flag requests
+     */
+    evaluateBatch(requests) {
+        const serializedRequests = requests.map(serialize);
+        const batchResult = this.engine.evaluate_batch(serializedRequests);
+        if (batchResult === null) {
+            throw new Error('Failed to evaluate batch');
+        }
+        if (batchResult.status === 'failure') {
+            throw new Error(batchResult.errorMessage);
+        }
+        if (!batchResult.result) {
+            throw new Error('Failed to evaluate batch');
+        }
+        const responses = batchResult.result.responses
+            .map((response) => {
+            if (response.type === 'BOOLEAN_EVALUATION_RESPONSE_TYPE') {
+                const booleanResponse = deserialize(
+                // @ts-ignore
+                response.boolean_evaluation_response);
+                return {
+                    booleanEvaluationResponse: booleanResponse,
+                    type: 'BOOLEAN_EVALUATION_RESPONSE_TYPE'
+                };
+            }
+            if (response.type === 'VARIANT_EVALUATION_RESPONSE_TYPE') {
+                const variantResponse = deserialize(
+                // @ts-ignore
+                response.variant_evaluation_response);
+                return {
+                    variantEvaluationResponse: variantResponse,
+                    type: 'VARIANT_EVALUATION_RESPONSE_TYPE'
+                };
+            }
+            if (response.type === 'ERROR_EVALUATION_RESPONSE_TYPE') {
+                const errorResponse = deserialize(
+                // @ts-ignore
+                response.error_evaluation_response);
+                return {
+                    errorEvaluationResponse: errorResponse,
+                    type: 'ERROR_EVALUATION_RESPONSE_TYPE'
+                };
+            }
+            return undefined;
+        })
+            .filter((response) => response !== undefined);
+        return {
+            responses,
+            requestDurationMillis: batchResult.result.requestDurationMillis
+        };
+    }
+    listFlags() {
+        const listFlagsResult = this.engine.list_flags();
+        if (listFlagsResult === null) {
+            throw new Error('Failed to list flags');
+        }
+        const flags = deserialize(listFlagsResult);
+        if (flags.status === 'failure') {
+            throw new Error(flags.errorMessage);
+        }
+        if (!flags.result) {
+            throw new Error('Failed to list flags');
+        }
+        return flags.result.map((deserialize));
+    }
+}
+
+class FliptClient extends BaseFliptClient {
+    /**
+     * Initialize the client
+     * @param options - optional client options
+     * @param wasmOptions - options for loading WASM
+     * @returns {Promise<FliptClient>}
+     */
+    static async init(options = {
+        namespace: 'default',
+        url: 'http://localhost:8080',
+        reference: '',
+        updateInterval: 120,
+        errorStrategy: exports.ErrorStrategy.Fail
+    }, wasmOptions) {
+        if (!wasmOptions || !wasmOptions.wasm) {
+            throw new Error('WASM module must be provided in slim mode. Use the standard client or provide a wasm module.');
+        }
+        const namespace = options.namespace ?? 'default';
+        let url = options.url ?? 'http://localhost:8080';
+        url = url.replace(/\/$/, '');
+        url = `${url}/internal/v1/evaluation/snapshot/namespace/${namespace}`;
+        if (options.reference) {
+            url = `${url}?reference=${options.reference}`;
+        }
+        const headers = {
+            Accept: 'application/json',
+            'x-flipt-accept-server-version': '1.47.0'
+        };
+        if (options.authentication) {
+            if ('clientToken' in options.authentication) {
+                headers['Authorization'] =
+                    `Bearer ${options.authentication.clientToken}`;
+            }
+            else if ('jwtToken' in options.authentication) {
+                headers['Authorization'] = `JWT ${options.authentication.jwtToken}`;
+            }
+        }
+        let fetcher = options.fetcher;
+        if (!fetcher) {
+            fetcher = async (opts) => {
+                if (opts && opts.etag) {
+                    headers['If-None-Match'] = opts.etag;
+                }
+                const resp = await fetch(url, {
+                    method: 'GET',
+                    headers
+                });
+                if (!resp.ok && resp.status !== 304) {
+                    throw new Error(`Failed to fetch data: ${resp.statusText}`);
+                }
+                return resp;
+            };
+        }
+        // Initialize WASM engine with the provided WASM module
+        await __wbg_init(wasmOptions.wasm);
+        if (!fetcher) {
+            throw new Error('Failed to initialize fetcher');
+        }
+        // handle case if they pass in a custom fetcher that doesn't throw on non-2xx status codes
+        const resp = await fetcher();
+        if (!resp.ok) {
+            throw new Error(`Failed to fetch data: ${resp.statusText}`);
+        }
+        const data = await resp.json();
+        const engine = new Engine(namespace);
+        engine.snapshot(data);
+        // Create client instance
+        const client = new FliptClient(engine, fetcher);
+        client.storeEtag(resp);
+        client.errorStrategy = options.errorStrategy;
+        return client;
+    }
+}
+
+exports.BaseFliptClient = BaseFliptClient;
+exports.FliptClient = FliptClient;