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

package/README.md

@@ -0,0 +1,27 @@
+# @facteurjs/core
+
+Framework-agnostic notification system for Node.js with support for multiple channels.
+
+## Supported Channels
+
+- Email (via your mail provider)
+- SMS (Twilio, AWS SNS)
+- Push notifications (FCM, Expo, Web Push)
+- Real-time (Socket.IO, Transmit)
+- Webhooks
+- Chat (Slack, Discord)
+- Database storage
+
+## Installation
+
+```bash
+npm install @facteurjs/core
+```
+
+## Documentation
+
+Full documentation available at [facteur.julr.dev](https://facteur.julr.dev)
+
+## License
+
+MIT

package/dist/api/handlers/{notifications.js → notifications.mjs}

@@ -1,37 +1,52 @@
-import { defineRoute } from "../index.js";
+import { UNAUTHORIZED_RESPONSE, checkAuthorization, parseJsonSafe } from "./utils.mjs";
+import { defineRoute } from "../../api.mjs";
 
 //#region src/api/handlers/notifications.ts
 /**
 * Get all notifications for a given user
 */
-const getNotificationRoute = defineRoute(({ facteur }) => ({
+const getNotificationRoute = defineRoute(({ facteur, authorize }) => ({
 	method: "get",
 	route: "/notifications/notifiable/:notifiableId/notifications",
 	handler: async (request) => {
-		const userId = request.params.notifiableId;
-		const notifications = await facteur.db.getNotifications({
-			notifiableId: userId,
-			tenantId: request.query.tenantId,
-			page: request.query.page,
-			limit: request.query.limit,
-			status: request.query.status,
-			tags: request.query.tags ? JSON.parse(request.query.tags) : void 0
-		});
+		const notifiableId = request.params.notifiableId;
+		const tenantId = request.query.tenantId;
+		if (!await checkAuthorization({
+			authorize,
+			request,
+			notifiableId,
+			tenantId
+		})) return UNAUTHORIZED_RESPONSE;
 		return {
 			status: 200,
-			body: notifications || []
+			body: await facteur.db.getNotifications({
+				notifiableId,
+				tenantId,
+				page: request.query.page,
+				limit: request.query.limit,
+				status: request.query.status,
+				tags: parseJsonSafe(request.query.tags)
+			}) || []
 		};
 	}
 }));
 /**
 * Mark a specific notification as read or seen
 */
-const markNotificationAsRoute = defineRoute(({ facteur }) => ({
+const markNotificationAsRoute = defineRoute(({ facteur, authorize }) => ({
 	method: "post",
 	route: "/notifications/notifiable/:notifiableId/mark-as",
 	handler: async (request) => {
+		const notifiableId = request.params.notifiableId;
+		const tenantId = request.body.tenantId;
 		const notificationId = request.body.notificationId;
 		const status = request.body.status;
+		if (!await checkAuthorization({
+			authorize,
+			request,
+			notifiableId,
+			tenantId
+		})) return UNAUTHORIZED_RESPONSE;
 		if (!status) return {
 			status: 400,
 			body: { error: "Status is required" }
@@ -53,18 +68,26 @@ const markNotificationAsRoute = defineRoute(({ facteur }) => ({
 /**
 * Mark all notifications for a user as read or seen
 */
-const markAllNotificationsAsRoute = defineRoute(({ facteur }) => ({
+const markAllNotificationsAsRoute = defineRoute(({ facteur, authorize }) => ({
 	method: "post",
 	route: "/notifications/notifiable/:notifiableId/mark-all",
 	handler: async (request) => {
+		const notifiableId = request.params.notifiableId;
+		const tenantId = request.body.tenantId;
 		const status = request.body.status;
+		if (!await checkAuthorization({
+			authorize,
+			request,
+			notifiableId,
+			tenantId
+		})) return UNAUTHORIZED_RESPONSE;
 		if (!status) return {
 			status: 400,
 			body: { error: "Status is required" }
 		};
 		await facteur.db.updateAllNotifications({
-			notifiableId: request.params.notifiableId,
-			tenantId: request.body.tenantId,
+			notifiableId,
+			tenantId,
 			status
 		});
 		return {

package/dist/api/handlers/preferences.mjs

@@ -0,0 +1,73 @@
+import { UNAUTHORIZED_RESPONSE, checkAuthorization } from "./utils.mjs";
+import { defineRoute } from "../../api.mjs";
+
+//#region src/api/handlers/preferences.ts
+function validatePreferences(preferences) {
+	if (!preferences || typeof preferences !== "object" || Array.isArray(preferences)) return {
+		valid: false,
+		error: "Preferences must be an object"
+	};
+	for (const [channel, value] of Object.entries(preferences)) if (typeof value !== "boolean") return {
+		valid: false,
+		error: `Channel "${channel}" preference must be a boolean, got ${typeof value}`
+	};
+	return { valid: true };
+}
+const getPreferencesRoute = defineRoute(({ facteur, authorize }) => ({
+	method: "get",
+	route: "/notifications/notifiable/:notifiableId/preferences",
+	handler: async (request) => {
+		const notifiableId = request.params.notifiableId;
+		const tenantId = request.query.tenantId;
+		if (!await checkAuthorization({
+			authorize,
+			request,
+			notifiableId,
+			tenantId
+		})) return UNAUTHORIZED_RESPONSE;
+		return {
+			status: 200,
+			body: await facteur.db.getPreferences({
+				notifiableId,
+				tenantId
+			}) || {}
+		};
+	}
+}));
+const updatePreferencesRoute = defineRoute(({ facteur, authorize }) => ({
+	method: "post",
+	route: "/notifications/notifiable/:notifiableId/preferences",
+	handler: async (request) => {
+		const notifiableId = request.params.notifiableId;
+		const tenantId = request.body.tenantId;
+		const preferences = request.body.preferences;
+		if (!await checkAuthorization({
+			authorize,
+			request,
+			notifiableId,
+			tenantId
+		})) return UNAUTHORIZED_RESPONSE;
+		if (!preferences) return {
+			status: 400,
+			body: { error: "Preferences are required" }
+		};
+		const validation = validatePreferences(preferences);
+		if (!validation.valid) return {
+			status: 400,
+			body: { error: validation.error }
+		};
+		await facteur.db.updatePreferences({
+			notifiableId,
+			tenantId,
+			notificationName: request.body.notificationName,
+			channelPreferences: preferences
+		});
+		return {
+			status: 204,
+			body: {}
+		};
+	}
+}));
+
+//#endregion
+export { getPreferencesRoute, updatePreferencesRoute };

package/dist/api/handlers/utils.mjs

@@ -0,0 +1,23 @@
+//#region src/api/handlers/utils.ts
+const UNAUTHORIZED_RESPONSE = {
+	status: 403,
+	body: { error: "Unauthorized" }
+};
+async function checkAuthorization(options) {
+	return options.authorize({
+		notifiableId: options.notifiableId,
+		tenantId: options.tenantId,
+		request: options.request
+	});
+}
+function parseJsonSafe(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { UNAUTHORIZED_RESPONSE, checkAuthorization, parseJsonSafe };

package/dist/api/types.d.mts

@@ -0,0 +1,52 @@
+import { Identifier } from "../database/types.mjs";
+
+//#region src/api/types.d.ts
+type HTTPMethod = 'get' | 'post' | 'put' | 'patch';
+interface HTTPRequest<Context = unknown> {
+  body: Record<string, any>;
+  params: Record<string, any>;
+  query: Record<string, any>;
+  headers: Record<string, string | undefined>;
+  /**
+   * Framework-specific context (e.g., AdonisJS HttpContext, Hono Context).
+   * Use this to access framework-specific features like authentication.
+   */
+  context?: Context;
+}
+interface HTTPResponse {
+  status: number;
+  body: Record<string, any>;
+}
+interface RouteDefinition {
+  method: HTTPMethod;
+  route: string;
+  handler: (request: HTTPRequest) => Promise<HTTPResponse>;
+}
+interface ServerAdapter {
+  setRoutes(routes: RouteDefinition[]): void;
+}
+/**
+ * Context passed to the authorization callback
+ */
+interface AuthorizationContext {
+  /**
+   * The notifiable ID from the request (URL param)
+   */
+  notifiableId: Identifier;
+  /**
+   * The tenant ID from the request (query or body)
+   */
+  tenantId: Identifier | undefined;
+  /**
+   * The HTTP request object
+   */
+  request: HTTPRequest;
+}
+/**
+ * Callback to authorize a request.
+ * Should return true if the request is authorized, false otherwise.
+ * Can also throw an error to provide a custom error response.
+ */
+type AuthorizationCallback = (context: AuthorizationContext) => Promise<boolean> | boolean;
+//#endregion
+export { AuthorizationCallback, AuthorizationContext, HTTPMethod, HTTPRequest, HTTPResponse, RouteDefinition, ServerAdapter };

package/dist/api/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/api.d.mts

@@ -0,0 +1,22 @@
+import { Facteur } from "./facteur.mjs";
+import { AuthorizationCallback, RouteDefinition, ServerAdapter } from "./api/types.mjs";
+
+//#region src/api/index.d.ts
+interface DefineRouteOptions {
+  facteur: Facteur<any, any>;
+  authorize: AuthorizationCallback;
+}
+declare function defineRoute(routeDefinition: (options: DefineRouteOptions) => RouteDefinition): (options: DefineRouteOptions) => RouteDefinition;
+declare const routes: (options: DefineRouteOptions) => RouteDefinition[];
+interface CreateFacteurServerOptions {
+  adapter: ServerAdapter;
+  facteur: Facteur<any, any>;
+  /**
+   * Authorization callback to verify that the requester has access to the requested resources.
+   * This callback is required to ensure proper access control.
+   */
+  authorize: AuthorizationCallback;
+}
+declare function createFacteurServer(options: CreateFacteurServerOptions): void;
+//#endregion
+export { CreateFacteurServerOptions, DefineRouteOptions, createFacteurServer, defineRoute, routes };

package/dist/api.mjs

@@ -0,0 +1,25 @@
+import { getPreferencesRoute, updatePreferencesRoute } from "./api/handlers/preferences.mjs";
+import { getNotificationRoute, markAllNotificationsAsRoute, markNotificationAsRoute } from "./api/handlers/notifications.mjs";
+
+//#region src/api/index.ts
+function defineRoute(routeDefinition) {
+	return routeDefinition;
+}
+const routes = (options) => [
+	getNotificationRoute(options),
+	markNotificationAsRoute(options),
+	markAllNotificationsAsRoute(options),
+	getPreferencesRoute(options),
+	updatePreferencesRoute(options)
+];
+function createFacteurServer(options) {
+	const { adapter, facteur, authorize } = options;
+	if (!authorize) throw new Error("Authorization callback is required. You must provide an authorize function to control access to notification resources.");
+	adapter.setRoutes(routes({
+		facteur,
+		authorize
+	}));
+}
+
+//#endregion
+export { createFacteurServer, defineRoute, routes };

package/dist/channels/aws-sns/{channel.d.ts → channel.d.mts}

@@ -1,6 +1,6 @@
-import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
-import { AwsSnsMessage } from "./message.js";
-import { AwsSnsConfig, AwsSnsTargets } from "./types.js";
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.mjs";
+import { AwsSnsMessage } from "./message.mjs";
+import { AwsSnsConfig, AwsSnsTargets } from "./types.mjs";
 
 //#region src/channels/aws-sns/channel.d.ts
 declare function awsSnsChannel(config: AwsSnsConfig): AwsSnsChannel;

package/dist/channels/aws-sns/{channel.js → channel.mjs}

@@ -1,6 +1,5 @@
-import { errors } from "../../errors/index.js";
-import { kTargetSymbol } from "../../types/channel.js";
-import "../../types/index.js";
+import { errors } from "../../errors/index.mjs";
+import { kTargetSymbol } from "../../types/channel.mjs";
 import { PublishCommand, SNSClient } from "@aws-sdk/client-sns";
 
 //#region src/channels/aws-sns/channel.ts

package/dist/channels/aws-sns/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/channels/aws-sns.d.mts

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

package/dist/channels/aws-sns.mjs

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

package/dist/channels/discord/{channel.d.ts → channel.d.mts}

@@ -1,8 +1,8 @@
-import { Channel } from "../../types/channel.js";
-import { WebhookOptions, WebhookTargets } from "../webhook/types.js";
-import { DiscordResponse } from "./types.js";
-import { DiscordMessage } from "./message.js";
-import { WebhookChannel } from "../webhook/provider.js";
+import { Channel } from "../../types/channel.mjs";
+import { WebhookOptions, WebhookTargets } from "../webhook/types.mjs";
+import { DiscordResponse } from "./types.mjs";
+import { DiscordMessage } from "./message.mjs";
+import { WebhookChannel } from "../webhook/provider.mjs";
 
 //#region src/channels/discord/channel.d.ts
 declare function discordWebhookChannel<Options extends WebhookOptions<any>>(options: Options): DiscordProvider<Options>;

package/dist/channels/discord/{channel.js → channel.mjs}

@@ -1,4 +1,4 @@
-import { WebhookChannel } from "../webhook/provider.js";
+import { WebhookChannel } from "../webhook/provider.mjs";
 
 //#region src/channels/discord/channel.ts
 function discordWebhookChannel(options) {

package/dist/channels/discord/{message.d.ts → message.d.mts}

@@ -1,5 +1,5 @@
-import { WebhookMessage } from "../webhook/message.js";
-import { DiscordEmbedField, HexadecimalColor } from "./types.js";
+import { DiscordEmbedField, HexadecimalColor } from "./types.mjs";
+import { WebhookMessage } from "../webhook/message.mjs";
 
 //#region src/channels/discord/message.d.ts
 declare class DiscordMessage extends WebhookMessage {

package/dist/channels/discord/{message.js → message.mjs}

@@ -1,4 +1,4 @@
-import { WebhookMessage } from "../webhook/message.js";
+import { WebhookMessage } from "../webhook/message.mjs";
 
 //#region src/channels/discord/message.ts
 var DiscordMessage = class DiscordMessage extends WebhookMessage {

package/dist/channels/discord/{types.d.ts → types.d.mts}

@@ -1,4 +1,4 @@
-import { WebhookOptions, WebhookTargets } from "../webhook/types.js";
+import { WebhookOptions, WebhookTargets } from "../webhook/types.mjs";
 
 //#region src/channels/discord/types.d.ts
 type DiscordOptions<WebhooksNames extends string> = WebhookOptions<WebhooksNames>;

package/dist/channels/discord/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/channels/discord.d.mts

@@ -0,0 +1,3 @@
+import { DiscordMessage } from "./discord/message.mjs";
+import { DiscordProvider, discordWebhookChannel } from "./discord/channel.mjs";
+export { DiscordMessage, DiscordProvider, discordWebhookChannel };

package/dist/channels/discord.mjs

@@ -0,0 +1,4 @@
+import { DiscordMessage } from "./discord/message.mjs";
+import { DiscordProvider, discordWebhookChannel } from "./discord/channel.mjs";
+
+export { DiscordMessage, DiscordProvider, discordWebhookChannel };

package/dist/channels/expo/{channel.d.ts → channel.d.mts}

@@ -1,6 +1,6 @@
-import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
-import { ExpoMessage } from "./message.js";
-import { ExpoConfig, ExpoTargets } from "./types.js";
+import { BatchConfig, BatchSendResult, Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.mjs";
+import { ExpoMessage } from "./message.mjs";
+import { ExpoConfig, ExpoTargets } from "./types.mjs";
 
 //#region src/channels/expo/channel.d.ts
 declare function expoChannel(config?: ExpoConfig): ExpoChannel;
@@ -8,11 +8,13 @@ declare class ExpoChannel implements Channel<ExpoConfig, ExpoMessage, any, ExpoT
   #private;
   name: "expo";
   [kTargetSymbol]: ExpoTargets;
+  batchConfig: BatchConfig;
   constructor(config: ExpoConfig);
   send(options: ChannelSendParams<ExpoMessage, ExpoTargets>): Promise<{
     id: string;
     status: "ok";
   }>;
+  sendBatch(messages: ChannelSendParams<ExpoMessage, ExpoTargets>[]): Promise<BatchSendResult>;
 }
 declare module '@facteurjs/core/types' {
   interface Notification {

package/dist/channels/expo/channel.mjs

@@ -0,0 +1,69 @@
+import { errors } from "../../errors/index.mjs";
+import { kTargetSymbol } from "../../types/channel.mjs";
+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;
+	batchConfig = {
+		maxSize: 100,
+		enabled: true
+	};
+	#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"]);
+	}
+	#buildMessage(options) {
+		const targets = this.#resolveTargets(options);
+		return options.message.serialize({ to: targets.expoToken });
+	}
+	async send(options) {
+		const message = this.#buildMessage(options);
+		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
+		};
+	}
+	async sendBatch(messages) {
+		const expoMessages = messages.map((msg) => this.#buildMessage(msg));
+		const tickets = await this.#expo.sendPushNotificationsAsync(expoMessages);
+		let successCount = 0;
+		let failedCount = 0;
+		const results = tickets.map((ticket, index) => {
+			const result = {
+				index,
+				status: ticket.status === "ok" ? "success" : "failed"
+			};
+			if (ticket.status === "ok") {
+				successCount++;
+				result.response = ticket.id;
+			} else {
+				failedCount++;
+				result.error = new Error(ticket.message || "Unknown Expo error", { cause: ticket.details });
+			}
+			return result;
+		});
+		return {
+			success: successCount,
+			failed: failedCount,
+			results
+		};
+	}
+};
+
+//#endregion
+export { ExpoChannel, expoChannel };

package/dist/channels/expo/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/channels/expo.d.mts

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

package/dist/channels/expo.mjs

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

package/dist/channels/fcm/{channel.d.ts → channel.d.mts}

@@ -1,17 +1,17 @@
-import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
-import { FcmMessage } from "./message.js";
-import { FcmConfig, FcmTargets } from "./types.js";
+import { BatchConfig, BatchSendResult, Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.mjs";
+import { FcmMessage } from "./message.mjs";
+import { FcmConfig, FcmTargets } from "./types.mjs";
 
 //#region src/channels/fcm/channel.d.ts
 declare function fcmChannel(config: FcmConfig): FcmChannel;
 declare class FcmChannel implements Channel<FcmConfig, FcmMessage, any, FcmTargets> {
   #private;
-  private config;
   name: "fcm";
   [kTargetSymbol]: FcmTargets;
-  private messaging;
+  batchConfig: BatchConfig;
   constructor(config: FcmConfig);
   send(options: ChannelSendParams<FcmMessage, FcmTargets>): Promise<string>;
+  sendBatch(messages: ChannelSendParams<FcmMessage, FcmTargets>[]): Promise<BatchSendResult>;
 }
 declare module '@facteurjs/core/types' {
   interface Notification {

package/dist/channels/fcm/channel.mjs

@@ -0,0 +1,68 @@
+import { errors } from "../../errors/index.mjs";
+import { kTargetSymbol } from "../../types/channel.mjs";
+import { getMessaging } from "firebase-admin/messaging";
+import { cert, initializeApp } from "firebase-admin/app";
+
+//#region src/channels/fcm/channel.ts
+function fcmChannel(config) {
+	return new FcmChannel(config);
+}
+var FcmChannel = class {
+	name = "fcm";
+	[kTargetSymbol] = null;
+	batchConfig = {
+		maxSize: 500,
+		enabled: true
+	};
+	#messaging;
+	#config;
+	constructor(config) {
+		this.#config = config;
+		this.#messaging = getMessaging(initializeApp({
+			...config,
+			...config.serviceAccountKeyPath ? { credential: cert(config.serviceAccountKeyPath) } : {}
+		}));
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS(["FCM"]);
+	}
+	#handleError(error) {
+		if (error.code === "messaging/registration-token-not-registered") throw new Error(`FCM token is no longer valid: ${error.message}`);
+		if (error.code === "messaging/invalid-argument") throw new Error(`Invalid FCM message format: ${error.message}`);
+		throw error;
+	}
+	#buildMessage(options) {
+		const message = options.message.serialize();
+		const targets = this.#resolveTargets(options);
+		if (this.#config.debugToken) message.token = this.#config.debugToken;
+		if (targets.token) message.token = this.#config.debugToken || targets.token;
+		else if (targets.topic) message.topic = targets.topic;
+		else if (targets.condition) message.condition = targets.condition;
+		return message;
+	}
+	async send(options) {
+		const message = this.#buildMessage(options);
+		return await this.#messaging.send(message).catch((error) => this.#handleError(error));
+	}
+	async sendBatch(messages) {
+		const fcmMessages = messages.map((msg) => this.#buildMessage(msg));
+		const response = await this.#messaging.sendEach(fcmMessages);
+		return {
+			success: response.successCount,
+			failed: response.failureCount,
+			results: response.responses.map((r, index) => {
+				const result = {
+					index,
+					status: r.success ? "success" : "failed"
+				};
+				if (r.error) result.error = new Error(r.error.message, { cause: r.error });
+				if (r.messageId) result.response = r.messageId;
+				return result;
+			})
+		};
+	}
+};
+
+//#endregion
+export { FcmChannel, fcmChannel };

package/dist/channels/fcm/types.mjs

@@ -0,0 +1 @@
+export {  };

package/dist/channels/fcm.d.mts

@@ -0,0 +1,3 @@
+import { FcmMessage } from "./fcm/message.mjs";
+import { FcmChannel, fcmChannel } from "./fcm/channel.mjs";
+export { FcmChannel, FcmMessage, fcmChannel };

package/dist/channels/fcm.mjs

@@ -0,0 +1,4 @@
+import { FcmMessage } from "./fcm/message.mjs";
+import { FcmChannel, fcmChannel } from "./fcm/channel.mjs";
+
+export { FcmChannel, FcmMessage, fcmChannel };

package/dist/channels/slack/{channel.d.ts → channel.d.mts}

@@ -1,7 +1,7 @@
-import { Channel } from "../../types/channel.js";
-import { WebhookChannel } from "../webhook/provider.js";
-import { SlackMessage } from "./message.js";
-import { SlackOptions, SlackTargets } from "./types.js";
+import { Channel } from "../../types/channel.mjs";
+import { WebhookChannel } from "../webhook/provider.mjs";
+import { SlackMessage } from "./message.mjs";
+import { SlackOptions, SlackTargets } from "./types.mjs";
 
 //#region src/channels/slack/channel.d.ts
 declare function slackWebhookChannel<Options extends SlackOptions<any>>(options: Options): SlackWebhookChannel<Options>;
@@ -15,4 +15,4 @@ declare module '@facteurjs/core/types' {
   }
 }
 //#endregion
-export { slackWebhookChannel };
+export { SlackWebhookChannel, slackWebhookChannel };