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

package/dist/{node/flipt_engine_wasm_js.js → slim/index.mjs}

@@ -91,8 +91,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 +176,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 +478,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 +533,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,40 +544,15 @@ 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');
         }
     }
 
@@ -596,12 +565,283 @@ 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.
+ */
+var ErrorStrategy;
+(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";
+})(ErrorStrategy || (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 === 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: 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;
+    }
+}
+
+export { BaseFliptClient, ErrorStrategy, FliptClient };

package/dist/types/browser/index.d.ts

@@ -1,7 +1,7 @@
-import { BaseFliptClient } from '../core/base';
-import { ClientOptions } from '../core/types';
-export * from '../core/types';
-export * from '../core/base';
+import { BaseFliptClient } from '~/core/base';
+import { ClientOptions } from '~/core/types';
+export * from '~/core/types';
+export * from '~/core/base';
 export declare class FliptClient extends BaseFliptClient {
     /**
      * Initialize the client

package/dist/types/core/types.d.ts

@@ -164,6 +164,10 @@ export interface Flag {
      * Type of the feature flag. This can be either 'BOOLEAN_FLAG_TYPE' or 'VARIANT_FLAG_TYPE'.
      */
     type: string;
+    /**
+     * Optional description of the feature flag.
+     */
+    description?: string;
 }
 /**
  * Represents the response returned after evaluating a feature flag variant.

package/dist/types/node/index.d.ts

@@ -1,7 +1,7 @@
-import { BaseFliptClient } from '../core/base';
-import { ClientOptions } from '../core/types';
-export * from '../core/types';
-export * from '../core/base';
+import { BaseFliptClient } from '~/core/base';
+import { ClientOptions } from '~/core/types';
+export * from '~/core/types';
+export * from '~/core/base';
 export declare class FliptClient extends BaseFliptClient {
     private updateInterval?;
     /**

package/dist/types/slim/index.d.ts

@@ -0,0 +1,31 @@
+import { BaseFliptClient } from '~/core/base';
+import { ClientOptions } from '~/core/types';
+export * from '~/core/types';
+export * from '~/core/base';
+export interface WasmOptions {
+    /**
+     * The WASM module to use for evaluation.
+     * Can be provided as:
+     * - A URL string pointing to the WASM file
+     * - A filesystem path to the WASM file (in Node.js environments)
+     * - An ArrayBuffer or Uint8Array containing the WASM binary
+     * - A WebAssembly.Module object
+     *
+     * The simplest way to provide the WASM module is to import it directly from the package:
+     * ```
+     * import wasm from '@flipt-io/flipt-client-js/flipt.wasm';
+     *
+     * const client = await FliptClient.init({ ... }, { wasm });
+     * ```
+     */
+    wasm: ArrayBuffer | Uint8Array | WebAssembly.Module | string;
+}
+export declare class FliptClient extends BaseFliptClient {
+    /**
+     * Initialize the client
+     * @param options - optional client options
+     * @param wasmOptions - options for loading WASM
+     * @returns {Promise<FliptClient>}
+     */
+    static init(options?: ClientOptions, wasmOptions?: WasmOptions): Promise<FliptClient>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flipt-io/flipt-client-js",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Flipt Client Evaluation SDK for Web and Node.js",
   "type": "module",
   "main": "./dist/node/index.cjs",
@@ -20,6 +20,10 @@
       "default": {
         "import": "./dist/browser/index.mjs",
         "require": "./dist/browser/index.cjs"
+      },
+      "slim": {
+        "import": "./dist/slim/index.mjs",
+        "require": "./dist/slim/index.cjs"
       }
     },
     "./node": {
@@ -31,7 +35,13 @@
       "types": "./dist/types/index.d.ts",
       "import": "./dist/browser/index.mjs",
       "require": "./dist/browser/index.cjs"
-    }
+    },
+    "./slim": {
+      "types": "./dist/types/slim/index.d.ts",
+      "import": "./dist/slim/index.mjs",
+      "require": "./dist/slim/index.cjs"
+    },
+    "./engine.wasm": "./dist/flipt_engine_wasm_js_bg.wasm"
   },
   "typesVersions": {
     "*": {
@@ -43,13 +53,14 @@
       ],
       "browser": [
         "./dist/types/index.d.ts"
+      ],
+      "slim": [
+        "./dist/types/slim/index.d.ts"
       ]
     }
   },
   "files": [
-    "dist/browser",
-    "dist/node",
-    "dist/types",
+    "dist",
     "README.md"
   ],
   "scripts": {
@@ -65,18 +76,16 @@
   "devDependencies": {
     "@rollup/plugin-typescript": "^12.1.0",
     "@rollup/plugin-wasm": "^6.2.2",
-    "@types/glob": "^8.1.0",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.13.14",
     "@types/node-fetch": "^2.6.11",
     "@typescript-eslint/eslint-plugin": "^5.47.0",
     "@typescript-eslint/parser": "^5.47.0",
     "eslint": "^8.30.0",
-    "glob": "^8.1.0",
     "jest": "^29.7.0",
     "node-fetch": "^3.3.0",
     "prettier": "^3.1.0",
-    "rimraf": "^4.1.2",
+    "rimraf": "^6.0.1",
     "rollup": "^4.14.0",
     "ts-jest": "^29.0.3",
     "tslib": "^2.6.2",

package/dist/browser/flipt_engine_wasm_js.d.ts

@@ -1,53 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export class Engine {
-  free(): void;
-  constructor(namespace: string);
-  snapshot(data: any): void;
-  evaluate_boolean(request: any): any;
-  evaluate_variant(request: any): any;
-  evaluate_batch(request: any): any;
-  list_flags(): any;
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
-  readonly memory: WebAssembly.Memory;
-  readonly __wbg_engine_free: (a: number, b: number) => void;
-  readonly engine_new: (a: number, b: number) => number;
-  readonly engine_snapshot: (a: number, b: any) => [number, number];
-  readonly engine_evaluate_boolean: (a: number, b: any) => [number, number, number];
-  readonly engine_evaluate_variant: (a: number, b: any) => [number, number, number];
-  readonly engine_evaluate_batch: (a: number, b: any) => [number, number, number];
-  readonly engine_list_flags: (a: number) => [number, number, number];
-  readonly __wbindgen_malloc: (a: number, b: number) => number;
-  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-  readonly __wbindgen_exn_store: (a: number) => void;
-  readonly __externref_table_alloc: () => number;
-  readonly __wbindgen_export_4: WebAssembly.Table;
-  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
-  readonly __externref_table_dealloc: (a: number) => void;
-  readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-/**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
-*
-* @returns {Promise<InitOutput>}
-*/
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/dist/browser/flipt_engine_wasm_js_bg.wasm.d.ts

@@ -1,18 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-export const memory: WebAssembly.Memory;
-export const __wbg_engine_free: (a: number, b: number) => void;
-export const engine_new: (a: number, b: number) => number;
-export const engine_snapshot: (a: number, b: any) => [number, number];
-export const engine_evaluate_boolean: (a: number, b: any) => [number, number, number];
-export const engine_evaluate_variant: (a: number, b: any) => [number, number, number];
-export const engine_evaluate_batch: (a: number, b: any) => [number, number, number];
-export const engine_list_flags: (a: number) => [number, number, number];
-export const __wbindgen_malloc: (a: number, b: number) => number;
-export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
-export const __wbindgen_exn_store: (a: number) => void;
-export const __externref_table_alloc: () => number;
-export const __wbindgen_export_4: WebAssembly.Table;
-export const __wbindgen_free: (a: number, b: number, c: number) => void;
-export const __externref_table_dealloc: (a: number) => void;
-export const __wbindgen_start: () => void;