@scrypted/server 0.4.9 → 0.4.11

package/src/plugin/plugin-host-api.ts

@@ -61,14 +61,20 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
             const { interfaces } = await tableEntry.entry;
             if (!interfaces.has(eventInterface))
                 throw new Error(`${mixinProvider._id} does not mixin ${eventInterface} for ${id}`);
+
+            this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
         }
         else {
             const mixin: object = nativeIdOrMixinDevice;
-            if (!await this.scrypted.devices[device._id]?.handler?.isMixin(id, mixin)) {
+            let mixinProviderId = await this.scrypted.devices[device._id]?.handler?.getMixinProviderId(id, mixin);
+            if (!mixinProviderId)
                 throw new Error(`${mixin} does not mixin ${eventInterface} for ${id}`);
-            }
+
+            if (mixinProviderId === true)
+                mixinProviderId = undefined;
+            // this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
+            this.scrypted.stateManager.notifyInterfaceEventFromMixin(device, eventInterface, eventData, mixinProviderId as string);
         }
-        this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
     }
 
     async getMediaManager(): Promise<MediaManager> {
@@ -100,7 +106,11 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async setState(nativeId: ScryptedNativeId, key: string, value: any) {
         checkProperty(key, value);
-        this.scrypted.stateManager.setPluginState(this.pluginId, nativeId, this.propertyInterfaces?.[key], key, value);
+        const { pluginId } = this;
+        const device = this.scrypted.findPluginDevice(pluginId, nativeId);
+        if (!device)
+            throw new Error(`device not found for plugin id ${pluginId} native id ${nativeId}`);
+        await this.scrypted.stateManager.setPluginDeviceStateFromMixin(device, key, value, this.propertyInterfaces?.[key], device._id);
     }
 
     async setStorage(nativeId: ScryptedNativeId, storage: { [key: string]: string }) {
@@ -136,7 +146,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any) {
         const plugin = this.scrypted.findPluginDevice(this.pluginId, nativeId);
-        this.scrypted.stateManager.notifyInterfaceEvent(plugin, eventInterface, eventData);
+        this.scrypted.stateManager.notifyInterfaceEventFromMixin(plugin, eventInterface, eventData, plugin._id);
     }
 
     async getDeviceById<T>(id: string): Promise<T & ScryptedDevice> {
@@ -146,11 +156,11 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         return this.manageListener(this.scrypted.stateManager.listen(callback));
     }
     async listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister> {
-        const device = this.scrypted.findPluginDeviceById(id);
-        if (device) {
-            const self = this.scrypted.findPluginDevice(this.pluginId);
-            this.scrypted.getDeviceLogger(self).log('i', `requested listen ${getState(device, ScryptedInterfaceProperty.name)} ${JSON.stringify(event)}`);
-        }
+        // const device = this.scrypted.findPluginDeviceById(id);
+        // if (device) {
+        //     const self = this.scrypted.findPluginDevice(this.pluginId);
+        //     this.scrypted.getDeviceLogger(self).log('i', `requested listen ${getState(device, ScryptedInterfaceProperty.name)} ${JSON.stringify(event)}`);
+        // }
         return this.manageListener(this.scrypted.stateManager.listenDevice(id, event, callback));
     }
 

package/src/plugin/plugin-lazy-remote.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, SystemDeviceState } from '@scrypted/types'
+import { EventDetails, ScryptedNativeId, SystemDeviceState } from '@scrypted/types'
 import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 
 /**
@@ -42,7 +42,9 @@ import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
         }
         return this.remote.updateDeviceState(id, state);
     }
-    async notify(id: string, eventTime: number, eventInterface: string, property: string, propertyState: SystemDeviceState, changed?: boolean): Promise<void> {
+    // TODO: deprecate/clean up this signature
+    // 12/30/2022
+    async notify(id: string, eventTimeOrDetails: number| EventDetails, eventInterfaceOrData: string | SystemDeviceState | any, property?: string, value?: SystemDeviceState | any, changed?: boolean) {
         try {
             if (!this.remote)
                 await this.remoteReadyPromise;
@@ -50,7 +52,7 @@ import { PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
         catch (e) {
             return;
         }
-        return this.remote.notify(id, eventTime, eventInterface, property, propertyState, changed);
+        return this.remote.notify(id, eventTimeOrDetails as any, eventInterfaceOrData, property, value, changed);
     }
     async ioEvent(id: string, event: string, message?: any): Promise<void> {
         if (!this.remote)

package/src/plugin/plugin-remote.ts

@@ -1,4 +1,4 @@
-import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointManager, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
+import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointManager, EventDetails, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { AccessControls } from './acl';
 import { BufferSerializer } from './buffer-serializer';
@@ -175,8 +175,6 @@ class DeviceStateProxyHandler implements ProxyHandler<any> {
         checkProperty(p.toString(), value);
         const now = Date.now();
         this.deviceManager.systemManager.state[this.id][p as string] = {
-            lastEventTime: now,
-            stateTime: now,
             value,
         };
         this.setState(p.toString(), value);
@@ -367,7 +365,7 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
 
         const accessControls: AccessControls = peer.tags.acl;
 
-        const getAccessControlDeviceState = (id: string, state?:  { [property: string]: SystemDeviceState } ) => {
+        const getAccessControlDeviceState = (id: string, state?: { [property: string]: SystemDeviceState }) => {
             state = state || getSystemState()[id];
             if (accessControls && state) {
                 state = Object.assign({}, state);
@@ -420,11 +418,11 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
                 return;
             }
 
-            if (eventDetails.property) {
-                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, getSystemState()[id]?.[eventDetails.property], eventDetails.changed).catch(() => { });
+            if (eventDetails.property && !eventDetails.mixinId) {
+                remote.notify(id, eventDetails, getSystemState()[id]?.[eventDetails.property]).catch(() => { });
             }
             else {
-                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, eventData, eventDetails.changed).catch(() => { });
+                remote.notify(id, eventDetails, eventData).catch(() => { });
             }
         });
 
@@ -567,26 +565,48 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             async updateDeviceState(id: string, state: { [property: string]: SystemDeviceState }) {
                 if (!state) {
                     delete systemManager.state[id];
-                    systemManager.events.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
+                    systemManager.events.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, { changed: true });
                 }
                 else {
                     systemManager.state[id] = state;
-                    systemManager.events.notify(id, undefined, ScryptedInterface.ScryptedDevice, undefined, state, true);
+                    systemManager.events.notify(id, undefined, ScryptedInterface.ScryptedDevice, undefined, state, { changed: true });
                 }
             },
 
-            async notify(id: string, eventTime: number, eventInterface: string, property: string, value: SystemDeviceState | any, changed?: boolean) {
-                if (property) {
-                    const state = systemManager.state?.[id];
-                    if (!state) {
-                        log.w(`state not found for ${id}`);
-                        return;
+            async notify(id: string, eventTimeOrDetails: number| EventDetails, eventInterfaceOrData: string | SystemDeviceState | any, property?: string, value?: SystemDeviceState | any, changed?: boolean) {
+                if (typeof eventTimeOrDetails === 'number') {
+                    // TODO: remove legacy code path
+                    // 12/30/2022
+                    const eventTime = eventTimeOrDetails as number;
+                    const eventInterface = eventInterfaceOrData as string;
+                    if (property) {
+                        const state = systemManager.state?.[id];
+                        if (!state) {
+                            log.w(`state not found for ${id}`);
+                            return;
+                        }
+                        state[property] = value;
+                        systemManager.events.notify(id, eventTime, eventInterface, property, value.value, { changed });
+                    }
+                    else {
+                        systemManager.events.notify(id, eventTime, eventInterface, property, value, { changed });
                     }
-                    state[property] = value;
-                    systemManager.events.notify(id, eventTime, eventInterface, property, value.value, changed);
                 }
                 else {
-                    systemManager.events.notify(id, eventTime, eventInterface, property, value, changed);
+                    const eventDetails = eventTimeOrDetails as EventDetails;
+                    const eventData = eventInterfaceOrData as any;
+                    if (eventDetails.property && !eventDetails.mixinId) {
+                        const state = systemManager.state?.[id];
+                        if (!state) {
+                            log.w(`state not found for ${id}`);
+                            return;
+                        }
+                        state[eventDetails.property] = eventData;
+                        systemManager.events.notifyEventDetails(id, eventDetails, eventData.value);
+                    }
+                    else {
+                        systemManager.events.notifyEventDetails(id, eventDetails, eventData);
+                    }
                 }
             },
 

package/src/plugin/system.ts

@@ -166,15 +166,11 @@ export class SystemManagerImpl implements SystemManager {
         return this.events.listen(makeOneWayCallback((id, eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData)));
     }
     listenDevice(id: string, options: string | EventListenerOptions, callback: EventListener): EventListenerRegister {
-        let { event, watch } = (options || {}) as EventListenerOptions;
-        if (!event && typeof options === 'string')
-            event = options as string;
-        if (!event)
-            event = undefined;
+        let { watch } = (options || {}) as EventListenerOptions;
 
         // passive watching can be fast pathed to observe local state
         if (watch)
-            return this.events.listenDevice(id, event, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData));
+            return this.events.listenDevice(id, options, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData));
 
         return new EventListenerRegisterImpl(this.api.listenDevice(id, options, makeOneWayCallback((eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData))));
     }

package/src/rpc.ts

@@ -154,6 +154,9 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
 
         if (this.proxyOneWayMethods?.includes?.(method)) {
             rpcApply.oneway = true;
+            // a oneway callable object doesn't need to be in the JSON payload.
+            if (method === null)
+                delete rpcApply.method;
             this.peer.send(rpcApply, undefined, serializationContext);
             return Promise.resolve();
         }

package/src/runtime.ts

@@ -394,7 +394,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
         let accessControls: AccessControls;
         if (username) {
             const user = await this.datastore.tryGet(ScryptedUser, username);
-            if (user.aclId) {
+            if (user?.aclId) {
                 const accessControl = this.getDevice<SU>(user.aclId);
                 try {
                     const acls = await accessControl.getScryptedUserAccessControl();

package/src/services/plugin.ts

@@ -70,6 +70,8 @@ export class PluginComponent {
     async kill(pluginId: string) {
         return this.scrypted.plugins[pluginId]?.kill();
     }
+    // TODO: Remove this, ScryptedPlugin exists now.
+    // 12/29/2022
     async getPackageJson(pluginId: string) {
         return this.scrypted.getPackageJson(pluginId);
     }

package/src/state.ts

@@ -1,9 +1,9 @@
 import { EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
 import throttle from 'lodash/throttle';
 import { PluginDevice } from "./db-types";
-import { EventListenerRegisterImpl, EventRegistry } from "./event-registry";
-import { allInterfaceProperties, propertyInterfaces } from "./plugin/descriptor";
-import { RefreshSymbol } from "./plugin/plugin-device";
+import { EventListenerRegisterImpl, EventRegistry, getMixinEventName } from "./event-registry";
+import { propertyInterfaces } from "./plugin/descriptor";
+import { QueryInterfaceSymbol, RefreshSymbol } from "./plugin/plugin-device";
 import { ScryptedRuntime } from "./runtime";
 import { sleep } from "./sleep";
 
@@ -34,25 +34,74 @@ export class ScryptedStateManager extends EventRegistry {
         this.scrypted = scrypted;
     }
 
-    setPluginState(pluginId: string, nativeId: ScryptedNativeId, eventInterface: ScryptedInterface, property: string, value: any) {
-        const device = this.scrypted.findPluginDevice(pluginId, nativeId);
+    async getImplementerId(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string) {
+        if (!eventInterface)
+            throw new Error(`ScryptedInterface is required`);
+
+        const device = this.scrypted.getDevice(pluginDevice._id);
         if (!device)
-            throw new Error(`device not found for plugin id ${pluginId} native id ${nativeId}`);
-        this.setPluginDeviceState(device, property, value, eventInterface);
+            throw new Error(`device ${pluginDevice._id} not found?`);
+
+        const implementerId: string = await (device as any)[QueryInterfaceSymbol](eventInterface);
+        return implementerId;
+    }
+
+    async notifyInterfaceEventFromMixin(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId: string) {
+        // TODO: figure out how to clean this up this hack. For now,
+        // Settings interface is allowed to bubble from mixin devices..
+        if (eventInterface !== ScryptedInterface.Settings) {
+            const implementerId = await this.getImplementerId(pluginDevice, eventInterface);
+            if (implementerId !== mixinId) {
+                const event = getMixinEventName({
+                    event: eventInterface,
+                    mixinId,
+                });
+
+                this.notifyEventDetails(pluginDevice._id, {
+                    eventId: undefined,
+                    eventInterface,
+                    eventTime: Date.now(),
+                    mixinId,
+                }, value, event);
+
+                return;
+            }
+        }
+
+        this.notify(pluginDevice?._id, Date.now(), eventInterface, undefined, value);
+    }
+
+    async setPluginDeviceStateFromMixin(pluginDevice: PluginDevice, property: string, value: any, eventInterface: ScryptedInterface, mixinId: string) {
+        const implementerId = await this.getImplementerId(pluginDevice, eventInterface);
+        if (implementerId !== mixinId) {
+            const event = getMixinEventName({
+                event: eventInterface,
+                mixinId,
+            });
+            this.scrypted.getDeviceLogger(pluginDevice).log('i', `${property}: ${value} (mixin)`);
+            this.notifyEventDetails(pluginDevice._id, {
+                eventId: undefined,
+                eventInterface,
+                eventTime: Date.now(),
+                mixinId,
+                property,
+            }, value, event);
+            return false;
+        }
+
+        return this.setPluginDeviceState(pluginDevice, property, value, eventInterface);
     }
 
     setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: ScryptedInterface) {
         eventInterface = eventInterface || propertyInterfaces[property];
         if (!eventInterface)
-            throw new Error(`${property} is not a valid property`);
+            throw new Error(`eventInterface must be provided`);
 
         const changed = setState(device, property, value);
 
-        const eventTime = device?.state?.[property]?.lastEventTime;
-
         if (eventInterface !== ScryptedInterface.ScryptedDevice) {
-            if (this.notify(device?._id, eventTime, eventInterface, property, value, changed) && device) {
-                this.scrypted.getDeviceLogger(device).log('i', `state change: ${property} ${value}`);
+            if (this.notify(device?._id, Date.now(), eventInterface, property, value, { changed }) && device) {
+                this.scrypted.getDeviceLogger(device).log('i', `${property}: ${value}`);
             }
         }
 
@@ -63,15 +112,18 @@ export class ScryptedStateManager extends EventRegistry {
     }
 
     updateDescriptor(device: PluginDevice) {
-        this.notify(device._id, undefined, ScryptedInterface.ScryptedDevice, undefined, device.state, true);
+        this.notify(device._id, undefined, ScryptedInterface.ScryptedDevice, undefined, device.state, { changed: true });
     }
 
     removeDevice(id: string) {
-        this.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
+        this.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, { changed: true });
     }
 
-    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any) {
-        this.notify(device?._id, Date.now(), eventInterface, undefined, value, true);
+    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId?: string) {
+        this.notify(device?._id, Date.now(), eventInterface, undefined, value, {
+            changed: true,
+            mixinId,
+        });
     }
 
     setState(id: string, property: string, value: any) {
@@ -214,12 +266,8 @@ export function setState(pluginDevice: PluginDevice, property: string, value: an
     if (!pluginDevice.state[property])
         pluginDevice.state[property] = {};
     const state = pluginDevice.state[property];
-    const now = Date.now();
     const changed = !isSameValue(value, state.value);
-    if (changed)
-        state.stateTime = now;
     state.value = value;
-    state.lastEventTime = now;
     return changed;
 }