@facteurjs/core 1.0.0-beta.0

package/dist/api/handlers/notifications.js

@@ -0,0 +1,77 @@
+import { defineRoute } from "../index.js";
+
+//#region src/api/handlers/notifications.ts
+/**
+* Get all notifications for a given user
+*/
+const getNotificationRoute = defineRoute(({ facteur }) => ({
+	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
+		});
+		return {
+			status: 200,
+			body: notifications || []
+		};
+	}
+}));
+/**
+* Mark a specific notification as read or seen
+*/
+const markNotificationAsRoute = defineRoute(({ facteur }) => ({
+	method: "post",
+	route: "/notifications/notifiable/:notifiableId/mark-as",
+	handler: async (request) => {
+		const notificationId = request.body.notificationId;
+		const status = request.body.status;
+		if (!status) return {
+			status: 400,
+			body: { error: "Status is required" }
+		};
+		if (!notificationId) return {
+			status: 400,
+			body: { error: "Notification ID is required" }
+		};
+		await facteur.db.updateNotification({
+			id: notificationId,
+			status
+		});
+		return {
+			status: 204,
+			body: {}
+		};
+	}
+}));
+/**
+* Mark all notifications for a user as read or seen
+*/
+const markAllNotificationsAsRoute = defineRoute(({ facteur }) => ({
+	method: "post",
+	route: "/notifications/notifiable/:notifiableId/mark-all",
+	handler: async (request) => {
+		const status = request.body.status;
+		if (!status) return {
+			status: 400,
+			body: { error: "Status is required" }
+		};
+		await facteur.db.updateAllNotifications({
+			notifiableId: request.params.notifiableId,
+			tenantId: request.body.tenantId,
+			status
+		});
+		return {
+			status: 204,
+			body: {}
+		};
+	}
+}));
+
+//#endregion
+export { getNotificationRoute, markAllNotificationsAsRoute, markNotificationAsRoute };

package/dist/api/handlers/preferences.js

@@ -0,0 +1,43 @@
+import { defineRoute } from "../index.js";
+
+//#region src/api/handlers/preferences.ts
+const getPreferencesRoute = defineRoute(({ facteur }) => ({
+	method: "get",
+	route: "/notifications/notifiable/:notifiableId/preferences",
+	handler: async (request) => {
+		const userId = request.params.notifiableId;
+		const preferences = await facteur.db.getPreferences({
+			notifiableId: userId,
+			tenantId: request.query.tenantId
+		});
+		return {
+			status: 200,
+			body: preferences || {}
+		};
+	}
+}));
+const updatePreferencesRoute = defineRoute(({ facteur }) => ({
+	method: "post",
+	route: "/notifications/notifiable/:notifiableId/preferences",
+	handler: async (request) => {
+		const userId = request.params.notifiableId;
+		const preferences = request.body.preferences;
+		if (!preferences) return {
+			status: 400,
+			body: { error: "Preferences are required" }
+		};
+		await facteur.db.updatePreferences({
+			notifiableId: userId,
+			tenantId: request.body.tenantId,
+			notificationName: request.body.notificationName,
+			channelPreferences: preferences
+		});
+		return {
+			status: 204,
+			body: {}
+		};
+	}
+}));
+
+//#endregion
+export { getPreferencesRoute, updatePreferencesRoute };

package/dist/api/index.d.ts

@@ -0,0 +1,16 @@
+import { Facteur } from "../facteur.js";
+import { RouteDefinition, ServerAdapter } from "./types.js";
+
+//#region src/api/index.d.ts
+declare function defineRoute(routeDefinition: (options: {
+  facteur: Facteur<any, any>;
+}) => RouteDefinition): (options: {
+  facteur: Facteur<any, any>;
+}) => RouteDefinition;
+declare const routes: (facteur: Facteur<any, any>) => RouteDefinition[];
+declare function createFacteurServer(options: {
+  adapter: ServerAdapter;
+  facteur: Facteur<any, any>;
+}): void;
+//#endregion
+export { createFacteurServer, defineRoute, routes };

package/dist/api/index.js

@@ -0,0 +1,21 @@
+import { getPreferencesRoute, updatePreferencesRoute } from "./handlers/preferences.js";
+import { getNotificationRoute, markAllNotificationsAsRoute, markNotificationAsRoute } from "./handlers/notifications.js";
+
+//#region src/api/index.ts
+function defineRoute(routeDefinition) {
+	return routeDefinition;
+}
+const routes = (facteur) => [
+	getNotificationRoute({ facteur }),
+	markNotificationAsRoute({ facteur }),
+	markAllNotificationsAsRoute({ facteur }),
+	getPreferencesRoute({ facteur }),
+	updatePreferencesRoute({ facteur })
+];
+function createFacteurServer(options) {
+	const { adapter, facteur } = options;
+	adapter.setRoutes(routes(facteur));
+}
+
+//#endregion
+export { createFacteurServer, defineRoute, routes };

package/dist/api/types.d.ts

@@ -0,0 +1,22 @@
+//#region src/api/types.d.ts
+type HTTPMethod = 'get' | 'post' | 'put' | 'patch';
+interface HTTPRequest {
+  body: Record<string, any>;
+  params: Record<string, any>;
+  query: Record<string, any>;
+  headers: Record<string, string | undefined>;
+}
+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;
+}
+//#endregion
+export { HTTPMethod, HTTPRequest, HTTPResponse, RouteDefinition, ServerAdapter };

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

@@ -0,0 +1,18 @@
+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";
+
+//#region src/channels/discord/channel.d.ts
+declare function discordWebhookChannel<Options extends WebhookOptions<any>>(options: Options): DiscordProvider<Options>;
+declare class DiscordProvider<T extends WebhookOptions<any>> extends WebhookChannel<T> implements Channel<T, DiscordMessage, DiscordResponse, WebhookTargets<T>> {
+  name: any;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asDiscordMessage(): DiscordMessage;
+  }
+}
+//#endregion
+export { DiscordProvider, discordWebhookChannel };

package/dist/channels/discord/channel.js

@@ -0,0 +1,15 @@
+import { WebhookChannel } from "../webhook/provider.js";
+
+//#region src/channels/discord/channel.ts
+function discordWebhookChannel(options) {
+	return new DiscordProvider({
+		name: "discord",
+		...options
+	});
+}
+var DiscordProvider = class extends WebhookChannel {
+	name = "discord";
+};
+
+//#endregion
+export { DiscordProvider, discordWebhookChannel };

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

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

package/dist/channels/discord/index.js

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

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

@@ -0,0 +1,147 @@
+import { WebhookMessage } from "../webhook/message.js";
+import { DiscordEmbedField, HexadecimalColor } from "./types.js";
+
+//#region src/channels/discord/message.d.ts
+declare class DiscordMessage extends WebhookMessage {
+  #private;
+  /**
+   * Creates a new instance of DiscordMessage.
+   */
+  static create(): DiscordMessage;
+  /**
+   * Sets the content of the message.
+   */
+  setBody(body: string): this;
+  /**
+   * Sets the username of the bot that will send the message.
+   */
+  setBotUsername(username: string): this;
+  /**
+   * Sets the avatar URL for the bot that will send the message.
+   */
+  setBotAvatar(avatarUrl: string): this;
+  /**
+   * Adds an embed to the message using a callback function to configure it.
+   */
+  addEmbed(callback: (embed: DiscordEmbed) => void): this;
+  /**
+   * Whether or not this notification should be read as text to speech.
+   */
+  setTTS(flag: boolean): this;
+  serialize(): {
+    body: {
+      embeds: {
+        title: string | undefined;
+        description: string | undefined;
+        url: string | undefined;
+        color: number | undefined;
+        fields: DiscordEmbedField[] | undefined;
+        image: {
+          url: string;
+        } | undefined;
+        thumbnail: {
+          url: string;
+        } | undefined;
+        author: {
+          name: string | undefined;
+          url: string | undefined;
+          icon_url: string | undefined;
+        } | undefined;
+        footer: {
+          text: string;
+          icon_url: string | undefined;
+        } | undefined;
+        timestamp: string | undefined;
+      }[];
+      avatar_url?: string;
+      username?: string;
+      tts: boolean;
+      content: string;
+    };
+    headers: Record<string, string>;
+    queryParameters: Record<string, string>;
+  };
+}
+declare class DiscordEmbed {
+  #private;
+  /**
+   * Sets the author information for the embed.
+   */
+  setAuthor(options: {
+    name?: string;
+    url?: string;
+    iconUrl?: string;
+  }): this;
+  /**
+   * Sets the title of the embed.
+   */
+  setTitle(title: string): this;
+  /**
+   * Sets the description text for the embed.
+   */
+  setDescription(description: string): this;
+  /**
+   * Sets the URL for the embed title to link to.
+   */
+  setUrl(url: string): this;
+  /**
+   * Sets the color of the embed's left border. Accepts a hexadecimal color code.
+   */
+  setColor(color: HexadecimalColor): this;
+  /**
+   * Adds a field to the embed with a name and value.
+   *
+   * Inline fields will be displayed next to each other, rather than each on their own line.
+   */
+  addField(options: {
+    name: string;
+    value: string;
+    inline?: boolean;
+  }): this;
+  /**
+   * Sets the footer information for the embed, including optional timestamp.
+   */
+  setFooter(options: {
+    text: string;
+    iconUrl?: string;
+  }): this;
+  /**
+   * Set a date that will be displayed in the footer.
+   */
+  setTimestamp(timestamp: Date): this;
+  /**
+   * Adds an image to the embed.
+   * You can add up to 4 images when you have an URL in the Embed body. ( `embed.setUrl()` )
+   * Otherwise, only one image will be displayed.
+   */
+  setImage(image: string): this;
+  /**
+   * Sets the thumbnail image for the embed.
+   */
+  setThumbnail(url: string): this;
+  serialize(): {
+    title: string | undefined;
+    description: string | undefined;
+    url: string | undefined;
+    color: number | undefined;
+    fields: DiscordEmbedField[] | undefined;
+    image: {
+      url: string;
+    } | undefined;
+    thumbnail: {
+      url: string;
+    } | undefined;
+    author: {
+      name: string | undefined;
+      url: string | undefined;
+      icon_url: string | undefined;
+    } | undefined;
+    footer: {
+      text: string;
+      icon_url: string | undefined;
+    } | undefined;
+    timestamp: string | undefined;
+  };
+}
+//#endregion
+export { DiscordMessage };

package/dist/channels/discord/message.js

@@ -0,0 +1,176 @@
+import { WebhookMessage } from "../webhook/message.js";
+
+//#region src/channels/discord/message.ts
+var DiscordMessage = class DiscordMessage extends WebhookMessage {
+	#body = "";
+	#username = "";
+	#avatarUrl = "";
+	#tts = false;
+	#embeds = [];
+	/**
+	* Creates a new instance of DiscordMessage.
+	*/
+	static create() {
+		return new DiscordMessage().setQueryParameters({ wait: "true" });
+	}
+	/**
+	* Sets the content of the message.
+	*/
+	setBody(body) {
+		this.#body = body;
+		return this;
+	}
+	/**
+	* Sets the username of the bot that will send the message.
+	*/
+	setBotUsername(username) {
+		this.#username = username;
+		return this;
+	}
+	/**
+	* Sets the avatar URL for the bot that will send the message.
+	*/
+	setBotAvatar(avatarUrl) {
+		this.#avatarUrl = avatarUrl;
+		return this;
+	}
+	/**
+	* Adds an embed to the message using a callback function to configure it.
+	*/
+	addEmbed(callback) {
+		const embed = new DiscordEmbed();
+		callback(embed);
+		this.#embeds.push(embed);
+		return this;
+	}
+	/**
+	* Whether or not this notification should be read as text to speech.
+	*/
+	setTTS(flag) {
+		this.#tts = flag;
+		return this;
+	}
+	serialize() {
+		return {
+			...super.serialize(),
+			body: {
+				tts: this.#tts,
+				content: this.#body,
+				...this.#username ? { username: this.#username } : {},
+				...this.#avatarUrl ? { avatar_url: this.#avatarUrl } : {},
+				embeds: this.#embeds.map((embed) => embed.serialize())
+			}
+		};
+	}
+};
+var DiscordEmbed = class {
+	#title;
+	#description;
+	#url;
+	#color;
+	#fields;
+	#author;
+	#footer;
+	#image;
+	#timestamp;
+	#thumbnail;
+	/**
+	* Sets the author information for the embed.
+	*/
+	setAuthor(options) {
+		this.#author = options;
+		return this;
+	}
+	/**
+	* Sets the title of the embed.
+	*/
+	setTitle(title) {
+		this.#title = title;
+		return this;
+	}
+	/**
+	* Sets the description text for the embed.
+	*/
+	setDescription(description) {
+		this.#description = description;
+		return this;
+	}
+	/**
+	* Sets the URL for the embed title to link to.
+	*/
+	setUrl(url) {
+		this.#url = url;
+		return this;
+	}
+	/**
+	* Sets the color of the embed's left border. Accepts a hexadecimal color code.
+	*/
+	setColor(color) {
+		this.#color = Number.parseInt(color.slice(1), 16);
+		return this;
+	}
+	/**
+	* Adds a field to the embed with a name and value.
+	*
+	* Inline fields will be displayed next to each other, rather than each on their own line.
+	*/
+	addField(options) {
+		this.#fields = this.#fields || [];
+		this.#fields.push(options);
+		return this;
+	}
+	/**
+	* Sets the footer information for the embed, including optional timestamp.
+	*/
+	setFooter(options) {
+		this.#footer = options;
+		return this;
+	}
+	/**
+	* Set a date that will be displayed in the footer.
+	*/
+	setTimestamp(timestamp) {
+		this.#timestamp = timestamp;
+		return this;
+	}
+	/**
+	* Adds an image to the embed.
+	* You can add up to 4 images when you have an URL in the Embed body. ( `embed.setUrl()` )
+	* Otherwise, only one image will be displayed.
+	*/
+	setImage(image) {
+		this.#image = image;
+		return this;
+	}
+	/**
+	* Sets the thumbnail image for the embed.
+	*/
+	setThumbnail(url) {
+		this.#thumbnail = url;
+		return this;
+	}
+	serialize() {
+		return {
+			title: this.#title,
+			description: this.#description,
+			url: this.#url,
+			color: this.#color,
+			fields: this.#fields,
+			image: this.#image ? { url: this.#image } : void 0,
+			thumbnail: this.#thumbnail ? { url: this.#thumbnail } : void 0,
+			author: this.#author ? {
+				name: this.#author.name,
+				url: this.#author.url,
+				icon_url: this.#author.iconUrl
+			} : void 0,
+			footer: this.#footer ? {
+				text: this.#footer.text,
+				icon_url: this.#footer.iconUrl
+			} : void 0,
+			timestamp: this.#timestamp?.toISOString()
+		};
+	}
+};
+
+//#endregion
+export { DiscordMessage };

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

@@ -0,0 +1,52 @@
+import { WebhookOptions, WebhookTargets } from "../webhook/types.js";
+
+//#region src/channels/discord/types.d.ts
+type DiscordOptions<WebhooksNames extends string> = WebhookOptions<WebhooksNames>;
+type DiscordTargets<Options extends DiscordOptions<any>> = WebhookTargets<Options>;
+type HexadecimalColor = `#${string}`;
+interface DiscordResponse {
+  type: number;
+  content: string;
+  mentions: string[];
+  mention_roles: string[];
+  attachments: string[];
+  embeds: string[];
+  timestamp: string;
+  edited_timestamp: string | null;
+  flags: number;
+  components: string[];
+  id: string;
+  channel_id: string;
+  author: {
+    id: string;
+    username: string;
+    avatar: string | null;
+    discriminator: string;
+    public_flags: number;
+    flags: number;
+    bot: boolean;
+    global_name: string | null;
+    clan: string | null;
+    primary_guild: string | null;
+  };
+  pinned: boolean;
+  mention_everyone: boolean;
+  tts: boolean;
+  webhook_id: string;
+}
+interface DiscordEmbedField {
+  name: string;
+  value: string;
+  inline?: boolean;
+}
+interface DiscordEmbedAuthor {
+  name?: string;
+  url?: string;
+  iconUrl?: string;
+}
+interface DiscordEmbedFooter {
+  text: string;
+  iconUrl?: string;
+}
+//#endregion
+export { DiscordEmbedAuthor, DiscordEmbedField, DiscordEmbedFooter, DiscordOptions, DiscordResponse, DiscordTargets, HexadecimalColor };

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

@@ -0,0 +1,22 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { FcmMessage } from "./message.js";
+import { FcmConfig, FcmTargets } from "./types.js";
+
+//#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;
+  constructor(config: FcmConfig);
+  send(options: ChannelSendParams<FcmMessage, FcmTargets>): Promise<string>;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asFcmMessage(): FcmMessage;
+  }
+}
+//#endregion
+export { FcmChannel, fcmChannel };

package/dist/channels/fcm/channel.js

@@ -0,0 +1,44 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+import { cert, initializeApp } from "firebase-admin/app";
+import { getMessaging } from "firebase-admin/messaging";
+
+//#region src/channels/fcm/channel.ts
+function fcmChannel(config) {
+	return new FcmChannel(config);
+}
+var FcmChannel = class {
+	name = "fcm";
+	[kTargetSymbol] = null;
+	messaging;
+	constructor(config) {
+		this.config = config;
+		const app = initializeApp({
+			...config,
+			...config.serviceAccountKeyPath ? { credential: cert(config.serviceAccountKeyPath) } : {}
+		});
+		this.messaging = getMessaging(app);
+	}
+	#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;
+	}
+	async send(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 await this.messaging.send(message).catch((error) => this.#handleError(error));
+	}
+};
+
+//#endregion
+export { FcmChannel, fcmChannel };

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

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

package/dist/channels/fcm/index.js

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