@orieljs/notifications 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,9 @@
+Oriel
+Copyright 2026 meeeet-dev and Oriel contributors
+
+This product includes software developed by the Oriel project
+(https://orieljs.vercel.app, https://github.com/orieljs).
+
+Oriel is licensed under the Apache License, Version 2.0 (see LICENSE).
+The Oriel name and logo are not covered by that license; see TRADEMARKS.md
+(https://github.com/orieljs/framework/blob/main/TRADEMARKS.md).

package/dist/index.d.ts

@@ -0,0 +1,260 @@
+import { OrielError, MailRecipient, NotificationChannel, Notifiable as Notifiable$1, Notification as Notification$1, NotificationDispatcher, Container, Job } from '@orieljs/contracts';
+import * as _orieljs_support from '@orieljs/support';
+import { ServiceProvider } from '@orieljs/support';
+
+declare class UnrenderableNotificationMailError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "UnrenderableNotificationMailError";
+    constructor(notification: string);
+}
+declare class MailUnavailableError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "MailUnavailableError";
+    constructor();
+}
+declare class DatabaseUnavailableError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "DatabaseUnavailableError";
+    constructor();
+}
+declare class NotDatabaseNotifiableError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "NotDatabaseNotifiableError";
+    constructor(notifiable: string);
+}
+declare class UnrenderableNotificationDataError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "UnrenderableNotificationDataError";
+    constructor(notification: string);
+}
+declare class UnknownNotificationChannelError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "UnknownNotificationChannelError";
+    constructor(channel: string);
+}
+declare class NotificationQueueUnavailableError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "NotificationQueueUnavailableError";
+    constructor();
+}
+declare class NotificationDispatcherUnavailableError extends Error implements OrielError {
+    readonly kind: "Server";
+    readonly status = 500;
+    readonly name = "NotificationDispatcherUnavailableError";
+    constructor();
+}
+
+interface MailMessageAction {
+    text: string;
+    url: string;
+}
+/**
+ * Laravel's Illuminate\Notifications\Messages\MailMessage: greeting/line/action/salutation, rendered to a default
+ * HTML+text template with no View involved. line() appends to the intro before action() is called, and to the
+ * outro afterwards — exactly like Laravel's SimpleMessage.
+ */
+declare class MailMessage {
+    subjectLine?: string;
+    greetingLine?: string;
+    introLines: string[];
+    actionData?: MailMessageAction;
+    outroLines: string[];
+    salutationLine: string;
+    toAddresses: MailRecipient[];
+    ccAddresses: MailRecipient[];
+    bccAddresses: MailRecipient[];
+    fromAddress?: MailRecipient;
+    subject(subject: string): this;
+    greeting(greeting: string): this;
+    /** Before action(), appends to the intro; after action(), to the outro. */
+    line(text: string): this;
+    lines(lines: string[]): this;
+    action(text: string, url: string): this;
+    salutation(salutation: string): this;
+    from(address: MailRecipient): this;
+    to(recipients: MailRecipient | MailRecipient[]): this;
+    cc(recipients: MailRecipient | MailRecipient[]): this;
+    bcc(recipients: MailRecipient | MailRecipient[]): this;
+    /** Renders the default notification mail template. No ViewFactory involved. */
+    render(): {
+        html: string;
+        text: string;
+    };
+}
+
+/**
+ * What Auth's default ResetPassword notification's toMail() returns: plain data, since Auth can't import
+ * Notifications. `{ subject, lines, actionText, actionUrl, outroLines }` exactly; `greeting`/`salutation` are
+ * optional extensions any other notification's plain toMail() may also use.
+ */
+interface PlainNotificationMail {
+    subject?: string;
+    greeting?: string;
+    lines: string[];
+    actionText?: string;
+    actionUrl?: string;
+    outroLines?: string[];
+    salutation?: string;
+}
+declare class MailNotificationChannel implements NotificationChannel {
+    send(notifiable: Notifiable$1, notification: Notification$1): Promise<void>;
+}
+
+declare const NOTIFICATIONS_TABLE = "notifications";
+interface DatabaseNotificationRecord {
+    readonly id: string;
+    readonly type: string;
+    readonly data: Record<string, unknown>;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readAt: Date | undefined;
+    markAsRead(): Promise<void>;
+    markAsUnread(): Promise<void>;
+}
+/**
+ * Database writes Dates as zoneless UTC (`'2026-09-25 04:30:00'`) and hands them back as strings, so
+ * `new Date()` would read such a string as local time; it is parsed as UTC here instead.
+ */
+declare function parseStoredDate(value: unknown): Date;
+/** notifiable_type + notifiable_id together, never id alone. */
+declare function fetchNotifications(notifiableType: string, notifiableId: unknown, filter?: 'all' | 'read' | 'unread'): Promise<DatabaseNotificationRecord[]>;
+declare class DatabaseNotificationChannel implements NotificationChannel {
+    send(notifiable: Notifiable$1, notification: Notification$1): Promise<void>;
+}
+
+declare const NOTIFICATIONS_TABLE_MIGRATION = "import { Migration, Schema } from '@orieljs/framework'\n\nexport default class extends Migration {\n  async up() {\n    await Schema.create('notifications', (t) => {\n      t.uuid('id').primary()\n      t.string('type')\n      t.morphs('notifiable')\n      t.text('data')\n      t.timestamp('read_at').nullable()\n      t.timestamps()\n    })\n  }\n\n  async down() {\n    await Schema.dropIfExists('notifications')\n  }\n}\n";
+
+/**
+ * The Queue/Bus protocol's shared marker (the "Queue/Bus protocol" section of the Queue/Bus design notes) —
+ * identical to Mail's `symbols.ts`. `Symbol.for` is a *global* registry key, so this is the literal same runtime
+ * symbol Bus's `Queueable` base class and `isQueueable()` use, with no import needed (and none allowed).
+ */
+declare const SHOULD_QUEUE: unique symbol;
+
+/**
+ * Returned by `Notification.route(channel, address)` for sending to an address with no model behind it. The
+ * routes are an own plain record and every method sits on the prototype, so a queued on-demand notification
+ * survives Queue's serializer (which rejects functions in own fields) and is restored on the worker as this class
+ * (registered as `'Notifications.AnonymousNotifiable'` in ClassRegistry).
+ */
+declare class AnonymousNotifiable implements Notifiable$1 {
+    routes: Record<string, unknown>;
+    /** Adds a route; chains, so one on-demand notifiable can go to several channels. */
+    route(channel: string, route: unknown): this;
+    routeNotificationFor(channel: string): unknown;
+    notify(notification: Notification$1): Promise<void>;
+    notifyNow(notification: Notification$1, channels?: string[]): Promise<void>;
+}
+
+/**
+ * One notifiable, an array, or any other iterable of them (a Database `Collection` from `await User.where(...).get()`,
+ * a Set, ...), as Laravel's `Notification::send($users, ...)` accepts. A notifiable is recognised by its
+ * routeNotificationFor() method first, so an iterable model is still treated as one notifiable.
+ */
+declare function toNotifiableList(notifiables: Notifiable$1 | Iterable<Notifiable$1>): Notifiable$1[];
+/** Resolves channels by name from a factory map — mirrors MailManager's driver resolution. */
+declare class Dispatcher implements NotificationDispatcher {
+    private readonly container;
+    private readonly factories;
+    private readonly channels;
+    constructor(container: Container);
+    extend(channel: string, factory: () => NotificationChannel): void;
+    private resolve;
+    send(notifiables: Notifiable$1 | Iterable<Notifiable$1>, notification: Notification$1): Promise<void>;
+    sendNow(notifiables: Notifiable$1 | Iterable<Notifiable$1>, notification: Notification$1, channels?: string[]): Promise<void>;
+    /** On-demand: an AnonymousNotifiable, whose notify() goes through the bound NotificationDispatcher. */
+    route(channel: string, route: unknown): AnonymousNotifiable;
+}
+
+/**
+ * Dispatched by Dispatcher.send() when the notification is queueable. Runs on the worker: calls sendNow()
+ * directly (never send()), so it can't re-detect itself as queueable and loop.
+ *
+ * Carries `SHOULD_QUEUE` on its own prototype, per the Queue/Bus protocol, so `BusDispatcher.dispatch()` — which
+ * re-decides queued-or-now on whatever job it's handed — actually enqueues it instead of running it inline; the
+ * notification's own queueability (checked by Dispatcher, above) only decides whether to wrap it at all. Like
+ * Laravel's SendQueuedNotifications, it forwards failed(), retryUntil(), middleware() and displayName() to the
+ * notification.
+ */
+declare class SendQueuedNotifications implements Job {
+    readonly notifiables: Notifiable$1[];
+    readonly notification: Notification$1;
+    readonly channels?: string[] | undefined;
+    connection?: string;
+    queue?: string;
+    delay?: number;
+    tries?: number;
+    backoff?: number | number[];
+    timeout?: number;
+    failOnTimeout?: boolean;
+    deleteWhenMissingModels?: boolean;
+    constructor(notifiables: Notifiable$1[], notification: Notification$1, channels?: string[] | undefined);
+    handle(): Promise<void>;
+    /** Called by Queue after the final failed attempt. */
+    failed(error: unknown): Promise<void>;
+    /** `failed_jobs` and `queue:failed` show the notification's class, not the wrapper's. */
+    displayName(): string;
+    retryUntil(): unknown;
+    middleware(): unknown[];
+}
+
+type NotifiableConstructor = new (...args: any[]) => object;
+/**
+ * Mirrors Laravel's Illuminate\Notifications\Notifiable trait: `class User extends Notifiable(Model) {}`. Custom
+ * routing per channel follows Laravel's own resolution order: a `routeNotificationFor<Channel>()` method (Studly
+ * name) wins if present, else 'mail' reads `email`/`getAttribute('email')`, 'database' returns the instance itself
+ * (the database channel derives the table row from it directly), and anything else is unrouted (`undefined`).
+ */
+declare function Notifiable<TBase extends NotifiableConstructor>(Base: TBase): {
+    new (...args: any[]): {
+        routeNotificationFor(channel: string, notification: Notification$1): unknown;
+        notify(notification: Notification$1): Promise<void>;
+        notifyNow(notification: Notification$1, channels?: string[]): Promise<void>;
+        notifications(): Promise<DatabaseNotificationRecord[]>;
+        unreadNotifications(): Promise<DatabaseNotificationRecord[]>;
+        readNotifications(): Promise<DatabaseNotificationRecord[]>;
+    };
+} & TBase;
+
+/**
+ * Mirrors Laravel's Illuminate\Notifications\Notification: override via(), and whichever toXxx() the channels
+ * need.
+ *
+ * The statics are the `Notification` facade, so one export serves both `class InvoicePaid extends Notification`
+ * and `Notification.send(users, new InvoicePaid())`.
+ */
+declare abstract class Notification implements Notification$1 {
+    id?: string;
+    abstract via(notifiable: Notifiable$1): string[];
+    /** Queues it when the notification is queueable, otherwise sends now. Accepts one notifiable, an array or any iterable. */
+    static send(notifiables: Notifiable$1 | Iterable<Notifiable$1>, notification: Notification$1): Promise<void>;
+    static sendNow(notifiables: Notifiable$1 | Iterable<Notifiable$1>, notification: Notification$1, channels?: string[]): Promise<void>;
+    /** On-demand: `Notification.route('mail', 'a@b.c').notify(new InvoicePaid())`. */
+    static route(channel: string, route: unknown): Notifiable$1 & {
+        notify(notification: Notification$1): Promise<void>;
+    };
+    static extend(channel: string, factory: () => NotificationChannel): void;
+    /** Replace the dispatcher in the current container (what a NotificationFake uses). */
+    static swap(fake: NotificationDispatcher): void;
+}
+
+/**
+ * The plain facade over NotificationDispatcher. App code normally uses the `Notification` base class's statics
+ * instead (one `Notification` export is both the base class and the facade); this stays exported for code that
+ * wants the contract-typed proxy (getFacadeRoot(), swap()).
+ */
+declare const NotificationFacade: _orieljs_support.Facade<NotificationDispatcher, object>;
+
+declare class NotificationsServiceProvider extends ServiceProvider {
+    register(): void;
+    boot(): void;
+}
+
+export { AnonymousNotifiable, DatabaseNotificationChannel, type DatabaseNotificationRecord, DatabaseUnavailableError, Dispatcher, MailMessage, type MailMessageAction, MailNotificationChannel, MailUnavailableError, NOTIFICATIONS_TABLE, NOTIFICATIONS_TABLE_MIGRATION, NotDatabaseNotifiableError, Notifiable, type NotifiableConstructor, Notification, NotificationDispatcherUnavailableError, NotificationFacade, NotificationQueueUnavailableError, NotificationsServiceProvider, type PlainNotificationMail, SHOULD_QUEUE, SendQueuedNotifications, UnknownNotificationChannelError, UnrenderableNotificationDataError, UnrenderableNotificationMailError, fetchNotifications, parseStoredDate, toNotifiableList };

package/dist/index.js

@@ -0,0 +1,571 @@
+// errors.ts
+var UnrenderableNotificationMailError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "UnrenderableNotificationMailError";
+  constructor(notification) {
+    super(
+      `[${notification}].toMail() must return a Mailable, a MailMessage, or { subject?, greeting?, lines, actionText?, actionUrl?, outroLines?, salutation? }.`
+    );
+  }
+};
+var MailUnavailableError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "MailUnavailableError";
+  constructor() {
+    super("Sending a notification's mail requires the Mail component. Register MailManager first.");
+  }
+};
+var DatabaseUnavailableError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "DatabaseUnavailableError";
+  constructor() {
+    super("The database notification channel requires the Database component. Register DatabaseManager first.");
+  }
+};
+var NotDatabaseNotifiableError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "NotDatabaseNotifiableError";
+  constructor(notifiable) {
+    super(`[${notifiable}] has no getKey() \u2014 the database channel and notification-listing methods need a model.`);
+  }
+};
+var UnrenderableNotificationDataError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "UnrenderableNotificationDataError";
+  constructor(notification) {
+    super(`[${notification}] needs a toDatabase() or toArray() method to use the database channel.`);
+  }
+};
+var UnknownNotificationChannelError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "UnknownNotificationChannelError";
+  constructor(channel) {
+    super(`Notification channel [${channel}] is not registered. Register it first with NotificationDispatcher.extend().`);
+  }
+};
+var NotificationQueueUnavailableError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "NotificationQueueUnavailableError";
+  constructor() {
+    super("Queueing a notification requires the Bus component. Register BusDispatcher, or call sendNow() instead.");
+  }
+};
+var NotificationDispatcherUnavailableError = class extends Error {
+  kind = "Server";
+  status = 500;
+  name = "NotificationDispatcherUnavailableError";
+  constructor() {
+    super("notify()/notifyNow() require the Notifications component. Register NotificationDispatcher first.");
+  }
+};
+
+// MailMessage.ts
+var MailMessage = class {
+  subjectLine;
+  greetingLine;
+  introLines = [];
+  actionData;
+  outroLines = [];
+  salutationLine = "Regards,\nApplication";
+  toAddresses = [];
+  ccAddresses = [];
+  bccAddresses = [];
+  fromAddress;
+  subject(subject) {
+    this.subjectLine = subject;
+    return this;
+  }
+  greeting(greeting) {
+    this.greetingLine = greeting;
+    return this;
+  }
+  /** Before action(), appends to the intro; after action(), to the outro. */
+  line(text) {
+    ;
+    (this.actionData ? this.outroLines : this.introLines).push(text);
+    return this;
+  }
+  lines(lines) {
+    for (const line of lines) this.line(line);
+    return this;
+  }
+  action(text, url) {
+    this.actionData = { text, url };
+    return this;
+  }
+  salutation(salutation) {
+    this.salutationLine = salutation;
+    return this;
+  }
+  from(address) {
+    this.fromAddress = address;
+    return this;
+  }
+  to(recipients) {
+    this.toAddresses.push(...Array.isArray(recipients) ? recipients : [recipients]);
+    return this;
+  }
+  cc(recipients) {
+    this.ccAddresses.push(...Array.isArray(recipients) ? recipients : [recipients]);
+    return this;
+  }
+  bcc(recipients) {
+    this.bccAddresses.push(...Array.isArray(recipients) ? recipients : [recipients]);
+    return this;
+  }
+  /** Renders the default notification mail template. No ViewFactory involved. */
+  render() {
+    const greeting = this.greetingLine ?? "Hello!";
+    const html = [`<p>${escapeHtml(greeting)}</p>`];
+    const text = [greeting];
+    for (const line of this.introLines) {
+      html.push(`<p>${escapeHtml(line)}</p>`);
+      text.push(line);
+    }
+    if (this.actionData) {
+      const { text: actionText, url } = this.actionData;
+      html.push(`<p><a href="${escapeHtml(url)}" class="button" target="_blank">${escapeHtml(actionText)}</a></p>`);
+      text.push(`${actionText}: ${url}`);
+    }
+    for (const line of this.outroLines) {
+      html.push(`<p>${escapeHtml(line)}</p>`);
+      text.push(line);
+    }
+    html.push(`<p>${escapeHtml(this.salutationLine).replace(/\n/g, "<br>")}</p>`);
+    text.push(this.salutationLine);
+    return { html: `<!doctype html><html><body>${html.join("\n")}</body></html>`, text: text.join("\n\n") };
+  }
+};
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// channels/MailNotificationChannel.ts
+import {
+  MailManager as MailManagerToken
+} from "@orieljs/contracts";
+import { currentContainer } from "@orieljs/container";
+function isMailable(value) {
+  return typeof value === "object" && value !== null && typeof value.envelope === "function" && typeof value.content === "function";
+}
+function isPlainNotificationMail(value) {
+  return typeof value === "object" && value !== null && Array.isArray(value.lines);
+}
+function toMailMessage(result, notificationName) {
+  if (result instanceof MailMessage) return result;
+  if (!isPlainNotificationMail(result)) throw new UnrenderableNotificationMailError(notificationName);
+  const message = new MailMessage();
+  if (result.subject) message.subject(result.subject);
+  if (result.greeting) message.greeting(result.greeting);
+  message.lines(result.lines);
+  if (result.actionText && result.actionUrl) message.action(result.actionText, result.actionUrl);
+  for (const line of result.outroLines ?? []) message.line(line);
+  if (result.salutation) message.salutation(result.salutation);
+  return message;
+}
+function mailableFromMessage(message, fallbackTo) {
+  return {
+    envelope: async () => ({
+      subject: message.subjectLine ?? "",
+      to: message.toAddresses.length > 0 ? message.toAddresses : fallbackTo,
+      cc: message.ccAddresses,
+      bcc: message.bccAddresses,
+      from: message.fromAddress
+    }),
+    content: async () => {
+      const rendered = message.render();
+      return { htmlString: rendered.html, textString: rendered.text };
+    }
+  };
+}
+function normalizeRoute(route) {
+  if (route === void 0 || route === null) return [];
+  return Array.isArray(route) ? route : [route];
+}
+var MailNotificationChannel = class {
+  async send(notifiable, notification) {
+    if (!notification.toMail) throw new UnrenderableNotificationMailError(notification.constructor.name);
+    const result = await notification.toMail(notifiable);
+    const to = normalizeRoute(notifiable.routeNotificationFor("mail", notification));
+    if (to.length === 0 && !isMailable(result)) return;
+    const mailable = isMailable(result) ? result : mailableFromMessage(toMailMessage(result, notification.constructor.name), to);
+    const container = currentContainer();
+    if (!container?.bound(MailManagerToken)) throw new MailUnavailableError();
+    await container.make(MailManagerToken).send(mailable);
+  }
+};
+
+// channels/DatabaseNotificationChannel.ts
+import { randomUUID } from "crypto";
+import {
+  DatabaseManager as DatabaseManagerToken
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer2 } from "@orieljs/container";
+var NOTIFICATIONS_TABLE = "notifications";
+var ZONELESS_TIMESTAMP = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(:\d{2}(\.\d+)?)?$/;
+function parseStoredDate(value) {
+  if (value instanceof Date) return value;
+  if (typeof value === "number") return new Date(value);
+  const text = String(value);
+  return ZONELESS_TIMESTAMP.test(text) ? /* @__PURE__ */ new Date(`${text.replace(" ", "T")}Z`) : new Date(text);
+}
+function wrapRow(row, db) {
+  const record = {
+    id: String(row.id),
+    type: String(row.type),
+    data: JSON.parse(String(row.data)),
+    createdAt: parseStoredDate(row.created_at),
+    updatedAt: parseStoredDate(row.updated_at),
+    readAt: row.read_at ? parseStoredDate(row.read_at) : void 0,
+    async markAsRead() {
+      if (record.readAt) return;
+      const now = /* @__PURE__ */ new Date();
+      await db.table(NOTIFICATIONS_TABLE).where("id", record.id).update({ read_at: now, updated_at: now });
+      record.readAt = now;
+    },
+    async markAsUnread() {
+      if (!record.readAt) return;
+      await db.table(NOTIFICATIONS_TABLE).where("id", record.id).update({ read_at: null, updated_at: /* @__PURE__ */ new Date() });
+      record.readAt = void 0;
+    }
+  };
+  return record;
+}
+function requireDatabase() {
+  const container = currentContainer2();
+  if (!container?.bound(DatabaseManagerToken)) throw new DatabaseUnavailableError();
+  return container.make(DatabaseManagerToken).connection();
+}
+async function fetchNotifications(notifiableType, notifiableId, filter = "all") {
+  const db = requireDatabase();
+  let query = db.table(NOTIFICATIONS_TABLE).where("notifiable_type", notifiableType).where("notifiable_id", notifiableId).orderBy("created_at", "desc");
+  if (filter === "unread") query = query.whereNull("read_at");
+  if (filter === "read") query = query.whereNotNull("read_at");
+  const rows = await query.get();
+  return rows.all().map((row) => wrapRow(row, db));
+}
+var DatabaseNotificationChannel = class {
+  async send(notifiable, notification) {
+    if (!notification.toDatabase && !notification.toArray) {
+      throw new UnrenderableNotificationDataError(notification.constructor.name);
+    }
+    const data = notification.toDatabase ? notification.toDatabase(notifiable) : notification.toArray(notifiable);
+    const model = notifiable;
+    if (typeof model.getKey !== "function") throw new NotDatabaseNotifiableError(notifiable.constructor.name);
+    const db = requireDatabase();
+    const now = /* @__PURE__ */ new Date();
+    await db.table(NOTIFICATIONS_TABLE).insert({
+      id: notification.id ?? randomUUID(),
+      type: notification.constructor.name,
+      notifiable_type: notifiable.constructor.name,
+      notifiable_id: model.getKey(),
+      data: JSON.stringify(data),
+      read_at: null,
+      created_at: now,
+      updated_at: now
+    });
+  }
+};
+
+// migrations.ts
+var NOTIFICATIONS_TABLE_MIGRATION = `import { Migration, Schema } from '@orieljs/framework'
+
+export default class extends Migration {
+  async up() {
+    await Schema.create('notifications', (t) => {
+      t.uuid('id').primary()
+      t.string('type')
+      t.morphs('notifiable')
+      t.text('data')
+      t.timestamp('read_at').nullable()
+      t.timestamps()
+    })
+  }
+
+  async down() {
+    await Schema.dropIfExists('notifications')
+  }
+}
+`;
+
+// symbols.ts
+var SHOULD_QUEUE = /* @__PURE__ */ Symbol.for("oriel:bus.shouldQueue");
+
+// Dispatcher.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  BusDispatcher as BusDispatcherToken
+} from "@orieljs/contracts";
+
+// Notifiable.ts
+import {
+  NotificationDispatcher as NotificationDispatcherToken
+} from "@orieljs/contracts";
+import { currentContainer as currentContainer3 } from "@orieljs/container";
+import { Str } from "@orieljs/support";
+function resolveDispatcher() {
+  const container = currentContainer3();
+  if (!container?.bound(NotificationDispatcherToken)) throw new NotificationDispatcherUnavailableError();
+  return container.make(NotificationDispatcherToken);
+}
+function requireKey(instance) {
+  const model = instance;
+  if (typeof model.getKey !== "function") throw new NotDatabaseNotifiableError(instance.constructor.name);
+  return model.getKey();
+}
+function Notifiable(Base) {
+  return class NotifiableMixin extends Base {
+    routeNotificationFor(channel, notification) {
+      const custom = this[`routeNotificationFor${Str.studly(channel)}`];
+      if (typeof custom === "function") return custom.call(this, notification);
+      if (channel === "mail") {
+        const withAttrs = this;
+        return typeof withAttrs.getAttribute === "function" ? withAttrs.getAttribute("email") : withAttrs.email;
+      }
+      if (channel === "database") return this;
+      return void 0;
+    }
+    async notify(notification) {
+      await resolveDispatcher().send(this, notification);
+    }
+    async notifyNow(notification, channels) {
+      await resolveDispatcher().sendNow(this, notification, channels);
+    }
+    notifications() {
+      return fetchNotifications(this.constructor.name, requireKey(this));
+    }
+    unreadNotifications() {
+      return fetchNotifications(this.constructor.name, requireKey(this), "unread");
+    }
+    readNotifications() {
+      return fetchNotifications(this.constructor.name, requireKey(this), "read");
+    }
+  };
+}
+
+// AnonymousNotifiable.ts
+var AnonymousNotifiable = class {
+  routes = {};
+  /** Adds a route; chains, so one on-demand notifiable can go to several channels. */
+  route(channel, route) {
+    this.routes[channel] = route;
+    return this;
+  }
+  routeNotificationFor(channel) {
+    return this.routes[channel];
+  }
+  async notify(notification) {
+    await resolveDispatcher().send(this, notification);
+  }
+  async notifyNow(notification, channels) {
+    await resolveDispatcher().sendNow(this, notification, channels);
+  }
+};
+
+// Jobs/SendQueuedNotifications.ts
+import { NotificationDispatcher as NotificationDispatcherToken2 } from "@orieljs/contracts";
+import { inject } from "@orieljs/container";
+var QUEUE_OPTIONS = [
+  "connection",
+  "queue",
+  "delay",
+  "tries",
+  "backoff",
+  "timeout",
+  "failOnTimeout",
+  "deleteWhenMissingModels"
+];
+function copyShouldQueueFields(target, source) {
+  const fields = source;
+  for (const option of QUEUE_OPTIONS) {
+    if (fields[option] !== void 0) target[option] = fields[option];
+  }
+}
+var SendQueuedNotifications = class {
+  constructor(notifiables, notification, channels) {
+    this.notifiables = notifiables;
+    this.notification = notification;
+    this.channels = channels;
+    copyShouldQueueFields(this, notification);
+  }
+  notifiables;
+  notification;
+  channels;
+  async handle() {
+    await inject(NotificationDispatcherToken2).sendNow(this.notifiables, this.notification, this.channels);
+  }
+  /** Called by Queue after the final failed attempt. */
+  async failed(error) {
+    const hooks = this.notification;
+    if (typeof hooks.failed === "function") await hooks.failed.call(this.notification, error);
+  }
+  /** `failed_jobs` and `queue:failed` show the notification's class, not the wrapper's. */
+  displayName() {
+    return this.notification.constructor.name;
+  }
+  retryUntil() {
+    const hooks = this.notification;
+    return typeof hooks.retryUntil === "function" ? hooks.retryUntil.call(this.notification) : void 0;
+  }
+  middleware() {
+    const declared = this.notification.middleware;
+    return (typeof declared === "function" ? declared.call(this.notification) : declared) ?? [];
+  }
+};
+SendQueuedNotifications.prototype[SHOULD_QUEUE] = true;
+
+// Dispatcher.ts
+function isQueueableNotification(notification) {
+  const record = notification;
+  if (record[SHOULD_QUEUE] === true) return true;
+  return record.connection !== void 0 || record.queue !== void 0 || record.delay !== void 0 || record.tries !== void 0 || record.backoff !== void 0 || record.timeout !== void 0 || typeof record.uniqueId === "function" || typeof record.retryUntil === "function";
+}
+function forNotifiable(notification) {
+  if (notification.id) return notification;
+  const copy = Object.assign(Object.create(Object.getPrototypeOf(notification)), notification);
+  copy.id = randomUUID2();
+  return copy;
+}
+function toNotifiableList(notifiables) {
+  if (Array.isArray(notifiables)) return notifiables;
+  if (typeof notifiables.routeNotificationFor === "function") return [notifiables];
+  if (typeof notifiables === "object" && notifiables !== null && Symbol.iterator in notifiables) {
+    return [...notifiables];
+  }
+  return [notifiables];
+}
+var Dispatcher = class {
+  constructor(container) {
+    this.container = container;
+  }
+  container;
+  factories = /* @__PURE__ */ new Map();
+  channels = /* @__PURE__ */ new Map();
+  extend(channel, factory) {
+    this.factories.set(channel, factory);
+    this.channels.delete(channel);
+  }
+  resolve(name) {
+    const cached = this.channels.get(name);
+    if (cached) return cached;
+    const factory = this.factories.get(name);
+    if (!factory) throw new UnknownNotificationChannelError(name);
+    const channel = factory();
+    this.channels.set(name, channel);
+    return channel;
+  }
+  async send(notifiables, notification) {
+    const list = toNotifiableList(notifiables);
+    if (list.length === 0) return;
+    if (isQueueableNotification(notification)) {
+      if (!this.container.bound(BusDispatcherToken)) throw new NotificationQueueUnavailableError();
+      const bus = this.container.make(BusDispatcherToken);
+      for (const notifiable of list) {
+        const own = forNotifiable(notification);
+        for (const channel of notification.via(notifiable)) {
+          await bus.dispatch(new SendQueuedNotifications([notifiable], own, [channel]));
+        }
+      }
+      return;
+    }
+    await this.sendNow(list, notification);
+  }
+  async sendNow(notifiables, notification, channels) {
+    const list = toNotifiableList(notifiables);
+    for (const notifiable of list) {
+      const own = forNotifiable(notification);
+      const names = channels ?? notification.via(notifiable);
+      for (const name of names) {
+        if (name === "database" && notifiable instanceof AnonymousNotifiable) continue;
+        await this.resolve(name).send(notifiable, own);
+      }
+    }
+  }
+  /** On-demand: an AnonymousNotifiable, whose notify() goes through the bound NotificationDispatcher. */
+  route(channel, route) {
+    return new AnonymousNotifiable().route(channel, route);
+  }
+};
+
+// Notification.ts
+import {
+  NotificationDispatcher as NotificationDispatcherToken3
+} from "@orieljs/contracts";
+import { facade } from "@orieljs/support";
+var Notification = class {
+  id;
+  /** Queues it when the notification is queueable, otherwise sends now. Accepts one notifiable, an array or any iterable. */
+  static send(notifiables, notification) {
+    return resolveDispatcher().send(toNotifiableList(notifiables), notification);
+  }
+  static sendNow(notifiables, notification, channels) {
+    return resolveDispatcher().sendNow(toNotifiableList(notifiables), notification, channels);
+  }
+  /** On-demand: `Notification.route('mail', 'a@b.c').notify(new InvoicePaid())`. */
+  static route(channel, route) {
+    return resolveDispatcher().route(channel, route);
+  }
+  static extend(channel, factory) {
+    resolveDispatcher().extend(channel, factory);
+  }
+  /** Replace the dispatcher in the current container (what a NotificationFake uses). */
+  static swap(fake) {
+    facade(NotificationDispatcherToken3).swap(fake);
+  }
+};
+
+// facade.ts
+import { NotificationDispatcher as NotificationDispatcherToken4 } from "@orieljs/contracts";
+import { facade as facade2 } from "@orieljs/support";
+var NotificationFacade = facade2(NotificationDispatcherToken4);
+
+// NotificationsServiceProvider.ts
+import { ClassRegistry as ClassRegistryToken, NotificationDispatcher as NotificationDispatcherToken5 } from "@orieljs/contracts";
+import { ServiceProvider } from "@orieljs/support";
+var NotificationsServiceProvider = class extends ServiceProvider {
+  register() {
+    this.app.singleton(NotificationDispatcherToken5, (container) => new Dispatcher(container));
+    const registry = this.app.make(ClassRegistryToken);
+    registry.register(SendQueuedNotifications, "Notifications.SendQueuedNotifications");
+    registry.register(AnonymousNotifiable, "Notifications.AnonymousNotifiable");
+  }
+  boot() {
+    const dispatcher = this.app.make(NotificationDispatcherToken5);
+    dispatcher.extend("mail", () => new MailNotificationChannel());
+    dispatcher.extend("database", () => new DatabaseNotificationChannel());
+  }
+};
+export {
+  AnonymousNotifiable,
+  DatabaseNotificationChannel,
+  DatabaseUnavailableError,
+  Dispatcher,
+  MailMessage,
+  MailNotificationChannel,
+  MailUnavailableError,
+  NOTIFICATIONS_TABLE,
+  NOTIFICATIONS_TABLE_MIGRATION,
+  NotDatabaseNotifiableError,
+  Notifiable,
+  Notification,
+  NotificationDispatcherUnavailableError,
+  NotificationFacade,
+  NotificationQueueUnavailableError,
+  NotificationsServiceProvider,
+  SHOULD_QUEUE,
+  SendQueuedNotifications,
+  UnknownNotificationChannelError,
+  UnrenderableNotificationDataError,
+  UnrenderableNotificationMailError,
+  fetchNotifications,
+  parseStoredDate,
+  toNotifiableList
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../errors.ts","../MailMessage.ts","../channels/MailNotificationChannel.ts","../channels/DatabaseNotificationChannel.ts","../migrations.ts","../symbols.ts","../Dispatcher.ts","../Notifiable.ts","../AnonymousNotifiable.ts","../Jobs/SendQueuedNotifications.ts","../Notification.ts","../facade.ts","../NotificationsServiceProvider.ts"],"sourcesContent":["import type { OrielError } from '@orieljs/contracts'\n\nexport class UnrenderableNotificationMailError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'UnrenderableNotificationMailError'\n  constructor(notification: string) {\n    super(\n      `[${notification}].toMail() must return a Mailable, a MailMessage, or ` +\n        '{ subject?, greeting?, lines, actionText?, actionUrl?, outroLines?, salutation? }.',\n    )\n  }\n}\n\nexport class MailUnavailableError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'MailUnavailableError'\n  constructor() {\n    super(\"Sending a notification's mail requires the Mail component. Register MailManager first.\")\n  }\n}\n\nexport class DatabaseUnavailableError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'DatabaseUnavailableError'\n  constructor() {\n    super('The database notification channel requires the Database component. Register DatabaseManager first.')\n  }\n}\n\nexport class NotDatabaseNotifiableError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'NotDatabaseNotifiableError'\n  constructor(notifiable: string) {\n    super(`[${notifiable}] has no getKey() — the database channel and notification-listing methods need a model.`)\n  }\n}\n\nexport class UnrenderableNotificationDataError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'UnrenderableNotificationDataError'\n  constructor(notification: string) {\n    super(`[${notification}] needs a toDatabase() or toArray() method to use the database channel.`)\n  }\n}\n\nexport class UnknownNotificationChannelError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'UnknownNotificationChannelError'\n  constructor(channel: string) {\n    super(`Notification channel [${channel}] is not registered. Register it first with NotificationDispatcher.extend().`)\n  }\n}\n\nexport class NotificationQueueUnavailableError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'NotificationQueueUnavailableError'\n  constructor() {\n    super('Queueing a notification requires the Bus component. Register BusDispatcher, or call sendNow() instead.')\n  }\n}\n\nexport class NotificationDispatcherUnavailableError extends Error implements OrielError {\n  readonly kind = 'Server' as const\n  readonly status = 500\n  override readonly name = 'NotificationDispatcherUnavailableError'\n  constructor() {\n    super('notify()/notifyNow() require the Notifications component. Register NotificationDispatcher first.')\n  }\n}\n","import type { MailRecipient } from '@orieljs/contracts'\n\nexport interface MailMessageAction {\n  text: string\n  url: string\n}\n\n/**\n * Laravel's Illuminate\\Notifications\\Messages\\MailMessage: greeting/line/action/salutation, rendered to a default\n * HTML+text template with no View involved. line() appends to the intro before action() is called, and to the\n * outro afterwards — exactly like Laravel's SimpleMessage.\n */\nexport class MailMessage {\n  subjectLine?: string\n  greetingLine?: string\n  introLines: string[] = []\n  actionData?: MailMessageAction\n  outroLines: string[] = []\n  salutationLine = 'Regards,\\nApplication'\n  toAddresses: MailRecipient[] = []\n  ccAddresses: MailRecipient[] = []\n  bccAddresses: MailRecipient[] = []\n  fromAddress?: MailRecipient\n\n  subject(subject: string): this {\n    this.subjectLine = subject\n    return this\n  }\n\n  greeting(greeting: string): this {\n    this.greetingLine = greeting\n    return this\n  }\n\n  /** Before action(), appends to the intro; after action(), to the outro. */\n  line(text: string): this {\n    ;(this.actionData ? this.outroLines : this.introLines).push(text)\n    return this\n  }\n\n  lines(lines: string[]): this {\n    for (const line of lines) this.line(line)\n    return this\n  }\n\n  action(text: string, url: string): this {\n    this.actionData = { text, url }\n    return this\n  }\n\n  salutation(salutation: string): this {\n    this.salutationLine = salutation\n    return this\n  }\n\n  from(address: MailRecipient): this {\n    this.fromAddress = address\n    return this\n  }\n\n  to(recipients: MailRecipient | MailRecipient[]): this {\n    this.toAddresses.push(...(Array.isArray(recipients) ? recipients : [recipients]))\n    return this\n  }\n\n  cc(recipients: MailRecipient | MailRecipient[]): this {\n    this.ccAddresses.push(...(Array.isArray(recipients) ? recipients : [recipients]))\n    return this\n  }\n\n  bcc(recipients: MailRecipient | MailRecipient[]): this {\n    this.bccAddresses.push(...(Array.isArray(recipients) ? recipients : [recipients]))\n    return this\n  }\n\n  /** Renders the default notification mail template. No ViewFactory involved. */\n  render(): { html: string; text: string } {\n    const greeting = this.greetingLine ?? 'Hello!'\n    const html: string[] = [`<p>${escapeHtml(greeting)}</p>`]\n    const text: string[] = [greeting]\n\n    for (const line of this.introLines) {\n      html.push(`<p>${escapeHtml(line)}</p>`)\n      text.push(line)\n    }\n    if (this.actionData) {\n      const { text: actionText, url } = this.actionData\n      html.push(`<p><a href=\"${escapeHtml(url)}\" class=\"button\" target=\"_blank\">${escapeHtml(actionText)}</a></p>`)\n      text.push(`${actionText}: ${url}`)\n    }\n    for (const line of this.outroLines) {\n      html.push(`<p>${escapeHtml(line)}</p>`)\n      text.push(line)\n    }\n    html.push(`<p>${escapeHtml(this.salutationLine).replace(/\\n/g, '<br>')}</p>`)\n    text.push(this.salutationLine)\n\n    return { html: `<!doctype html><html><body>${html.join('\\n')}</body></html>`, text: text.join('\\n\\n') }\n  }\n}\n\nfunction escapeHtml(value: string): string {\n  return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\"/g, '&quot;')\n}\n","import {\n  MailManager as MailManagerToken,\n  type Mailable,\n  type MailRecipient,\n  type Notifiable,\n  type Notification,\n  type NotificationChannel,\n} from '@orieljs/contracts'\nimport { currentContainer } from '@orieljs/container'\nimport { MailUnavailableError, UnrenderableNotificationMailError } from '../errors'\nimport { MailMessage } from '../MailMessage'\n\n/**\n * What Auth's default ResetPassword notification's toMail() returns: plain data, since Auth can't import\n * Notifications. `{ subject, lines, actionText, actionUrl, outroLines }` exactly; `greeting`/`salutation` are\n * optional extensions any other notification's plain toMail() may also use.\n */\nexport interface PlainNotificationMail {\n  subject?: string\n  greeting?: string\n  lines: string[]\n  actionText?: string\n  actionUrl?: string\n  outroLines?: string[]\n  salutation?: string\n}\n\nfunction isMailable(value: unknown): value is Mailable {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    typeof (value as Mailable).envelope === 'function' &&\n    typeof (value as Mailable).content === 'function'\n  )\n}\n\nfunction isPlainNotificationMail(value: unknown): value is PlainNotificationMail {\n  return typeof value === 'object' && value !== null && Array.isArray((value as PlainNotificationMail).lines)\n}\n\nfunction toMailMessage(result: unknown, notificationName: string): MailMessage {\n  if (result instanceof MailMessage) return result\n  if (!isPlainNotificationMail(result)) throw new UnrenderableNotificationMailError(notificationName)\n  const message = new MailMessage()\n  if (result.subject) message.subject(result.subject)\n  if (result.greeting) message.greeting(result.greeting)\n  message.lines(result.lines)\n  if (result.actionText && result.actionUrl) message.action(result.actionText, result.actionUrl)\n  for (const line of result.outroLines ?? []) message.line(line)\n  if (result.salutation) message.salutation(result.salutation)\n  return message\n}\n\n/**\n * Wraps a MailMessage as a Mailable, so it can go through MailManager.send() without a View: the default template's\n * HTML goes in `htmlString` and its plain-text twin in `textString`.\n */\nfunction mailableFromMessage(message: MailMessage, fallbackTo: MailRecipient[]): Mailable {\n  return {\n    envelope: async () => ({\n      subject: message.subjectLine ?? '',\n      to: message.toAddresses.length > 0 ? message.toAddresses : fallbackTo,\n      cc: message.ccAddresses,\n      bcc: message.bccAddresses,\n      from: message.fromAddress,\n    }),\n    content: async () => {\n      const rendered = message.render()\n      return { htmlString: rendered.html, textString: rendered.text }\n    },\n  }\n}\n\nfunction normalizeRoute(route: unknown): MailRecipient[] {\n  if (route === undefined || route === null) return []\n  return Array.isArray(route) ? (route as MailRecipient[]) : [route as MailRecipient]\n}\n\nexport class MailNotificationChannel implements NotificationChannel {\n  async send(notifiable: Notifiable, notification: Notification): Promise<void> {\n    if (!notification.toMail) throw new UnrenderableNotificationMailError(notification.constructor.name)\n    const result = await notification.toMail(notifiable)\n    const to = normalizeRoute(notifiable.routeNotificationFor('mail', notification))\n\n    // Matches Laravel's MailChannel: with no route and no Mailable to supply its own recipients, there's nothing to send.\n    if (to.length === 0 && !isMailable(result)) return\n\n    const mailable = isMailable(result) ? result : mailableFromMessage(toMailMessage(result, notification.constructor.name), to)\n    const container = currentContainer()\n    if (!container?.bound(MailManagerToken)) throw new MailUnavailableError()\n    // MailManager.send() is the only send path the contract offers, so a queueable Mailable returned from toMail()\n    // is queued again from here (even when this notification is itself running on a queue worker).\n    await container.make(MailManagerToken).send(mailable)\n  }\n}\n","import { randomUUID } from 'node:crypto'\nimport {\n  DatabaseManager as DatabaseManagerToken,\n  type DatabaseConnection,\n  type ModelInstance,\n  type Notifiable,\n  type Notification,\n  type NotificationChannel,\n  type Row,\n} from '@orieljs/contracts'\nimport { currentContainer } from '@orieljs/container'\nimport { DatabaseUnavailableError, NotDatabaseNotifiableError, UnrenderableNotificationDataError } from '../errors'\n\nexport const NOTIFICATIONS_TABLE = 'notifications'\n\nexport interface DatabaseNotificationRecord {\n  readonly id: string\n  readonly type: string\n  readonly data: Record<string, unknown>\n  readonly createdAt: Date\n  readonly updatedAt: Date\n  readAt: Date | undefined\n  markAsRead(): Promise<void>\n  markAsUnread(): Promise<void>\n}\n\nconst ZONELESS_TIMESTAMP = /^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}(:\\d{2}(\\.\\d+)?)?$/\n\n/**\n * Database writes Dates as zoneless UTC (`'2026-09-25 04:30:00'`) and hands them back as strings, so\n * `new Date()` would read such a string as local time; it is parsed as UTC here instead.\n */\nexport function parseStoredDate(value: unknown): Date {\n  if (value instanceof Date) return value\n  if (typeof value === 'number') return new Date(value)\n  const text = String(value)\n  return ZONELESS_TIMESTAMP.test(text) ? new Date(`${text.replace(' ', 'T')}Z`) : new Date(text)\n}\n\nfunction wrapRow(row: Row, db: DatabaseConnection): DatabaseNotificationRecord {\n  const record: DatabaseNotificationRecord = {\n    id: String(row.id),\n    type: String(row.type),\n    data: JSON.parse(String(row.data)) as Record<string, unknown>,\n    createdAt: parseStoredDate(row.created_at),\n    updatedAt: parseStoredDate(row.updated_at),\n    readAt: row.read_at ? parseStoredDate(row.read_at) : undefined,\n    async markAsRead() {\n      if (record.readAt) return\n      const now = new Date()\n      await db.table(NOTIFICATIONS_TABLE).where('id', record.id).update({ read_at: now, updated_at: now })\n      record.readAt = now\n    },\n    async markAsUnread() {\n      if (!record.readAt) return\n      await db.table(NOTIFICATIONS_TABLE).where('id', record.id).update({ read_at: null, updated_at: new Date() })\n      record.readAt = undefined\n    },\n  }\n  return record\n}\n\nfunction requireDatabase(): DatabaseConnection {\n  const container = currentContainer()\n  if (!container?.bound(DatabaseManagerToken)) throw new DatabaseUnavailableError()\n  return container.make(DatabaseManagerToken).connection()\n}\n\n/** notifiable_type + notifiable_id together, never id alone. */\nexport async function fetchNotifications(\n  notifiableType: string,\n  notifiableId: unknown,\n  filter: 'all' | 'read' | 'unread' = 'all',\n): Promise<DatabaseNotificationRecord[]> {\n  const db = requireDatabase()\n  let query = db\n    .table(NOTIFICATIONS_TABLE)\n    .where('notifiable_type', notifiableType)\n    .where('notifiable_id', notifiableId)\n    .orderBy('created_at', 'desc')\n  if (filter === 'unread') query = query.whereNull('read_at')\n  if (filter === 'read') query = query.whereNotNull('read_at')\n  const rows = await query.get()\n  return rows.all().map((row) => wrapRow(row, db))\n}\n\nexport class DatabaseNotificationChannel implements NotificationChannel {\n  async send(notifiable: Notifiable, notification: Notification): Promise<void> {\n    if (!notification.toDatabase && !notification.toArray) {\n      throw new UnrenderableNotificationDataError(notification.constructor.name)\n    }\n    const data = notification.toDatabase ? notification.toDatabase(notifiable) : notification.toArray!(notifiable)\n    const model = notifiable as Partial<ModelInstance>\n    if (typeof model.getKey !== 'function') throw new NotDatabaseNotifiableError(notifiable.constructor.name)\n\n    const db = requireDatabase()\n    const now = new Date()\n    await db.table(NOTIFICATIONS_TABLE).insert({\n      id: notification.id ?? randomUUID(),\n      type: notification.constructor.name,\n      notifiable_type: notifiable.constructor.name,\n      notifiable_id: model.getKey(),\n      data: JSON.stringify(data),\n      read_at: null,\n      created_at: now,\n      updated_at: now,\n    })\n  }\n}\n","export const NOTIFICATIONS_TABLE_MIGRATION = `import { Migration, Schema } from '@orieljs/framework'\n\nexport default class extends Migration {\n  async up() {\n    await Schema.create('notifications', (t) => {\n      t.uuid('id').primary()\n      t.string('type')\n      t.morphs('notifiable')\n      t.text('data')\n      t.timestamp('read_at').nullable()\n      t.timestamps()\n    })\n  }\n\n  async down() {\n    await Schema.dropIfExists('notifications')\n  }\n}\n`\n","/**\n * The Queue/Bus protocol's shared marker (the \"Queue/Bus protocol\" section of the Queue/Bus design notes) —\n * identical to Mail's `symbols.ts`. `Symbol.for` is a *global* registry key, so this is the literal same runtime\n * symbol Bus's `Queueable` base class and `isQueueable()` use, with no import needed (and none allowed).\n */\nexport const SHOULD_QUEUE: unique symbol = Symbol.for('oriel:bus.shouldQueue')\n","import { randomUUID } from 'node:crypto'\nimport {\n  BusDispatcher as BusDispatcherToken,\n  type Container,\n  type Notifiable,\n  type Notification,\n  type NotificationChannel,\n  type NotificationDispatcher as NotificationDispatcherContract,\n} from '@orieljs/contracts'\nimport { AnonymousNotifiable } from './AnonymousNotifiable'\nimport { NotificationQueueUnavailableError, UnknownNotificationChannelError } from './errors'\nimport { SendQueuedNotifications } from './Jobs/SendQueuedNotifications'\nimport { SHOULD_QUEUE } from './symbols'\n\n/**\n * Matches the Queue/Bus protocol's `isQueueable()` exactly: true when the notification carries\n * `SHOULD_QUEUE === true`, or has a defined value for any of ShouldQueue's fields, or declares a\n * `uniqueId()`/`retryUntil()` method (same rule as Mail's `isQueueableMailable`). `implements ShouldQueue` itself\n * leaves no runtime trace. Call sendNow() explicitly to bypass this for a notification with none of these.\n */\nfunction isQueueableNotification(notification: Notification): boolean {\n  const record = notification as unknown as Record<PropertyKey, unknown>\n  if (record[SHOULD_QUEUE] === true) return true\n  return (\n    record.connection !== undefined ||\n    record.queue !== undefined ||\n    record.delay !== undefined ||\n    record.tries !== undefined ||\n    record.backoff !== undefined ||\n    record.timeout !== undefined ||\n    typeof record.uniqueId === 'function' ||\n    typeof record.retryUntil === 'function'\n  )\n}\n\n/**\n * The notification one notifiable receives. With no id set, a shallow copy (same prototype, own fields copied)\n * carrying a fresh id, so every notifiable gets its own id (the database channel's primary key) and the caller's\n * instance is left untouched; a caller-preset id is kept as is. The copy keeps its class, so Queue's serializer\n * restores it as that class on the worker.\n */\nfunction forNotifiable(notification: Notification): Notification {\n  if (notification.id) return notification\n  const copy = Object.assign(Object.create(Object.getPrototypeOf(notification) as object) as Notification, notification)\n  copy.id = randomUUID()\n  return copy\n}\n\n/**\n * One notifiable, an array, or any other iterable of them (a Database `Collection` from `await User.where(...).get()`,\n * a Set, ...), as Laravel's `Notification::send($users, ...)` accepts. A notifiable is recognised by its\n * routeNotificationFor() method first, so an iterable model is still treated as one notifiable.\n */\nexport function toNotifiableList(notifiables: Notifiable | Iterable<Notifiable>): Notifiable[] {\n  if (Array.isArray(notifiables)) return notifiables as Notifiable[]\n  if (typeof (notifiables as Partial<Notifiable>).routeNotificationFor === 'function') return [notifiables as Notifiable]\n  if (typeof notifiables === 'object' && notifiables !== null && Symbol.iterator in notifiables) {\n    return [...(notifiables as Iterable<Notifiable>)]\n  }\n  return [notifiables as Notifiable]\n}\n\n/** Resolves channels by name from a factory map — mirrors MailManager's driver resolution. */\nexport class Dispatcher implements NotificationDispatcherContract {\n  private readonly factories = new Map<string, () => NotificationChannel>()\n  private readonly channels = new Map<string, NotificationChannel>()\n\n  constructor(private readonly container: Container) {}\n\n  extend(channel: string, factory: () => NotificationChannel): void {\n    this.factories.set(channel, factory)\n    this.channels.delete(channel)\n  }\n\n  private resolve(name: string): NotificationChannel {\n    const cached = this.channels.get(name)\n    if (cached) return cached\n    const factory = this.factories.get(name)\n    if (!factory) throw new UnknownNotificationChannelError(name)\n    const channel = factory()\n    this.channels.set(name, channel)\n    return channel\n  }\n\n  async send(notifiables: Notifiable | Iterable<Notifiable>, notification: Notification): Promise<void> {\n    const list = toNotifiableList(notifiables)\n    if (list.length === 0) return\n    if (isQueueableNotification(notification)) {\n      if (!this.container.bound(BusDispatcherToken)) throw new NotificationQueueUnavailableError()\n      const bus = this.container.make(BusDispatcherToken)\n      // One job per notifiable per channel, as Laravel does, so a failing channel or recipient retries alone.\n      for (const notifiable of list) {\n        const own = forNotifiable(notification)\n        for (const channel of notification.via(notifiable)) {\n          await bus.dispatch(new SendQueuedNotifications([notifiable], own, [channel]))\n        }\n      }\n      return\n    }\n    await this.sendNow(list, notification)\n  }\n\n  async sendNow(notifiables: Notifiable | Iterable<Notifiable>, notification: Notification, channels?: string[]): Promise<void> {\n    const list = toNotifiableList(notifiables)\n    for (const notifiable of list) {\n      const own = forNotifiable(notification)\n      const names = channels ?? notification.via(notifiable)\n      for (const name of names) {\n        // An on-demand notifiable has no model to store a row against, so it skips 'database' as in Laravel.\n        if (name === 'database' && notifiable instanceof AnonymousNotifiable) continue\n        await this.resolve(name).send(notifiable, own)\n      }\n    }\n  }\n\n  /** On-demand: an AnonymousNotifiable, whose notify() goes through the bound NotificationDispatcher. */\n  route(channel: string, route: unknown): AnonymousNotifiable {\n    return new AnonymousNotifiable().route(channel, route)\n  }\n}\n","import {\n  NotificationDispatcher as NotificationDispatcherToken,\n  type ModelInstance,\n  type Notifiable as NotifiableContract,\n  type Notification,\n  type NotificationDispatcher,\n} from '@orieljs/contracts'\nimport { currentContainer } from '@orieljs/container'\nimport { Str } from '@orieljs/support'\nimport { fetchNotifications, type DatabaseNotificationRecord } from './channels/DatabaseNotificationChannel'\nimport { NotDatabaseNotifiableError, NotificationDispatcherUnavailableError } from './errors'\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type NotifiableConstructor = new (...args: any[]) => object\n\n/** The bound NotificationDispatcher, or a clear error when the Notifications component isn't registered. */\nexport function resolveDispatcher(): NotificationDispatcher {\n  const container = currentContainer()\n  if (!container?.bound(NotificationDispatcherToken)) throw new NotificationDispatcherUnavailableError()\n  return container.make(NotificationDispatcherToken)\n}\n\nfunction requireKey(instance: object): unknown {\n  const model = instance as Partial<ModelInstance>\n  if (typeof model.getKey !== 'function') throw new NotDatabaseNotifiableError(instance.constructor.name)\n  return model.getKey()\n}\n\n/**\n * Mirrors Laravel's Illuminate\\Notifications\\Notifiable trait: `class User extends Notifiable(Model) {}`. Custom\n * routing per channel follows Laravel's own resolution order: a `routeNotificationFor<Channel>()` method (Studly\n * name) wins if present, else 'mail' reads `email`/`getAttribute('email')`, 'database' returns the instance itself\n * (the database channel derives the table row from it directly), and anything else is unrouted (`undefined`).\n */\nexport function Notifiable<TBase extends NotifiableConstructor>(Base: TBase) {\n  return class NotifiableMixin extends Base implements NotifiableContract {\n    routeNotificationFor(channel: string, notification: Notification): unknown {\n      const custom = (this as unknown as Record<string, unknown>)[`routeNotificationFor${Str.studly(channel)}`]\n      if (typeof custom === 'function') return (custom as (n: Notification) => unknown).call(this, notification)\n      if (channel === 'mail') {\n        const withAttrs = this as unknown as { email?: string; getAttribute?: (key: string) => unknown }\n        return typeof withAttrs.getAttribute === 'function' ? withAttrs.getAttribute('email') : withAttrs.email\n      }\n      if (channel === 'database') return this\n      return undefined\n    }\n\n    async notify(notification: Notification): Promise<void> {\n      await resolveDispatcher().send(this as unknown as NotifiableContract, notification)\n    }\n\n    async notifyNow(notification: Notification, channels?: string[]): Promise<void> {\n      await resolveDispatcher().sendNow(this as unknown as NotifiableContract, notification, channels)\n    }\n\n    notifications(): Promise<DatabaseNotificationRecord[]> {\n      return fetchNotifications(this.constructor.name, requireKey(this))\n    }\n\n    unreadNotifications(): Promise<DatabaseNotificationRecord[]> {\n      return fetchNotifications(this.constructor.name, requireKey(this), 'unread')\n    }\n\n    readNotifications(): Promise<DatabaseNotificationRecord[]> {\n      return fetchNotifications(this.constructor.name, requireKey(this), 'read')\n    }\n  }\n}\n","import type { Notifiable, Notification } from '@orieljs/contracts'\nimport { resolveDispatcher } from './Notifiable'\n\n/**\n * Returned by `Notification.route(channel, address)` for sending to an address with no model behind it. The\n * routes are an own plain record and every method sits on the prototype, so a queued on-demand notification\n * survives Queue's serializer (which rejects functions in own fields) and is restored on the worker as this class\n * (registered as `'Notifications.AnonymousNotifiable'` in ClassRegistry).\n */\nexport class AnonymousNotifiable implements Notifiable {\n  routes: Record<string, unknown> = {}\n\n  /** Adds a route; chains, so one on-demand notifiable can go to several channels. */\n  route(channel: string, route: unknown): this {\n    this.routes[channel] = route\n    return this\n  }\n\n  routeNotificationFor(channel: string): unknown {\n    return this.routes[channel]\n  }\n\n  async notify(notification: Notification): Promise<void> {\n    await resolveDispatcher().send(this, notification)\n  }\n\n  async notifyNow(notification: Notification, channels?: string[]): Promise<void> {\n    await resolveDispatcher().sendNow(this, notification, channels)\n  }\n}\n","import { NotificationDispatcher as NotificationDispatcherToken, type Job, type Notifiable, type Notification } from '@orieljs/contracts'\nimport { inject } from '@orieljs/container'\nimport { SHOULD_QUEUE } from '../symbols'\n\n/** The ShouldQueue options copied from the notification onto the wrapper job. */\nconst QUEUE_OPTIONS = [\n  'connection',\n  'queue',\n  'delay',\n  'tries',\n  'backoff',\n  'timeout',\n  'failOnTimeout',\n  'deleteWhenMissingModels',\n] as const\n\n/** The job hooks Queue reads off a job instance, when the wrapped notification defines them. */\ninterface JobHooks {\n  failed?: (error: unknown) => unknown\n  retryUntil?: () => unknown\n  middleware?: unknown[] | (() => unknown[])\n}\n\n/**\n * Copies the notification's own ShouldQueue fields onto the wrapper job (when set) — same reasoning as Mail's\n * SendQueuedMailable. Uses `declare` fields on the class (no runtime auto-initialization to `undefined`), so a\n * field is a genuinely own property only when the notification actually set it.\n */\nfunction copyShouldQueueFields(target: Record<PropertyKey, unknown>, source: object): void {\n  const fields = source as Record<string, unknown>\n  for (const option of QUEUE_OPTIONS) {\n    if (fields[option] !== undefined) target[option] = fields[option]\n  }\n}\n\n/**\n * Dispatched by Dispatcher.send() when the notification is queueable. Runs on the worker: calls sendNow()\n * directly (never send()), so it can't re-detect itself as queueable and loop.\n *\n * Carries `SHOULD_QUEUE` on its own prototype, per the Queue/Bus protocol, so `BusDispatcher.dispatch()` — which\n * re-decides queued-or-now on whatever job it's handed — actually enqueues it instead of running it inline; the\n * notification's own queueability (checked by Dispatcher, above) only decides whether to wrap it at all. Like\n * Laravel's SendQueuedNotifications, it forwards failed(), retryUntil(), middleware() and displayName() to the\n * notification.\n */\nexport class SendQueuedNotifications implements Job {\n  declare connection?: string\n  declare queue?: string\n  declare delay?: number\n  declare tries?: number\n  declare backoff?: number | number[]\n  declare timeout?: number\n  declare failOnTimeout?: boolean\n  declare deleteWhenMissingModels?: boolean\n\n  constructor(\n    readonly notifiables: Notifiable[],\n    readonly notification: Notification,\n    readonly channels?: string[],\n  ) {\n    copyShouldQueueFields(this as unknown as Record<PropertyKey, unknown>, notification)\n  }\n\n  async handle(): Promise<void> {\n    await inject(NotificationDispatcherToken).sendNow(this.notifiables, this.notification, this.channels)\n  }\n\n  /** Called by Queue after the final failed attempt. */\n  async failed(error: unknown): Promise<void> {\n    const hooks = this.notification as unknown as JobHooks\n    if (typeof hooks.failed === 'function') await hooks.failed.call(this.notification, error)\n  }\n\n  /** `failed_jobs` and `queue:failed` show the notification's class, not the wrapper's. */\n  displayName(): string {\n    return this.notification.constructor.name\n  }\n\n  retryUntil(): unknown {\n    const hooks = this.notification as unknown as JobHooks\n    return typeof hooks.retryUntil === 'function' ? hooks.retryUntil.call(this.notification) : undefined\n  }\n\n  middleware(): unknown[] {\n    const declared = (this.notification as unknown as JobHooks).middleware\n    return (typeof declared === 'function' ? declared.call(this.notification) : declared) ?? []\n  }\n}\n;(SendQueuedNotifications.prototype as unknown as Record<PropertyKey, unknown>)[SHOULD_QUEUE] = true\n","import {\n  NotificationDispatcher as NotificationDispatcherToken,\n  type Notifiable,\n  type Notification as NotificationContract,\n  type NotificationChannel,\n  type NotificationDispatcher,\n} from '@orieljs/contracts'\nimport { facade } from '@orieljs/support'\nimport { toNotifiableList } from './Dispatcher'\nimport { resolveDispatcher } from './Notifiable'\n\n/**\n * Mirrors Laravel's Illuminate\\Notifications\\Notification: override via(), and whichever toXxx() the channels\n * need.\n *\n * The statics are the `Notification` facade, so one export serves both `class InvoicePaid extends Notification`\n * and `Notification.send(users, new InvoicePaid())`.\n */\nexport abstract class Notification implements NotificationContract {\n  id?: string\n  abstract via(notifiable: Notifiable): string[]\n\n  /** Queues it when the notification is queueable, otherwise sends now. Accepts one notifiable, an array or any iterable. */\n  static send(notifiables: Notifiable | Iterable<Notifiable>, notification: NotificationContract): Promise<void> {\n    return resolveDispatcher().send(toNotifiableList(notifiables), notification)\n  }\n\n  static sendNow(\n    notifiables: Notifiable | Iterable<Notifiable>,\n    notification: NotificationContract,\n    channels?: string[],\n  ): Promise<void> {\n    return resolveDispatcher().sendNow(toNotifiableList(notifiables), notification, channels)\n  }\n\n  /** On-demand: `Notification.route('mail', 'a@b.c').notify(new InvoicePaid())`. */\n  static route(channel: string, route: unknown): Notifiable & { notify(notification: NotificationContract): Promise<void> } {\n    return resolveDispatcher().route(channel, route)\n  }\n\n  static extend(channel: string, factory: () => NotificationChannel): void {\n    resolveDispatcher().extend(channel, factory)\n  }\n\n  /** Replace the dispatcher in the current container (what a NotificationFake uses). */\n  static swap(fake: NotificationDispatcher): void {\n    facade<NotificationDispatcher>(NotificationDispatcherToken).swap(fake)\n  }\n}\n","import type { NotificationDispatcher } from '@orieljs/contracts'\nimport { NotificationDispatcher as NotificationDispatcherToken } from '@orieljs/contracts'\nimport { facade } from '@orieljs/support'\n\n/**\n * The plain facade over NotificationDispatcher. App code normally uses the `Notification` base class's statics\n * instead (one `Notification` export is both the base class and the facade); this stays exported for code that\n * wants the contract-typed proxy (getFacadeRoot(), swap()).\n */\nexport const NotificationFacade = facade<NotificationDispatcher>(NotificationDispatcherToken)\n","import { ClassRegistry as ClassRegistryToken, NotificationDispatcher as NotificationDispatcherToken } from '@orieljs/contracts'\nimport { ServiceProvider } from '@orieljs/support'\nimport { AnonymousNotifiable } from './AnonymousNotifiable'\nimport { DatabaseNotificationChannel } from './channels/DatabaseNotificationChannel'\nimport { MailNotificationChannel } from './channels/MailNotificationChannel'\nimport { Dispatcher } from './Dispatcher'\nimport { SendQueuedNotifications } from './Jobs/SendQueuedNotifications'\n\nexport class NotificationsServiceProvider extends ServiceProvider {\n  override register(): void {\n    this.app.singleton(NotificationDispatcherToken, (container) => new Dispatcher(container))\n    // Namespaced names, registered in register() (not boot()) — the Queue/Bus protocol rule for wrapper classes.\n    // ClassRegistry is safe to use here: Application's own constructor binds it before any provider registers.\n    const registry = this.app.make(ClassRegistryToken)\n    registry.register(SendQueuedNotifications, 'Notifications.SendQueuedNotifications')\n    registry.register(AnonymousNotifiable, 'Notifications.AnonymousNotifiable')\n  }\n\n  override boot(): void {\n    const dispatcher = this.app.make(NotificationDispatcherToken)\n    dispatcher.extend('mail', () => new MailNotificationChannel())\n    dispatcher.extend('database', () => new DatabaseNotificationChannel())\n  }\n}\n"],"mappings":"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","names":["currentContainer","currentContainer","randomUUID","currentContainer","currentContainer","NotificationDispatcherToken","NotificationDispatcherToken","randomUUID","NotificationDispatcherToken","NotificationDispatcherToken","NotificationDispatcherToken","facade","NotificationDispatcherToken","NotificationDispatcherToken"]}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@orieljs/notifications",
+  "version": "0.1.0-alpha.1",
+  "description": "The Oriel Notifications component.",
+  "type": "module",
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orieljs/framework.git",
+    "directory": "src/Oriel/Notifications"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "dependencies": {
+    "@orieljs/contracts": "0.1.0-alpha.1",
+    "@orieljs/container": "0.1.0-alpha.1",
+    "@orieljs/support": "0.1.0-alpha.1"
+  },
+  "scripts": {
+    "build": "tsup && node ../../../scripts/copy-license.mjs"
+  }
+}