David
feff828ec1
src/dispatcher.ts routes a directive to capability.on(name | "*"), device.onDirective() or device.onReportState(), with the payload checked by the descriptor of the interface. The DirectiveContext answers with respond/report/defer/error; respond() and report() start from device.state(). A handler or 1.x listener that throws or rejects is answered with INTERNAL_ERROR (an AlexaError with itself) and reported through "error", never as an unhandled rejection. Undeclared interface, unknown directive, AdjustMode on an unordered mode and a missing handler get INVALID_DIRECTIVE, a bad payload INVALID_VALUE; a device with an "Event" or "ReportState" listener keeps the answer to itself. Every answer passes the dispatcher: the first one per correlationToken is published, a second is refused. No answer within answerWithinMs (6500, 0 = off, unref'd timer) sends INTERNAL_ERROR and emits "unanswered". A messageId that arrived in the last 60 s is dropped. New: "unknownEndpoint", options answerUnknownEndpoints, publisher, timers, and bridge.receive() to run a bridge without a broker. 168 tests pass (18 new). Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
78 lines
3.2 KiB
JavaScript
78 lines
3.2 KiB
JavaScript
/** What was thrown, as an Error. */
|
|
export const asError = (err) => (err instanceof Error ? err : new Error(String(err)));
|
|
/**
|
|
* Publishes to the broker through the client the bridge has at the time: a new one after disconnect() and connect(),
|
|
* none before connect() and after disconnect(). Without a client the publish is refused. With a client that lost
|
|
* its connection mqtt.js keeps the message and sends it after the reconnect, and the publish resolves then.
|
|
*/
|
|
export class MqttPublisher {
|
|
constructor(client) {
|
|
this.client = client;
|
|
}
|
|
publish(topic, message) {
|
|
const client = this.client();
|
|
return new Promise((resolve) => {
|
|
const failed = (err) => resolve({ ok: false, topic, error: asError(err) });
|
|
if (!client) {
|
|
failed(new Error(`nothing was published to ${topic}: the bridge is not connected, call connect() first`));
|
|
return;
|
|
}
|
|
try {
|
|
client.publish(topic, JSON.stringify(message), (err) => (err ? failed(err) : resolve({ ok: true, topic })));
|
|
}
|
|
catch (err) {
|
|
failed(err);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Keeps what it is asked to publish, for tests and dry runs without a broker:
|
|
*
|
|
* const sent = new MemoryPublisher();
|
|
* device.publisher = sent; // or new Alex2MQTT(..., { publisher: sent }) and bridge.receive()
|
|
* await device.getStatusMessage(token, true).addPowerControllerProp(PowerController.ON).send();
|
|
* sent.published[0] // { topic: "<root>/<endpointId>/alexaResponce", message: { event, context } }
|
|
*/
|
|
export class MemoryPublisher {
|
|
constructor() {
|
|
/** Oldest first. The message is what a subscriber gets after JSON.parse. */
|
|
this.published = [];
|
|
/** Set it and every publish fails with this error, as a publish to a broker that is gone does. */
|
|
this.failWith = null;
|
|
}
|
|
publish(topic, message) {
|
|
if (this.failWith)
|
|
return Promise.resolve({ ok: false, topic, error: this.failWith });
|
|
try {
|
|
this.published.push({ topic, message: JSON.parse(JSON.stringify(message)) });
|
|
}
|
|
catch (err) {
|
|
return Promise.resolve({ ok: false, topic, error: asError(err) });
|
|
}
|
|
return Promise.resolve({ ok: true, topic });
|
|
}
|
|
}
|
|
/**
|
|
* send() as 1.x promises it: resolves with the topic, or with "" when nothing was published, and never rejects
|
|
* (1.5.1 rejected, and a send() nobody caught killed the host on any broker hiccup). What went wrong goes to report:
|
|
* the message cannot be built, the device is on no bridge, or the publish failed.
|
|
*/
|
|
export async function send(publisher, topic, build, report) {
|
|
let result;
|
|
try {
|
|
const message = build();
|
|
if (!publisher) {
|
|
throw new Error(`nothing was published to ${topic}: the device is on no bridge, register it with addDevice() or registerDevice()`);
|
|
}
|
|
result = await publisher.publish(topic, message);
|
|
}
|
|
catch (err) {
|
|
result = { ok: false, topic, error: asError(err) };
|
|
}
|
|
if (result.ok)
|
|
return topic;
|
|
if (report)
|
|
report(result.error);
|
|
return "";
|
|
}
|