@savvagent/solid 1.0.0 → 1.1.0

package/dist/index.mjs

@@ -1,31 +1,79 @@
 // src/index.tsx
-import {
-  createContext,
-  useContext,
-  createSignal,
-  createResource,
-  createEffect,
-  onCleanup
-} from "solid-js";
+import { createComponent as _$createComponent } from "solid-js/web";
+import { createContext, useContext, createSignal, createResource, createEffect, createMemo, onCleanup } from "solid-js";
 import { FlagClient } from "@savvagent/sdk";
 import { FlagClient as FlagClient2 } from "@savvagent/sdk";
 var SavvagentContext = createContext();
 function SavvagentProvider(props) {
-  const client = new FlagClient(props.config);
+  const [isReady, setIsReady] = createSignal(false);
+  let client;
+  try {
+    client = new FlagClient(props.config);
+    setIsReady(true);
+  } catch (error) {
+    console.error("[Savvagent] Failed to initialize client:", error);
+    props.config.onError?.(error);
+    client = new FlagClient({
+      ...props.config,
+      apiKey: ""
+    });
+  }
+  const normalizedDefaultContext = createMemo(() => ({
+    application_id: props.defaultContext?.applicationId,
+    environment: props.defaultContext?.environment,
+    organization_id: props.defaultContext?.organizationId,
+    user_id: props.defaultContext?.userId,
+    anonymous_id: props.defaultContext?.anonymousId,
+    session_id: props.defaultContext?.sessionId,
+    language: props.defaultContext?.language,
+    attributes: props.defaultContext?.attributes
+  }));
+  if (props.defaultContext?.userId) {
+    client.setUserId(props.defaultContext.userId);
+  }
   onCleanup(() => {
     client.close();
   });
-  return /* @__PURE__ */ React.createElement(SavvagentContext.Provider, { value: client }, props.children);
+  const contextValue = {
+    client,
+    isReady,
+    defaultContext: normalizedDefaultContext
+  };
+  return _$createComponent(SavvagentContext.Provider, {
+    value: contextValue,
+    get children() {
+      return props.children;
+    }
+  });
 }
 function useSavvagent() {
-  const client = useContext(SavvagentContext);
-  if (!client) {
+  const context = useContext(SavvagentContext);
+  if (!context) {
     throw new Error("useSavvagent must be used within a SavvagentProvider");
   }
-  return client;
+  return context;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return a === b;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!keysB.includes(key)) return false;
+    if (!deepEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
 }
 function createFlag(flagKey, options = {}) {
-  const client = useSavvagent();
+  const {
+    client,
+    isReady,
+    defaultContext
+  } = useSavvagent();
   const {
     context,
     defaultValue = false,
@@ -33,23 +81,39 @@ function createFlag(flagKey, options = {}) {
     onError
   } = options;
   const [trigger, setTrigger] = createSignal(0);
-  const [result] = createResource(
-    trigger,
-    async () => {
-      try {
-        return await client.evaluate(flagKey, context);
-      } catch (err) {
-        const error2 = err;
-        onError?.(error2);
-        throw error2;
+  const mergedContext = createMemo(() => {
+    const def = defaultContext();
+    return {
+      ...def,
+      ...context,
+      attributes: {
+        ...def?.attributes,
+        ...context?.attributes
       }
+    };
+  });
+  let prevContext;
+  const [result] = createResource(() => ({
+    trigger: trigger(),
+    context: mergedContext(),
+    ready: isReady()
+  }), async (source) => {
+    if (!source.ready) {
+      return null;
+    }
+    try {
+      return await client.evaluate(flagKey, source.context);
+    } catch (err) {
+      const error2 = err;
+      onError?.(error2);
+      throw error2;
     }
-  );
+  });
   const value = () => result()?.value ?? defaultValue;
   const loading = () => result.loading;
   const error = () => result.error ?? null;
   createEffect(() => {
-    if (!realtime) return;
+    if (!realtime || !isReady()) return;
     const unsubscribe = client.subscribe(flagKey, () => {
       setTrigger((t) => t + 1);
     });
@@ -57,6 +121,22 @@ function createFlag(flagKey, options = {}) {
       unsubscribe();
     });
   });
+  createEffect(() => {
+    if (!isReady()) return;
+    const unsubscribe = client.onOverrideChange(() => {
+      setTrigger((t) => t + 1);
+    });
+    onCleanup(() => {
+      unsubscribe();
+    });
+  });
+  createEffect(() => {
+    const currentContext = mergedContext();
+    if (prevContext !== void 0 && !deepEqual(prevContext, currentContext)) {
+      setTrigger((t) => t + 1);
+    }
+    prevContext = currentContext;
+  });
   return {
     value,
     loading,
@@ -69,8 +149,176 @@ function createFlagValue(flagKey, options = {}) {
   const flag = createFlag(flagKey, options);
   return flag.value;
 }
+function createFlags(flagKeys, options = {}) {
+  const {
+    client,
+    isReady,
+    defaultContext
+  } = useSavvagent();
+  const {
+    context,
+    defaultValues = {},
+    realtime = true,
+    onError
+  } = options;
+  const [trigger, setTrigger] = createSignal(0);
+  const mergedContext = createMemo(() => {
+    const def = defaultContext();
+    return {
+      ...def,
+      ...context,
+      attributes: {
+        ...def?.attributes,
+        ...context?.attributes
+      }
+    };
+  });
+  const initialValues = {};
+  const initialErrors = {};
+  const initialResults = {};
+  for (const key of flagKeys) {
+    initialValues[key] = defaultValues[key] ?? false;
+    initialErrors[key] = null;
+    initialResults[key] = null;
+  }
+  const [values, setValues] = createSignal(initialValues);
+  const [errors, setErrors] = createSignal(initialErrors);
+  const [results, setResults] = createSignal(initialResults);
+  const [loading, setLoading] = createSignal(true);
+  let prevContext;
+  const evaluateFlags = async () => {
+    if (!isReady()) return;
+    setLoading(true);
+    const newValues = {};
+    const newErrors = {};
+    const newResults = {};
+    const ctx = mergedContext();
+    await Promise.all(flagKeys.map(async (flagKey) => {
+      try {
+        const evalResult = await client.evaluate(flagKey, ctx);
+        newValues[flagKey] = evalResult.value;
+        newErrors[flagKey] = null;
+        newResults[flagKey] = evalResult;
+      } catch (err) {
+        const error = err;
+        newValues[flagKey] = defaultValues[flagKey] ?? false;
+        newErrors[flagKey] = error;
+        newResults[flagKey] = null;
+        onError?.(error, flagKey);
+      }
+    }));
+    setValues(newValues);
+    setErrors(newErrors);
+    setResults(newResults);
+    setLoading(false);
+  };
+  createEffect(() => {
+    trigger();
+    if (isReady()) {
+      evaluateFlags();
+    }
+  });
+  createEffect(() => {
+    if (!realtime || !isReady()) return;
+    const unsubscribes = flagKeys.map((flagKey) => client.subscribe(flagKey, () => {
+      setTrigger((t) => t + 1);
+    }));
+    onCleanup(() => {
+      unsubscribes.forEach((unsubscribe) => unsubscribe());
+    });
+  });
+  createEffect(() => {
+    if (!isReady()) return;
+    const unsubscribe = client.onOverrideChange(() => {
+      setTrigger((t) => t + 1);
+    });
+    onCleanup(() => {
+      unsubscribe();
+    });
+  });
+  createEffect(() => {
+    const currentContext = mergedContext();
+    if (prevContext !== void 0 && !deepEqual(prevContext, currentContext)) {
+      setTrigger((t) => t + 1);
+    }
+    prevContext = currentContext;
+  });
+  return {
+    values,
+    loading,
+    errors,
+    results,
+    refetch: () => setTrigger((t) => t + 1)
+  };
+}
+function createWithFlag(flagKey, callback, options = {}) {
+  const {
+    client,
+    isReady
+  } = useSavvagent();
+  const {
+    context,
+    onError
+  } = options;
+  createEffect(() => {
+    if (!isReady()) return;
+    client.withFlag(flagKey, callback, context).catch((error) => {
+      console.error(`[Savvagent] Error in withFlag callback for ${flagKey}:`, error);
+      onError?.(error);
+    });
+  });
+}
+function createUser() {
+  const {
+    client
+  } = useSavvagent();
+  const [userId, setUserIdSignal] = createSignal(client.getUserId());
+  const [anonymousId, setAnonymousIdSignal] = createSignal(client.getAnonymousId());
+  const setUserId = (id) => {
+    client.setUserId(id);
+    setUserIdSignal(id);
+  };
+  const getUserId = () => {
+    return client.getUserId();
+  };
+  const setAnonymousId = (id) => {
+    client.setAnonymousId(id);
+    setAnonymousIdSignal(id);
+  };
+  const getAnonymousId = () => {
+    return client.getAnonymousId();
+  };
+  return {
+    userId,
+    setUserId,
+    getUserId,
+    anonymousId,
+    setAnonymousId,
+    getAnonymousId
+  };
+}
+function createEnvironment() {
+  const {
+    client
+  } = useSavvagent();
+  const [environment, setEnvironmentSignal] = createSignal(client.getEnvironment());
+  const setEnvironment = (env) => {
+    client.setEnvironment(env);
+    setEnvironmentSignal(env);
+  };
+  const getEnvironment = () => {
+    return client.getEnvironment();
+  };
+  return {
+    environment,
+    setEnvironment,
+    getEnvironment
+  };
+}
 function createUserSignals() {
-  const client = useSavvagent();
+  const {
+    client
+  } = useSavvagent();
   const [userId, setUserIdSignal] = createSignal(client.getUserId());
   const setUserId = (id) => {
     client.setUserId(id);
@@ -78,16 +326,31 @@ function createUserSignals() {
   };
   return [userId, setUserId];
 }
+function createTrackError(flagKey, context) {
+  const {
+    client
+  } = useSavvagent();
+  return (error) => {
+    client.trackError(flagKey, error, context);
+  };
+}
 function trackError(flagKey, error, context) {
-  const client = useSavvagent();
+  const {
+    client
+  } = useSavvagent();
   client.trackError(flagKey, error, context);
 }
 export {
   FlagClient2 as FlagClient,
   SavvagentProvider,
+  createEnvironment,
   createFlag,
   createFlagValue,
+  createFlags,
+  createTrackError,
+  createUser,
   createUserSignals,
+  createWithFlag,
   trackError,
   useSavvagent
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savvagent/solid",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "SolidJS SDK for Savvagent feature flags with reactive primitives",
   "author": "Savvagent",
   "license": "MIT",
@@ -21,12 +21,21 @@
     "solid-js": ">=1.0.0"
   },
   "dependencies": {
-    "@savvagent/sdk": "1.0.0"
+    "@savvagent/sdk": "1.1.0"
   },
   "devDependencies": {
-    "solid-js": "^1.8.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.4.0"
+    "@solidjs/testing-library": "0.8.10",
+    "@testing-library/jest-dom": "6.9.1",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "esbuild-plugin-solid": "0.6.0",
+    "eslint": "^8.57.0",
+    "jsdom": "27.2.0",
+    "solid-js": "^1.9.10",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vite-plugin-solid": "^2.11.10",
+    "vitest": "4.0.14"
   },
   "keywords": [
     "savvagent",
@@ -50,8 +59,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.tsx --format cjs,esm --dts --external solid-js",
-    "dev": "tsup src/index.tsx --format cjs,esm --dts --external solid-js --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest",
     "lint": "eslint src --ext .ts,.tsx",
     "format": "prettier --write \"src/**/*.{ts,tsx}\""