@smplkit/sdk 1.6.17 → 1.7.0

package/dist/index.cjs

@@ -17347,7 +17347,8 @@ var ConfigClient = class {
     if (this._getSharedWs) {
       const ws = this._getSharedWs();
       ws.on("config_changed", this._handleConfigChanged);
-      ws.on("config_deleted", this._handleConfigChanged);
+      ws.on("config_deleted", this._handleConfigDeleted);
+      ws.on("configs_changed", this._handleConfigsChanged);
     }
   }
   /** @internal — called by SmplClient for backward compat. */
@@ -17370,13 +17371,75 @@ var ConfigClient = class {
   // Internal: WebSocket handler
   // ------------------------------------------------------------------
   _handleConfigChanged = (data) => {
-    debug("websocket", `config event received: ${JSON.stringify(data)}`);
+    debug("websocket", `config_changed event received: ${JSON.stringify(data)}`);
+    const configKey = data.id;
+    if (!configKey) return;
+    void this._fetchSingleConfig(configKey).then((newConfig) => {
+      const environment = this._parent?._environment;
+      if (!environment) return;
+      const oldValues = this._configCache[configKey];
+      let newValues;
+      if (newConfig !== null) {
+        newValues = this._resolveConfigValues(newConfig, environment);
+      } else {
+        newValues = {};
+      }
+      const oldJson = JSON.stringify(oldValues ?? {});
+      const newJson = JSON.stringify(newValues);
+      if (oldJson === newJson) return;
+      const oldCache = { ...this._configCache };
+      if (newConfig !== null) {
+        this._configCache[configKey] = newValues;
+      } else {
+        delete this._configCache[configKey];
+      }
+      this._diffAndFire(oldCache, this._configCache, "websocket");
+    }).catch((err) => {
+      debug(
+        "websocket",
+        `config_changed handler error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  };
+  _handleConfigDeleted = (data) => {
+    debug("websocket", `config_deleted event received: ${JSON.stringify(data)}`);
+    const configKey = data.id;
+    if (!configKey) return;
+    if (configKey in this._configCache) {
+      const oldCache = { ...this._configCache };
+      delete this._configCache[configKey];
+      this._diffAndFire(oldCache, this._configCache, "websocket");
+    }
+  };
+  _handleConfigsChanged = (_data) => {
+    debug("websocket", `configs_changed event received`);
     void this.refresh().catch(() => {
     });
   };
   // ------------------------------------------------------------------
   // Internal: change detection
   // ------------------------------------------------------------------
+  /** Fetch a single config by key. Returns null if not found. @internal */
+  async _fetchSingleConfig(key) {
+    debug("api", `GET /api/v1/configs/${key}`);
+    try {
+      const result = await this._http.GET("/api/v1/configs/{id}", {
+        params: { path: { id: key } }
+      });
+      if (!result.response.ok) return null;
+      if (!result.data?.data) return null;
+      return resourceToConfig(result.data.data, this);
+    } catch {
+      return null;
+    }
+  }
+  /** Resolve a config's values for an environment (no parent chain). @internal */
+  _resolveConfigValues(config, environment) {
+    const base = config.items ?? {};
+    const envEntry = config.environments?.[environment];
+    if (!envEntry?.values) return { ...base };
+    return { ...base, ...envEntry.values };
+  }
   /** @internal */
   _diffAndFire(oldCache, newCache, source) {
     const allConfigKeys = /* @__PURE__ */ new Set([...Object.keys(oldCache), ...Object.keys(newCache)]);
@@ -17656,9 +17719,12 @@ function evaluateFlag(flagDef, environment, evalDict) {
 var FlagChangeEvent = class {
   id;
   source;
-  constructor(id, source) {
+  /** True when the flag was deleted. */
+  deleted;
+  constructor(id, source, deleted) {
     this.id = id;
     this.source = source;
+    if (deleted) this.deleted = deleted;
   }
 };
 var ResolutionCache = class {
@@ -18168,6 +18234,7 @@ var FlagsClient = class {
     this._wsManager = this._ensureWs();
     this._wsManager.on("flag_changed", this._handleFlagChanged);
     this._wsManager.on("flag_deleted", this._handleFlagDeleted);
+    this._wsManager.on("flags_changed", this._handleFlagsChanged);
     this._flagFlushTimer = setInterval(() => {
       void this._flushFlags();
     }, FLAG_REGISTRATION_FLUSH_INTERVAL_MS);
@@ -18177,6 +18244,7 @@ var FlagsClient = class {
     if (this._wsManager !== null) {
       this._wsManager.off("flag_changed", this._handleFlagChanged);
       this._wsManager.off("flag_deleted", this._handleFlagDeleted);
+      this._wsManager.off("flags_changed", this._handleFlagsChanged);
       this._wsManager = null;
     }
     if (this._flagFlushTimer !== null) {
@@ -18341,6 +18409,7 @@ var FlagsClient = class {
     this._wsManager = this._ensureWs();
     this._wsManager.on("flag_changed", this._handleFlagChanged);
     this._wsManager.on("flag_deleted", this._handleFlagDeleted);
+    this._wsManager.on("flags_changed", this._handleFlagsChanged);
     this._flagFlushTimer = setInterval(() => {
       void this._flushFlags();
     }, FLAG_REGISTRATION_FLUSH_INTERVAL_MS);
@@ -18349,19 +18418,84 @@ var FlagsClient = class {
   // Internal: event handlers (called by SharedWebSocket)
   // ------------------------------------------------------------------
   _handleFlagChanged = (data) => {
-    debug("websocket", `flag event received: ${JSON.stringify(data)}`);
-    const flagId = data.id;
-    void this._fetchAllFlags().then(() => {
+    debug("websocket", `flag_changed event received: ${JSON.stringify(data)}`);
+    const flagKey = data.id;
+    if (!flagKey) return;
+    void this._fetchSingleFlag(flagKey).then((newDef) => {
+      const oldDef = this._flagStore[flagKey];
+      const oldJson = oldDef !== void 0 ? JSON.stringify(oldDef) : null;
+      const newJson = newDef !== void 0 ? JSON.stringify(newDef) : null;
+      if (oldJson === newJson) return;
+      if (newDef !== void 0) {
+        this._flagStore[flagKey] = newDef;
+      } else {
+        delete this._flagStore[flagKey];
+      }
       this._cache.clear();
-      this._fireChangeListeners(flagId ?? null, "websocket");
+      this._fireChangeListeners(flagKey, "websocket");
     });
   };
   _handleFlagDeleted = (data) => {
-    debug("websocket", `flag deleted event received: ${JSON.stringify(data)}`);
-    const flagId = data.id;
+    debug("websocket", `flag_deleted event received: ${JSON.stringify(data)}`);
+    const flagKey = data.id;
+    if (!flagKey) return;
+    if (flagKey in this._flagStore) {
+      delete this._flagStore[flagKey];
+    }
+    this._cache.clear();
+    const deletedEvent = new FlagChangeEvent(flagKey, "websocket", true);
+    for (const cb of this._globalListeners) {
+      try {
+        cb(deletedEvent);
+      } catch {
+      }
+    }
+    const keyCallbacks = this._keyListeners.get(flagKey);
+    if (keyCallbacks) {
+      for (const cb of keyCallbacks) {
+        try {
+          cb(deletedEvent);
+        } catch {
+        }
+      }
+    }
+  };
+  _handleFlagsChanged = (_data) => {
+    debug("websocket", `flags_changed event received`);
+    const preStore = { ...this._flagStore };
     void this._fetchAllFlags().then(() => {
       this._cache.clear();
-      this._fireChangeListeners(flagId ?? null, "websocket");
+      const postStore = this._flagStore;
+      const changedKeys = /* @__PURE__ */ new Set();
+      const allKeys = /* @__PURE__ */ new Set([...Object.keys(preStore), ...Object.keys(postStore)]);
+      for (const key of allKeys) {
+        const preJson = preStore[key] !== void 0 ? JSON.stringify(preStore[key]) : null;
+        const postJson = postStore[key] !== void 0 ? JSON.stringify(postStore[key]) : null;
+        if (preJson !== postJson) {
+          changedKeys.add(key);
+        }
+      }
+      if (changedKeys.size === 0) return;
+      const [firstKey] = changedKeys;
+      const globalEvent = new FlagChangeEvent(firstKey, "websocket");
+      for (const cb of this._globalListeners) {
+        try {
+          cb(globalEvent);
+        } catch {
+        }
+      }
+      for (const key of changedKeys) {
+        const keyCallbacks = this._keyListeners.get(key);
+        if (keyCallbacks) {
+          const keyEvent = new FlagChangeEvent(key, "websocket");
+          for (const cb of keyCallbacks) {
+            try {
+              cb(keyEvent);
+            } catch {
+            }
+          }
+        }
+      }
     });
   };
   // ------------------------------------------------------------------
@@ -18375,6 +18509,20 @@ var FlagsClient = class {
     }
     this._flagStore = store;
   }
+  /** Fetch a single flag by key. Returns undefined if not found. @internal */
+  async _fetchSingleFlag(key) {
+    debug("api", `GET /api/v1/flags/${key}`);
+    try {
+      const result = await this._http.GET("/api/v1/flags/{id}", {
+        params: { path: { id: key } }
+      });
+      if (!result.response.ok) return void 0;
+      if (!result.data?.data) return void 0;
+      return this._resourceToPlainDict(result.data.data);
+    } catch {
+      return void 0;
+    }
+  }
   async _fetchFlagsList() {
     debug("api", "GET /api/v1/flags");
     let data;
@@ -18754,6 +18902,11 @@ var LoggingClient = class {
   _explicitAdapters = false;
   _loggerBuffer = new LoggerRegistrationBuffer();
   _loggerFlushTimer = null;
+  // Local stores for diff-based listener firing
+  _loggerStore = {};
+  // key -> level
+  _groupStore = {};
+  // key -> level
   /** @internal */
   constructor(apiKey, ensureWs, timeout, baseUrl) {
     this._apiKey = apiKey;
@@ -18874,12 +19027,21 @@ var LoggingClient = class {
   }
   /** @internal */
   async _mgGetGroup(id) {
-    const groups = await this.management.listGroups();
-    const match = groups.find((g) => g.id === id);
-    if (!match) {
+    let data;
+    try {
+      const result = await this._http.GET("/api/v1/log_groups/{id}", {
+        params: { path: { id } }
+      });
+      if (result.error !== void 0)
+        await checkError3(result.response, `LogGroup with id '${id}' not found`);
+      data = result.data;
+    } catch (err) {
+      wrapFetchError3(err);
+    }
+    if (!data || !data.data) {
       throw new SmplNotFoundError(`LogGroup with id '${id}' not found`);
     }
-    return match;
+    return this._groupToModel(data.data);
   }
   /** @internal */
   async _mgListGroups() {
@@ -19042,13 +19204,20 @@ var LoggingClient = class {
         `fetched ${serverLoggers.length} logger(s) and ${serverGroups.length} group(s) from server`
       );
       this._applyLevels(serverLoggers);
+      for (const l of serverLoggers) {
+        this._loggerStore[l.id] = l.level;
+      }
+      for (const g of serverGroups) {
+        this._groupStore[g.id] = g.level;
+      }
     } catch {
     }
     this._wsManager = this._ensureWs();
     this._wsManager.on("logger_changed", this._handleLoggerChanged);
-    this._wsManager.on("logger_deleted", this._handleLoggerChanged);
+    this._wsManager.on("logger_deleted", this._handleLoggerDeleted);
     this._wsManager.on("group_changed", this._handleGroupChanged);
-    this._wsManager.on("group_deleted", this._handleGroupChanged);
+    this._wsManager.on("group_deleted", this._handleGroupDeleted);
+    this._wsManager.on("loggers_changed", this._handleLoggersChanged);
     this._loggerFlushTimer = setInterval(() => {
       void this._flushLoggerBuffer();
     }, 3e4);
@@ -19096,9 +19265,10 @@ var LoggingClient = class {
     }
     if (this._wsManager !== null) {
       this._wsManager.off("logger_changed", this._handleLoggerChanged);
-      this._wsManager.off("logger_deleted", this._handleLoggerChanged);
+      this._wsManager.off("logger_deleted", this._handleLoggerDeleted);
       this._wsManager.off("group_changed", this._handleGroupChanged);
-      this._wsManager.off("group_deleted", this._handleGroupChanged);
+      this._wsManager.off("group_deleted", this._handleGroupDeleted);
+      this._wsManager.off("loggers_changed", this._handleLoggersChanged);
       this._wsManager = null;
     }
     this._started = false;
@@ -19192,47 +19362,225 @@ var LoggingClient = class {
   // Internal: WebSocket handler
   // ------------------------------------------------------------------
   _handleLoggerChanged = (data) => {
-    debug("websocket", `logger event received: ${JSON.stringify(data)}`);
+    debug("websocket", `logger_changed event received: ${JSON.stringify(data)}`);
     const id = data.id;
-    if (id) {
-      void Promise.all([this.management.list(), this.management.listGroups()]).then(([serverLoggers]) => {
-        debug("resolution", `resolution pass (trigger: websocket event for logger ${id})`);
-        this._applyLevels(serverLoggers);
-        const logger = serverLoggers.find((l) => l.id === id);
-        const level = logger?.level ?? null;
-        const event = {
-          id,
-          level,
-          source: "websocket"
-        };
-        for (const cb of this._globalListeners) {
+    if (!id) return;
+    void this._fetchSingleLogger(id).then((logger) => {
+      const oldLevel = this._loggerStore[id] ?? null;
+      const newLevel = logger?.level ?? null;
+      if (oldLevel === newLevel) return;
+      this._loggerStore[id] = newLevel;
+      if (logger) {
+        this._applyLevels([logger]);
+      }
+      const event = {
+        id,
+        level: newLevel,
+        source: "websocket"
+      };
+      for (const cb of this._globalListeners) {
+        try {
+          cb(event);
+        } catch {
+        }
+      }
+      const idCallbacks = this._keyListeners.get(id);
+      if (idCallbacks) {
+        for (const cb of idCallbacks) {
           try {
             cb(event);
           } catch {
           }
         }
-        const idCallbacks = this._keyListeners.get(id);
-        if (idCallbacks) {
-          for (const cb of idCallbacks) {
-            try {
-              cb(event);
-            } catch {
-            }
-          }
+      }
+    }).catch((err) => {
+      debug(
+        "websocket",
+        `logger_changed handler error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  };
+  _handleLoggerDeleted = (data) => {
+    debug("websocket", `logger_deleted event received: ${JSON.stringify(data)}`);
+    const id = data.id;
+    if (!id) return;
+    delete this._loggerStore[id];
+    const event = {
+      id,
+      level: null,
+      source: "websocket",
+      deleted: true
+    };
+    for (const cb of this._globalListeners) {
+      try {
+        cb(event);
+      } catch (err) {
+        debug(
+          "websocket",
+          `logger_deleted listener error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const idCallbacks = this._keyListeners.get(id);
+    if (idCallbacks) {
+      for (const cb of idCallbacks) {
+        try {
+          cb(event);
+        } catch (err) {
+          debug(
+            "websocket",
+            `logger_deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
+          );
         }
+      }
+    }
+  };
+  _handleGroupChanged = (data) => {
+    debug("websocket", `group_changed event received: ${JSON.stringify(data)}`);
+    const id = data.id;
+    if (!id) return;
+    void this._fetchSingleGroup(id).then((group) => {
+      const oldLevel = this._groupStore[id] ?? null;
+      const newLevel = group?.level ?? null;
+      if (oldLevel === newLevel) return;
+      this._groupStore[id] = newLevel;
+      void this.management.list().then((loggers) => {
+        this._applyLevels(loggers);
       }).catch(() => {
       });
+    }).catch((err) => {
+      debug(
+        "websocket",
+        `group_changed handler error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    });
+  };
+  _handleGroupDeleted = (data) => {
+    debug("websocket", `group_deleted event received: ${JSON.stringify(data)}`);
+    const id = data.id;
+    if (!id) return;
+    delete this._groupStore[id];
+    const event = {
+      id,
+      level: null,
+      source: "websocket",
+      deleted: true
+    };
+    for (const cb of this._globalListeners) {
+      try {
+        cb(event);
+      } catch (err) {
+        debug(
+          "websocket",
+          `group_deleted listener error: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    const idCallbacks = this._keyListeners.get(id);
+    if (idCallbacks) {
+      for (const cb of idCallbacks) {
+        try {
+          cb(event);
+        } catch (err) {
+          debug(
+            "websocket",
+            `group_deleted key listener error: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
     }
   };
-  _handleGroupChanged = (data) => {
-    debug("websocket", `group event received: ${JSON.stringify(data)}`);
-    void Promise.all([this.management.list(), this.management.listGroups()]).then(([serverLoggers]) => {
-      debug("resolution", `resolution pass (trigger: group websocket event)`);
+  _handleLoggersChanged = (_data) => {
+    debug("websocket", `loggers_changed event received`);
+    void Promise.all([this.management.list(), this.management.listGroups()]).then(([serverLoggers, serverGroups]) => {
+      debug("resolution", `resolution pass (trigger: loggers_changed event)`);
+      const changedLoggerIds = /* @__PURE__ */ new Set();
+      const newLoggerKeys = new Set(serverLoggers.map((l) => l.id));
+      for (const logger of serverLoggers) {
+        const key = logger.id;
+        const oldLevel = this._loggerStore[key] ?? null;
+        const newLevel = logger.level ?? null;
+        if (oldLevel !== newLevel || !(key in this._loggerStore)) {
+          changedLoggerIds.add(key);
+          this._loggerStore[key] = newLevel;
+        }
+      }
+      for (const key of Object.keys(this._loggerStore)) {
+        if (!newLoggerKeys.has(key)) {
+          changedLoggerIds.add(key);
+          delete this._loggerStore[key];
+        }
+      }
+      for (const group of serverGroups) {
+        this._groupStore[group.id] = group.level ?? null;
+      }
       this._applyLevels(serverLoggers);
+      if (changedLoggerIds.size === 0) return;
+      const [firstKey] = changedLoggerIds;
+      const firstLogger = serverLoggers.find((l) => l.id === firstKey);
+      const globalEvent = {
+        id: firstKey,
+        level: firstLogger?.level ?? null,
+        source: "websocket"
+      };
+      for (const cb of this._globalListeners) {
+        try {
+          cb(globalEvent);
+        } catch {
+        }
+      }
+      for (const key of changedLoggerIds) {
+        const keyCallbacks = this._keyListeners.get(key);
+        if (keyCallbacks) {
+          const l = serverLoggers.find((x) => x.id === key);
+          const keyEvent = {
+            id: key,
+            level: l?.level ?? null,
+            source: "websocket"
+          };
+          for (const cb of keyCallbacks) {
+            try {
+              cb(keyEvent);
+            } catch {
+            }
+          }
+        }
+      }
     }).catch(() => {
     });
   };
   // ------------------------------------------------------------------
+  // Internal: single-resource fetchers
+  // ------------------------------------------------------------------
+  /** Fetch a single logger by key. Returns null if not found. @internal */
+  async _fetchSingleLogger(key) {
+    debug("api", `GET /api/v1/loggers/${key}`);
+    try {
+      const result = await this._http.GET("/api/v1/loggers/{id}", {
+        params: { path: { id: key } }
+      });
+      if (result.error !== void 0) return null;
+      if (!result.data?.data) return null;
+      return this._loggerToModel(result.data.data);
+    } catch {
+      return null;
+    }
+  }
+  /** Fetch a single log group by key. Returns null if not found. @internal */
+  async _fetchSingleGroup(key) {
+    debug("api", `GET /api/v1/log_groups/${key}`);
+    try {
+      const result = await this._http.GET("/api/v1/log_groups/{id}", {
+        params: { path: { id: key } }
+      });
+      if (result.error !== void 0) return null;
+      if (!result.data?.data) return null;
+      return this._groupToModel(result.data.data);
+    } catch {
+      return null;
+    }
+  }
+  // ------------------------------------------------------------------
   // Internal: model conversion
   // ------------------------------------------------------------------
   _loggerToModel(resource) {