@smarthome.exchange/api 0.1.0 → 1.0.1

package/dist_ts/classes.smarthomeexchangeapiclient.js

@@ -1,78 +1,364 @@
 import * as plugins from './plugins.js';
+const maxLifecycleOperationCount = 64;
 export class SmarthomeExchangeApiClient {
-    hubUrl;
+    #homeId;
+    #httpEndpoint;
+    #hubUrl;
+    #socketConnectionPreparationTimeoutMs;
+    #authorizationHeaderProvider;
+    lifecycleTail = Promise.resolve();
+    lifecycleOperationCount = 0;
+    queuedLifecycleOperation;
+    stopIntentGeneration = 0;
+    pendingStartAbortController;
+    socketPendingStop;
+    socketNeedsCleanup = false;
+    #typedsocketClient;
     typedrouter = new plugins.typedrequest.TypedRouter();
-    typedsocketClient;
-    constructor(optionsArg = {}) {
-        this.hubUrl = (optionsArg.hubUrl || 'http://localhost:8080').replace(/\/$/, '');
+    constructor(optionsArg) {
+        this.assertKnownProperties(optionsArg, ['hubUrl', 'homeId', 'authorizationHeaderProvider', 'socketConnectionPreparationTimeoutMs'], 'Client options');
+        if (!optionsArg || typeof optionsArg.homeId !== 'string'
+            || optionsArg.homeId.length < 1 || optionsArg.homeId.length > 200
+            || optionsArg.homeId.trim() !== optionsArg.homeId
+            || typeof optionsArg.authorizationHeaderProvider !== 'function'
+            || (optionsArg.hubUrl !== undefined && typeof optionsArg.hubUrl !== 'string')) {
+            throw new TypeError('The API client requires a homeId and authorizationHeaderProvider.');
+        }
+        let hubUrl;
+        try {
+            hubUrl = new URL(optionsArg.hubUrl ?? 'http://localhost:8080');
+        }
+        catch {
+            throw new TypeError('hubUrl must be an absolute HTTP or HTTPS URL.');
+        }
+        if (!['http:', 'https:'].includes(hubUrl.protocol)
+            || hubUrl.username || hubUrl.password || hubUrl.search || hubUrl.hash) {
+            throw new TypeError('hubUrl must be an HTTP or HTTPS URL without credentials, query, or fragment.');
+        }
+        const preparationTimeoutMs = optionsArg.socketConnectionPreparationTimeoutMs;
+        if (preparationTimeoutMs !== undefined && (!Number.isInteger(preparationTimeoutMs)
+            || preparationTimeoutMs < 1
+            || preparationTimeoutMs > plugins.typedsocket.TYPEDSOCKET_MAX_CONNECTION_PREPARATION_TIMEOUT_MS)) {
+            throw new TypeError('Socket credential preparation requires a positive deadline no greater than 10000ms.');
+        }
+        this.#socketConnectionPreparationTimeoutMs = preparationTimeoutMs;
+        this.#hubUrl = hubUrl.href.replace(/\/$/, '');
+        hubUrl.pathname = `${hubUrl.pathname.replace(/\/+$/, '')}/typedrequest`;
+        this.#httpEndpoint = hubUrl.href;
+        this.#homeId = optionsArg.homeId;
+        this.#authorizationHeaderProvider = optionsArg.authorizationHeaderProvider;
     }
-    get httpEndpoint() {
-        return `${this.hubUrl}/typedrequest`;
+    get homeId() {
+        return this.#homeId;
     }
-    createWsRequest(operationArg) {
-        return this.typedsocketClient?.createTypedRequest(operationArg);
+    get typedsocketClient() {
+        return this.#typedsocketClient;
     }
     createHttpRequest(operationArg) {
-        return new plugins.typedrequest.TypedRequest(this.httpEndpoint, operationArg);
+        return new plugins.typedrequest.TypedRequest(this.#httpEndpoint, operationArg);
     }
-    async fire(operationArg, payloadArg) {
-        const wsRequest = this.createWsRequest(operationArg);
-        if (wsRequest) {
-            return wsRequest.fire(payloadArg);
+    captureRequestOptions(optionsArg) {
+        this.assertKnownProperties(optionsArg, ['abortSignal', 'timeoutMs', 'useCache'], 'Request options');
+        const options = { ...optionsArg };
+        if ((options.abortSignal !== undefined && !(options.abortSignal instanceof AbortSignal))
+            || (options.useCache !== undefined && typeof options.useCache !== 'boolean')
+            || (options.timeoutMs !== undefined && (!Number.isInteger(options.timeoutMs)
+                || options.timeoutMs < 1 || options.timeoutMs > 2_147_483_647))) {
+            throw new TypeError('Request options require an AbortSignal, boolean cache option, and positive timer-safe deadline.');
         }
-        return this.createHttpRequest(operationArg).fire(payloadArg);
+        return options;
     }
-    async start() {
-        this.typedsocketClient = await plugins.typedsocket.TypedSocket.createClient(this.typedrouter, this.hubUrl);
+    async fire(operationArg, requestPayloadArg, optionsArg = {}) {
+        const requestOptions = this.captureRequestOptions(optionsArg);
+        requestOptions.abortSignal?.throwIfAborted();
+        if (this.#typedsocketClient) {
+            return this.#typedsocketClient.createTypedRequest(operationArg, undefined, {
+                timeoutMs: requestOptions.timeoutMs,
+            }).fire(requestPayloadArg, {
+                ...requestOptions,
+                maxRetries: 0,
+            });
+        }
+        const authorization = await this.getAuthorization(Object.freeze({
+            homeId: this.#homeId,
+            endpoint: this.#httpEndpoint,
+            method: operationArg,
+            transport: 'http',
+            abortSignal: requestOptions.abortSignal,
+        }));
+        requestOptions.abortSignal?.throwIfAborted();
+        return this.createHttpRequest(operationArg).fire(requestPayloadArg, {
+            ...requestOptions,
+            maxRetries: 0,
+            headers: { authorization },
+        });
     }
-    async stop() {
-        await this.typedsocketClient?.stop();
-        this.typedsocketClient = undefined;
+    async getAuthorization(contextArg) {
+        const signal = contextArg.abortSignal;
+        signal?.throwIfAborted();
+        let removeAbortHandler = () => { };
+        let authorization;
+        try {
+            authorization = await new Promise((resolve, reject) => {
+                const onAbort = () => reject(signal?.reason);
+                signal?.addEventListener('abort', onAbort, { once: true });
+                removeAbortHandler = () => signal?.removeEventListener('abort', onAbort);
+                if (signal?.aborted) {
+                    onAbort();
+                    return;
+                }
+                void Promise.resolve(this.#authorizationHeaderProvider(contextArg)).then(resolve, reject);
+            });
+        }
+        finally {
+            removeAbortHandler();
+        }
+        if (typeof authorization !== 'string' || authorization.trim().length === 0) {
+            throw new TypeError('authorizationHeaderProvider must return a nonempty Authorization header.');
+        }
+        return authorization;
     }
-    async listDevices(requestArg = {}) {
-        return this.fire('listDevices', requestArg);
+    async prepareSocketConnection(contextArg) {
+        if (!contextArg.supportsHeaders) {
+            throw new plugins.typedsocket.TypedSocketConnectionPreparationError('unsupported-headers');
+        }
+        const authorization = await this.getAuthorization(Object.freeze({
+            homeId: this.#homeId,
+            endpoint: contextArg.url,
+            method: 'connect',
+            transport: 'websocket',
+            abortSignal: contextArg.abortSignal,
+            attempt: contextArg.attempt,
+            deadline: contextArg.deadline,
+        }));
+        contextArg.abortSignal.throwIfAborted();
+        return { headers: { authorization } };
     }
-    async listAgents() {
-        return this.fire('listAgents', {});
+    prepareRequest(payloadArg, allowedKeysArg, omitUndefinedFiltersArg = false) {
+        this.assertKnownProperties(payloadArg, allowedKeysArg, 'Request');
+        const normalizedPayload = { ...payloadArg };
+        if (omitUndefinedFiltersArg) {
+            for (const key of allowedKeysArg) {
+                if (Object.getOwnPropertyDescriptor(normalizedPayload, key)?.value === undefined) {
+                    Reflect.deleteProperty(normalizedPayload, key);
+                }
+            }
+        }
+        this.assertJsonData(normalizedPayload);
+        return { ...structuredClone(normalizedPayload), context: { homeId: this.#homeId } };
     }
-    async listTools(requestArg = {}) {
-        return this.fire('listTools', requestArg);
+    assertJsonData(valueArg) {
+        const activeObjects = new WeakSet();
+        const pending = [{ value: valueArg }];
+        while (pending.length > 0) {
+            const entry = pending.pop();
+            if (!entry)
+                continue;
+            const value = entry.value;
+            if (entry.exiting) {
+                if (value && typeof value === 'object')
+                    activeObjects.delete(value);
+                continue;
+            }
+            if (value === null || typeof value === 'string' || typeof value === 'boolean')
+                continue;
+            if (typeof value === 'number' && Number.isFinite(value))
+                continue;
+            if (!value || typeof value !== 'object' || activeObjects.has(value)) {
+                throw new TypeError('Request payload must contain finite, acyclic JSON data.');
+            }
+            const isArray = Array.isArray(value);
+            if (!isArray && ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+                throw new TypeError('Request payload must contain plain JSON objects.');
+            }
+            const keys = Reflect.ownKeys(value);
+            if (isArray && keys.length !== value.length + 1) {
+                throw new TypeError('Request payload arrays must contain only populated indices.');
+            }
+            activeObjects.add(value);
+            pending.push({ value, exiting: true });
+            for (const key of keys) {
+                if (isArray && key === 'length')
+                    continue;
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                if (typeof key !== 'string' || !descriptor || !('value' in descriptor)
+                    || !descriptor.enumerable
+                    || (isArray && (!/^(0|[1-9][0-9]*)$/.test(key) || Number(key) >= value.length))) {
+                    throw new TypeError('Request payload cannot contain accessors or unsupported properties.');
+                }
+                pending.push({ value: descriptor.value });
+            }
+        }
     }
-    async getHomeSnapshot() {
-        return this.fire('getHomeSnapshot', {});
+    assertKnownProperties(valueArg, allowedKeysArg, labelArg) {
+        if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)
+            || ![Object.prototype, null].includes(Object.getPrototypeOf(valueArg))) {
+            throw new TypeError(`${labelArg} must be a plain object.`);
+        }
+        for (const key of Reflect.ownKeys(valueArg)) {
+            const descriptor = Object.getOwnPropertyDescriptor(valueArg, key);
+            if (typeof key !== 'string' || !allowedKeysArg.includes(key)
+                || !descriptor || !('value' in descriptor) || !descriptor.enumerable) {
+                throw new TypeError(`${labelArg} contains unsupported properties.`);
+            }
+        }
+    }
+    queueLifecycleOperation(targetArg) {
+        if (this.queuedLifecycleOperation?.target === targetArg) {
+            return this.queuedLifecycleOperation.promise;
+        }
+        if (this.lifecycleOperationCount >= maxLifecycleOperationCount) {
+            return Promise.reject(new Error(`SmarthomeExchangeApiClient lifecycle queue is limited to ${maxLifecycleOperationCount} active and queued operations.`));
+        }
+        const startStopIntentGeneration = this.stopIntentGeneration;
+        if (targetArg === 'stopped') {
+            this.stopIntentGeneration++;
+            this.pendingStartAbortController?.abort();
+        }
+        this.lifecycleOperationCount++;
+        const operationPromise = this.lifecycleTail.then(async () => {
+            if (targetArg === 'started') {
+                if (this.stopIntentGeneration !== startStopIntentGeneration) {
+                    return;
+                }
+                if (this.socketNeedsCleanup) {
+                    throw new Error('Cannot start while the existing TypedSocket requires successful cleanup.');
+                }
+                if (!this.#typedsocketClient) {
+                    const startAbortController = new AbortController();
+                    this.pendingStartAbortController = startAbortController;
+                    try {
+                        const createdSocket = await plugins.typedsocket.TypedSocket.createClient(this.typedrouter, this.#hubUrl, {
+                            abortSignal: startAbortController.signal,
+                            autoReconnect: false,
+                            prepareConnection: (contextArg) => this.prepareSocketConnection(contextArg),
+                            connectionPreparationTimeoutMs: this.#socketConnectionPreparationTimeoutMs,
+                        });
+                        if (this.stopIntentGeneration !== startStopIntentGeneration) {
+                            this.socketPendingStop = createdSocket;
+                        }
+                        else {
+                            this.#typedsocketClient = createdSocket;
+                        }
+                    }
+                    catch (error) {
+                        if (startAbortController.signal.aborted &&
+                            this.stopIntentGeneration !== startStopIntentGeneration &&
+                            error instanceof plugins.typedsocket.TypedSocketClientStartupAbortedError) {
+                            return;
+                        }
+                        throw error;
+                    }
+                    finally {
+                        if (this.pendingStartAbortController === startAbortController) {
+                            this.pendingStartAbortController = undefined;
+                        }
+                    }
+                }
+                return;
+            }
+            const socketToStop = this.socketPendingStop ?? this.#typedsocketClient;
+            if (!socketToStop) {
+                return;
+            }
+            try {
+                await socketToStop.stop();
+            }
+            catch (error) {
+                this.socketNeedsCleanup = true;
+                throw error;
+            }
+            if (this.socketPendingStop === socketToStop) {
+                this.socketPendingStop = undefined;
+            }
+            if (this.#typedsocketClient === socketToStop) {
+                this.#typedsocketClient = undefined;
+            }
+            this.socketNeedsCleanup = false;
+        });
+        const lifecycleOperation = {
+            target: targetArg,
+            promise: operationPromise,
+        };
+        this.queuedLifecycleOperation = lifecycleOperation;
+        this.lifecycleTail = operationPromise.catch(() => undefined);
+        const finishOperation = () => {
+            this.lifecycleOperationCount--;
+            if (this.queuedLifecycleOperation === lifecycleOperation) {
+                this.queuedLifecycleOperation = undefined;
+            }
+        };
+        void operationPromise.then(finishOperation, finishOperation);
+        return operationPromise;
+    }
+    start() {
+        return this.queueLifecycleOperation('started');
+    }
+    stop() {
+        return this.queueLifecycleOperation('stopped');
+    }
+    async listDevices(requestArg = {}, optionsArg) {
+        return this.fire('listDevices', this.prepareRequest(requestArg, ['room', 'capability'], true), optionsArg);
+    }
+    async listAgents(optionsArg) {
+        return this.fire('listAgents', this.prepareRequest({}, []), optionsArg);
+    }
+    async listTools(requestArg = {}, optionsArg) {
+        return this.fire('listTools', this.prepareRequest(requestArg, ['ownerId'], true), optionsArg);
+    }
+    async getHomeSnapshot(optionsArg) {
+        return this.fire('getHomeSnapshot', this.prepareRequest({}, []), optionsArg);
     }
     watchHomeSnapshot(callbackArg, optionsArg = {}) {
-        const intervalMs = optionsArg.intervalMs ?? 5000;
+        this.assertKnownProperties(optionsArg, ['abortSignal', 'timeoutMs', 'intervalMs', 'immediate', 'onError'], 'Watcher options');
+        const options = { ...optionsArg };
+        if (typeof callbackArg !== 'function'
+            || (options.immediate !== undefined && typeof options.immediate !== 'boolean')
+            || (options.onError !== undefined && typeof options.onError !== 'function')) {
+            throw new TypeError('Snapshot watchers require a callback, boolean immediate option, and optional error handler.');
+        }
+        this.captureRequestOptions({ abortSignal: options.abortSignal, timeoutMs: options.timeoutMs });
+        const intervalMs = options.intervalMs ?? 5000;
         if (!Number.isInteger(intervalMs) || intervalMs < 1 || intervalMs > 2_147_483_647) {
             throw new Error('watchHomeSnapshot intervalMs must be an integer from 1 through 2147483647.');
         }
         let stopped = false;
         let timeout;
         let activePoll;
+        let activeRequestController;
         let userHandlerActive = false;
         const clearScheduledPoll = () => {
-            if (timeout) {
+            if (timeout !== undefined) {
                 clearTimeout(timeout);
                 timeout = undefined;
             }
         };
+        const stopForReason = async (reasonArg) => {
+            stopped = true;
+            clearScheduledPoll();
+            options.abortSignal?.removeEventListener('abort', onExternalAbort);
+            activeRequestController?.abort(reasonArg);
+            const pollToWait = userHandlerActive ? undefined : activePoll;
+            await pollToWait;
+        };
+        const onExternalAbort = () => {
+            void stopForReason(options.abortSignal?.reason);
+        };
         const scheduleNextPoll = () => {
-            if (stopped) {
+            if (stopped)
                 return;
-            }
             timeout = setTimeout(() => {
                 timeout = undefined;
                 activePoll = runPoll();
             }, intervalMs);
         };
         const handlePollError = async (errorArg) => {
-            if (stopped) {
+            if (stopped)
                 return;
-            }
-            if (optionsArg.onError) {
+            if (options.onError) {
                 userHandlerActive = true;
                 try {
-                    await optionsArg.onError(errorArg);
+                    await options.onError(errorArg);
                 }
                 catch (errorHandlerError) {
                     console.error('watchHomeSnapshot error handler failed:', errorHandlerError);
@@ -85,8 +371,13 @@ export class SmarthomeExchangeApiClient {
             console.error('watchHomeSnapshot poll failed:', errorArg);
         };
         const runPoll = async () => {
+            const controller = new AbortController();
+            activeRequestController = controller;
             try {
-                const snapshotResponse = await this.getHomeSnapshot();
+                const snapshotResponse = await this.getHomeSnapshot({
+                    abortSignal: controller.signal,
+                    timeoutMs: options.timeoutMs,
+                });
                 if (!stopped) {
                     userHandlerActive = true;
                     try {
@@ -101,33 +392,41 @@ export class SmarthomeExchangeApiClient {
                 await handlePollError(error);
             }
             finally {
+                controller.abort();
+                if (activeRequestController === controller)
+                    activeRequestController = undefined;
                 activePoll = undefined;
                 scheduleNextPoll();
             }
         };
-        if (optionsArg.immediate === false) {
+        options.abortSignal?.addEventListener('abort', onExternalAbort, { once: true });
+        if (options.abortSignal?.aborted) {
+            stopped = true;
+            options.abortSignal.removeEventListener('abort', onExternalAbort);
+        }
+        else if (options.immediate === false) {
             scheduleNextPoll();
         }
         else {
             activePoll = runPoll();
         }
-        return async () => {
-            stopped = true;
-            clearScheduledPoll();
-            const pollToWait = userHandlerActive ? undefined : activePoll;
-            await pollToWait;
-        };
+        return () => stopForReason();
     }
-    async executeToolPlan(planArg) {
-        return this.fire('executeToolPlan', {
-            plan: planArg,
-        });
+    async executeToolPlan(planArg, optionsArg) {
+        const request = this.prepareRequest({ plan: planArg }, ['plan']);
+        this.assertKnownProperties(request.plan, ['id', 'callerId', 'title', 'reason', 'confidence', 'calls'], 'Tool plan');
+        if (!Array.isArray(request.plan.calls))
+            throw new TypeError('Tool plan calls must be an array.');
+        for (const call of request.plan.calls) {
+            this.assertKnownProperties(call, ['id', 'toolId', 'callerId', 'input'], 'Tool call');
+        }
+        return this.fire('executeToolPlan', request, optionsArg);
     }
-    async listApprovals(requestArg = {}) {
-        return this.fire('listApprovals', requestArg);
+    async listApprovals(requestArg = {}, optionsArg) {
+        return this.fire('listApprovals', this.prepareRequest(requestArg, ['status'], true), optionsArg);
     }
-    async submitApproval(requestArg) {
-        return this.fire('submitApproval', requestArg);
+    async submitApproval(requestArg, optionsArg) {
+        return this.fire('submitApproval', this.prepareRequest(requestArg, ['approvalId', 'expectedActionDigest', 'decision']), optionsArg);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.smarthomeexchangeapiclient.js","sourceRoot":"","sources":["../ts/classes.smarthomeexchangeapiclient.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smarthome.exchange/api",
-  "version": "0.1.0",
+  "version": "1.0.1",
   "private": false,
   "description": "Typed API client for smarthome.exchange hubs.",
   "exports": {
@@ -10,18 +10,19 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "dependencies": {
-    "@api.global/typedrequest": "^7.0.2",
+    "@api.global/typedrequest": "9.1.0",
     "@api.global/typedrequest-interfaces": "^7.0.0",
-    "@api.global/typedsocket": "^7.1.0",
+    "@api.global/typedsocket": "9.0.0",
     "@push.rocks/smartpromise": "^4.2.4",
-    "@smarthome.exchange/interfaces": "0.1.0"
+    "@smarthome.exchange/interfaces": "2.1.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^4.4.2",
-    "@git.zone/tsdoc": "^2.1.1",
-    "@git.zone/tsrun": "^2.0.6",
-    "@git.zone/tstest": "^4.0.0",
-    "@types/node": "^26.2.0"
+    "@git.zone/tsbuild": "6.0.0-beta.0",
+    "@git.zone/tsdoc": "^3.0.2",
+    "@git.zone/tsrun": "^3.0.2",
+    "@git.zone/tstest": "^7.2.0",
+    "@push.rocks/smartserve": "9.0.0",
+    "@types/node": "^26.6.3"
   },
   "files": [
     "ts/**/*",