@facteurjs/core 1.0.0-beta.4 → 2.0.0-beta.0

package/dist/channels/twilio/index.d.ts

@@ -1,4 +0,0 @@
-import { TwilioMessage } from "./message.js";
-import { TwilioConfig, TwilioTargets } from "./types.js";
-import { TwilioChannel, twilioChannel } from "./channel.js";
-export { TwilioChannel, type TwilioConfig, TwilioMessage, type TwilioTargets, twilioChannel };

package/dist/channels/twilio/index.js

@@ -1,4 +0,0 @@
-import { TwilioMessage } from "./message.js";
-import { TwilioChannel, twilioChannel } from "./channel.js";
-
-export { TwilioChannel, TwilioMessage, twilioChannel };

package/dist/channels/webhook/index.d.ts

@@ -1,4 +0,0 @@
-import { WebhookMessage } from "./message.js";
-import { WebhookChannel, webhookChannel } from "./provider.js";
-import { WebhookRequestException, errors } from "./exceptions.js";
-export { WebhookChannel, WebhookMessage, WebhookRequestException, errors, webhookChannel };

package/dist/channels/webhook/index.js

@@ -1,5 +0,0 @@
-import { WebhookMessage } from "./message.js";
-import { WebhookRequestException, errors } from "./exceptions.js";
-import { WebhookChannel, webhookChannel } from "./provider.js";
-
-export { WebhookChannel, WebhookMessage, WebhookRequestException, errors, webhookChannel };

package/dist/channels/webpush/index.d.ts

@@ -1,3 +0,0 @@
-import { WebpushMessage } from "./message.js";
-import { WebpushChannel, webpushChannel } from "./channel.js";
-export { WebpushChannel, WebpushMessage, webpushChannel };

package/dist/channels/webpush/index.js

@@ -1,4 +0,0 @@
-import { WebpushMessage } from "./message.js";
-import { WebpushChannel, webpushChannel } from "./channel.js";
-
-export { WebpushChannel, WebpushMessage, webpushChannel };

package/dist/database/index.d.ts

@@ -1,3 +0,0 @@
-import { DatabaseMessage } from "./message.js";
-import { DatabaseChannel, databaseChannel } from "./channel.js";
-export { DatabaseChannel, DatabaseMessage, databaseChannel };

package/dist/database/index.js

@@ -1,4 +0,0 @@
-import { DatabaseMessage } from "./message.js";
-import { DatabaseChannel, databaseChannel } from "./channel.js";
-
-export { DatabaseChannel, DatabaseMessage, databaseChannel };

package/dist/facteur.d.ts

@@ -1,37 +0,0 @@
-import { DatabaseAdapter } from "./database/types.js";
-import { Channel } from "./types/channel.js";
-import { FacteurConfiguration, SendOptions } from "./types/options.js";
-import { Notification, NotificationClass, NotificationSendResult } from "./types/notifications.js";
-import { FacteurFake } from "./fake.js";
-import { FacteurDatabase } from "./database/database.js";
-
-//#region src/facteur.d.ts
-declare function createFacteur<T extends Record<string, Channel>>(config: FacteurConfiguration<T>): Facteur<T, null>;
-/**
- * Main manager class for Facteur library.
- */
-declare class Facteur<KnownChannels extends Record<string, Channel>, DBAdapter extends DatabaseAdapter | null = null> {
-  #private;
-  constructor(config: FacteurConfiguration<KnownChannels, DBAdapter>);
-  get db(): DBAdapter extends DatabaseAdapter ? FacteurDatabase : never;
-  get discoverer(): {
-    discoverNotifications: () => Promise<(new (...args: any[]) => Notification)[]>;
-    getNotifications: () => Promise<(new (...args: any[]) => Notification)[]>;
-    getNotificationTags: () => Promise<string[]>;
-    clearCache: () => void;
-  };
-  /**
-   * Fake the notification sending process for testing purposes
-   */
-  fake(): FacteurFake;
-  /**
-   * Restore the original notification sending process after faking it
-   */
-  restore(): void;
-  /**
-   * Send a notification
-   */
-  send<TNotificationClass extends NotificationClass<any, any>>(options: SendOptions<TNotificationClass>): Promise<NotificationSendResult>;
-}
-//#endregion
-export { Facteur, createFacteur };

package/dist/facteur.js

@@ -1,100 +0,0 @@
-import { FacteurFake } from "./fake.js";
-import { FacteurOptions } from "./options.js";
-import { FacteurDatabase } from "./database/database.js";
-import { ChannelResolver } from "./notifications/channel_resolver.js";
-import { NotificationSender } from "./notifications/notification_sender.js";
-import "./types/index.js";
-import { NotificationDiscoverer } from "./notifications/notification_discoverer.js";
-
-//#region src/facteur.ts
-function createFacteur(config) {
-	return new Facteur(config);
-}
-/**
-* Main manager class for Facteur library.
-*/
-var Facteur = class {
-	#sender;
-	#fake = null;
-	#db = null;
-	#discoverer;
-	#channelResolver;
-	#options;
-	constructor(config) {
-		this.#options = new FacteurOptions(config);
-		this.#discoverer = new NotificationDiscoverer({
-			searchDirectory: config.discoverer.searchDirectory,
-			fileSuffix: config.discoverer.fileSuffix
-		});
-		if (this.#options.databaseAdapter) {
-			const options = this.#options;
-			this.#db = new FacteurDatabase(options, this.#discoverer);
-			this.#channelResolver = new ChannelResolver(this.#db);
-		} else this.#channelResolver = new ChannelResolver();
-		this.#sender = new NotificationSender(this.#options.channels, this.#channelResolver, this.#options.emitter);
-	}
-	get db() {
-		if (!this.#options.databaseAdapter) throw new Error("No database adapter configured");
-		return this.#db;
-	}
-	get discoverer() {
-		return {
-			discoverNotifications: () => this.#discoverer.discoverNotifications(),
-			getNotifications: () => this.#discoverer.getNotifications(),
-			getNotificationTags: () => this.#discoverer.getAllNotificationTags(),
-			clearCache: () => this.#discoverer.clearCache()
-		};
-	}
-	/**
-	* Fake the notification sending process for testing purposes
-	*/
-	fake() {
-		this.#fake = new FacteurFake();
-		return this.#fake;
-	}
-	/**
-	* Restore the original notification sending process after faking it
-	*/
-	restore() {
-		this.#fake = null;
-	}
-	/**
-	* Send a notification
-	*/
-	async send(options) {
-		if ("via" in options && !("to" in options)) return this.#sendToSingle(options);
-		const optionsWithTo = options;
-		const recipients = Array.isArray(optionsWithTo.to) ? optionsWithTo.to : [optionsWithTo.to];
-		const results = await Promise.all(recipients.map((recipient) => this.#sendToSingle({
-			...optionsWithTo,
-			to: recipient
-		})));
-		return {
-			success: results.reduce((sum, result) => sum + result.success, 0),
-			failed: results.reduce((sum, result) => sum + result.failed, 0),
-			results: results.flatMap((result) => result.results)
-		};
-	}
-	/**
-	* Send notification to a single recipient
-	*/
-	async #sendToSingle(options) {
-		const notification = await this.#options.notificationResolver(options.notification, {
-			to: "to" in options ? options.to : void 0,
-			params: options.params,
-			tenantId: options.tenantId
-		});
-		await notification.beforeSend();
-		const shouldSend = await notification.shouldSend();
-		if (shouldSend === false) return {
-			success: 0,
-			failed: 0,
-			results: []
-		};
-		if (this.#fake) return this.#fake.recordSent(options);
-		return this.#sender.send(options, notification);
-	}
-};
-
-//#endregion
-export { Facteur, createFacteur };

package/dist/notifications/notification_sender.js

@@ -1,211 +0,0 @@
-import { errors } from "../errors/index.js";
-import debug_default from "../debug.js";
-import { facteurEvents } from "../events/events.js";
-import "./channel_resolver.js";
-import { capitalizeFirstLetter } from "../helpers.js";
-
-//#region src/notifications/notification_sender.ts
-/**
-* Responsible for sending notifications and messages
-*/
-var NotificationSender = class {
-	constructor(channels, channelResolver, emitter) {
-		this.channels = channels;
-		this.channelResolver = channelResolver;
-		this.emitter = emitter;
-	}
-	/**
-	* Emit notification sending event
-	*/
-	#emitNotificationSending(notification, resolvedChannels) {
-		const event = facteurEvents.notificationSending({
-			notification,
-			resolvedChannels
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Emit notification sent event
-	*/
-	#emitNotificationSent(notification, results) {
-		const event = facteurEvents.notificationSent({
-			notification,
-			results
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Emit notification failed event
-	*/
-	#emitNotificationFailed(notification, errors$1) {
-		const event = facteurEvents.notificationFailed({
-			notification,
-			errors: errors$1
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Emit message sending event
-	*/
-	#emitMessageSending(notification, channelName, message) {
-		const event = facteurEvents.messageSending({
-			notification,
-			channelName,
-			message
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Emit message sent event
-	*/
-	#emitMessageSent(notification, channelName, message) {
-		const event = facteurEvents.messageSent({
-			notification,
-			channelName,
-			message
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Emit message failed event
-	*/
-	#emitMessageFailed(notification, channelName, message, error) {
-		const event = facteurEvents.messageFailed({
-			notification,
-			channelName,
-			message,
-			error
-		});
-		this.emitter.emit(event.name, event.data);
-	}
-	/**
-	* Get a channel by its name
-	*/
-	#getChannel(channelName) {
-		const channel = this.channels[channelName];
-		if (!channel) throw new Error(`Channel '${channelName}' is not registered`);
-		return channel;
-	}
-	/**
-	* Send a single message through a specific channel
-	*/
-	async #sendMessage(options) {
-		const { channelName, options: sendOptions, channelConfig } = options;
-		/**
-		* First build the message content using the notification's
-		* `as<ChannelName>Message` method
-		*/
-		const channel = this.#getChannel(channelName);
-		const capitalizedChannelName = capitalizeFirstLetter(channelName);
-		const channelMethodName = `as${capitalizedChannelName}Message`;
-		const messageBuilder = options.notification[channelMethodName];
-		if (typeof messageBuilder !== "function") throw new errors.E_MISSING_MESSAGE_METHOD([capitalizedChannelName]);
-		const messageContent = messageBuilder.call(options.notification, {
-			to: sendOptions.to,
-			params: sendOptions.params,
-			tenantId: sendOptions.tenantId
-		});
-		if (!messageContent) return null;
-		/**
-		* Send the message and emit appropriate events
-		*/
-		debug_default(`Sending message via ${channelName}: %O`, messageContent);
-		this.#emitMessageSending(options.notification, channelName, messageContent);
-		try {
-			await channel.send({
-				tenantId: sendOptions.tenantId,
-				message: messageContent,
-				targets: channelConfig.target,
-				to: sendOptions.to
-			});
-			debug_default(`Message sent via ${channelName}`);
-			this.#emitMessageSent(options.notification, channelName, messageContent);
-			return {
-				channel: channelName,
-				status: "success"
-			};
-		} catch (error) {
-			this.#emitMessageFailed(options.notification, channelName, messageContent, error);
-			throw error;
-		}
-	}
-	/**
-	* Process results from sending messages and emit appropriate events
-	*/
-	async #processResults(options) {
-		const { results, throwOnError, notification } = options;
-		const channelResults = results.filter((result) => result !== null);
-		const successes = channelResults.filter((r) => r.status === "success");
-		const failures = channelResults.filter((r) => r.status === "failed");
-		/**
-		* Everything succeeded
-		*/
-		if (!failures.length) {
-			this.#emitNotificationSent(notification, channelResults);
-			await notification.afterSend();
-			return {
-				failed: failures.length,
-				success: successes.length,
-				results: channelResults
-			};
-		}
-		/**
-		* Some channels failed
-		*/
-		const failureReasons = failures.map((r) => r.error);
-		this.#emitNotificationFailed(notification, failureReasons);
-		await notification.afterSend();
-		if (throwOnError !== false) throw new errors.E_SEND_NOTIFICATION_FAILED(failureReasons);
-		return {
-			failed: failures.length,
-			success: successes.length,
-			results: channelResults
-		};
-	}
-	/**
-	* Send a notification through all resolved channels
-	*/
-	async send(options, notification) {
-		const { via, params, tenantId } = options;
-		const to = "to" in options ? options.to : void 0;
-		const resolvedChannels = await this.channelResolver.resolveChannels({
-			to,
-			params,
-			tenantId,
-			notification: options.notification,
-			...via ? { via } : {}
-		});
-		debug_default(`Resolved channels: %O`, resolvedChannels);
-		this.#emitNotificationSending(notification, resolvedChannels);
-		/**
-		* Send messages for each resolved channel
-		*/
-		const promises = Object.entries(resolvedChannels).map(async ([name, config]) => {
-			if (!config.shouldSend || !config.target) return null;
-			return await this.#sendMessage({
-				notification,
-				channelConfig: config,
-				channelName: name,
-				options
-			}).catch((error) => {
-				debug_default(`Failed to send notification via ${name}: %O`, error);
-				return {
-					channel: name,
-					status: "failed",
-					error
-				};
-			});
-		});
-		/**
-		* Process results and emit appropriate events
-		*/
-		return await this.#processResults({
-			notification,
-			results: await Promise.all(promises),
-			throwOnError: options.throwOnError !== false
-		});
-	}
-};
-
-//#endregion
-export { NotificationSender };

package/dist/types/channel.d.ts

@@ -1,18 +0,0 @@
-import { Identifier } from "../database/types.js";
-import { Awaitable } from "@julr/utils/types";
-
-//#region src/types/channel.d.ts
-type ChannelSendParams<Message, Targets> = {
-  to?: any;
-  message: Message;
-  targets?: Targets;
-  tenantId?: Identifier | undefined;
-};
-declare const kTargetSymbol: unique symbol;
-interface Channel<_Options = any, Message = any, Response = any, Targets = any> {
-  [kTargetSymbol]: Targets;
-  name: string;
-  send: (options: ChannelSendParams<Message, Targets>) => Awaitable<Response>;
-}
-//#endregion
-export { Channel, ChannelSendParams, kTargetSymbol };

package/dist/types/index.d.ts

@@ -1,8 +0,0 @@
-import { Channel, ChannelSendParams, kTargetSymbol } from "./channel.js";
-import { Emitter, FacteurEvents } from "./events.js";
-import { QueueAdapter, QueueItemOptions } from "./queue.js";
-import { DefaultPreferences, ResolvedDefaultPreferences } from "./preferences.js";
-import { ChannelName, DatabaseContent, InferChannelsFromConfig, NotificationChannels } from "./extend.js";
-import { Arrayable, ChannelSpecificConfig, CommonSendOptions, DeliverByOptions, ExtractChannelTargets, ExtractNotifiable, ExtractParams, FacteurConfiguration, MessageCtx, NotificationOptions, NotificationParams, NotificationResolver, ProviderTarget, SendOptions } from "./options.js";
-import { ChannelSendResult, Notifiable, NotifiableTargets, Notification, NotificationClass, NotificationSendResult } from "./notifications.js";
-export { Arrayable, Channel, ChannelName, ChannelSendParams, ChannelSendResult, ChannelSpecificConfig, CommonSendOptions, DatabaseContent, DefaultPreferences, DeliverByOptions, Emitter, ExtractChannelTargets, ExtractNotifiable, ExtractParams, FacteurConfiguration, FacteurEvents, InferChannelsFromConfig, MessageCtx, Notifiable, NotifiableTargets, Notification, NotificationChannels, NotificationClass, NotificationOptions, NotificationParams, NotificationResolver, NotificationSendResult, ProviderTarget, QueueAdapter, QueueItemOptions, ResolvedDefaultPreferences, SendOptions, kTargetSymbol };

package/dist/types/index.js

@@ -1,4 +0,0 @@
-import { kTargetSymbol } from "./channel.js";
-import { Notification } from "./notifications.js";
-
-export { Notification, kTargetSymbol };