@facteurjs/core 1.0.0-beta.0

package/dist/channels/twilio/message.js

@@ -0,0 +1,152 @@
+//#region src/channels/twilio/message.ts
+var TwilioMessage = class TwilioMessage {
+	#body = "";
+	#from;
+	#messagingServiceSid;
+	#alphanumericSender;
+	#maxPrice;
+	#validityPeriod;
+	#forceDelivery;
+	#provideFeedback;
+	#applicationSid;
+	/**
+	* Creates a new instance of TwilioMessage
+	*/
+	static create() {
+		return new TwilioMessage();
+	}
+	/**
+	* Sets the message content/body
+	*/
+	setBody(body) {
+		this.#body = body;
+		return this;
+	}
+	/**
+	* Gets the message body
+	*/
+	getBody() {
+		return this.#body;
+	}
+	/**
+	* Sets the sender phone number
+	*/
+	setFrom(from) {
+		this.#from = from;
+		return this;
+	}
+	/**
+	* Gets the sender phone number
+	*/
+	getFrom() {
+		return this.#from;
+	}
+	/**
+	* Sets the messaging service SID
+	*/
+	setMessagingServiceSid(sid) {
+		this.#messagingServiceSid = sid;
+		return this;
+	}
+	/**
+	* Gets the messaging service SID.
+	*/
+	getMessagingServiceSid() {
+		return this.#messagingServiceSid;
+	}
+	/**
+	* Sets the alphanumeric sender
+	*/
+	setAlphanumericSender(sender) {
+		this.#alphanumericSender = sender;
+		return this;
+	}
+	/**
+	* Gets the alphanumeric sender
+	*/
+	getAlphanumericSender() {
+		return this.#alphanumericSender;
+	}
+	/**
+	* Sets the maximum price per message in USD
+	*/
+	setMaxPrice(price) {
+		this.#maxPrice = price;
+		return this;
+	}
+	/**
+	* Gets the maximum price.
+	*/
+	getMaxPrice() {
+		return this.#maxPrice;
+	}
+	/**
+	* Sets the validity period in seconds
+	*/
+	setValidityPeriod(seconds) {
+		this.#validityPeriod = seconds;
+		return this;
+	}
+	/**
+	* Gets the validity period.
+	*/
+	getValidityPeriod() {
+		return this.#validityPeriod;
+	}
+	/**
+	* Sets force delivery option.
+	*/
+	setForceDelivery(force) {
+		this.#forceDelivery = force;
+		return this;
+	}
+	/**
+	* Gets force delivery option
+	*/
+	getForceDelivery() {
+		return this.#forceDelivery;
+	}
+	/**
+	* Sets provide feedback option
+	*/
+	setProvideFeedback(provide) {
+		this.#provideFeedback = provide;
+		return this;
+	}
+	/**
+	* Gets provide feedback option.
+	*/
+	getProvideFeedback() {
+		return this.#provideFeedback;
+	}
+	/**
+	* Sets the application SID for status callbacks.
+	*/
+	setApplicationSid(sid) {
+		this.#applicationSid = sid;
+		return this;
+	}
+	/**
+	* Gets the application SID
+	*/
+	getApplicationSid() {
+		return this.#applicationSid;
+	}
+	/**
+	* Serializes the message to Twilio API format
+	*/
+	serialize() {
+		const data = { body: this.#body };
+		if (this.#from) data.from = this.#from;
+		if (this.#messagingServiceSid) data.messagingServiceSid = this.#messagingServiceSid;
+		if (this.#maxPrice !== void 0) data.maxPrice = this.#maxPrice;
+		if (this.#validityPeriod !== void 0) data.validityPeriod = this.#validityPeriod;
+		if (this.#forceDelivery !== void 0) data.forceDelivery = this.#forceDelivery;
+		if (this.#provideFeedback !== void 0) data.provideFeedback = this.#provideFeedback;
+		if (this.#applicationSid) data.applicationSid = this.#applicationSid;
+		return data;
+	}
+};
+
+//#endregion
+export { TwilioMessage };

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

@@ -0,0 +1,51 @@
+//#region src/channels/twilio/types.d.ts
+interface TwilioConfig {
+  /**
+   * Twilio Account SID
+   */
+  accountSid: string;
+  /**
+   * Twilio Auth Token
+   */
+  authToken: string;
+  /**
+   * Default phone number to send messages from
+   */
+  from?: string;
+  /**
+   * Messaging Service SID (recommended by Twilio)
+   */
+  messagingServiceSid?: string;
+  /**
+   * Alphanumeric sender (for supported regions)
+   */
+  alphanumericSender?: string;
+  /**
+   * Maximum price per message in USD
+   */
+  maxPrice?: number;
+  /**
+   * Debug mode - redirect all messages to this number
+   */
+  debugTo?: string;
+  /**
+   * Enable URL shortening
+   */
+  shortenUrls?: boolean;
+  /**
+   * Twilio error codes to ignore
+   */
+  ignoredErrorCodes?: (string | number)[];
+}
+interface TwilioTargets {
+  /**
+   * The phone number to send the message to
+   */
+  to: string;
+  /**
+   * Override the from number for this specific message
+   */
+  from?: string;
+}
+//#endregion
+export { TwilioConfig, TwilioTargets };

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

@@ -0,0 +1,18 @@
+import { HTTPErrorInfo } from "../../errors/http_error.js";
+
+//#region src/channels/webhook/exceptions.d.ts
+
+/**
+ * Exception thrown when a webhook request fails
+ */
+declare class WebhookRequestException extends Error {
+  code: string;
+  url: string;
+  responseBody: string;
+  constructor(httpErrorInfo: HTTPErrorInfo);
+}
+declare const errors: {
+  E_WEBHOOK_REQUEST_FAILED: typeof WebhookRequestException;
+};
+//#endregion
+export { WebhookRequestException, errors };

package/dist/channels/webhook/exceptions.js

@@ -0,0 +1,24 @@
+//#region src/channels/webhook/exceptions.ts
+/**
+* Exception thrown when a webhook request fails
+*/
+var WebhookRequestException = class extends Error {
+	constructor(httpErrorInfo) {
+		const { url, status, statusText, responseBody } = httpErrorInfo;
+		const message = [
+			`\n- Webhook request failed to ${url}`,
+			`- Status: ${status} ${statusText}`,
+			`- Response body:`,
+			responseBody
+		].join("\n");
+		super(message);
+		this.name = "WebhookRequestException";
+		this.code = "E_WEBHOOK_REQUEST_FAILED";
+		this.url = url;
+		this.responseBody = responseBody;
+	}
+};
+const errors = { E_WEBHOOK_REQUEST_FAILED: WebhookRequestException };
+
+//#endregion
+export { WebhookRequestException, errors };

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,5 @@
+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/webhook/message.d.ts

@@ -0,0 +1,24 @@
+//#region src/channels/webhook/message.d.ts
+declare class WebhookMessage {
+  #private;
+  static create(): WebhookMessage;
+  /**
+   * Set the data for the webhook message
+   */
+  setBody(body: any): this;
+  /**
+   * Set a header for the webhook message
+   */
+  setHeader(name: string, value: string): this;
+  /**
+   * Set query parameters that will be appended to the webhook URL
+   */
+  setQueryParameters(params: Record<string, string>): this;
+  serialize(): {
+    body: any;
+    headers: Record<string, string>;
+    queryParameters: Record<string, string>;
+  };
+}
+//#endregion
+export { WebhookMessage };

package/dist/channels/webhook/message.js

@@ -0,0 +1,40 @@
+//#region src/channels/webhook/message.ts
+var WebhookMessage = class WebhookMessage {
+	#body;
+	#headers = {};
+	#queryParameters = {};
+	static create() {
+		return new WebhookMessage();
+	}
+	/**
+	* Set the data for the webhook message
+	*/
+	setBody(body) {
+		this.#body = body;
+		return this;
+	}
+	/**
+	* Set a header for the webhook message
+	*/
+	setHeader(name, value) {
+		this.#headers[name] = value;
+		return this;
+	}
+	/**
+	* Set query parameters that will be appended to the webhook URL
+	*/
+	setQueryParameters(params) {
+		this.#queryParameters = params;
+		return this;
+	}
+	serialize() {
+		return {
+			body: this.#body,
+			headers: this.#headers,
+			queryParameters: this.#queryParameters
+		};
+	}
+};
+
+//#endregion
+export { WebhookMessage };

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

@@ -0,0 +1,19 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { WebhookMessage } from "./message.js";
+import { WebhookOptions, WebhookTargets } from "./types.js";
+
+//#region src/channels/webhook/provider.d.ts
+declare function webhookChannel<Options extends WebhookOptions<any>>(options: Options & {
+  name: string;
+}): WebhookChannel<Options>;
+declare class WebhookChannel<T extends WebhookOptions<any>> implements Channel<T, WebhookMessage, any, WebhookTargets<T>> {
+  #private;
+  name: "webhook";
+  [kTargetSymbol]: WebhookTargets<T>;
+  constructor(options: T & {
+    name: string;
+  });
+  send(params: ChannelSendParams<WebhookMessage, WebhookTargets<T>>): Promise<any>;
+}
+//#endregion
+export { WebhookChannel, webhookChannel };

package/dist/channels/webhook/provider.js

@@ -0,0 +1,63 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+import { WebhookRequestException } from "./exceptions.js";
+import { HTTPErrorExtractor } from "../../errors/http_error.js";
+import ky, { HTTPError } from "ky";
+
+//#region src/channels/webhook/provider.ts
+function webhookChannel(options) {
+	return new WebhookChannel(options);
+}
+var WebhookChannel = class {
+	name = "webhook";
+	[kTargetSymbol] = null;
+	#webhooksUrls = /* @__PURE__ */ new Map();
+	#name;
+	constructor(options) {
+		this.#name = options.name;
+		this.#initWebhooksEndpoints(options);
+	}
+	#buildWebhookEntry(key, endpoint) {
+		const url = new URL(endpoint);
+		return [key, url];
+	}
+	#initWebhooksEndpoints(options) {
+		if ("webhookUrl" in options) {
+			this.#webhooksUrls.set(...this.#buildWebhookEntry("default", options.webhookUrl));
+			return;
+		}
+		if (!options.webhooks) return;
+		for (const [key, endpoint] of Object.entries(options.webhooks)) this.#webhooksUrls.set(key, new URL(endpoint));
+	}
+	async #sendMessageToWebhook(url, message) {
+		const serialized = message.serialize();
+		return await ky.post(url, {
+			searchParams: serialized.queryParameters,
+			headers: serialized.headers,
+			json: serialized.body
+		}).catch(async (error) => {
+			if (error instanceof HTTPError) throw new WebhookRequestException(await HTTPErrorExtractor.extract(error));
+			throw error;
+		});
+	}
+	#normalizeTargets(targets) {
+		if (!targets) return [...this.#webhooksUrls.values()];
+		if ("webhookUrl" in targets) return [this.#buildWebhookEntry("default", targets.webhookUrl)[1]];
+		return Object.keys(targets).map((key) => this.#webhooksUrls.get(key)).filter(Boolean);
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS([this.#name]);
+	}
+	async send(params) {
+		const { message } = params;
+		const targets = this.#resolveTargets(params);
+		const normalizedTargets = this.#normalizeTargets(targets);
+		for (const url of normalizedTargets) await this.#sendMessageToWebhook(url, message);
+		return null;
+	}
+};
+
+//#endregion
+export { WebhookChannel, webhookChannel };

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

@@ -0,0 +1,15 @@
+//#region src/channels/webhook/types.d.ts
+type WebhookOptions<WebhookNames extends string> = {
+  webhookUrl: string;
+} | {
+  webhooks: Record<WebhookNames, string>;
+};
+type WebhookTargets<Options extends WebhookOptions<any>> = Options extends {
+  webhooks: infer Webhooks;
+} ? { [key in keyof Webhooks]?: boolean } & {
+  webhookUrl?: string;
+} : {
+  webhookUrl: string;
+};
+//#endregion
+export { WebhookOptions, WebhookTargets };

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

@@ -0,0 +1,26 @@
+import { Channel, ChannelSendParams, kTargetSymbol } from "../../types/channel.js";
+import { WebpushMessage } from "./message.js";
+import { WebpushConfig, WebpushTargets } from "./types.js";
+import webpush from "web-push";
+
+//#region src/channels/webpush/channel.d.ts
+declare function webpushChannel(config: WebpushConfig): WebpushChannel;
+declare class WebpushChannel implements Channel<WebpushConfig, WebpushMessage, any, WebpushTargets> {
+  #private;
+  private config;
+  name: "webpush";
+  [kTargetSymbol]: WebpushTargets;
+  constructor(config: WebpushConfig);
+  send(options: ChannelSendParams<WebpushMessage, WebpushTargets>): Promise<{
+    statusCode: number;
+    headers: webpush.Headers;
+    body: string;
+  }>;
+}
+declare module '@facteurjs/core/types' {
+  interface Notification {
+    asWebpushMessage(): WebpushMessage;
+  }
+}
+//#endregion
+export { WebpushChannel, webpushChannel };

package/dist/channels/webpush/channel.js

@@ -0,0 +1,55 @@
+import { errors } from "../../errors/index.js";
+import { kTargetSymbol } from "../../types/channel.js";
+import "../../types/index.js";
+import webpush from "web-push";
+
+//#region src/channels/webpush/channel.ts
+function webpushChannel(config) {
+	return new WebpushChannel(config);
+}
+var WebpushChannel = class {
+	name = "webpush";
+	[kTargetSymbol] = null;
+	constructor(config) {
+		this.config = config;
+		webpush.setVapidDetails(config.vapidSubject, config.vapidPublicKey, config.vapidPrivateKey);
+		if (config.gcmApiKey) webpush.setGCMAPIKey(config.gcmApiKey);
+	}
+	#resolveTargets(options) {
+		if (options.targets) return options.targets;
+		throw new errors.E_UNAVAILABLE_TARGETS(["Webpush"]);
+	}
+	#buildOptions() {
+		const options = {};
+		if (this.config.ttl !== void 0) options.TTL = this.config.ttl;
+		if (this.config.urgency) options.urgency = this.config.urgency;
+		if (this.config.proxy) options.proxy = this.config.proxy;
+		if (this.config.timeout) options.timeout = this.config.timeout;
+		return options;
+	}
+	#handleError(error) {
+		if (error.statusCode === 410) throw new Error(`Webpush subscription is no longer valid: ${error.body}`);
+		if (error.statusCode === 413) throw new Error(`Webpush payload too large: ${error.body}`);
+		if (error.statusCode === 400) throw new Error(`Invalid webpush request: ${error.body}`);
+		if (error.statusCode === 429) throw new Error(`Webpush rate limit exceeded: ${error.body}`);
+		throw error;
+	}
+	async send(options) {
+		const payload = options.message.serialize();
+		const targets = this.#resolveTargets(options);
+		const webpushOptions = this.#buildOptions();
+		try {
+			const result = await webpush.sendNotification(targets.subscription, payload, webpushOptions);
+			return {
+				statusCode: result.statusCode,
+				headers: result.headers,
+				body: result.body
+			};
+		} catch (error) {
+			return this.#handleError(error);
+		}
+	}
+};
+
+//#endregion
+export { WebpushChannel, webpushChannel };

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

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

package/dist/channels/webpush/index.js

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

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

@@ -0,0 +1,90 @@
+//#region src/channels/webpush/message.d.ts
+declare class WebpushMessage {
+  #private;
+  /**
+   * Creates a new instance of WebpushMessage
+   */
+  static create(): WebpushMessage;
+  /**
+   * Sets the notification title
+   */
+  setTitle(title: string): this;
+  /**
+   * Sets the notification body
+   */
+  setBody(body: string): this;
+  /**
+   * Sets the notification icon
+   */
+  setIcon(icon: string): this;
+  /**
+   * Sets the notification image
+   */
+  setImage(image: string): this;
+  /**
+   * Sets the notification badge
+   */
+  setBadge(badge: string): this;
+  /**
+   * Sets the notification tag
+   */
+  setTag(tag: string): this;
+  /**
+   * Sets the notification data
+   */
+  setData(data: any): this;
+  /**
+   * Sets the notification actions
+   */
+  setActions(actions: Array<{
+    action: string;
+    title: string;
+    icon?: string;
+  }>): this;
+  /**
+   * Adds a single action
+   */
+  addAction(options: {
+    action: string;
+    title: string;
+    icon?: string;
+  }): this;
+  /**
+   * Sets the URL to open when notification is clicked
+   */
+  setUrl(url: string): this;
+  /**
+   * Sets whether the notification requires interaction
+   */
+  setRequireInteraction(requireInteraction: boolean): this;
+  /**
+   * Sets whether the notification should be silent
+   */
+  setSilent(silent: boolean): this;
+  /**
+   * Sets whether to renotify when replacing an existing notification
+   */
+  setRenotify(renotify: boolean): this;
+  /**
+   * Sets the notification timestamp
+   */
+  setTimestamp(timestamp: number): this;
+  /**
+   * Sets the vibration pattern
+   */
+  setVibrate(vibrate: number[]): this;
+  /**
+   * Sets the text direction
+   */
+  setDir(dir: 'auto' | 'ltr' | 'rtl'): this;
+  /**
+   * Sets the notification language
+   */
+  setLang(lang: string): this;
+  /**
+   * Serializes the message to web push format
+   */
+  serialize(): string;
+}
+//#endregion
+export { WebpushMessage };