alepha 0.19.0 → 0.19.2

package/src/topic/mqtt/providers/MqttTopicProvider.spec.ts

@@ -1,160 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { Alepha, t } from "alepha";
-import { MqttClientProvider, MqttJsClientProvider } from "alepha/mqtt";
-import { $topic, TopicProvider } from "alepha/topic";
-import { describe, expect, it } from "vitest";
-import {
-  testTopicAsSub,
-  testTopicLateSubscribe,
-  testTopicParams,
-} from "../../core/__tests__/shared.ts";
-import { MqttTopicProvider } from "../index.ts";
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-const configure = (app: Alepha) => {
-  app.with({ provide: MqttClientProvider, use: MqttJsClientProvider });
-};
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-describe("$topic - mqtt", () => {
-  it("should subscribe and publish", async ({ expect }) => {
-    // Use a unique topic name to avoid cross-test interference.
-    const uid = randomUUID();
-
-    class TestTopic {
-      t = $topic({
-        name: `basic-${uid}`,
-        schema: { payload: t.object({ value: t.text() }) },
-      });
-    }
-
-    const alepha = Alepha.create();
-
-    configure(alepha);
-
-    alepha
-      .with({ provide: TopicProvider, use: MqttTopicProvider })
-      .with(TestTopic);
-
-    await alepha.start();
-
-    const test = alepha.inject(TestTopic);
-    const received: string[] = [];
-
-    await test.t.subscribe(async (m) => {
-      received.push(m.payload.value);
-    });
-
-    await test.t.publish({ value: "hello" });
-    await test.t.publish({ value: "world" });
-
-    await expect
-      .poll(() => received, { timeout: 5000 })
-      .toEqual(["hello", "world"]);
-
-    await alepha.stop();
-  });
-
-  it("should subscribe with handler", async () => {
-    await testTopicAsSub(MqttTopicProvider, configure);
-  });
-
-  it("should subscribe after start with provider", async () => {
-    await testTopicLateSubscribe(MqttTopicProvider, configure);
-  });
-
-  it("should deliver retained message to new subscriber", {
-    retry: 3,
-  }, async () => {
-    // Uses two separate apps to avoid same-client retained message delivery races.
-    const topicName = `retain-test-${randomUUID()}`;
-
-    class Publisher {
-      t = $topic({
-        name: topicName,
-        schema: { payload: t.object({ value: t.text() }) },
-        retain: true,
-        mqtt: { qos: 1 },
-      });
-    }
-
-    class Subscriber {
-      t = $topic({
-        name: topicName,
-        schema: { payload: t.object({ value: t.text() }) },
-        retain: true,
-        mqtt: { qos: 1 },
-      });
-    }
-
-    const pubApp = Alepha.create();
-    const subApp = Alepha.create();
-
-    configure(pubApp);
-    configure(subApp);
-
-    pubApp
-      .with({ provide: TopicProvider, use: MqttTopicProvider })
-      .with(Publisher);
-    subApp
-      .with({ provide: TopicProvider, use: MqttTopicProvider })
-      .with(Subscriber);
-
-    await pubApp.start();
-    const pub = pubApp.inject(Publisher);
-
-    await pub.t.publish({ value: "retained" });
-
-    await subApp.start();
-    const sub = subApp.inject(Subscriber);
-
-    const received: string[] = [];
-    await sub.t.subscribe(async (m) => {
-      received.push(m.payload.value);
-    });
-
-    await expect.poll(() => received, { timeout: 5000 }).toEqual(["retained"]);
-
-    await pubApp.stop();
-    await subApp.stop();
-  });
-
-  it("should support parameterized topic names", async () => {
-    await testTopicParams(MqttTopicProvider, configure);
-  });
-
-  it("should support QoS via mqtt options", async ({ expect }) => {
-    class QosTopic {
-      sensor = $topic({
-        name: "qos-test",
-        schema: { payload: t.object({ value: t.number() }) },
-        mqtt: { qos: 1 },
-      });
-    }
-
-    const alepha = Alepha.create();
-
-    configure(alepha);
-
-    alepha
-      .with({ provide: TopicProvider, use: MqttTopicProvider })
-      .with(QosTopic);
-
-    await alepha.start();
-
-    const topic = alepha.inject(QosTopic);
-    const received: number[] = [];
-
-    await topic.sensor.subscribe(async (m) => {
-      received.push(m.payload.value);
-    });
-
-    await topic.sensor.publish({ value: 42 });
-
-    await expect.poll(() => received, { timeout: 5000 }).toEqual([42]);
-
-    await alepha.stop();
-  });
-});

package/src/topic/mqtt/providers/MqttTopicProvider.ts

@@ -1,146 +0,0 @@
-import { $atom, $hook, $inject, $use, type Static, t } from "alepha";
-import { $logger } from "alepha/logger";
-import { MqttClientProvider } from "alepha/mqtt";
-import {
-  type SubscribeCallback,
-  TopicProvider,
-  type TopicPublishOptions,
-  type TopicSubscribeOptions,
-  type UnSubscribeFn,
-} from "alepha/topic";
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-/**
- * MQTT topic configuration atom.
- */
-export const mqttTopicOptions = $atom({
-  name: "alepha.topic.mqtt.options",
-  schema: t.object({
-    prefix: t.text({
-      default: "topic",
-      description: "Prefix for all topic channels in MQTT.",
-    }),
-  }),
-  default: {
-    prefix: "topic",
-  },
-});
-
-export type MqttTopicOptions = Static<typeof mqttTopicOptions.schema>;
-
-declare module "alepha" {
-  interface State {
-    [mqttTopicOptions.key]: MqttTopicOptions;
-  }
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-/**
- * Module augmentation — adds MQTT-specific publish options to $topic.
- *
- * Only used when the active TopicProvider is MqttTopicProvider.
- * Ignored by Memory and Redis providers.
- */
-declare module "alepha/topic" {
-  interface TopicSubscribeOptions {
-    mqtt?: {
-      qos?: 0 | 1 | 2;
-    };
-  }
-
-  interface TopicPrimitiveOptions<T> {
-    /**
-     * MQTT-specific options for this topic.
-     * Only used when the active TopicProvider is MqttTopicProvider.
-     * Ignored by Memory and Redis providers.
-     */
-    mqtt?: {
-      /**
-       * MQTT Quality of Service level.
-       * - 0: At most once (fire and forget)
-       * - 1: At least once (acknowledged delivery)
-       * - 2: Exactly once (four-step handshake)
-       *
-       * @default 0
-       */
-      qos?: 0 | 1 | 2;
-    };
-  }
-}
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-export class MqttTopicProvider extends TopicProvider {
-  protected readonly mqttClient = $inject(MqttClientProvider);
-  protected readonly options = $use(mqttTopicOptions);
-  protected readonly log = $logger();
-
-  protected readonly start = $hook({
-    on: "start",
-    handler: async () => {
-      const subscribers = this.subscribers();
-      if (subscribers.length) {
-        await Promise.all(subscribers.map((fn) => fn()));
-        for (const subscriber of subscribers) {
-          this.log.debug(`Subscribed to topic '${subscriber.name}'`);
-        }
-      }
-    },
-  });
-
-  /**
-   * Returns the MQTT topic path with prefix applied (using / separator).
-   */
-  public prefix(name: string): string {
-    return `${this.options.prefix}/${name}`;
-  }
-
-  /**
-   * Strips the prefix from a received MQTT topic path.
-   */
-  protected unprefix(topic: string): string {
-    const pfx = `${this.options.prefix}/`;
-    return topic.startsWith(pfx) ? topic.slice(pfx.length) : topic;
-  }
-
-  /**
-   * MQTT uses + as the single-level wildcard character.
-   */
-  protected override wildcardChar(): string {
-    return "+";
-  }
-
-  public async publish(
-    topic: string,
-    message: string,
-    options?: TopicPublishOptions,
-  ): Promise<void> {
-    await this.mqttClient.publish(this.prefix(topic), message, {
-      qos: (options as any)?.mqtt?.qos ?? 0,
-      retain: options?.retain ?? false,
-    });
-  }
-
-  public async subscribe(
-    name: string,
-    callback: SubscribeCallback,
-    options?: TopicSubscribeOptions,
-  ): Promise<UnSubscribeFn> {
-    const qos = options?.mqtt?.qos;
-
-    return this.mqttClient.subscribe(
-      this.prefix(name),
-      (receivedTopic, payload) => {
-        const unprefixed = this.unprefix(receivedTopic);
-        return callback(payload, unprefixed);
-      },
-      qos !== undefined ? { qos } : undefined,
-    );
-  }
-
-  public async unsubscribe(name: string): Promise<void> {
-    await this.mqttClient.unsubscribe(this.prefix(name));
-  }
-}