@digital-alchemy/hass 25.10.27-beta.1 → 25.11.16

package/src/services/entity.service.mts

@@ -290,19 +290,20 @@ export function EntityManager({
   }
 
   // #MARK: onConnect
+  void hass.socket.subscribe({
+    context,
+    event_type: "entity_registry_updated",
+    async exec() {
+      const ms = perf();
+      await debounce(ENTITY_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+      logger.debug("entity registry updated");
+      hass.entity.registry.current = await hass.entity.registry.list();
+      event.emit(ENTITY_REGISTRY_UPDATED);
+      hass.diagnostics.entity?.registry_updated.publish({ ms: ms() });
+    },
+  });
+
   hass.socket.onConnect(async () => {
-    hass.socket.subscribe({
-      context,
-      event_type: "entity_registry_updated",
-      async exec() {
-        const ms = perf();
-        await debounce(ENTITY_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
-        logger.debug("entity registry updated");
-        hass.entity.registry.current = await hass.entity.registry.list();
-        event.emit(ENTITY_REGISTRY_UPDATED);
-        hass.diagnostics.entity?.registry_updated.publish({ ms: ms() });
-      },
-    });
     hass.entity.registry.current = await hass.entity.registry.list();
   });
 

package/src/services/floor.service.mts

@@ -13,6 +13,19 @@ export function Floor({
   logger,
   lifecycle,
 }: TServiceParams): HassFloorService {
+  void hass.socket.subscribe({
+    context,
+    event_type: "floor_registry_updated",
+    async exec() {
+      const ms = perf();
+      await debounce(FLOOR_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+      hass.floor.current = await hass.floor.list();
+      logger.debug(`floor registry updated`);
+      event.emit(FLOOR_REGISTRY_UPDATED);
+      hass.diagnostics.floor?.registry_update.publish({ ms: ms() });
+    },
+  });
+
   hass.socket.onConnect(async () => {
     let loading = new Promise<void>(async done => {
       hass.floor.current = await hass.floor.list();
@@ -20,19 +33,6 @@ export function Floor({
       done();
     });
     lifecycle.onReady(async () => loading && (await loading), EARLY_ON_READY);
-
-    hass.socket.subscribe({
-      context,
-      event_type: "floor_registry_updated",
-      async exec() {
-        const ms = perf();
-        await debounce(FLOOR_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
-        hass.floor.current = await hass.floor.list();
-        logger.debug(`floor registry updated`);
-        event.emit(FLOOR_REGISTRY_UPDATED);
-        hass.diagnostics.floor?.registry_update.publish({ ms: ms() });
-      },
-    });
   });
 
   return {

package/src/services/index.mts

@@ -3,6 +3,7 @@ export * from "./area.service.mts";
 export * from "./backup.service.mts";
 export * from "./call-proxy.service.mts";
 export * from "./config.service.mts";
+export * from "./conversation.service.mts";
 export * from "./device.service.mts";
 export * from "./diagnostics.service.mts";
 export * from "./entity.service.mts";

package/src/services/label.service.mts

@@ -13,6 +13,19 @@ export function Label({
   event,
   context,
 }: TServiceParams): HassLabelService {
+  void hass.socket.subscribe({
+    context,
+    event_type: "label_registry_updated",
+    async exec() {
+      const ms = perf();
+      await debounce(LABEL_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+      hass.label.current = await hass.label.list();
+      logger.debug(`label registry updated`);
+      event.emit(LABEL_REGISTRY_UPDATED);
+      hass.diagnostics.label?.registry_update.publish({ ms: ms() });
+    },
+  });
+
   hass.socket.onConnect(async () => {
     let loading = new Promise<void>(async done => {
       hass.label.current = await hass.label.list();
@@ -20,19 +33,6 @@ export function Label({
       done();
     });
     lifecycle.onReady(async () => loading && (await loading), EARLY_ON_READY);
-
-    hass.socket.subscribe({
-      context,
-      event_type: "label_registry_updated",
-      async exec() {
-        const ms = perf();
-        await debounce(LABEL_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
-        hass.label.current = await hass.label.list();
-        logger.debug(`label registry updated`);
-        event.emit(LABEL_REGISTRY_UPDATED);
-        hass.diagnostics.label?.registry_update.publish({ ms: ms() });
-      },
-    });
   });
 
   async function create(details: LabelOptions) {

package/src/services/registry.service.mts

@@ -1,7 +1,7 @@
+/* eslint-disable sonarjs/deprecation */
 import type { TServiceParams } from "@digital-alchemy/core";
 
 import type {
-  ConfigEntry,
   HassConfig,
   HassRegistryService,
   ManifestItem,
@@ -29,10 +29,11 @@ export function Registry({ hass }: TServiceParams): HassRegistryService {
     });
   }
 
+  /**
+   * @deprecated Use hass.configure.get() instead. This method will be removed in a future version.
+   */
   async function getConfigEntries() {
-    return await hass.socket.sendMessage<ConfigEntry[]>({
-      type: "config_entries/get",
-    });
+    return await hass.configure.get();
   }
 
   return {

package/src/services/websocket-api.service.mts

@@ -1,5 +1,5 @@
 import type { TBlackHole, TServiceParams } from "@digital-alchemy/core";
-import { InternalError, SECOND, sleep, START } from "@digital-alchemy/core";
+import { INCREMENT, InternalError, NONE, SECOND, sleep, START } from "@digital-alchemy/core";
 import type { Dayjs } from "dayjs";
 import dayjs from "dayjs";
 import EventEmitter from "events";
@@ -41,6 +41,7 @@ export function WebsocketAPI({
   lifecycle,
   logger,
   scheduler,
+  als,
 }: TServiceParams): HassWebsocketAPI {
   const { is } = internal.utils;
 
@@ -57,6 +58,10 @@ export function WebsocketAPI({
   const isOld = (date: Dayjs) =>
     is.undefined(date) || date.diff(dayjs(), "s") >= config.hass.RETRY_INTERVAL;
 
+  // Track all subscriptions for re-establishment on reconnect
+  // Map of event_type to count of active subscriptions
+  const subscriptionRegistry = new Map<string, number>();
+
   // Start the socket
   lifecycle.onBootstrap(async () => {
     logger.debug({ name: "onBootstrap" }, `auto starting connection`);
@@ -298,7 +303,7 @@ export function WebsocketAPI({
     callback: (message: T) => TBlackHole,
   ) {
     const handlers = messageHandlers.get(type) ?? [];
-    logger.trace({ type }, "register socket message handler");
+    logger.trace("register socket message handler [%s]", type);
     if (!messageHandlers.has(type)) {
       messageHandlers.set(type, []);
     }
@@ -504,18 +509,73 @@ export function WebsocketAPI({
     EVENT extends string,
     PAYLOAD extends Record<string, unknown> = EmptyObject,
   >({ event_type, context, exec }: SocketSubscribeOptions<EVENT, PAYLOAD>) {
-    await hass.socket.sendMessage({ event_type, type: "subscribe_events" });
-    return hass.socket.onEvent({
+    // Memory leak detection: warn if subscribe is called during onConnect using ALS
+    const store = als.getStore();
+    if (store?.logs?.hassOnConnect) {
+      logger.warn(
+        { context, event_type, name: subscribe },
+        `⚠️ MEMORY LEAK DETECTED: subscribe() called during onConnect callback. ` +
+          `This will create duplicate subscriptions on each reconnect. ` +
+          `Move subscription to root level using lifecycle hooks instead.`,
+      );
+    }
+
+    const current = subscriptionRegistry.get(event_type) ?? NONE;
+    if (current == NONE && hass.socket.connectionState === "connected") {
+      await hass.socket.sendMessage({ event_type, type: "subscribe_events" });
+    }
+    subscriptionRegistry.set(event_type, current + INCREMENT);
+
+    // Register event handler
+    const { remove } = hass.socket.onEvent({
       context,
       event: event_type,
       exec,
     });
+
+    return internal.removeFn(() => {
+      remove();
+      const current = subscriptionRegistry.get(event_type) - INCREMENT;
+      if (current === NONE) {
+        subscriptionRegistry.delete(event_type);
+        return;
+      }
+      subscriptionRegistry.set(event_type, current);
+    });
   }
 
   // #MARK: onConnect
   function onConnect(callback: () => TBlackHole) {
     const wrapped = async () => {
-      await internal.safeExec(async () => await callback());
+      // Get current store or create new one
+      const currentStore = als.getStore();
+      const baseData = currentStore || { logs: {} };
+
+      // Set ALS flag to indicate we're in a connect callback
+      als.enterWith({
+        ...baseData,
+        logs: {
+          ...baseData.logs,
+          hassOnConnect: true,
+        },
+      });
+
+      try {
+        await internal.safeExec(async () => await callback());
+      } finally {
+        // Restore previous ALS context (or clear if none)
+        if (currentStore) {
+          als.enterWith({
+            ...currentStore,
+            logs: {
+              ...currentStore.logs,
+              hassOnConnect: false,
+            },
+          });
+        } else {
+          als.enterWith({ logs: {} });
+        }
+      }
     };
     if (hass.socket.connectionState === "connected") {
       logger.debug(
@@ -544,6 +604,27 @@ export function WebsocketAPI({
       event.emit(SOCKET_CONNECTED);
     });
 
+    // Re-establish all registered subscriptions once per connection
+    hass.socket.onConnect(async () => {
+      if (is.empty(subscriptionRegistry)) {
+        return;
+      }
+      const subscriptions = [...subscriptionRegistry.keys()];
+      logger.trace(
+        { name: onConnect, subscriptions },
+        `re-establishing [%s] subscriptions`,
+        subscriptionRegistry.size,
+      );
+      await Promise.all(
+        subscriptions.map(event_type =>
+          hass.socket.sendMessage({
+            event_type,
+            type: "subscribe_events",
+          }),
+        ),
+      );
+    });
+
     hass.socket.registerMessageHandler("event", async (message: SocketMessageDTO) => {
       const id = Number(message.id);
       return await onMessageEvent(id, message);

package/src/services/zone.service.mts

@@ -12,6 +12,19 @@ export function Zone({
   context,
   lifecycle,
 }: TServiceParams): HassZoneService {
+  void hass.socket.subscribe({
+    context,
+    event_type: "zone_registry_updated",
+    async exec() {
+      const ms = perf();
+      await debounce(ZONE_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
+      hass.zone.current = await hass.zone.list();
+      logger.debug(`zone registry updated`);
+      event.emit(ZONE_REGISTRY_UPDATED);
+      hass.diagnostics.zone?.registry_update.publish({ ms: ms() });
+    },
+  });
+
   hass.socket.onConnect(async () => {
     let loading = new Promise<void>(async done => {
       hass.zone.current = await hass.zone.list();
@@ -19,19 +32,6 @@ export function Zone({
       done();
     });
     lifecycle.onReady(async () => loading && (await loading), EARLY_ON_READY);
-
-    hass.socket.subscribe({
-      context,
-      event_type: "zone_registry_updated",
-      async exec() {
-        const ms = perf();
-        await debounce(ZONE_REGISTRY_UPDATED, config.hass.EVENT_DEBOUNCE_MS);
-        hass.zone.current = await hass.zone.list();
-        logger.debug(`zone registry updated`);
-        event.emit(ZONE_REGISTRY_UPDATED);
-        hass.diagnostics.zone?.registry_update.publish({ ms: ms() });
-      },
-    });
   });
 
   async function ZoneCreate(options: ZoneOptions) {