feat: update sdks

Author: tilyupo

packages/react/src/hooks.ts

@@ -11,7 +11,7 @@ export function useReplane<T extends object = UntypedReplaneConfig>(): ReplaneCl
   return context.client as ReplaneClient<T>;
 }
 
-export function useConfig<T>(name: string, options?: GetConfigOptions): T {
+export function useConfig<T>(name: string, options?: GetConfigOptions<T>): T {
   const client = useReplane();
 
   const subscribe = useCallback(
@@ -75,7 +75,7 @@ export function createReplaneHook<TConfigs extends object>() {
 export function createConfigHook<TConfigs extends object>() {
   return function useTypedConfig<K extends keyof TConfigs>(
     name: K,
-    options?: GetConfigOptions
+    options?: GetConfigOptions<TConfigs[K]>
   ): TConfigs[K] {
     return useConfig<TConfigs[K]>(String(name), options);
   };

packages/sdk/README.md

@@ -118,13 +118,15 @@ Parameters:
 - `name` (K extends keyof T) – config name to fetch. TypeScript will enforce that this is a valid config name from your `Configs` interface.
 - `options` (object) – optional configuration:
   - `context` (object) – context merged with client-level context for override evaluation.
+  - `default` (T[K]) – default value to return if the config is not found. When provided, the method will not throw.
 
 Returns the config value of type `T[K]` (synchronous). The return type is automatically inferred from your `Configs` interface.
 
 Notes:
 
 - The Replane client receives realtime updates via SSE in the background.
-- If the config is not found, throws a `ReplaneError` with code `not_found`.
+- If the config is not found and no default is provided, throws a `ReplaneError` with code `not_found`.
+- If the config is not found and a default is provided, returns the default value without throwing.
 - Context-based overrides are evaluated automatically based on context.
 
 Example:
@@ -148,6 +150,9 @@ const userEnabled = replane.get("billing-enabled", {
   context: { userId: "user-123", plan: "premium" },
 });
 
+// Get value with default - won't throw if config doesn't exist
+const maxConnections = replane.get("max-connections", { default: 10 });
+
 // Clean up when done
 replane.close();
 ```

packages/sdk/src/client-types.ts

@@ -19,11 +19,16 @@ export interface ReplaneLogger {
 /**
  * Options for getting a config value
  */
-export interface GetConfigOptions {
+export interface GetConfigOptions<T> {
   /**
    * Context for override evaluation (merged with client-level context).
    */
   context?: ReplaneContext;
+  /**
+   * Default value to return if the config is not found.
+   * When provided, the method will not throw if the config doesn't exist.
+   */
+  default?: T;
 }
 
 /**
@@ -56,7 +61,7 @@ export interface ReplaneSnapshot<_T extends object = object> {
  */
 export interface ReplaneClient<T extends object> {
   /** Get a config by its name. */
-  get<K extends keyof T>(configName: K, options?: GetConfigOptions): T[K];
+  get<K extends keyof T>(configName: K, options?: GetConfigOptions<T[K]>): T[K];
   /** Subscribe to config changes.
    *  @param callback - A function to call when an config is changed. The callback will be called with the new config value.
    *  @returns A function to unsubscribe from the config changes.

packages/sdk/src/client.ts

@@ -99,10 +99,13 @@ function createClientCore<T extends object = Record<string, unknown>>(
     }
   }
 
-  function get<K extends keyof T>(configName: K, getConfigOptions: GetConfigOptions = {}): T[K] {
+  function get<K extends keyof T>(configName: K, getConfigOptions: GetConfigOptions<T[K]> = {}): T[K] {
     const config = configs.get(String(configName));
 
     if (config === undefined) {
+      if ("default" in getConfigOptions) {
+        return getConfigOptions.default as T[K];
+      }
       throw new ReplaneError({
         message: `Config not found: ${String(configName)}`,
         code: ReplaneErrorCode.NotFound,
@@ -221,9 +224,12 @@ export function createInMemoryReplaneClient<T extends object = Record<string, un
   initialData: T
 ): ReplaneClient<T> {
   return {
-    get: (configName) => {
+    get: (configName, options) => {
       const config = initialData[configName];
       if (config === undefined) {
+        if (options && "default" in options) {
+          return options.default as T[typeof configName];
+        }
         throw new ReplaneError({
           message: `Config not found: ${String(configName)}`,
           code: ReplaneErrorCode.NotFound,

packages/sdk/tests/index.spec.ts

@@ -103,6 +103,40 @@ describe("createReplaneClient", () => {
       expect(() => client.get("nonexistent")).toThrow("Config not found: nonexistent");
     });
 
+    it("should return default value when config not found and default is provided", async () => {
+      clientPromise = createClient();
+      const connection = await mockServer.acceptConnection();
+      await connection.push({
+        type: "init",
+        configs: [{ name: "config1", overrides: [], value: "value1" }],
+      });
+
+      const client = await clientPromise;
+      await sync();
+
+      expect(client.get("nonexistent", { default: "fallback" })).toBe("fallback");
+      expect(client.get("nonexistent", { default: 42 })).toBe(42);
+      expect(client.get("nonexistent", { default: null })).toBe(null);
+      expect(client.get("nonexistent", { default: false })).toBe(false);
+      expect(client.get("nonexistent", { default: { nested: "value" } })).toEqual({
+        nested: "value",
+      });
+    });
+
+    it("should return actual value when config exists even if default is provided", async () => {
+      clientPromise = createClient();
+      const connection = await mockServer.acceptConnection();
+      await connection.push({
+        type: "init",
+        configs: [{ name: "config1", overrides: [], value: "actual" }],
+      });
+
+      const client = await clientPromise;
+      await sync();
+
+      expect(client.get("config1", { default: "fallback" })).toBe("actual");
+    });
+
     it("should handle config values of different types", async () => {
       clientPromise = createClient();
       const connection = await mockServer.acceptConnection();
@@ -1900,6 +1934,28 @@ describe("createInMemoryReplaneClient", () => {
     expect(() => client.get("nonexistent" as never)).toThrow("Config not found: nonexistent");
   });
 
+  it("should return default value when config not found and default is provided", () => {
+    const client = createInMemoryReplaneClient({
+      config1: "value1",
+    });
+
+    expect(client.get("nonexistent" as never, { default: "fallback" as never })).toBe("fallback");
+    expect(client.get("nonexistent" as never, { default: 42 as never })).toBe(42);
+    expect(client.get("nonexistent" as never, { default: null as never })).toBe(null);
+    expect(client.get("nonexistent" as never, { default: false as never })).toBe(false);
+    expect(client.get("nonexistent" as never, { default: { nested: "value" } as never })).toEqual({
+      nested: "value",
+    });
+  });
+
+  it("should return actual value when config exists even if default is provided", () => {
+    const client = createInMemoryReplaneClient({
+      config1: "actual",
+    });
+
+    expect(client.get("config1", { default: "fallback" })).toBe("actual");
+  });
+
   it("should handle complex values", () => {
     const client = createInMemoryReplaneClient({
       array: [1, 2, 3],
@@ -2007,6 +2063,32 @@ describe("restoreReplaneClient", () => {
       expect(() => client.get("nonexistent")).toThrow("Config not found: nonexistent");
     });
 
+    it("should return default value when config not found and default is provided", () => {
+      const snapshot: ReplaneSnapshot<Record<string, unknown>> = {
+        configs: [{ name: "config1", value: "value1", overrides: [] }],
+      };
+
+      const client = restoreReplaneClient({ snapshot });
+
+      expect(client.get("nonexistent", { default: "fallback" })).toBe("fallback");
+      expect(client.get("nonexistent", { default: 42 })).toBe(42);
+      expect(client.get("nonexistent", { default: null })).toBe(null);
+      expect(client.get("nonexistent", { default: false })).toBe(false);
+      expect(client.get("nonexistent", { default: { nested: "value" } })).toEqual({
+        nested: "value",
+      });
+    });
+
+    it("should return actual value when config exists even if default is provided", () => {
+      const snapshot: ReplaneSnapshot<Record<string, unknown>> = {
+        configs: [{ name: "config1", value: "actual", overrides: [] }],
+      };
+
+      const client = restoreReplaneClient({ snapshot });
+
+      expect(client.get("config1", { default: "fallback" })).toBe("actual");
+    });
+
     it("should have a no-op close method", () => {
       const snapshot: ReplaneSnapshot<Record<string, unknown>> = {
         configs: [{ name: "config1", value: "value1", overrides: [] }],
@@ -2230,7 +2312,9 @@ describe("restoreReplaneClient", () => {
             overrides: [
               {
                 name: "non-na-override",
-                conditions: [{ operator: "not_in", property: "country", value: ["US", "CA", "MX"] }],
+                conditions: [
+                  { operator: "not_in", property: "country", value: ["US", "CA", "MX"] },
+                ],
                 value: "non-na-value",
               },
             ],

packages/svelte/README.md

@@ -19,13 +19,13 @@ npm install @replanejs/svelte
   import { ReplaneContext, config } from '@replanejs/svelte';
   import { createReplaneClient } from '@replanejs/svelte';
 
-  const client = await createReplaneClient({
+  const replane = await createReplaneClient({
     baseUrl: 'https://your-replane-server.com',
     sdkKey: 'your-sdk-key',
   });
 </script>
 
-<ReplaneContext {client}>
+<ReplaneContext client={replane}>
   <MyComponent />
 </ReplaneContext>
 ```
@@ -77,10 +77,10 @@ Get direct access to the Replane client from context.
 <script>
   import { getReplane } from '@replanejs/svelte';
 
-  const { client } = getReplane();
+  const replane = getReplane();
 
   function handleClick() {
-    const value = client.get('some-config');
+    const value = replane.get('some-config');
     console.log(value);
   }
 </script>
@@ -90,14 +90,15 @@ Get direct access to the Replane client from context.
 
 ### configFrom
 
-Create a reactive store from a client directly (without context).
+Create a reactive store from a client directly (without context). Type-safe with full autocomplete for config names.
 
 ```svelte
 <script>
   import { configFrom } from '@replanejs/svelte';
-  import { client } from './replane-client';
+  import { replane } from './replane-client';
 
-  const featureEnabled = configFrom<boolean>(client, 'featureEnabled');
+  // Config name is validated against TConfigs, return type is inferred
+  const featureEnabled = configFrom(replane, 'featureEnabled');
 </script>
 
 {#if $featureEnabled}
@@ -117,13 +118,13 @@ Can be used in three ways:
 <script>
   import { ReplaneContext, createReplaneClient } from '@replanejs/svelte';
 
-  const client = await createReplaneClient({
+  const replane = await createReplaneClient({
     baseUrl: 'https://your-replane-server.com',
     sdkKey: 'your-sdk-key',
   });
 </script>
 
-<ReplaneContext {client}>
+<ReplaneContext client={replane}>
   <App />
 </ReplaneContext>
 ```
@@ -193,11 +194,15 @@ export const getAppReplane = createTypedReplane<AppConfigs>();
 
 ```svelte
 <script lang="ts">
-  import { appConfig } from '$lib/replane';
+  import { appConfig, getAppReplane } from '$lib/replane';
 
   // Config names autocomplete, values are fully typed
   const theme = appConfig("theme");
   // $theme is { darkMode: boolean; primaryColor: string }
+
+  // Direct client access
+  const replane = getAppReplane();
+  const features = replane.get("features"); // fully typed
 </script>
 
 <div style:color={$theme.primaryColor}>

packages/svelte/examples/basic/src/lib/ConfigDisplay.svelte

@@ -12,13 +12,13 @@
     experimentalFeatures: boolean;
   }
 
-  const { client } = getReplane();
+  const replane = getReplane();
   const theme = config<ThemeConfig>("theme-config");
   const features = config<FeatureFlags>("feature-flags");
 
   // Get value with premium context override
   const premiumFeatures = $derived(
-    client.get("feature-flags", { context: { plan: "premium" } })
+    replane.get("feature-flags", { context: { plan: "premium" } })
   );
 </script>
 
@@ -43,7 +43,7 @@
   <div class="config-card">
     <h3>With Context Override</h3>
     <p>You can pass context for user-specific evaluation:</p>
-    <pre>{`const premiumFeatures = client.get("feature-flags", {
+    <pre>{`const premiumFeatures = replane.get("feature-flags", {
   context: { userId: "123", plan: "premium" }
 });`}</pre>
     <p>Current value with premium context:</p>

packages/svelte/src/index.ts

@@ -33,7 +33,6 @@ export type {
   ReplaneContextProps,
   ReplaneContextWithClientProps,
   ReplaneContextWithOptionsProps,
-  ConfigOptions,
 } from "./types";
 
 // Type guards