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

package/src/testing/websocket.spec.mts

@@ -1,3 +1,5 @@
+import { sleep } from "@digital-alchemy/core";
+
 import { hassTestRunner } from "../mock_assistant/index.mts";
 
 describe("Websocket", () => {
@@ -5,6 +7,9 @@ describe("Websocket", () => {
     await hassTestRunner.teardown();
     vi.restoreAllMocks();
   });
+  beforeEach(() => {
+    hassTestRunner.emitLogs("silent");
+  });
 
   describe("API Interactions", () => {
     it("should emit events onConnect", async () => {
@@ -212,4 +217,224 @@ describe("Websocket", () => {
       });
     });
   });
+
+  describe("Memory Leak Detection", () => {
+    it("should NOT warn when subscribe is called outside onConnect", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, logger, context }) => {
+        const warnSpy = vi.spyOn(logger, "warn").mockImplementation(() => {});
+
+        lifecycle.onReady(async () => {
+          await hass.socket.subscribe({
+            context,
+            event_type: "test_event",
+            exec: () => {},
+          });
+
+          // Should not have been called with memory leak warning
+          const memoryLeakWarnings = warnSpy.mock.calls.filter(call =>
+            call[1]?.toString().includes("MEMORY LEAK DETECTED"),
+          );
+          expect(memoryLeakWarnings.length).toBe(0);
+        });
+      });
+    });
+
+    it("should warn when subscribe is called inside onConnect callback", async () => {
+      expect.assertions(2);
+      const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+      await hassTestRunner.emitLogs("warn").run(({ lifecycle, hass, internal, context, event }) => {
+        internal.boilerplate.configuration.set("boilerplate", "LOG_LEVEL", "warn");
+        lifecycle.onReady(async () => {
+          // Wait for initial connection to complete
+          await new Promise(resolve => setTimeout(resolve, 100));
+
+          // Ensure socket is connected
+          expect(hass.socket.connectionState).toBe("connected");
+
+          // Register onConnect callback that subscribes (this should trigger warning)
+          hass.socket.onConnect(async () => {
+            await hass.socket.subscribe({
+              context,
+              event_type: "test_event_warn",
+              exec: () => {},
+            });
+          });
+
+          // Trigger onConnect by emitting SOCKET_CONNECTED event again
+          event.emit("SOCKET_CONNECTED");
+          await sleep(0);
+
+          expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining("MEMORY LEAK DETECTED"));
+        });
+      });
+    });
+  });
+
+  describe("Subscription Registry", () => {
+    it("should prevent duplicate subscriptions", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, context }) => {
+        const sendMessageSpy = vi
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => undefined);
+
+        lifecycle.onReady(async () => {
+          // Clear spy after initial bootstrap subscriptions
+          sendMessageSpy.mockClear();
+
+          // Subscribe to the same event twice (even with same context)
+          // Since registry tracks by event_type only, second subscription won't send message
+          await hass.socket.subscribe({
+            context,
+            event_type: "duplicate_test",
+            exec: () => {},
+          });
+
+          await hass.socket.subscribe({
+            context,
+            event_type: "duplicate_test",
+            exec: () => {},
+          });
+
+          // Should only send subscribe message once (duplicate event_type is prevented)
+          const subscribeCalls = sendMessageSpy.mock.calls.filter(
+            call =>
+              call[0]?.type === "subscribe_events" && call[0]?.event_type === "duplicate_test",
+          );
+          expect(subscribeCalls.length).toBe(1);
+        });
+      });
+    });
+
+    it("should allow different event types with same context", async () => {
+      expect.assertions(1);
+      await hassTestRunner.run(({ lifecycle, hass, context }) => {
+        const sendMessageSpy = vi
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => undefined);
+
+        lifecycle.onReady(async () => {
+          await hass.socket.subscribe({
+            context,
+            event_type: "event_type_1",
+            exec: () => {},
+          });
+
+          await hass.socket.subscribe({
+            context,
+            event_type: "event_type_2",
+            exec: () => {},
+          });
+
+          // Should send subscribe message for both
+          const subscribeCalls = sendMessageSpy.mock.calls.filter(
+            call => call[0]?.type === "subscribe_events",
+          );
+          expect(subscribeCalls.length).toBeGreaterThanOrEqual(2);
+        });
+      });
+    });
+
+    it("should re-establish subscriptions on reconnect", async () => {
+      expect.assertions(2);
+      await hassTestRunner.run(({ lifecycle, hass, context, event }) => {
+        const sendMessageSpy = vi
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => undefined);
+
+        lifecycle.onReady(async () => {
+          // Register a subscription
+          await hass.socket.subscribe({
+            context,
+            event_type: "reconnect_test",
+            exec: () => {},
+          });
+
+          // Clear the spy to only track re-establishment calls
+          sendMessageSpy.mockClear();
+
+          // Register an onConnect callback that will trigger re-establishment
+          hass.socket.onConnect(async () => {
+            // This callback will trigger re-establishment
+          });
+
+          // Trigger reconnect by emitting SOCKET_CONNECTED event
+          event.emit("SOCKET_CONNECTED");
+
+          // Wait for async operations
+          await new Promise(resolve => setTimeout(resolve, 50));
+
+          // Should have re-established the subscription
+          const reestablishCalls = sendMessageSpy.mock.calls.filter(
+            call =>
+              call[0]?.type === "subscribe_events" && call[0]?.event_type === "reconnect_test",
+          );
+          expect(reestablishCalls.length).toBeGreaterThan(0);
+          expect(sendMessageSpy).toHaveBeenCalled();
+        });
+      });
+    });
+
+    it("should re-establish multiple subscriptions on reconnect", async () => {
+      expect.assertions(4);
+      await hassTestRunner.run(({ lifecycle, hass, context, event }) => {
+        const sendMessageSpy = vi
+          .spyOn(hass.socket, "sendMessage")
+          .mockImplementation(async () => undefined);
+
+        lifecycle.onReady(async () => {
+          // Wait for initial connection to complete
+          await new Promise(resolve => setTimeout(resolve, 50));
+
+          // Register multiple subscriptions
+          await hass.socket.subscribe({
+            context,
+            event_type: "multi_test_1",
+            exec: () => {},
+          });
+
+          await hass.socket.subscribe({
+            context,
+            event_type: "multi_test_2",
+            exec: () => {},
+          });
+
+          await hass.socket.subscribe({
+            context,
+            event_type: "multi_test_3",
+            exec: () => {},
+          });
+
+          // Clear the spy to only track re-establishment calls
+          sendMessageSpy.mockClear();
+
+          // Register an onConnect callback that will trigger re-establishment
+          hass.socket.onConnect(async () => {
+            // This callback will trigger re-establishment
+          });
+
+          // Trigger reconnect by emitting SOCKET_CONNECTED event
+          event.emit("SOCKET_CONNECTED");
+
+          // Wait for async operations
+          await new Promise(resolve => setTimeout(resolve, 150));
+
+          // Should have re-established our specific subscriptions (along with others)
+          const reestablishCalls = sendMessageSpy.mock.calls.filter(
+            call =>
+              call[0]?.type === "subscribe_events" &&
+              (call[0]?.event_type === "multi_test_1" ||
+                call[0]?.event_type === "multi_test_2" ||
+                call[0]?.event_type === "multi_test_3"),
+          );
+          // Verify each specific subscription was re-established
+          expect(reestablishCalls.length).toBe(3);
+          expect(reestablishCalls.some(call => call[0]?.event_type === "multi_test_1")).toBe(true);
+          expect(reestablishCalls.some(call => call[0]?.event_type === "multi_test_2")).toBe(true);
+          expect(reestablishCalls.some(call => call[0]?.event_type === "multi_test_3")).toBe(true);
+        });
+      });
+    });
+  });
 });

package/src/user.mts

@@ -50,12 +50,26 @@ export interface HassThemeMapping {
   // "{theme_name}": true | "light" | "dark" | "light" | "dark"
 }
 
+export interface HassConfigEntryMapping {
+  // "{entry_id}": { title: string; domain: string }
+}
+
+// Reverse lookup: find entry_id by title
+export type FindEntryIdByTitle<
+  TITLE extends HassConfigEntryMapping[keyof HassConfigEntryMapping]["title"],
+> = {
+  [K in keyof HassConfigEntryMapping]: HassConfigEntryMapping[K]["title"] extends TITLE ? K : never;
+}[keyof HassConfigEntryMapping];
+
+export type TConfigEntryTitle = HassConfigEntryMapping[keyof HassConfigEntryMapping]["title"];
+
 // #MARK: extract
 export type TAreaId = UnPrefix<keyof HassAreaMapping>;
 export type TDeviceId = UnPrefix<keyof HassDeviceMapping>;
 export type TFloorId = UnPrefix<keyof HassFloorMapping>;
 export type TLabelId = UnPrefix<keyof HassLabelMapping>;
 export type TPlatformId = UnPrefix<keyof HassPlatformMapping>;
+export type TConfigEntryId = keyof HassConfigEntryMapping;
 
 export type TRawDomains = keyof HassDomainMapping;
 export type TZoneId = keyof HassZoneMapping;