@digital-alchemy/hass 25.3.2 → 25.5.2

package/src/services/id-by.service.mts

@@ -5,7 +5,6 @@ import {
   ALL_DOMAINS,
   ANY_ENTITY,
   HassUniqueIdMapping,
-  PICK_ENTITY,
   PICK_FROM_AREA,
   PICK_FROM_DEVICE,
   PICK_FROM_FLOOR,
@@ -22,6 +21,7 @@ import {
 export function IDByExtension({
   hass,
   logger,
+  config,
   internal: {
     utils: { is },
   },
@@ -33,12 +33,16 @@ export function IDByExtension({
     return raw;
   };
 
+  const getEntities = () =>
+    config.hass.FILTER_DISABLED_ENTITIES_ID_BY
+      ? hass.entity.registry.current.filter(i => is.empty(i.disabled_by))
+      : hass.entity.registry.current;
+
   // * byDomain
-  function byDomain<DOMAIN extends ALL_DOMAINS>(domain: DOMAIN) {
-    const MASTER_STATE = hass.entity._masterState();
-    return Object.keys(MASTER_STATE[domain] ?? {}).map(
-      id => `${domain}.${id}` as PICK_ENTITY<DOMAIN>,
-    );
+  function byDomain<DOMAIN extends ALL_DOMAINS>(target: DOMAIN) {
+    return getEntities()
+      .map(i => i.entity_id)
+      .filter(i => is.domain(i, target));
   }
 
   /**
@@ -74,8 +78,9 @@ export function IDByExtension({
           domain(i.entity_id) !== "update",
       );
       if (trimmed.length > SINGLE) {
+        const available_entity_ids = trimmed.map(i => i.entity_id);
         logger.warn(
-          { available_entity_ids: trimmed.map(i => i.entity_id), unique_id },
+          { available_entity_ids, unique_id },
           `unique_id collision during lookup (chose first in list)`,
         );
       } else {
@@ -88,6 +93,12 @@ export function IDByExtension({
       list = trimmed;
     }
     const [entity] = list;
+    if (config.hass.FILTER_DISABLED_ENTITIES_ID_BY && !is.empty(entity?.disabled_by)) {
+      logger.debug(
+        { entity_id: entity?.entity_id, unique_id },
+        `access disabled entity by unique_id`,
+      );
+    }
     return entity?.entity_id;
   }
 
@@ -98,7 +109,7 @@ export function IDByExtension({
   ) {
     hass.entity.warnEarly("label");
     return check(
-      hass.entity.registry.current
+      getEntities()
         .filter(i => i.labels.includes(label))
         .map(i => i.entity_id as PICK_FROM_LABEL<LABEL, DOMAIN>),
       domains,
@@ -113,9 +124,8 @@ export function IDByExtension({
     hass.entity.warnEarly("area");
 
     // find entities are associated with the area directly
-    const fromEntity = hass.entity.registry.current
-      .filter(i => i.area_id === area)
-      .map(i => i.entity_id);
+    const entities = getEntities();
+    const fromEntity = entities.filter(i => i.area_id === area).map(i => i.entity_id);
 
     // identify devices
     const devices = new Set(
@@ -123,7 +133,7 @@ export function IDByExtension({
     );
 
     // extract entities associated with device, that have not been assigned to a room
-    const fromDevice = hass.entity.registry.current
+    const fromDevice = entities
       .filter(entity => devices.has(entity.device_id) && is.empty(entity.area_id))
       .map(i => i.entity_id);
 
@@ -141,7 +151,7 @@ export function IDByExtension({
   ): PICK_FROM_DEVICE<DEVICE, DOMAIN>[] {
     hass.entity.warnEarly("device");
     return check(
-      hass.entity.registry.current
+      getEntities()
         .filter(i => i.device_id === device)
         .map(i => i.entity_id as PICK_FROM_DEVICE<DEVICE, DOMAIN>),
       domains,
@@ -158,7 +168,7 @@ export function IDByExtension({
       hass.area.current.filter(i => i.floor_id === floor).map(i => i.area_id),
     );
     return check(
-      hass.entity.registry.current
+      getEntities()
         .filter(i => areas.has(i.area_id))
         .map(i => i.entity_id as PICK_FROM_FLOOR<FLOOR, DOMAIN>),
       domains,
@@ -172,7 +182,7 @@ export function IDByExtension({
   ): PICK_FROM_PLATFORM<PLATFORM, DOMAIN>[] {
     hass.entity.warnEarly("platform");
     return check(
-      hass.entity.registry.current
+      getEntities()
         .filter(i => i.platform === platform)
         .map(i => i.entity_id as PICK_FROM_PLATFORM<PLATFORM, DOMAIN>),
       domains,

package/src/services/index.mts

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

package/src/services/label.service.mts

@@ -6,6 +6,7 @@ import {
   LABEL_REGISTRY_UPDATED,
   LabelDefinition,
   LabelOptions,
+  perf,
 } from "../helpers/index.mts";
 import { TLabelId } from "../user.mts";
 
@@ -29,10 +30,12 @@ export function Label({
       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() });
       },
     });
   });

package/src/services/reference.service.mts

@@ -8,6 +8,7 @@ import {
   domain,
   ENTITY_STATE,
   HassReferenceService,
+  perf,
   RemoveCallback,
 } from "../helpers/index.mts";
 import {
@@ -164,10 +165,11 @@ export function ReferenceService({
     const listeners = new Set<() => void>();
 
     // just because you can't do generics properly....
-    return new Proxy(thing, {
+    const proxy = new Proxy(thing, {
       // things that shouldn't be needed: this extract
       // eslint-disable-next-line sonarjs/function-return-type
       get: (_, property: Extract<keyof ByIdProxy<ENTITY_ID>, string>) => {
+        hass.diagnostics.reference?.get_property.publish({ entity_id, property });
         switch (property) {
           // #MARK: onUpdate
           case "onUpdate": {
@@ -304,7 +306,6 @@ export function ReferenceService({
                 listeners.add(remove);
 
                 const complete = (entity: ENTITY_STATE<ENTITY_ID>) => {
-                  // eslint-disable-next-line sonarjs/different-types-comparison
                   if (entity.state !== state) {
                     logger.trace(
                       {
@@ -340,11 +341,20 @@ export function ReferenceService({
         // #MARK: service calls
         if (hass.configure.isService(entity_domain, property)) {
           return async function (data = {}) {
+            const ms = perf();
             // @ts-expect-error i don't care, this is fine
-            return await hass.call[entity_domain][property]({
+            const result = await hass.call[entity_domain][property]({
               entity_id,
               ...data,
             });
+            hass.diagnostics.reference?.call_service.publish({
+              data,
+              entity_domain,
+              entity_id,
+              ms: ms(),
+              property,
+            });
+            return result;
           };
         }
         return proxyGetLogic(entity_id, property);
@@ -392,6 +402,8 @@ export function ReferenceService({
         return false;
       },
     });
+    hass.diagnostics.reference?.create_proxy.publish({ entity_id, proxy });
+    return proxy;
   }
 
   // #MARK: <return>

package/src/services/registry.service.mts

@@ -10,35 +10,35 @@ import {
 } from "../helpers/index.mts";
 
 export function Registry({ hass }: TServiceParams): HassRegistryService {
-  async function ManifestList() {
+  async function manifestList() {
     return await hass.socket.sendMessage<ManifestItem[]>({
       type: "manifest/list",
     });
   }
 
-  async function UpdateCore(options: UpdateCoreOptions) {
+  async function updateCore(options: UpdateCoreOptions) {
     await hass.socket.sendMessage<ZoneDetails[]>({
       ...options,
       type: "config/core/update",
     });
   }
 
-  async function GetConfig() {
+  async function getConfig() {
     return await hass.socket.sendMessage<HassConfig>({
       type: "get_config",
     });
   }
 
-  async function GetConfigEntries() {
+  async function getConfigEntries() {
     return await hass.socket.sendMessage<ConfigEntry[]>({
       type: "config_entries/get",
     });
   }
 
   return {
-    getConfig: GetConfig,
-    getConfigEntries: GetConfigEntries,
-    manifestList: ManifestList,
-    updateCore: UpdateCore,
+    getConfig,
+    getConfigEntries,
+    manifestList,
+    updateCore,
   };
 }

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

@@ -73,6 +73,7 @@ export function WebsocketAPI({
   // #MARK: setConnectionState
   function setConnectionState(state: ConnectionState) {
     hass.socket.connectionState = state;
+    hass.diagnostics.websocket?.set_connection_state.publish({ state });
   }
 
   // #MARK: handleUnknownConnectionState
@@ -87,6 +88,7 @@ export function WebsocketAPI({
     // send a ping message to force a pong
     logger.trace({ name }, `emitting ping`);
     lastPingAttempt = now;
+    hass.diagnostics.websocket?.send_ping.publish({});
 
     // emit a ping, do not wait for reply (inline)
     hass.socket.sendMessage({ type: "ping" }, false);
@@ -109,6 +111,7 @@ export function WebsocketAPI({
       logger.warn({ name }, "failed to receive expected {pong}");
       return;
     }
+    hass.diagnostics.websocket?.failed_ping.publish({});
     // 🪦 oof, get rid of the current connection and try again
     await hass.socket.teardown();
     logger.warn({ name }, "hass stopped replying {unknown} => {offline}");
@@ -215,11 +218,13 @@ export function WebsocketAPI({
 
   // #MARK: fireEvent
   async function fireEvent(event_type: string, event_data: object = {}) {
-    return await hass.socket.sendMessage({
+    const result = await hass.socket.sendMessage({
       event_data,
       event_type,
       type: "fire_event",
     });
+    hass.diagnostics.websocket?.fire_event.publish({ event_data, event_type, result });
+    return result;
   }
 
   // #MARK: sendMessage
@@ -245,6 +250,7 @@ export function WebsocketAPI({
     if (data.type !== "auth") {
       data.id = id;
     }
+    hass.diagnostics.websocket?.send_message.publish({ data, waitForResponse });
     const json = JSON.stringify(data);
     const sentAt = new Date();
 
@@ -275,6 +281,7 @@ export function WebsocketAPI({
     //
     // discard the promise so whatever flow is depending on this can get garbage collected
     waitingCallback.delete(id);
+    hass.diagnostics.websocket?.missed_reply.publish({ data, sentAt });
     logger.warn(
       {
         message: data,
@@ -398,10 +405,11 @@ export function WebsocketAPI({
    */
   async function onMessage(message: SocketMessageDTO) {
     const id = Number(message.id);
+    setImmediate(() => hass.diagnostics.websocket?.message_received.publish({ message }));
     switch (message.type) {
       case "auth_required": {
         logger.trace({ name: onMessage }, `sending authentication`);
-        hass.socket.sendMessage({ access_token: config.hass.TOKEN, type: "auth" }, false);
+        void hass.socket.sendMessage({ access_token: config.hass.TOKEN, type: "auth" }, false);
         return;
       }
 

package/src/services/zone.service.mts

@@ -4,6 +4,7 @@ import {
   EARLY_ON_READY,
   HassZoneService,
   ManifestItem,
+  perf,
   ZONE_REGISTRY_UPDATED,
   ZoneDetails,
   ZoneOptions,
@@ -29,10 +30,12 @@ export function Zone({
       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() });
       },
     });
   });