@facteurjs/core 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/channels/aws-sns/channel.d.ts

@@ -0,0 +1,21 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { AwsSnsMessage } from "./message.js";
+import { AwsSnsConfig, AwsSnsTargets } from "./types.js";
+
+//#region src/channels/aws-sns/channel.d.ts
+declare function awsSnsChannel(config: AwsSnsConfig): AwsSnsChannel;
+declare class AwsSnsChannel implements Channel<AwsSnsConfig, AwsSnsMessage, any, AwsSnsTargets> {
+  #private;
+  private config;
+  name: "awsSns";
+  [kTargetSymbol]: AwsSnsTargets;
+  constructor(config: AwsSnsConfig);
+  send(options: ChannelSendParams<AwsSnsMessage, AwsSnsTargets>): Promise<void>;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asAwsSnsMessage(): AwsSnsMessage;
+  }
+}
+//#endregion
+export { AwsSnsChannel, awsSnsChannel };

package/dist/channels/aws-sns/channel.js

@@ -0,0 +1,42 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+import { PublishCommand, SNSClient } from "@aws-sdk/client-sns";
+
+//#region src/channels/aws-sns/channel.ts
+function awsSnsChannel(config) {
+	return new AwsSnsChannel(config);
+}
+var AwsSnsChannel = class {
+	name = "awsSns";
+	[kTargetSymbol] = null;
+	#client;
+	constructor(config) {
+		this.config = config;
+		this.#client = new SNSClient({
+			region: this.config.region,
+			credentials: {
+				accessKeyId: this.config.accessKeyId,
+				secretAccessKey: this.config.secretAccessKey,
+				...this.config.sessionToken && { sessionToken: this.config.sessionToken }
+			}
+		});
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS(["AWS SNS"]);
+	}
+	async send(options) {
+		const message = options.message;
+		const targets = this.#resolveTargets(options);
+		const messageData = message.serialize();
+		const command = new PublishCommand({
+			PhoneNumber: targets.to,
+			Message: messageData.Message
+		});
+		await this.#client.send(command);
+	}
+};
+
+//#endregion
+export { AwsSnsChannel, awsSnsChannel };

package/dist/channels/aws-sns/index.d.ts

@@ -0,0 +1,3 @@
+import { AwsSnsMessage } from "./message.js";
+import { AwsSnsChannel, awsSnsChannel } from "./channel.js";
+export { AwsSnsChannel, AwsSnsMessage, awsSnsChannel };

package/dist/channels/aws-sns/index.js

@@ -0,0 +1,4 @@
+import { AwsSnsMessage } from "./message.js";
+import { AwsSnsChannel, awsSnsChannel } from "./channel.js";
+
+export { AwsSnsChannel, AwsSnsMessage, awsSnsChannel };

package/dist/channels/aws-sns/message.d.ts

@@ -0,0 +1,23 @@
+//#region src/channels/aws-sns/message.d.ts
+/**
+ * AWS SNS SMS message
+ */
+declare class AwsSnsMessage {
+  #private;
+  /**
+   * Creates a new instance of AwsSnsMessage
+   */
+  static create(): AwsSnsMessage;
+  /**
+   * Set the message content
+   */
+  setMessage(message: string): this;
+  /**
+   * Serialize the message to AWS SNS format
+   */
+  serialize(): {
+    Message: string;
+  };
+}
+//#endregion
+export { AwsSnsMessage };

package/dist/channels/aws-sns/message.js

@@ -0,0 +1,29 @@
+//#region src/channels/aws-sns/message.ts
+/**
+* AWS SNS SMS message
+*/
+var AwsSnsMessage = class AwsSnsMessage {
+	#message = "";
+	/**
+	* Creates a new instance of AwsSnsMessage
+	*/
+	static create() {
+		return new AwsSnsMessage();
+	}
+	/**
+	* Set the message content
+	*/
+	setMessage(message) {
+		this.#message = message;
+		return this;
+	}
+	/**
+	* Serialize the message to AWS SNS format
+	*/
+	serialize() {
+		return { Message: this.#message };
+	}
+};
+
+//#endregion
+export { AwsSnsMessage };

package/dist/channels/aws-sns/types.d.ts

@@ -0,0 +1,35 @@
+//#region src/channels/aws-sns/types.d.ts
+/**
+ * Configuration for AWS SNS SMS channel
+ */
+interface AwsSnsConfig {
+  region: string;
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+}
+/**
+ * SMS message data for AWS SNS
+ */
+interface AwsSnsSmsData {
+  to: string;
+  content: string;
+}
+/**
+ * AWS SNS targets
+ */
+interface AwsSnsTargets {
+  to: string;
+}
+interface AwsSnsTargets {
+  /**
+   * The phone number to send the SMS to (in E.164 format)
+   */
+  to: string;
+  /**
+   * Override the sender ID for this specific message
+   */
+  senderId?: string;
+}
+//#endregion
+export { AwsSnsConfig, AwsSnsSmsData, AwsSnsTargets };

package/dist/channels/expo/channel.d.ts

@@ -0,0 +1,23 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { ExpoMessage } from "./message.js";
+import { ExpoConfig, ExpoTargets } from "./types.js";
+
+//#region src/channels/expo/channel.d.ts
+declare function expoChannel(config?: ExpoConfig): ExpoChannel;
+declare class ExpoChannel implements Channel<ExpoConfig, ExpoMessage, any, ExpoTargets> {
+  #private;
+  name: "expo";
+  [kTargetSymbol]: ExpoTargets;
+  constructor(config: ExpoConfig);
+  send(options: ChannelSendParams<ExpoMessage, ExpoTargets>): Promise<{
+    id: string;
+    status: "ok";
+  }>;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asExpoMessage(): ExpoMessage;
+  }
+}
+//#endregion
+export { ExpoChannel, expoChannel };

package/dist/channels/expo/channel.js

@@ -0,0 +1,38 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+import { Expo } from "expo-server-sdk";
+
+//#region src/channels/expo/channel.ts
+function expoChannel(config = {}) {
+	return new ExpoChannel(config);
+}
+var ExpoChannel = class {
+	name = "expo";
+	[kTargetSymbol] = null;
+	#expo;
+	constructor(config) {
+		this.#expo = new Expo(config);
+		if (config.accessToken) this.#validateExpoToken(config.accessToken);
+	}
+	#validateExpoToken(token) {
+		if (!Expo.isExpoPushToken(token)) throw new Error(`Invalid Expo push token: ${token}`);
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS(["Expo"]);
+	}
+	async send(options) {
+		const targets = this.#resolveTargets(options);
+		const message = options.message.serialize({ to: targets.expoToken });
+		const [ticket] = await this.#expo.sendPushNotificationsAsync([message]);
+		if (ticket?.status === "error") throw new Error(`Expo push notification failed: ${ticket.message}`);
+		return {
+			id: ticket?.id,
+			status: ticket?.status
+		};
+	}
+};
+
+//#endregion
+export { ExpoChannel, expoChannel };

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

@@ -0,0 +1,3 @@
+import { ExpoMessage } from "./message.js";
+import { ExpoChannel, expoChannel } from "./channel.js";
+export { ExpoChannel, ExpoMessage, expoChannel };

package/dist/channels/expo/index.js

@@ -0,0 +1,4 @@
+import { ExpoMessage } from "./message.js";
+import { ExpoChannel, expoChannel } from "./channel.js";
+
+export { ExpoChannel, ExpoMessage, expoChannel };

package/dist/channels/expo/message.d.ts

@@ -0,0 +1,70 @@
+import { ExpoPushMessage } from "expo-server-sdk";
+
+//#region src/channels/expo/message.d.ts
+
+/**
+ * Expo push notification message
+ */
+declare class ExpoMessage {
+  #private;
+  /**
+   * Creates a new instance of ExpoMessage
+   */
+  static create(): ExpoMessage;
+  /**
+   * Set the notification title
+   */
+  setTitle(title: string): this;
+  /**
+   * Set the notification body
+   */
+  setBody(body: string): this;
+  /**
+   * Set additional data payload
+   */
+  setData(data: any): this;
+  /**
+   * Set the sound to play. Use 'default' for default sound
+   */
+  setSound(sound: string): this;
+  /**
+   * Set the badge number for iOS
+   */
+  setBadge(badge: number): this;
+  /**
+   * Set the notification channel ID for Android
+   */
+  setChannelId(channelId: string): this;
+  /**
+   * Set the notification category ID
+   */
+  setCategoryId(categoryId: string): this;
+  /**
+   * Set the subtitle (iOS only)
+   */
+  setSubtitle(subtitle: string): this;
+  /**
+   * Set the delivery priority
+   */
+  setPriority(priority: 'default' | 'normal' | 'high'): this;
+  /**
+   * Set time to live in seconds
+   */
+  setTtl(ttl: number): this;
+  /**
+   * Set expiration timestamp
+   */
+  setExpiration(expiration: number): this;
+  /**
+   * Set whether notification can be intercepted by client app (iOS only)
+   */
+  setMutableContent(mutableContent: boolean): this;
+  /**
+   * Serialize the message to Expo format
+   */
+  serialize(options: {
+    to: string;
+  }): ExpoPushMessage;
+}
+//#endregion
+export { ExpoMessage };

package/dist/channels/expo/message.js

@@ -0,0 +1,130 @@
+//#region src/channels/expo/message.ts
+/**
+* Expo push notification message
+*/
+var ExpoMessage = class ExpoMessage {
+	#title;
+	#body;
+	#data;
+	#sound;
+	#badge;
+	#channelId;
+	#categoryId;
+	#subtitle;
+	#priority = "default";
+	#ttl;
+	#expiration;
+	#mutableContent;
+	/**
+	* Creates a new instance of ExpoMessage
+	*/
+	static create() {
+		return new ExpoMessage();
+	}
+	/**
+	* Set the notification title
+	*/
+	setTitle(title) {
+		this.#title = title;
+		return this;
+	}
+	/**
+	* Set the notification body
+	*/
+	setBody(body) {
+		this.#body = body;
+		return this;
+	}
+	/**
+	* Set additional data payload
+	*/
+	setData(data) {
+		this.#data = data;
+		return this;
+	}
+	/**
+	* Set the sound to play. Use 'default' for default sound
+	*/
+	setSound(sound) {
+		this.#sound = sound;
+		return this;
+	}
+	/**
+	* Set the badge number for iOS
+	*/
+	setBadge(badge) {
+		this.#badge = badge;
+		return this;
+	}
+	/**
+	* Set the notification channel ID for Android
+	*/
+	setChannelId(channelId) {
+		this.#channelId = channelId;
+		return this;
+	}
+	/**
+	* Set the notification category ID
+	*/
+	setCategoryId(categoryId) {
+		this.#categoryId = categoryId;
+		return this;
+	}
+	/**
+	* Set the subtitle (iOS only)
+	*/
+	setSubtitle(subtitle) {
+		this.#subtitle = subtitle;
+		return this;
+	}
+	/**
+	* Set the delivery priority
+	*/
+	setPriority(priority) {
+		this.#priority = priority;
+		return this;
+	}
+	/**
+	* Set time to live in seconds
+	*/
+	setTtl(ttl) {
+		this.#ttl = ttl;
+		return this;
+	}
+	/**
+	* Set expiration timestamp
+	*/
+	setExpiration(expiration) {
+		this.#expiration = expiration;
+		return this;
+	}
+	/**
+	* Set whether notification can be intercepted by client app (iOS only)
+	*/
+	setMutableContent(mutableContent) {
+		this.#mutableContent = mutableContent;
+		return this;
+	}
+	/**
+	* Serialize the message to Expo format
+	*/
+	serialize(options) {
+		const message = { to: options.to };
+		if (this.#title) message.title = this.#title;
+		if (this.#body) message.body = this.#body;
+		if (this.#data !== void 0) message.data = this.#data;
+		if (this.#sound) message.sound = this.#sound;
+		if (this.#badge !== void 0) message.badge = this.#badge;
+		if (this.#channelId) message.channelId = this.#channelId;
+		if (this.#categoryId) message.categoryId = this.#categoryId;
+		if (this.#subtitle) message.subtitle = this.#subtitle;
+		if (this.#priority !== "default") message.priority = this.#priority;
+		if (this.#ttl !== void 0) message.ttl = this.#ttl;
+		if (this.#expiration !== void 0) message.expiration = this.#expiration;
+		if (this.#mutableContent !== void 0) message.mutableContent = this.#mutableContent;
+		return message;
+	}
+};
+
+//#endregion
+export { ExpoMessage };

package/dist/channels/expo/types.d.ts

@@ -0,0 +1,9 @@
+import { ExpoClientOptions } from "expo-server-sdk";
+
+//#region src/channels/expo/types.d.ts
+interface ExpoConfig extends Partial<ExpoClientOptions> {}
+interface ExpoTargets {
+  expoToken: string;
+}
+//#endregion
+export { ExpoConfig, ExpoTargets };

package/dist/channels/socketio/channel.d.ts

@@ -0,0 +1,23 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { SocketIoMessage } from "./message.js";
+import { SocketIOConfig, SocketIOTargets } from "./types.js";
+import { Server } from "socket.io";
+
+//#region src/channels/socketio/channel.d.ts
+declare function socketIoChannel(config: SocketIOConfig): SocketIOChannel;
+declare class SocketIOChannel implements Channel<SocketIOConfig, SocketIoMessage, any, SocketIOTargets> {
+  #private;
+  private config;
+  name: "socketIo";
+  [kTargetSymbol]: SocketIOTargets;
+  protected server: () => Server;
+  constructor(config: SocketIOConfig);
+  send(options: ChannelSendParams<SocketIoMessage, SocketIOTargets>): Promise<void>;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asSocketIoMessage(): SocketIoMessage;
+  }
+}
+//#endregion
+export { SocketIOChannel, socketIoChannel };

package/dist/channels/socketio/channel.js

@@ -0,0 +1,29 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+
+//#region src/channels/socketio/channel.ts
+function socketIoChannel(config) {
+	return new SocketIOChannel(config);
+}
+var SocketIOChannel = class {
+	name = "socketIo";
+	[kTargetSymbol] = null;
+	server;
+	constructor(config) {
+		this.config = config;
+		this.server = typeof this.config.server === "function" ? this.config.server : () => this.config.server;
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS(["SocketIO"]);
+	}
+	async send(options) {
+		const message = options.message.serialize();
+		const targets = this.#resolveTargets(options);
+		this.server().of(targets.namespace || "/").emit(targets.event, message.data);
+	}
+};
+
+//#endregion
+export { SocketIOChannel, socketIoChannel };

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

@@ -0,0 +1,3 @@
+import { SocketIoMessage } from "./message.js";
+import { SocketIOChannel, socketIoChannel } from "./channel.js";
+export { SocketIOChannel, SocketIoMessage, socketIoChannel };

package/dist/channels/socketio/index.js

@@ -0,0 +1,4 @@
+import { SocketIoMessage } from "./message.js";
+import { SocketIOChannel, socketIoChannel } from "./channel.js";
+
+export { SocketIOChannel, SocketIoMessage, socketIoChannel };

package/dist/channels/socketio/message.d.ts

@@ -0,0 +1,11 @@
+//#region src/channels/socketio/message.d.ts
+declare class SocketIoMessage {
+  #private;
+  static create(): SocketIoMessage;
+  setData(data: Record<string, any>): this;
+  serialize(): {
+    data: Record<string, any>;
+  };
+}
+//#endregion
+export { SocketIoMessage };

package/dist/channels/socketio/message.js

@@ -0,0 +1,17 @@
+//#region src/channels/socketio/message.ts
+var SocketIoMessage = class SocketIoMessage {
+	#data = {};
+	static create() {
+		return new SocketIoMessage();
+	}
+	setData(data) {
+		this.#data = data;
+		return this;
+	}
+	serialize() {
+		return { data: this.#data };
+	}
+};
+
+//#endregion
+export { SocketIoMessage };

package/dist/channels/socketio/types.d.ts

@@ -0,0 +1,21 @@
+import { Server } from "socket.io";
+
+//#region src/channels/socketio/types.d.ts
+interface SocketIOTargets {
+  /**
+   * Namespace to emit the event to
+   */
+  namespace?: string;
+  /**
+   * Event to emit
+   */
+  event: string;
+}
+interface SocketIOConfig {
+  /**
+   * Socket.IO server instance. Can be a function that will be resolved when needed
+   */
+  server: Server | (() => Server);
+}
+//#endregion
+export { SocketIOConfig, SocketIOTargets };

package/dist/facteur.js

@@ -62,8 +62,25 @@ var Facteur = class {
 	* 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, {
-			notifiable: "notifiable" in options ? options.notifiable : void 0,
+			to: "to" in options ? options.to : void 0,
 			params: options.params,
 			tenantId: options.tenantId
 		});

package/dist/fake.d.ts

@@ -4,7 +4,7 @@ import { Notification, NotificationSendResult } from "./types/notifications.js";
 //#region src/fake.d.ts
 interface SentNotification<N extends Notification = Notification> {
   notification: N;
-  notifiable: N extends Notification<infer TNotifiable, any> ? TNotifiable : never;
+  to: N extends Notification<infer TNotifiable, any> ? TNotifiable : never;
   params?: N extends Notification<any, infer P> ? P : never;
   via?: any;
 }

package/dist/fake.js

@@ -7,10 +7,14 @@ var FacteurFake = class {
 	* Record a notification as sent during fake mode
 	*/
 	recordSent(options) {
-		const notification = new options.notification();
+		const notification = new options.notification({
+			to: options.to,
+			params: options.params,
+			tenantId: options.tenantId
+		});
 		this.#sentNotifications.push({
 			notification,
-			notifiable: options.notifiable,
+			to: options.to,
 			params: options.params,
 			via: options.via
 		});

package/dist/helpers.js

@@ -0,0 +1,8 @@
+//#region src/helpers.ts
+function capitalizeFirstLetter(str) {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+//#endregion
+export { capitalizeFirstLetter };

package/dist/notifications/channel_resolver.js

@@ -12,7 +12,7 @@ var ChannelResolver = class {
 	* Resolve channels and targets provided by via
 	*/
 	#resolveVia(options) {
-		const notifiableTargets = options.notifiable?.notificationTargets?.();
+		const notifiableTargets = options.to?.notificationTargets?.();
 		return mapEntries(options.via, (channelName, channelConfig) => {
 			const shouldSend = typeof channelConfig === "boolean" ? channelConfig : true;
 			const target = invoke(() => {
@@ -26,10 +26,10 @@ var ChannelResolver = class {
 		});
 	}
 	async resolveChannels(options) {
-		const { notification, notifiable, params, via, tenantId } = options;
+		const { notification, to, params, via, tenantId } = options;
 		const notificationOptions = notification.options;
 		const notificationIdentifier = notificationOptions.identifier || notification.name;
-		const notifiableTargets = options.notifiable?.notificationTargets?.();
+		const notifiableTargets = options.to?.notificationTargets?.();
 		/**
 		* First, if via is provided it should override everything.
 		*/
@@ -38,7 +38,7 @@ var ChannelResolver = class {
 		* Get preferences for the notifiable and tenant
 		*/
 		const preferences = await this.#database?.getPreferences({
-			notifiableId: notifiable.id,
+			notifiableId: to.id,
 			tenantId
 		});
 		/**
@@ -48,7 +48,7 @@ var ChannelResolver = class {
 			const shouldSend = invoke(() => {
 				if (typeof deliverBy === "boolean") return deliverBy;
 				return deliverBy.if({
-					notifiable,
+					to,
 					params,
 					preferences
 				});

package/dist/notifications/notification_sender.js

@@ -2,7 +2,7 @@ import { errors } from "../errors/index.js";
 import debug_default from "../debug.js";
 import { facteurEvents } from "../events/events.js";
 import "./channel_resolver.js";
-import { capitalize } from "@julr/utils/string";
+import { capitalizeFirstLetter } from "../helpers.js";
 
 //#region src/notifications/notification_sender.ts
 /**
@@ -96,11 +96,12 @@ var NotificationSender = class {
 		* `as<ChannelName>Message` method
 		*/
 		const channel = this.#getChannel(channelName);
-		const channelMethodName = `as${capitalize(channelName)}Message`;
+		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([capitalize(channelName)]);
+		if (typeof messageBuilder !== "function") throw new errors.E_MISSING_MESSAGE_METHOD([capitalizedChannelName]);
 		const messageContent = messageBuilder.call(options.notification, {
-			notifiable: sendOptions.notifiable,
+			to: sendOptions.to,
 			params: sendOptions.params,
 			tenantId: sendOptions.tenantId
 		});
@@ -115,7 +116,7 @@ var NotificationSender = class {
 				tenantId: sendOptions.tenantId,
 				message: messageContent,
 				targets: channelConfig.target,
-				notifiable: sendOptions.notifiable
+				to: sendOptions.to
 			});
 			debug_default(`Message sent via ${channelName}`);
 			this.#emitMessageSent(options.notification, channelName, messageContent);
@@ -166,9 +167,9 @@ var NotificationSender = class {
 	*/
 	async send(options, notification) {
 		const { via, params, tenantId } = options;
-		const notifiable = "notifiable" in options ? options.notifiable : void 0;
+		const to = "to" in options ? options.to : void 0;
 		const resolvedChannels = await this.channelResolver.resolveChannels({
-			notifiable,
+			to,
 			params,
 			tenantId,
 			notification: options.notification,

package/dist/types/channel.d.ts

@@ -3,7 +3,7 @@ import { Awaitable } from "@julr/utils/types";
 
 //#region src/types/channel.d.ts
 type ChannelSendParams<Message, Targets> = {
-  notifiable?: any;
+  to?: any;
   message: Message;
   targets?: Targets;
   tenantId?: Identifier | undefined;

package/dist/types/index.d.ts

@@ -3,6 +3,6 @@ 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 { ChannelSpecificConfig, CommonSendOptions, DeliverByOptions, ExtractChannelTargets, ExtractNotifiable, ExtractParams, FacteurConfiguration, MessageCtx, NotificationOptions, NotificationParams, NotificationResolver, ProviderTarget, SendOptions } from "./options.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 { 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 };
+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/notifications.js

@@ -7,7 +7,7 @@ var Notification = class {
 	params;
 	tenantId;
 	constructor(ctx) {
-		this.notifiable = ctx.notifiable;
+		this.notifiable = ctx.to;
 		this.params = ctx.params;
 		this.tenantId = ctx.tenantId;
 	}

package/dist/types/options.d.ts

@@ -10,6 +10,10 @@ import { Awaitable } from "@julr/utils/types";
 
 //#region src/types/options.d.ts
 
+/**
+ * Type for values that can be a single item or an array of items
+ */
+type Arrayable<T> = T | T[];
 /**
  * Configuration options for the Facteur library
  */
@@ -92,7 +96,7 @@ interface NotificationOptions<N extends Notifiable = Notifiable> {
 }
 interface DeliverByOptions<N extends Notifiable = Notifiable> {
   if: (options: {
-    notifiable: N;
+    to: N;
     params?: any;
     preferences?: Record<string, boolean | undefined>;
   }) => boolean;
@@ -101,7 +105,7 @@ interface DeliverByOptions<N extends Notifiable = Notifiable> {
  * Parameters received by the `as*Message` methods of a notification.
  */
 interface MessageCtx<N extends Notifiable | undefined = Notifiable, Params extends Record<string, any> = {}> {
-  notifiable: N;
+  to: N;
   params: Params;
   tenantId?: Identifier | undefined;
 }
@@ -146,7 +150,7 @@ type SendOptions<TNotificationClass extends NotificationClass<any, any>> = IsAno
   tenantId?: Identifier;
 } : CommonSendOptions<TNotificationClass> & {
   notification: TNotificationClass;
-  notifiable: NonNullable<ExtractNotifiable<TNotificationClass>>;
+  to: Arrayable<NonNullable<ExtractNotifiable<TNotificationClass>>>;
   via?: ChannelSpecificConfig<ExtractNotifiable<TNotificationClass>>;
   tenantId?: Identifier;
 };
@@ -154,4 +158,4 @@ type ChannelSpecificConfig<N extends Notifiable> = { [K in ChannelName]?: boolea
 type ExtractChannelTargets<T> = T extends Channel<any, any, any, infer U> ? U : never;
 type ProviderTarget<_N extends Notifiable, K extends ChannelName> = ExtractChannelTargets<NotificationChannels[K]>;
 //#endregion
-export { ChannelSpecificConfig, CommonSendOptions, DeliverByOptions, ExtractChannelTargets, ExtractNotifiable, ExtractParams, FacteurConfiguration, MessageCtx, NotificationOptions, NotificationParams, NotificationResolver, ProviderTarget, SendOptions };
+export { Arrayable, ChannelSpecificConfig, CommonSendOptions, DeliverByOptions, ExtractChannelTargets, ExtractNotifiable, ExtractParams, FacteurConfiguration, MessageCtx, NotificationOptions, NotificationParams, NotificationResolver, ProviderTarget, SendOptions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@facteurjs/core",
   "type": "module",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "Core package for facteur",
   "author": "Julien Ripouteau <julien@ripouteau.com>",
   "license": "ISC",
@@ -13,12 +13,18 @@
     ".": "./dist/index.js",
     "./api": "./dist/api/index.js",
     "./api/types": "./dist/api/types.js",
+    "./channels/aws-sns": "./dist/channels/aws-sns/index.js",
+    "./channels/aws-sns/types": "./dist/channels/aws-sns/types.js",
     "./channels/discord": "./dist/channels/discord/index.js",
     "./channels/discord/types": "./dist/channels/discord/types.js",
+    "./channels/expo": "./dist/channels/expo/index.js",
+    "./channels/expo/types": "./dist/channels/expo/types.js",
     "./channels/fcm": "./dist/channels/fcm/index.js",
     "./channels/fcm/types": "./dist/channels/fcm/types.js",
     "./channels/slack": "./dist/channels/slack/index.js",
     "./channels/slack/types": "./dist/channels/slack/types.js",
+    "./channels/socketio": "./dist/channels/socketio/index.js",
+    "./channels/socketio/types": "./dist/channels/socketio/types.js",
     "./channels/transmit": "./dist/channels/transmit/index.js",
     "./channels/transmit/types": "./dist/channels/transmit/types.js",
     "./channels/twilio": "./dist/channels/twilio/index.js",
@@ -42,13 +48,56 @@
     "@poppinss/exception": "^1.2.2",
     "ky": "^1.8.2"
   },
+  "peerDependencies": {
+    "@aws-sdk/client-sns": "^3.856.0",
+    "@boringnode/transmit": "^0.3.0",
+    "expo-server-sdk": "^3.15.0",
+    "firebase-admin": "^13.4.0",
+    "knex": "^3.1.0",
+    "kysely": "^0.28.3",
+    "socket.io": "^4.8.1",
+    "twilio": "^5.8.0",
+    "web-push": "^3.6.7"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-sns": {
+      "optional": true
+    },
+    "@boringnode/transmit": {
+      "optional": true
+    },
+    "expo-server-sdk": {
+      "optional": true
+    },
+    "firebase-admin": {
+      "optional": true
+    },
+    "knex": {
+      "optional": true
+    },
+    "kysely": {
+      "optional": true
+    },
+    "socket.io": {
+      "optional": true
+    },
+    "twilio": {
+      "optional": true
+    },
+    "web-push": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@aws-sdk/client-sns": "^3.856.0",
     "@boringnode/transmit": "^0.3.0",
     "@types/web-push": "^3.6.4",
+    "expo-server-sdk": "^3.15.0",
     "firebase-admin": "^13.4.0",
     "knex": "^3.1.0",
     "kysely": "^0.28.3",
     "p-event": "^6.0.1",
+    "socket.io": "^4.8.1",
     "twilio": "^5.8.0",
     "web-push": "^3.6.7"
   },