alepha 0.19.0 → 0.19.2

package/dist/topic/mqtt/index.js

@@ -1,88 +0,0 @@
-import { $atom, $hook, $inject, $module, $use, t } from "alepha";
-import { AlephaTopic, TopicProvider } from "alepha/topic";
-import { $logger } from "alepha/logger";
-import { MqttClientProvider } from "alepha/mqtt";
-//#region ../../src/topic/mqtt/providers/MqttTopicProvider.ts
-/**
-* MQTT topic configuration atom.
-*/
-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" }
-});
-var MqttTopicProvider = class extends TopicProvider {
-	mqttClient = $inject(MqttClientProvider);
-	options = $use(mqttTopicOptions);
-	log = $logger();
-	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).
-	*/
-	prefix(name) {
-		return `${this.options.prefix}/${name}`;
-	}
-	/**
-	* Strips the prefix from a received MQTT topic path.
-	*/
-	unprefix(topic) {
-		const pfx = `${this.options.prefix}/`;
-		return topic.startsWith(pfx) ? topic.slice(pfx.length) : topic;
-	}
-	/**
-	* MQTT uses + as the single-level wildcard character.
-	*/
-	wildcardChar() {
-		return "+";
-	}
-	async publish(topic, message, options) {
-		await this.mqttClient.publish(this.prefix(topic), message, {
-			qos: options?.mqtt?.qos ?? 0,
-			retain: options?.retain ?? false
-		});
-	}
-	async subscribe(name, callback, options) {
-		const qos = options?.mqtt?.qos;
-		return this.mqttClient.subscribe(this.prefix(name), (receivedTopic, payload) => {
-			return callback(payload, this.unprefix(receivedTopic));
-		}, qos !== void 0 ? { qos } : void 0);
-	}
-	async unsubscribe(name) {
-		await this.mqttClient.unsubscribe(this.prefix(name));
-	}
-};
-//#endregion
-//#region ../../src/topic/mqtt/index.ts
-/**
-* Plugin for Alepha Topic that provides MQTT pub/sub capabilities.
-*
-* Users must register `AlephaMqtt` separately for the MQTT client transport.
-*
-* @see {@link MqttTopicProvider}
-* @module alepha.topic.mqtt
-*/
-const AlephaTopicMqtt = $module({
-	name: "alepha.topic.mqtt",
-	services: [MqttTopicProvider],
-	register: (alepha) => alepha.with({
-		optional: true,
-		provide: TopicProvider,
-		use: MqttTopicProvider
-	}).with(AlephaTopic)
-});
-//#endregion
-export { AlephaTopicMqtt, MqttTopicProvider, mqttTopicOptions };
-
-//# sourceMappingURL=index.js.map

package/dist/topic/mqtt/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../src/topic/mqtt/providers/MqttTopicProvider.ts","../../../src/topic/mqtt/index.ts"],"sourcesContent":["import { $atom, $hook, $inject, $use, type Static, t } from \"alepha\";\nimport { $logger } from \"alepha/logger\";\nimport { MqttClientProvider } from \"alepha/mqtt\";\nimport {\n  type SubscribeCallback,\n  TopicProvider,\n  type TopicPublishOptions,\n  type TopicSubscribeOptions,\n  type UnSubscribeFn,\n} from \"alepha/topic\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * MQTT topic configuration atom.\n */\nexport const mqttTopicOptions = $atom({\n  name: \"alepha.topic.mqtt.options\",\n  schema: t.object({\n    prefix: t.text({\n      default: \"topic\",\n      description: \"Prefix for all topic channels in MQTT.\",\n    }),\n  }),\n  default: {\n    prefix: \"topic\",\n  },\n});\n\nexport type MqttTopicOptions = Static<typeof mqttTopicOptions.schema>;\n\ndeclare module \"alepha\" {\n  interface State {\n    [mqttTopicOptions.key]: MqttTopicOptions;\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Module augmentation — adds MQTT-specific publish options to $topic.\n *\n * Only used when the active TopicProvider is MqttTopicProvider.\n * Ignored by Memory and Redis providers.\n */\ndeclare module \"alepha/topic\" {\n  interface TopicSubscribeOptions {\n    mqtt?: {\n      qos?: 0 | 1 | 2;\n    };\n  }\n\n  interface TopicPrimitiveOptions<T> {\n    /**\n     * MQTT-specific options for this topic.\n     * Only used when the active TopicProvider is MqttTopicProvider.\n     * Ignored by Memory and Redis providers.\n     */\n    mqtt?: {\n      /**\n       * MQTT Quality of Service level.\n       * - 0: At most once (fire and forget)\n       * - 1: At least once (acknowledged delivery)\n       * - 2: Exactly once (four-step handshake)\n       *\n       * @default 0\n       */\n      qos?: 0 | 1 | 2;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class MqttTopicProvider extends TopicProvider {\n  protected readonly mqttClient = $inject(MqttClientProvider);\n  protected readonly options = $use(mqttTopicOptions);\n  protected readonly log = $logger();\n\n  protected readonly start = $hook({\n    on: \"start\",\n    handler: async () => {\n      const subscribers = this.subscribers();\n      if (subscribers.length) {\n        await Promise.all(subscribers.map((fn) => fn()));\n        for (const subscriber of subscribers) {\n          this.log.debug(`Subscribed to topic '${subscriber.name}'`);\n        }\n      }\n    },\n  });\n\n  /**\n   * Returns the MQTT topic path with prefix applied (using / separator).\n   */\n  public prefix(name: string): string {\n    return `${this.options.prefix}/${name}`;\n  }\n\n  /**\n   * Strips the prefix from a received MQTT topic path.\n   */\n  protected unprefix(topic: string): string {\n    const pfx = `${this.options.prefix}/`;\n    return topic.startsWith(pfx) ? topic.slice(pfx.length) : topic;\n  }\n\n  /**\n   * MQTT uses + as the single-level wildcard character.\n   */\n  protected override wildcardChar(): string {\n    return \"+\";\n  }\n\n  public async publish(\n    topic: string,\n    message: string,\n    options?: TopicPublishOptions,\n  ): Promise<void> {\n    await this.mqttClient.publish(this.prefix(topic), message, {\n      qos: (options as any)?.mqtt?.qos ?? 0,\n      retain: options?.retain ?? false,\n    });\n  }\n\n  public async subscribe(\n    name: string,\n    callback: SubscribeCallback,\n    options?: TopicSubscribeOptions,\n  ): Promise<UnSubscribeFn> {\n    const qos = options?.mqtt?.qos;\n\n    return this.mqttClient.subscribe(\n      this.prefix(name),\n      (receivedTopic, payload) => {\n        const unprefixed = this.unprefix(receivedTopic);\n        return callback(payload, unprefixed);\n      },\n      qos !== undefined ? { qos } : undefined,\n    );\n  }\n\n  public async unsubscribe(name: string): Promise<void> {\n    await this.mqttClient.unsubscribe(this.prefix(name));\n  }\n}\n","import { $module, type Alepha } from \"alepha\";\nimport { AlephaTopic, TopicProvider } from \"alepha/topic\";\nimport { MqttTopicProvider } from \"./providers/MqttTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/MqttTopicProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Topic that provides MQTT pub/sub capabilities.\n *\n * Users must register `AlephaMqtt` separately for the MQTT client transport.\n *\n * @see {@link MqttTopicProvider}\n * @module alepha.topic.mqtt\n */\nexport const AlephaTopicMqtt = $module({\n  name: \"alepha.topic.mqtt\",\n  services: [MqttTopicProvider],\n  register: (alepha: Alepha): Alepha =>\n    alepha\n      .with({\n        optional: true,\n        provide: TopicProvider,\n        use: MqttTopicProvider,\n      })\n      .with(AlephaTopic),\n});\n"],"mappings":";;;;;;;;AAgBA,MAAa,mBAAmB,MAAM;CACpC,MAAM;CACN,QAAQ,EAAE,OAAO,EACf,QAAQ,EAAE,KAAK;EACb,SAAS;EACT,aAAa;EACd,CAAC,EACH,CAAC;CACF,SAAS,EACP,QAAQ,SACT;CACF,CAAC;AA+CF,IAAa,oBAAb,cAAuC,cAAc;CACnD,aAAgC,QAAQ,mBAAmB;CAC3D,UAA6B,KAAK,iBAAiB;CACnD,MAAyB,SAAS;CAElC,QAA2B,MAAM;EAC/B,IAAI;EACJ,SAAS,YAAY;GACnB,MAAM,cAAc,KAAK,aAAa;AACtC,OAAI,YAAY,QAAQ;AACtB,UAAM,QAAQ,IAAI,YAAY,KAAK,OAAO,IAAI,CAAC,CAAC;AAChD,SAAK,MAAM,cAAc,YACvB,MAAK,IAAI,MAAM,wBAAwB,WAAW,KAAK,GAAG;;;EAIjE,CAAC;;;;CAKF,OAAc,MAAsB;AAClC,SAAO,GAAG,KAAK,QAAQ,OAAO,GAAG;;;;;CAMnC,SAAmB,OAAuB;EACxC,MAAM,MAAM,GAAG,KAAK,QAAQ,OAAO;AACnC,SAAO,MAAM,WAAW,IAAI,GAAG,MAAM,MAAM,IAAI,OAAO,GAAG;;;;;CAM3D,eAA0C;AACxC,SAAO;;CAGT,MAAa,QACX,OACA,SACA,SACe;AACf,QAAM,KAAK,WAAW,QAAQ,KAAK,OAAO,MAAM,EAAE,SAAS;GACzD,KAAM,SAAiB,MAAM,OAAO;GACpC,QAAQ,SAAS,UAAU;GAC5B,CAAC;;CAGJ,MAAa,UACX,MACA,UACA,SACwB;EACxB,MAAM,MAAM,SAAS,MAAM;AAE3B,SAAO,KAAK,WAAW,UACrB,KAAK,OAAO,KAAK,GAChB,eAAe,YAAY;AAE1B,UAAO,SAAS,SADG,KAAK,SAAS,cAAc,CACX;KAEtC,QAAQ,KAAA,IAAY,EAAE,KAAK,GAAG,KAAA,EAC/B;;CAGH,MAAa,YAAY,MAA6B;AACpD,QAAM,KAAK,WAAW,YAAY,KAAK,OAAO,KAAK,CAAC;;;;;;;;;;;;;AC7HxD,MAAa,kBAAkB,QAAQ;CACrC,MAAM;CACN,UAAU,CAAC,kBAAkB;CAC7B,WAAW,WACT,OACG,KAAK;EACJ,UAAU;EACV,SAAS;EACT,KAAK;EACN,CAAC,CACD,KAAK,YAAY;CACvB,CAAC"}

package/src/api/users/parameters/UserParameters.ts

@@ -1,23 +0,0 @@
-import { $parameter } from "alepha/api/parameters";
-import { realmAuthSettingsAtom } from "../atoms/realmAuthSettingsAtom.ts";
-
-/**
- * User-specific parameter service.
- *
- * This service wraps the core ParameterProvider to provide realm settings management.
- * It is lazy-loaded when the `parameters` feature is enabled in the realm.
- */
-export class UserParameters {
-  /**
-   * Realm authentication settings parameter.
-   *
-   * Controls user registration, login methods, verification requirements,
-   * and password policies for the realm.
-   */
-  public readonly realmSettings = $parameter({
-    name: "api.users.realmSettings",
-    description: "Realm authentication and registration settings",
-    schema: realmAuthSettingsAtom.schema,
-    default: realmAuthSettingsAtom.options.default,
-  });
-}

package/src/api/users/services/SessionService.spec.ts

@@ -1,303 +0,0 @@
-import { Alepha } from "alepha";
-import { AlephaOrmPostgres } from "alepha/orm/postgres";
-import {
-  AlephaSecurity,
-  CryptoProvider,
-  InvalidCredentialsError,
-} from "alepha/security";
-import { describe, it } from "vitest";
-import {
-  AlephaApiUsers,
-  RealmProvider,
-  SessionService,
-  UserService,
-} from "../index.ts";
-
-const setup = async (options?: { username?: "optional" | "required" }) => {
-  const alepha = Alepha.create({
-    env: { LOG_LEVEL: "error" },
-  });
-
-  alepha.with(AlephaOrmPostgres);
-  alepha.with(AlephaSecurity);
-  alepha.with(AlephaApiUsers);
-
-  await alepha.start();
-
-  const sessionService = alepha.inject(SessionService);
-
-  // Configure realm settings if provided
-  if (options?.username) {
-    const realmProvider = alepha.inject(RealmProvider);
-    realmProvider.register("default", {
-      settings: {
-        username: options.username,
-      } as never,
-    });
-  }
-
-  return {
-    alepha,
-    sessionService,
-    userService: alepha.inject(UserService),
-    cryptoProvider: alepha.inject(CryptoProvider),
-    identities: sessionService.identities(),
-  };
-};
-
-describe("alepha/api/users - SessionService.login", () => {
-  it("should login successfully with valid credentials", async ({ expect }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup();
-
-    // Create a test user
-    const user = await userService.users().create({
-      username: "loginsuccessuser",
-      email: "login-success@example.com",
-      roles: ["user"],
-    });
-
-    // Create identity with password
-    const password = "securePassword123!";
-    const hashedPassword = await cryptoProvider.hashPassword(password);
-
-    await identities.create({
-      provider: "local",
-      providerUserId: "login-success@example.com",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Test login
-    const result = await sessionService.login(
-      "local",
-      "login-success@example.com",
-      password,
-    );
-
-    expect(result?.id).toBe(user.id);
-    expect(result?.email).toBe("login-success@example.com");
-  });
-
-  it("should throw InvalidCredentialsError when identity not found", async ({
-    expect,
-  }) => {
-    const { sessionService } = await setup();
-
-    await expect(
-      sessionService.login("local", "nonexistent@example.com", "password"),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-
-  it("should throw InvalidCredentialsError when password is invalid", async ({
-    expect,
-  }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup();
-
-    // Create a test user
-    const user = await userService.users().create({
-      username: "invalidpassworduser",
-      email: "invalid-password@example.com",
-      roles: ["user"],
-    });
-
-    // Create identity with password
-    const hashedPassword = await cryptoProvider.hashPassword("correctPassword");
-
-    await identities.create({
-      provider: "local",
-      providerUserId: "invalid-password@example.com",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Test login with wrong password
-    await expect(
-      sessionService.login(
-        "local",
-        "invalid-password@example.com",
-        "wrongPassword",
-      ),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-
-  it("should throw InvalidCredentialsError when identity has no password configured", async ({
-    expect,
-  }) => {
-    const { sessionService, userService, identities } = await setup();
-
-    // Create a test user
-    const user = await userService.users().create({
-      username: "nopassworduser",
-      email: "no-password@example.com",
-      roles: ["user"],
-    });
-
-    // Create identity without password
-    await identities.create({
-      provider: "local",
-      providerUserId: "no-password@example.com",
-      userId: user.id,
-      providerData: {}, // No password
-    });
-
-    await expect(
-      sessionService.login("local", "no-password@example.com", "anyPassword"),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-
-  it("should throw InvalidCredentialsError when user is deleted after identity creation", async ({
-    expect,
-  }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup();
-
-    // Create a user, then delete them to simulate orphan identity
-    const user = await userService.users().create({
-      username: "orphanidentityuser",
-      email: "orphan-identity@example.com",
-      roles: ["user"],
-    });
-
-    const hashedPassword = await cryptoProvider.hashPassword("password123");
-
-    await identities.create({
-      provider: "local",
-      providerUserId: "orphan-identity@example.com",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Delete the user to create orphan identity scenario
-    await userService.users().deleteById(user.id);
-
-    await expect(
-      sessionService.login(
-        "local",
-        "orphan-identity@example.com",
-        "password123",
-      ),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-
-  it("should throw InvalidCredentialsError with same message for all failure types", async ({
-    expect,
-  }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup();
-
-    // Setup for invalid password test
-    const user = await userService.users().create({
-      username: "sameerroruser",
-      email: "same-error@example.com",
-      roles: ["user"],
-    });
-    const hashedPassword = await cryptoProvider.hashPassword("correctPass");
-    await identities.create({
-      provider: "local",
-      providerUserId: "same-error@example.com",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Test identity not found
-    try {
-      await sessionService.login("local", "notfound@example.com", "password");
-    } catch (error) {
-      expect(error).toBeInstanceOf(InvalidCredentialsError);
-      expect((error as Error).message).toBe("Invalid credentials");
-    }
-
-    // Test invalid password
-    try {
-      await sessionService.login(
-        "local",
-        "same-error@example.com",
-        "wrongPassword",
-      );
-    } catch (error) {
-      expect(error).toBeInstanceOf(InvalidCredentialsError);
-      expect((error as Error).message).toBe("Invalid credentials");
-    }
-  });
-
-  it("should include random delay to prevent timing attacks", async ({
-    expect,
-  }) => {
-    const { sessionService } = await setup();
-
-    const start = Date.now();
-
-    try {
-      await sessionService.login(
-        "local",
-        "timing-attack@example.com",
-        "password",
-      );
-    } catch {
-      // Expected to fail
-    }
-
-    const elapsed = Date.now() - start;
-
-    // Should take at least 50ms due to random delay
-    expect(elapsed).toBeGreaterThanOrEqual(50);
-  });
-
-  it("should handle different providers correctly", async ({ expect }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup({ username: "optional" });
-
-    const user = await userService.users().create({
-      username: "multiprovideruser",
-      email: "multi-provider@example.com",
-      roles: ["user"],
-    });
-
-    // Create identity for 'custom' provider
-    const hashedPassword = await cryptoProvider.hashPassword("customPass");
-    await identities.create({
-      provider: "custom",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Login with correct provider
-    const result = await sessionService.login(
-      "custom",
-      "multiprovideruser",
-      "customPass",
-    );
-    expect(result?.id).toBe(user.id);
-
-    // Should fail with wrong provider
-    await expect(
-      sessionService.login("local", "custom-user-id", "customPass"),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-
-  it("should handle empty password correctly", async ({ expect }) => {
-    const { sessionService, userService, cryptoProvider, identities } =
-      await setup();
-
-    const user = await userService.users().create({
-      username: "emptypassworduser",
-      email: "empty-password@example.com",
-      roles: ["user"],
-    });
-
-    const hashedPassword = await cryptoProvider.hashPassword("realPassword");
-    await identities.create({
-      provider: "local",
-      providerUserId: "empty-password@example.com",
-      userId: user.id,
-      password: hashedPassword,
-    });
-
-    // Empty password should fail
-    await expect(
-      sessionService.login("local", "empty-password@example.com", ""),
-    ).rejects.toThrowError(InvalidCredentialsError);
-  });
-});