alepha 0.12.1 → 0.13.1

package/dist/sms/index.cjs

@@ -1,221 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let alepha = require("alepha");
-let alepha_logger = require("alepha/logger");
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = __toESM(node_fs_promises);
-let node_path = require("node:path");
-node_path = __toESM(node_path);
-
-//#region src/sms/providers/MemorySmsProvider.ts
-var MemorySmsProvider = class {
-	log = (0, alepha_logger.$logger)();
-	records = [];
-	async send(options) {
-		const { to, message } = options;
-		this.log.debug("Sending SMS to memory store", {
-			to,
-			message
-		});
-		for (const recipient of Array.isArray(to) ? to : [to]) this.records.push({
-			to: recipient,
-			message,
-			sentAt: /* @__PURE__ */ new Date()
-		});
-	}
-	/**
-	* Get the last SMS sent (for testing purposes).
-	*/
-	get last() {
-		return this.records[this.records.length - 1];
-	}
-};
-
-//#endregion
-//#region src/sms/providers/SmsProvider.ts
-/**
-* SMS provider interface.
-*
-* All methods are asynchronous and return promises.
-*/
-var SmsProvider = class {};
-
-//#endregion
-//#region src/sms/descriptors/$sms.ts
-const $sms = (options = {}) => (0, alepha.createDescriptor)(SmsDescriptor, options);
-/**
-* SMS descriptor for sending SMS messages through various providers.
-*
-* Usage:
-* ```typescript
-* class MyService {
-*   private readonly welcomeSms = $sms({ name: "welcome" });
-*
-*   async sendWelcome(phoneNumber: string, userName: string) {
-*     await this.welcomeSms.send({
-*       to: phoneNumber,
-*       message: `Hello ${userName}! Welcome to our service.`
-*     });
-*   }
-* }
-* ```
-*/
-var SmsDescriptor = class extends alepha.Descriptor {
-	provider = this.$provider();
-	get name() {
-		return this.options.name ?? `${this.config.propertyKey}`;
-	}
-	/**
-	* Send an SMS using the configured provider.
-	*/
-	async send(options) {
-		await this.alepha.events.emit("sms:sending", {
-			to: options.to,
-			template: this.name,
-			variables: {},
-			provider: this.provider,
-			abort: () => {
-				throw new Error("SMS sending aborted by hook");
-			}
-		});
-		await this.provider.send(options);
-		await this.alepha.events.emit("sms:sent", {
-			to: options.to,
-			template: this.name,
-			provider: this.provider
-		});
-	}
-	$provider() {
-		if (!this.options.provider) return this.alepha.inject(SmsProvider);
-		if (this.options.provider === "memory") return this.alepha.inject(MemorySmsProvider);
-		return this.alepha.inject(this.options.provider);
-	}
-};
-$sms[alepha.KIND] = SmsDescriptor;
-
-//#endregion
-//#region src/sms/errors/SmsError.ts
-var SmsError = class extends Error {
-	constructor(message, cause) {
-		super(message);
-		this.name = "SmsError";
-		this.cause = cause;
-	}
-};
-
-//#endregion
-//#region src/sms/providers/LocalSmsProvider.ts
-var LocalSmsProvider = class {
-	log = (0, alepha_logger.$logger)();
-	directory;
-	constructor(options = {}) {
-		this.directory = options.directory ?? "node_modules/.sms";
-	}
-	async send(options) {
-		const { to, message } = options;
-		this.log.debug("Sending SMS to local file", {
-			to,
-			message,
-			directory: this.directory
-		});
-		try {
-			await node_fs_promises.mkdir(this.directory, { recursive: true });
-			const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-			for (const recipient of Array.isArray(to) ? to : [to]) {
-				const filename = `${recipient.replace(/[^0-9+]/g, "_")}+${timestamp}.txt`;
-				const filepath = node_path.join(this.directory, filename);
-				const textContent = this.createSmsText({
-					to: recipient,
-					message
-				});
-				await node_fs_promises.writeFile(filepath, textContent, "utf8");
-				this.log.info("SMS saved to local file", {
-					filepath,
-					to
-				});
-			}
-		} catch (error) {
-			const message$1 = `Failed to save SMS to local file: ${error instanceof Error ? error.message : String(error)}`;
-			this.log.error(message$1, {
-				to,
-				directory: this.directory
-			});
-			throw new SmsError(message$1, error instanceof Error ? error : void 0);
-		}
-	}
-	createSmsText(options) {
-		const { to, message } = options;
-		return `SMS Message
-===========
-
-Sent: ${(/* @__PURE__ */ new Date()).toISOString()}
-To: ${to}
-
-Message:
---------
-${message}
-`;
-	}
-};
-
-//#endregion
-//#region src/sms/index.ts
-/**
-* Provides SMS sending capabilities for Alepha applications with multiple provider backends.
-*
-* The SMS module enables declarative SMS sending through the `$sms` descriptor, allowing you to send
-* text messages through different providers: memory (for testing) or local file system.
-* It supports automatic provider selection based on environment configuration.
-*
-* @see {@link SmsProvider}
-* @module alepha.sms
-*/
-const AlephaSms = (0, alepha.$module)({
-	name: "alepha.sms",
-	descriptors: [$sms],
-	services: [
-		SmsProvider,
-		MemorySmsProvider,
-		LocalSmsProvider
-	],
-	register: (alepha$1) => alepha$1.with({
-		optional: true,
-		provide: SmsProvider,
-		use: MemorySmsProvider
-	})
-});
-
-//#endregion
-exports.$sms = $sms;
-exports.AlephaSms = AlephaSms;
-exports.LocalSmsProvider = LocalSmsProvider;
-exports.MemorySmsProvider = MemorySmsProvider;
-exports.SmsDescriptor = SmsDescriptor;
-exports.SmsError = SmsError;
-exports.SmsProvider = SmsProvider;
-//# sourceMappingURL=index.cjs.map

package/dist/sms/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["Descriptor","KIND","fs","path","message","alepha"],"sources":["../../src/sms/providers/MemorySmsProvider.ts","../../src/sms/providers/SmsProvider.ts","../../src/sms/descriptors/$sms.ts","../../src/sms/errors/SmsError.ts","../../src/sms/providers/LocalSmsProvider.ts","../../src/sms/index.ts"],"sourcesContent":["import { $logger } from \"alepha/logger\";\nimport type { SmsProvider, SmsSendOptions } from \"./SmsProvider.ts\";\n\nexport interface SmsRecord {\n  to: string;\n  message: string;\n  sentAt: Date;\n}\n\nexport class MemorySmsProvider implements SmsProvider {\n  protected readonly log = $logger();\n  public records: SmsRecord[] = [];\n\n  public async send(options: SmsSendOptions): Promise<void> {\n    const { to, message } = options;\n    this.log.debug(\"Sending SMS to memory store\", { to, message });\n\n    for (const recipient of Array.isArray(to) ? to : [to]) {\n      this.records.push({\n        to: recipient,\n        message,\n        sentAt: new Date(),\n      });\n    }\n  }\n\n  /**\n   * Get the last SMS sent (for testing purposes).\n   */\n  public get last(): SmsRecord | undefined {\n    return this.records[this.records.length - 1];\n  }\n}\n","/**\n * SMS provider interface.\n *\n * All methods are asynchronous and return promises.\n */\nexport abstract class SmsProvider {\n  /**\n   * Send an SMS.\n   *\n   * @return Promise that resolves when the SMS is sent.\n   */\n  public abstract send(options: SmsSendOptions): Promise<void>;\n}\n\nexport type SmsSendOptions = {\n  to: string | string[];\n  message: string;\n};\n","import {\n  createDescriptor,\n  Descriptor,\n  type InstantiableClass,\n  KIND,\n} from \"alepha\";\nimport { MemorySmsProvider } from \"../providers/MemorySmsProvider.ts\";\nimport type { SmsSendOptions } from \"../providers/SmsProvider.ts\";\nimport { SmsProvider } from \"../providers/SmsProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport const $sms = (options: SmsDescriptorOptions = {}) =>\n  createDescriptor(SmsDescriptor, options);\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport interface SmsDescriptorOptions {\n  name?: string;\n  provider?: InstantiableClass<SmsProvider> | \"memory\";\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * SMS descriptor for sending SMS messages through various providers.\n *\n * Usage:\n * ```typescript\n * class MyService {\n *   private readonly welcomeSms = $sms({ name: \"welcome\" });\n *\n *   async sendWelcome(phoneNumber: string, userName: string) {\n *     await this.welcomeSms.send({\n *       to: phoneNumber,\n *       message: `Hello ${userName}! Welcome to our service.`\n *     });\n *   }\n * }\n * ```\n */\nexport class SmsDescriptor extends Descriptor<SmsDescriptorOptions> {\n  protected readonly provider = this.$provider();\n\n  public get name() {\n    return this.options.name ?? `${this.config.propertyKey}`;\n  }\n\n  /**\n   * Send an SMS using the configured provider.\n   */\n  public async send(options: SmsSendOptions): Promise<void> {\n    await this.alepha.events.emit(\"sms:sending\", {\n      to: options.to,\n      template: this.name,\n      variables: {},\n      provider: this.provider,\n      abort: () => {\n        throw new Error(\"SMS sending aborted by hook\");\n      },\n    });\n\n    await this.provider.send(options);\n\n    await this.alepha.events.emit(\"sms:sent\", {\n      to: options.to,\n      template: this.name,\n      provider: this.provider,\n    });\n  }\n\n  protected $provider(): SmsProvider {\n    if (!this.options.provider) {\n      return this.alepha.inject(SmsProvider);\n    }\n    if (this.options.provider === \"memory\") {\n      return this.alepha.inject(MemorySmsProvider);\n    }\n    return this.alepha.inject(this.options.provider);\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n$sms[KIND] = SmsDescriptor;\n","export class SmsError extends Error {\n  constructor(message: string, cause?: Error) {\n    super(message);\n    this.name = \"SmsError\";\n    this.cause = cause;\n  }\n}\n","import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { $logger } from \"alepha/logger\";\nimport { SmsError } from \"../errors/SmsError.ts\";\nimport type { SmsProvider, SmsSendOptions } from \"./SmsProvider.ts\";\n\nexport interface LocalSmsProviderOptions {\n  /**\n   * Directory to save SMS files.\n   * @default \"node_modules/.sms\" (relative to project root)\n   */\n  directory?: string;\n}\n\nexport class LocalSmsProvider implements SmsProvider {\n  protected readonly log = $logger();\n  protected readonly directory: string;\n\n  constructor(options: LocalSmsProviderOptions = {}) {\n    this.directory = options.directory ?? \"node_modules/.sms\";\n  }\n\n  public async send(options: SmsSendOptions): Promise<void> {\n    const { to, message } = options;\n\n    this.log.debug(\"Sending SMS to local file\", {\n      to,\n      message,\n      directory: this.directory,\n    });\n\n    try {\n      // Ensure directory exists\n      await fs.mkdir(this.directory, { recursive: true });\n\n      // Create filename: phone+date\n      const timestamp = new Date().toISOString().replace(/[:.]/g, \"-\");\n      for (const recipient of Array.isArray(to) ? to : [to]) {\n        const sanitizedPhone = recipient.replace(/[^0-9+]/g, \"_\");\n        const filename = `${sanitizedPhone}+${timestamp}.txt`;\n        const filepath = path.join(this.directory, filename);\n\n        // Create text content\n        const textContent = this.createSmsText({\n          to: recipient,\n          message,\n        });\n\n        // Write to file\n        await fs.writeFile(filepath, textContent, \"utf8\");\n\n        this.log.info(\"SMS saved to local file\", { filepath, to });\n      }\n    } catch (error) {\n      const message = `Failed to save SMS to local file: ${error instanceof Error ? error.message : String(error)}`;\n      this.log.error(message, { to, directory: this.directory });\n      throw new SmsError(message, error instanceof Error ? error : undefined);\n    }\n  }\n\n  public createSmsText(options: { to: string; message: string }): string {\n    const { to, message } = options;\n    const timestamp = new Date().toISOString();\n\n    return `SMS Message\n===========\n\nSent: ${timestamp}\nTo: ${to}\n\nMessage:\n--------\n${message}\n`;\n  }\n}\n","import { $module } from \"alepha\";\nimport { $sms } from \"./descriptors/$sms.ts\";\nimport { LocalSmsProvider } from \"./providers/LocalSmsProvider.ts\";\nimport { MemorySmsProvider } from \"./providers/MemorySmsProvider.ts\";\nimport { SmsProvider } from \"./providers/SmsProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./descriptors/$sms.ts\";\nexport * from \"./errors/SmsError.ts\";\nexport * from \"./providers/LocalSmsProvider.ts\";\nexport * from \"./providers/MemorySmsProvider.ts\";\nexport * from \"./providers/SmsProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha\" {\n  interface Hooks {\n    \"sms:sending\": {\n      to: string | string[];\n      template: string;\n      variables: Record<string, unknown>;\n      provider: SmsProvider;\n      abort(): void;\n    };\n    \"sms:sent\": {\n      to: string | string[];\n      template: string;\n      provider: SmsProvider;\n    };\n  }\n}\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Provides SMS sending capabilities for Alepha applications with multiple provider backends.\n *\n * The SMS module enables declarative SMS sending through the `$sms` descriptor, allowing you to send\n * text messages through different providers: memory (for testing) or local file system.\n * It supports automatic provider selection based on environment configuration.\n *\n * @see {@link SmsProvider}\n * @module alepha.sms\n */\nexport const AlephaSms = $module({\n  name: \"alepha.sms\",\n  descriptors: [$sms],\n  services: [SmsProvider, MemorySmsProvider, LocalSmsProvider],\n  register: (alepha) =>\n    alepha.with({\n      optional: true,\n      provide: SmsProvider,\n      use: MemorySmsProvider,\n    }),\n});\n"],"mappings":"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"}

package/dist/sms/index.d.cts

@@ -1,130 +0,0 @@
-import * as alepha0 from "alepha";
-import { Descriptor, InstantiableClass, KIND } from "alepha";
-import * as alepha_logger0 from "alepha/logger";
-
-//#region src/sms/providers/SmsProvider.d.ts
-/**
- * SMS provider interface.
- *
- * All methods are asynchronous and return promises.
- */
-declare abstract class SmsProvider {
-  /**
-   * Send an SMS.
-   *
-   * @return Promise that resolves when the SMS is sent.
-   */
-  abstract send(options: SmsSendOptions): Promise<void>;
-}
-type SmsSendOptions = {
-  to: string | string[];
-  message: string;
-};
-//#endregion
-//#region src/sms/descriptors/$sms.d.ts
-declare const $sms: {
-  (options?: SmsDescriptorOptions): SmsDescriptor;
-  [KIND]: typeof SmsDescriptor;
-};
-interface SmsDescriptorOptions {
-  name?: string;
-  provider?: InstantiableClass<SmsProvider> | "memory";
-}
-/**
- * SMS descriptor for sending SMS messages through various providers.
- *
- * Usage:
- * ```typescript
- * class MyService {
- *   private readonly welcomeSms = $sms({ name: "welcome" });
- *
- *   async sendWelcome(phoneNumber: string, userName: string) {
- *     await this.welcomeSms.send({
- *       to: phoneNumber,
- *       message: `Hello ${userName}! Welcome to our service.`
- *     });
- *   }
- * }
- * ```
- */
-declare class SmsDescriptor extends Descriptor<SmsDescriptorOptions> {
-  protected readonly provider: SmsProvider;
-  get name(): string;
-  /**
-   * Send an SMS using the configured provider.
-   */
-  send(options: SmsSendOptions): Promise<void>;
-  protected $provider(): SmsProvider;
-}
-//#endregion
-//#region src/sms/errors/SmsError.d.ts
-declare class SmsError extends Error {
-  constructor(message: string, cause?: Error);
-}
-//#endregion
-//#region src/sms/providers/LocalSmsProvider.d.ts
-interface LocalSmsProviderOptions {
-  /**
-   * Directory to save SMS files.
-   * @default "node_modules/.sms" (relative to project root)
-   */
-  directory?: string;
-}
-declare class LocalSmsProvider implements SmsProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly directory: string;
-  constructor(options?: LocalSmsProviderOptions);
-  send(options: SmsSendOptions): Promise<void>;
-  createSmsText(options: {
-    to: string;
-    message: string;
-  }): string;
-}
-//#endregion
-//#region src/sms/providers/MemorySmsProvider.d.ts
-interface SmsRecord {
-  to: string;
-  message: string;
-  sentAt: Date;
-}
-declare class MemorySmsProvider implements SmsProvider {
-  protected readonly log: alepha_logger0.Logger;
-  records: SmsRecord[];
-  send(options: SmsSendOptions): Promise<void>;
-  /**
-   * Get the last SMS sent (for testing purposes).
-   */
-  get last(): SmsRecord | undefined;
-}
-//#endregion
-//#region src/sms/index.d.ts
-declare module "alepha" {
-  interface Hooks {
-    "sms:sending": {
-      to: string | string[];
-      template: string;
-      variables: Record<string, unknown>;
-      provider: SmsProvider;
-      abort(): void;
-    };
-    "sms:sent": {
-      to: string | string[];
-      template: string;
-      provider: SmsProvider;
-    };
-  }
-}
-/**
- * Provides SMS sending capabilities for Alepha applications with multiple provider backends.
- *
- * The SMS module enables declarative SMS sending through the `$sms` descriptor, allowing you to send
- * text messages through different providers: memory (for testing) or local file system.
- * It supports automatic provider selection based on environment configuration.
- *
- * @see {@link SmsProvider}
- * @module alepha.sms
- */
-declare const AlephaSms: alepha0.Service<alepha0.Module>;
-//#endregion
-export { $sms, AlephaSms, LocalSmsProvider, LocalSmsProviderOptions, MemorySmsProvider, SmsDescriptor, SmsDescriptorOptions, SmsError, SmsProvider, SmsRecord, SmsSendOptions };
-//# sourceMappingURL=index.d.cts.map