misc tweaks

package.json

@@ -2,7 +2,7 @@
   "name": "@digital-alchemy/hass",
   "repository": "https://github.com/Digital-Alchemy-TS/hass",
   "homepage": "https://docs.digital-alchemy.app/Hass",
-  "version": "0.3.14",
+  "version": "0.3.16",
   "scripts": {
     "build": "rm -rf dist/; tsc",
     "lint": "eslint src",

src/extensions/area.extension.ts

@@ -1,13 +1,25 @@
-import { TServiceParams } from "@digital-alchemy/core";
+import {
+  eachSeries,
+  InternalError,
+  TServiceParams,
+} from "@digital-alchemy/core";
 
 import { TAreaId } from "../dynamic";
-import { AreaCreate, AreaDetails, EARLY_ON_READY } from "../helpers";
+import {
+  AREA_REGISTRY_UPDATED,
+  AreaCreate,
+  AreaDetails,
+  EARLY_ON_READY,
+  ENTITY_REGISTRY_UPDATED,
+  PICK_ENTITY,
+} from "../helpers";
 
 export function Area({
   hass,
   context,
   config,
   logger,
+  event,
   lifecycle,
 }: TServiceParams) {
   hass.socket.onConnect(async () => {
@@ -26,22 +38,58 @@ export function Area({
       async exec() {
         hass.area.current = await hass.area.list();
         logger.debug(`area registry updated`);
+        event.emit(AREA_REGISTRY_UPDATED);
       },
     });
   });
 
   return {
+    async apply(area: TAreaId, entities: PICK_ENTITY[]) {
+      const out = { updated: [] as PICK_ENTITY[] };
+      await eachSeries(entities, async (entity: PICK_ENTITY) => {
+        const details = hass.entity.registry.current.find(
+          item => item.entity_id === entity,
+        );
+        if (!details) {
+          throw new InternalError(
+            context,
+            "UNKNOWN_ENTITY",
+            `Cannot find ${entity} in entity registry`,
+          );
+        }
+        if (details.area_id === area) {
+          return;
+        }
+        await new Promise<void>(async done => {
+          event.once(ENTITY_REGISTRY_UPDATED, done);
+          logger.trace({ area, entity }, `setting area`);
+          out.updated.push(entity);
+          await hass.socket.sendMessage({
+            area_id: area,
+            entity_id: entity,
+            type: "config/entity_registry/update",
+          });
+        });
+      });
+      return out;
+    },
     async create(details: AreaCreate) {
-      await hass.socket.sendMessage({
-        type: "config/area_registry/create",
-        ...details,
+      return await new Promise<void>(async done => {
+        event.once(AREA_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          type: "config/area_registry/create",
+          ...details,
+        });
       });
     },
     current: [] as AreaDetails[],
     async delete(area_id: TAreaId) {
-      await hass.socket.sendMessage({
-        area_id,
-        type: "config/area_registry/delete",
+      return await new Promise<void>(async done => {
+        event.once(AREA_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          area_id,
+          type: "config/area_registry/delete",
+        });
       });
     },
     async list() {
@@ -50,9 +98,12 @@ export function Area({
       });
     },
     async update(details: AreaDetails) {
-      await hass.socket.sendMessage({
-        type: "config/area_registry/update",
-        ...details,
+      return await new Promise<void>(async done => {
+        event.once(AREA_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          type: "config/area_registry/update",
+          ...details,
+        });
       });
     },
   };

src/extensions/backup.extension.ts

@@ -1,8 +1,25 @@
-import { HALF, SECOND, sleep, TServiceParams } from "@digital-alchemy/core";
+import { HALF, is, SECOND, sleep, TServiceParams } from "@digital-alchemy/core";
 
-import { BackupResponse, HomeAssistantBackup } from "../helpers";
+import {
+  BackupResponse,
+  HomeAssistantBackup,
+  SignRequestResponse,
+} from "../helpers";
 
 export function Backup({ logger, hass }: TServiceParams) {
+  async function download(slug: string, destination: string): Promise<void> {
+    const result = await hass.socket.sendMessage<SignRequestResponse>({
+      path: `/api/backup/download/${slug}`,
+      type: "auth/sign_path",
+    });
+    if (!is.object(result) || !("path" in result)) {
+      return;
+    }
+    await hass.fetch.download(destination, {
+      url: result.path,
+    });
+  }
+
   async function generate(): Promise<HomeAssistantBackup> {
     let current = await list();
     // const originalLength = current.backups.length;
@@ -41,5 +58,5 @@ export function Backup({ logger, hass }: TServiceParams) {
     await hass.socket.sendMessage({ slug, type: "backup/remove" }, false);
   }
 
-  return { generate, list, remove };
+  return { download, generate, list, remove };
 }

src/extensions/entity.extension.ts

@@ -17,6 +17,7 @@ import { Get } from "type-fest";
 import {
   ALL_DOMAINS,
   EditLabelOptions,
+  ENTITY_REGISTRY_UPDATED,
   ENTITY_STATE,
   EntityHistoryDTO,
   EntityHistoryResult,
@@ -77,6 +78,7 @@ export function EntityManager({
   hass,
   config,
   lifecycle,
+  event,
   context,
   internal,
 }: TServiceParams) {
@@ -93,8 +95,8 @@ export function EntityManager({
 
   // * Local event emitter for coordination of socket events
   // Other libraries will internally take advantage of this eventemitter
-  const event = new EventEmitter();
-  event.setMaxListeners(UNLIMITED);
+  const ENTITY_EVENTS = new EventEmitter();
+  ENTITY_EVENTS.setMaxListeners(UNLIMITED);
   let init = false;
 
   // #MARK: getCurrentState
@@ -150,11 +152,11 @@ export function EntityManager({
           get: (_, property: Extract<keyof ByIdProxy<ENTITY_ID>, string>) => {
             if (property === "onUpdate") {
               return (callback: TAnyFunction) =>
-                event.on(entity_id, async (a, b) => callback(a, b));
+                ENTITY_EVENTS.on(entity_id, async (a, b) => callback(a, b));
             }
             if (property === "once") {
               return (callback: TAnyFunction) =>
-                event.once(entity_id, async (a, b) => callback(a, b));
+                ENTITY_EVENTS.once(entity_id, async (a, b) => callback(a, b));
             }
             if (property === "entity_id") {
               return entity_id;
@@ -164,8 +166,10 @@ export function EntityManager({
             }
             if (property === "nextState") {
               return new Promise<ENTITY_STATE<ENTITY_ID>>(done => {
-                event.once(entity_id, (entity: ENTITY_STATE<ENTITY_ID>) =>
-                  done(entity as ENTITY_STATE<ENTITY_ID>),
+                ENTITY_EVENTS.once(
+                  entity_id,
+                  (entity: ENTITY_STATE<ENTITY_ID>) =>
+                    done(entity satisfies ENTITY_STATE<ENTITY_ID>),
                 );
               });
             }
@@ -329,7 +333,7 @@ export function EntityManager({
         async entity =>
           await EntityUpdateReceiver(
             entity.entity_id,
-            entity as ENTITY_STATE<PICK_ENTITY>,
+            entity satisfies ENTITY_STATE<PICK_ENTITY>,
             internal.utils.object.get(oldState, entity.entity_id),
           ),
       );
@@ -340,7 +344,7 @@ export function EntityManager({
   // #MARK: is.entity
   // Actually tie the type casting to real state
   is.entity = (entityId: PICK_ENTITY): entityId is PICK_ENTITY =>
-    is.undefined(internal.utils.object.get(MASTER_STATE, entityId));
+    !is.undefined(internal.utils.object.get(MASTER_STATE, entityId));
 
   // #MARK: EntityUpdateReceiver
   function EntityUpdateReceiver<ENTITY extends PICK_ENTITY = PICK_ENTITY>(
@@ -360,7 +364,7 @@ export function EntityManager({
     }
     internal.utils.object.set(MASTER_STATE, entity_id, new_state);
     if (!hass.socket.pauseMessages) {
-      event.emit(entity_id, new_state, old_state);
+      ENTITY_EVENTS.emit(entity_id, new_state, old_state);
     }
   }
 
@@ -376,10 +380,13 @@ export function EntityManager({
       logger.debug({ name: entity }, `already has label {%s}`, label);
       return;
     }
-    await hass.socket.sendMessage({
-      entity_id: entity,
-      labels: [...current.labels, label],
-      type: UPDATE_REGISTRY,
+    return await new Promise<void>(async done => {
+      event.once(ENTITY_REGISTRY_UPDATED, done);
+      await hass.socket.sendMessage({
+        entity_id: entity,
+        labels: [...current.labels, label],
+        type: UPDATE_REGISTRY,
+      });
     });
   }
 
@@ -402,10 +409,13 @@ export function EntityManager({
       return;
     }
     logger.debug({ name: entity }, `removing label [%s]`, label);
-    await hass.socket.sendMessage({
-      entity_id: entity,
-      labels: current.labels.filter(i => i !== label),
-      type: UPDATE_REGISTRY,
+    return await new Promise<void>(async done => {
+      event.once(ENTITY_REGISTRY_UPDATED, done);
+      await hass.socket.sendMessage({
+        entity_id: entity,
+        labels: current.labels.filter(i => i !== label),
+        type: UPDATE_REGISTRY,
+      });
     });
   }
 
@@ -427,6 +437,7 @@ export function EntityManager({
       async exec() {
         logger.debug("entity registry updated");
         hass.entity.registry.current = await hass.entity.registry.list();
+        event.emit(ENTITY_REGISTRY_UPDATED);
       },
     });
   });
@@ -560,6 +571,7 @@ export function EntityManager({
   };
 }
 
+// mental note: stop changing this from string
 declare module "@digital-alchemy/core" {
   export interface IsIt {
     entity(entity: string): entity is PICK_ENTITY;

src/extensions/floor.extension.ts

@@ -1,12 +1,18 @@
 import { is, TServiceParams } from "@digital-alchemy/core";
 
 import { TFloorId } from "../dynamic";
-import { EARLY_ON_READY, FloorCreate, FloorDetails } from "../helpers";
+import {
+  EARLY_ON_READY,
+  FLOOR_REGISTRY_UPDATED,
+  FloorCreate,
+  FloorDetails,
+} from "../helpers";
 
 export function Floor({
   hass,
   config,
   context,
+  event,
   logger,
   lifecycle,
 }: TServiceParams) {
@@ -26,6 +32,7 @@ export function Floor({
       async exec() {
         hass.floor.current = await hass.floor.list();
         logger.debug(`floor registry updated`);
+        event.emit(FLOOR_REGISTRY_UPDATED);
       },
     });
   });
@@ -35,16 +42,22 @@ export function Floor({
 
   return {
     async create(details: FloorCreate) {
-      await hass.socket.sendMessage({
-        type: "config/floor_registry/create",
-        ...details,
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          type: "config/floor_registry/create",
+          ...details,
+        });
       });
     },
     current: [] as FloorDetails[],
     async delete(floor_id: TFloorId) {
-      await hass.socket.sendMessage({
-        floor_id,
-        type: "config/floor_registry/delete",
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          floor_id,
+          type: "config/floor_registry/delete",
+        });
       });
     },
     async list() {
@@ -53,9 +66,12 @@ export function Floor({
       });
     },
     async update(details: FloorDetails) {
-      await hass.socket.sendMessage({
-        type: "config/floor_registry/update",
-        ...details,
+      return await new Promise<void>(async done => {
+        event.once(FLOOR_REGISTRY_UPDATED, done);
+        await hass.socket.sendMessage({
+          type: "config/floor_registry/update",
+          ...details,
+        });
       });
     },
   };