@house-rules/notifications 0.0.0-stage → 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,188 @@
+import { Notifications } from "./facade.js";
+import { bindNotifications } from "./notification/bind-notifications.js";
+export declare const NotificationsMount: {
+    map: {
+        name: string;
+        kind: "package";
+        package: string;
+    };
+    service: typeof Notifications;
+    operations: (import("@house-rules/domain").Operation<"Notifications.dueDeliveries", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").$Array<import("effect/Schema").Struct<{
+        readonly recipient: import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>;
+        readonly channel: import("effect/Schema").Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: import("effect/Schema").Literals<readonly ["immediate", "hourly", "daily"]>;
+        readonly deliveries: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly delivery: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").NonEmptyString;
+                readonly notificationId: import("effect/Schema").NonEmptyString;
+                readonly recipient: import("effect/Schema").Struct<{
+                    readonly kind: import("effect/Schema").NonEmptyString;
+                    readonly id: import("effect/Schema").NonEmptyString;
+                }>;
+                readonly channel: import("effect/Schema").Literals<readonly ["inapp", "push", "email"]>;
+                readonly mode: import("effect/Schema").Literals<readonly ["immediate", "hourly", "daily"]>;
+                readonly state: import("effect/Schema").Literals<readonly ["pending", "held", "sent", "failed", "cancelled"]>;
+                readonly dueAt: import("effect/Schema").Int;
+                readonly retryAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+                readonly sentAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+                readonly attempts: import("effect/Schema").Int;
+                readonly lastError: import("effect/Schema").NullOr<import("effect/Schema").String>;
+            }>;
+            readonly notification: import("effect/Schema").Struct<{
+                readonly id: import("effect/Schema").NonEmptyString;
+                readonly recipient: import("effect/Schema").Struct<{
+                    readonly kind: import("effect/Schema").NonEmptyString;
+                    readonly id: import("effect/Schema").NonEmptyString;
+                }>;
+                readonly category: import("effect/Schema").NonEmptyString;
+                readonly title: import("effect/Schema").NonEmptyString;
+                readonly body: import("effect/Schema").String;
+                readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+                readonly createdAt: import("effect/Schema").Int;
+                readonly readAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+            }>;
+        }>>;
+    }>>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Notifications.getMyPreferences", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").Struct<{
+        readonly preferences: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly category: import("effect/Schema").NonEmptyString;
+            readonly channel: import("effect/Schema").Literals<readonly ["inapp", "push", "email"]>;
+            readonly mode: import("effect/Schema").Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+        }>>;
+        readonly quietHours: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly start: import("effect/Schema").String;
+            readonly end: import("effect/Schema").String;
+        }>>;
+        readonly timeZone: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Notifications.listMine", import("effect/Schema").Struct<{
+        readonly page: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly size: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
+            readonly cursor: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                readonly createdAt: import("effect/Schema").Int;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>>;
+        }>>;
+    }>, import("effect/Schema").Struct<{
+        readonly notifications: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly category: import("effect/Schema").NonEmptyString;
+            readonly title: import("effect/Schema").NonEmptyString;
+            readonly body: import("effect/Schema").String;
+            readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly readAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>>;
+        readonly next: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly createdAt: import("effect/Schema").Int;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false> | import("@house-rules/domain").Operation<"Notifications.markAllRead", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").Struct<{
+        readonly notifications: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly category: import("effect/Schema").NonEmptyString;
+            readonly title: import("effect/Schema").NonEmptyString;
+            readonly body: import("effect/Schema").String;
+            readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly readAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>>;
+        readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"NotificationRead">;
+            readonly notificationId: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.markFailed", import("effect/Schema").Struct<{
+        readonly deliveryId: import("effect/Schema").NonEmptyString;
+        readonly error: import("effect/Schema").String;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.markRead", import("effect/Schema").Struct<{
+        readonly notificationId: import("effect/Schema").NonEmptyString;
+    }>, import("effect/Schema").Struct<{
+        readonly notifications: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly category: import("effect/Schema").NonEmptyString;
+            readonly title: import("effect/Schema").NonEmptyString;
+            readonly body: import("effect/Schema").String;
+            readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly readAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>>;
+        readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"NotificationRead">;
+            readonly notificationId: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.markSent", import("effect/Schema").Struct<{
+        readonly deliveryIds: import("effect/Schema").$Array<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.notify", import("effect/Schema").Struct<{
+        readonly recipients: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").NonEmptyString;
+            readonly id: import("effect/Schema").NonEmptyString;
+        }>>;
+        readonly category: import("effect/Schema").NonEmptyString;
+        readonly title: import("effect/Schema").NonEmptyString;
+        readonly body: import("effect/Schema").String;
+        readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+    }>, import("effect/Schema").Struct<{
+        readonly notifications: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly id: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly category: import("effect/Schema").NonEmptyString;
+            readonly title: import("effect/Schema").NonEmptyString;
+            readonly body: import("effect/Schema").String;
+            readonly data: import("effect/Schema").Codec<import("effect/Schema").Json, import("effect/Schema").Json, never, never>;
+            readonly createdAt: import("effect/Schema").Int;
+            readonly readAt: import("effect/Schema").NullOr<import("effect/Schema").Int>;
+        }>>;
+        readonly events: import("effect/Schema").$Array<import("effect/Schema").Struct<{
+            readonly kind: import("effect/Schema").Literal<"NotificationCreated">;
+            readonly notificationId: import("effect/Schema").NonEmptyString;
+            readonly recipient: import("effect/Schema").Struct<{
+                readonly kind: import("effect/Schema").NonEmptyString;
+                readonly id: import("effect/Schema").NonEmptyString;
+            }>;
+            readonly channels: import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["inapp", "push", "email"]>>;
+        }>>;
+    }>, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.setMyPreference", import("effect/Schema").Struct<{
+        readonly category: import("effect/Schema").NonEmptyString;
+        readonly channel: import("effect/Schema").Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: import("effect/Schema").Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.setMyQuietHours", import("effect/Schema").Struct<{
+        readonly quietHours: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
+            readonly start: import("effect/Schema").String;
+            readonly end: import("effect/Schema").String;
+        }>>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.setMyTimeZone", import("effect/Schema").Struct<{
+        readonly timeZone: import("effect/Schema").NullOr<import("effect/Schema").NonEmptyString>;
+    }>, import("effect/Schema").Void, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, false, false, true, false> | import("@house-rules/domain").Operation<"Notifications.unreadCount", import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Never>, import("effect/Schema").Int, import("effect/Schema").Union<readonly [typeof import("./contract.js").NotificationForbidden, typeof import("./contract.js").NotificationInputInvalid, typeof import("./contract.js").NotificationStoreUnavailable]>, NoInfer<readonly []>, true, false, false, false>)[];
+    bind: typeof bindNotifications;
+};
+export { Notifications } from "./facade.js";
+export { bindNotifications } from "./notification/bind-notifications.js";
+export { NotificationCategory, NotificationsOptions } from "./notification/options.js";
+export { NotificationStore } from "./storage.js";
+export { memoryNotificationStore } from "./adapters/memory/notification.js";
+export { postgresNotificationStore } from "./adapters/postgres/notification.js";
+export { Channel, Delivery, DeliveryItem, DeliveryMode, DueDelivery, LocalTime, MyPreferences, Notification, NotificationCreated, NotificationCursor, NotificationEvents, NotificationForbidden, NotificationInputInvalid, NotificationList, NotificationNotFound, NotificationPage, type NotificationPermission, NotificationPermissions, NotificationRead, NotificationStoreUnavailable, NotificationsOperations, NotifyInput, NotifyResult, Preference, QuietHours, ReadResult, Recipient, TimeZone, } from "./contract.js";

package/dist/index.js

@@ -0,0 +1,16 @@
+import { Notifications } from "./facade.js";
+import { NotificationsOperations } from "./contract.js";
+import { bindNotifications } from "./notification/bind-notifications.js";
+export const NotificationsMount = {
+    map: { name: "notifications", kind: "package", package: "@house-rules/notifications" },
+    service: Notifications,
+    operations: Object.values(NotificationsOperations),
+    bind: bindNotifications,
+};
+export { Notifications } from "./facade.js";
+export { bindNotifications } from "./notification/bind-notifications.js";
+export { NotificationCategory, NotificationsOptions } from "./notification/options.js";
+export { NotificationStore } from "./storage.js";
+export { memoryNotificationStore } from "./adapters/memory/notification.js";
+export { postgresNotificationStore } from "./adapters/postgres/notification.js";
+export { Channel, Delivery, DeliveryItem, DeliveryMode, DueDelivery, LocalTime, MyPreferences, Notification, NotificationCreated, NotificationCursor, NotificationEvents, NotificationForbidden, NotificationInputInvalid, NotificationList, NotificationNotFound, NotificationPage, NotificationPermissions, NotificationRead, NotificationStoreUnavailable, NotificationsOperations, NotifyInput, NotifyResult, Preference, QuietHours, ReadResult, Recipient, TimeZone, } from "./contract.js";

package/dist/notification/bind-notifications.d.ts

@@ -0,0 +1,3 @@
+import { type Binding } from "@house-rules/application";
+import type { NotificationsService } from "./notifications.js";
+export declare const bindNotifications: (service: NotificationsService) => readonly Binding[];

package/dist/notification/bind-notifications.js

@@ -0,0 +1,19 @@
+import { bindOperation } from "@house-rules/application";
+import { Effect } from "effect";
+import { NotificationForbidden } from "./notification.js";
+import { NotificationsOperations as operations } from "./operations.js";
+const forbidden = () => Effect.fail(new NotificationForbidden({ message: "This notification action is not allowed." }));
+export const bindNotifications = (service) => [
+    bindOperation(operations.notify, (input, { caller }) => caller.kind === "system" ? service.notify(input) : forbidden()),
+    bindOperation(operations.listMine, ({ page }, { caller }) => caller.kind === "person" ? service.listMine(caller.actor, page) : forbidden()),
+    bindOperation(operations.unreadCount, (_, { caller }) => caller.kind === "person" ? service.unreadCount(caller.actor) : forbidden()),
+    bindOperation(operations.markRead, ({ notificationId }, { caller }) => caller.kind === "person" ? service.markRead(caller.actor, notificationId) : forbidden()),
+    bindOperation(operations.markAllRead, (_, { caller }) => caller.kind === "person" ? service.markAllRead(caller.actor) : forbidden()),
+    bindOperation(operations.getMyPreferences, (_, { caller }) => caller.kind === "person" ? service.getMyPreferences(caller.actor) : forbidden()),
+    bindOperation(operations.setMyPreference, (input, { caller }) => caller.kind === "person" ? service.setMyPreference(caller.actor, input) : forbidden()),
+    bindOperation(operations.setMyQuietHours, ({ quietHours }, { caller }) => caller.kind === "person" ? service.setMyQuietHours(caller.actor, quietHours) : forbidden()),
+    bindOperation(operations.setMyTimeZone, ({ timeZone }, { caller }) => caller.kind === "person" ? service.setMyTimeZone(caller.actor, timeZone) : forbidden()),
+    bindOperation(operations.dueDeliveries, (_, { caller }) => caller.kind === "system" ? service.dueDeliveries() : forbidden()),
+    bindOperation(operations.markSent, ({ deliveryIds }, { caller }) => caller.kind === "system" ? service.markSent(deliveryIds) : forbidden()),
+    bindOperation(operations.markFailed, ({ deliveryId, error }, { caller }) => caller.kind === "system" ? service.markFailed(deliveryId, error) : forbidden()),
+];

package/dist/notification/notification.d.ts

@@ -0,0 +1,277 @@
+import { Schema } from "effect";
+export declare const Recipient: Schema.Struct<{
+    readonly kind: Schema.NonEmptyString;
+    readonly id: Schema.NonEmptyString;
+}>;
+export type Recipient = typeof Recipient.Type;
+export declare const Channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+export type Channel = typeof Channel.Type;
+export declare const DeliveryMode: Schema.Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+export type DeliveryMode = typeof DeliveryMode.Type;
+export declare const LocalTime: Schema.String;
+export declare const TimeZone: Schema.NonEmptyString;
+export declare const QuietHours: Schema.Struct<{
+    readonly start: Schema.String;
+    readonly end: Schema.String;
+}>;
+export type QuietHours = typeof QuietHours.Type;
+export declare const Notification: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly category: Schema.NonEmptyString;
+    readonly title: Schema.NonEmptyString;
+    readonly body: Schema.String;
+    readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly createdAt: Schema.Int;
+    readonly readAt: Schema.NullOr<Schema.Int>;
+}>;
+export type Notification = typeof Notification.Type;
+export declare const NotifyInput: Schema.Struct<{
+    readonly recipients: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+    readonly category: Schema.NonEmptyString;
+    readonly title: Schema.NonEmptyString;
+    readonly body: Schema.String;
+    readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type NotifyInput = typeof NotifyInput.Type;
+export declare const NotificationCreated: Schema.Struct<{
+    readonly kind: Schema.Literal<"NotificationCreated">;
+    readonly notificationId: Schema.NonEmptyString;
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly channels: Schema.$Array<Schema.Literals<readonly ["inapp", "push", "email"]>>;
+}>;
+export type NotificationCreated = typeof NotificationCreated.Type;
+export declare const NotificationRead: Schema.Struct<{
+    readonly kind: Schema.Literal<"NotificationRead">;
+    readonly notificationId: Schema.NonEmptyString;
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+}>;
+export type NotificationRead = typeof NotificationRead.Type;
+export declare const NotifyResult: Schema.Struct<{
+    readonly notifications: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly category: Schema.NonEmptyString;
+        readonly title: Schema.NonEmptyString;
+        readonly body: Schema.String;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly createdAt: Schema.Int;
+        readonly readAt: Schema.NullOr<Schema.Int>;
+    }>>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"NotificationCreated">;
+        readonly notificationId: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly channels: Schema.$Array<Schema.Literals<readonly ["inapp", "push", "email"]>>;
+    }>>;
+}>;
+export type NotifyResult = typeof NotifyResult.Type;
+export declare const ReadResult: Schema.Struct<{
+    readonly notifications: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly category: Schema.NonEmptyString;
+        readonly title: Schema.NonEmptyString;
+        readonly body: Schema.String;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly createdAt: Schema.Int;
+        readonly readAt: Schema.NullOr<Schema.Int>;
+    }>>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literal<"NotificationRead">;
+        readonly notificationId: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+    }>>;
+}>;
+export type ReadResult = typeof ReadResult.Type;
+export declare const NotificationCursor: Schema.Struct<{
+    readonly createdAt: Schema.Int;
+    readonly id: Schema.NonEmptyString;
+}>;
+export type NotificationCursor = typeof NotificationCursor.Type;
+export declare const NotificationPage: Schema.Struct<{
+    readonly size: Schema.optionalKey<Schema.Int>;
+    readonly cursor: Schema.optionalKey<Schema.Struct<{
+        readonly createdAt: Schema.Int;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+}>;
+export type NotificationPage = typeof NotificationPage.Type;
+export declare const NotificationList: Schema.Struct<{
+    readonly notifications: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly category: Schema.NonEmptyString;
+        readonly title: Schema.NonEmptyString;
+        readonly body: Schema.String;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly createdAt: Schema.Int;
+        readonly readAt: Schema.NullOr<Schema.Int>;
+    }>>;
+    readonly next: Schema.optionalKey<Schema.Struct<{
+        readonly createdAt: Schema.Int;
+        readonly id: Schema.NonEmptyString;
+    }>>;
+}>;
+export type NotificationList = typeof NotificationList.Type;
+export declare const Preference: Schema.Struct<{
+    readonly category: Schema.NonEmptyString;
+    readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+    readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+}>;
+export type Preference = typeof Preference.Type;
+export declare const MyPreferences: Schema.Struct<{
+    readonly preferences: Schema.$Array<Schema.Struct<{
+        readonly category: Schema.NonEmptyString;
+        readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily", "off"]>;
+    }>>;
+    readonly quietHours: Schema.NullOr<Schema.Struct<{
+        readonly start: Schema.String;
+        readonly end: Schema.String;
+    }>>;
+    readonly timeZone: Schema.NullOr<Schema.NonEmptyString>;
+}>;
+export type MyPreferences = typeof MyPreferences.Type;
+export declare const Delivery: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly notificationId: Schema.NonEmptyString;
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+    readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+    readonly state: Schema.Literals<readonly ["pending", "held", "sent", "failed", "cancelled"]>;
+    readonly dueAt: Schema.Int;
+    readonly retryAt: Schema.NullOr<Schema.Int>;
+    readonly sentAt: Schema.NullOr<Schema.Int>;
+    readonly attempts: Schema.Int;
+    readonly lastError: Schema.NullOr<Schema.String>;
+}>;
+export type Delivery = typeof Delivery.Type;
+export declare const DeliveryItem: Schema.Struct<{
+    readonly delivery: Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly notificationId: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+        readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+        readonly state: Schema.Literals<readonly ["pending", "held", "sent", "failed", "cancelled"]>;
+        readonly dueAt: Schema.Int;
+        readonly retryAt: Schema.NullOr<Schema.Int>;
+        readonly sentAt: Schema.NullOr<Schema.Int>;
+        readonly attempts: Schema.Int;
+        readonly lastError: Schema.NullOr<Schema.String>;
+    }>;
+    readonly notification: Schema.Struct<{
+        readonly id: Schema.NonEmptyString;
+        readonly recipient: Schema.Struct<{
+            readonly kind: Schema.NonEmptyString;
+            readonly id: Schema.NonEmptyString;
+        }>;
+        readonly category: Schema.NonEmptyString;
+        readonly title: Schema.NonEmptyString;
+        readonly body: Schema.String;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly createdAt: Schema.Int;
+        readonly readAt: Schema.NullOr<Schema.Int>;
+    }>;
+}>;
+export type DeliveryItem = typeof DeliveryItem.Type;
+export declare const DueDelivery: Schema.Struct<{
+    readonly recipient: Schema.Struct<{
+        readonly kind: Schema.NonEmptyString;
+        readonly id: Schema.NonEmptyString;
+    }>;
+    readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+    readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+    readonly deliveries: Schema.$Array<Schema.Struct<{
+        readonly delivery: Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly notificationId: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly channel: Schema.Literals<readonly ["inapp", "push", "email"]>;
+            readonly mode: Schema.Literals<readonly ["immediate", "hourly", "daily"]>;
+            readonly state: Schema.Literals<readonly ["pending", "held", "sent", "failed", "cancelled"]>;
+            readonly dueAt: Schema.Int;
+            readonly retryAt: Schema.NullOr<Schema.Int>;
+            readonly sentAt: Schema.NullOr<Schema.Int>;
+            readonly attempts: Schema.Int;
+            readonly lastError: Schema.NullOr<Schema.String>;
+        }>;
+        readonly notification: Schema.Struct<{
+            readonly id: Schema.NonEmptyString;
+            readonly recipient: Schema.Struct<{
+                readonly kind: Schema.NonEmptyString;
+                readonly id: Schema.NonEmptyString;
+            }>;
+            readonly category: Schema.NonEmptyString;
+            readonly title: Schema.NonEmptyString;
+            readonly body: Schema.String;
+            readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly createdAt: Schema.Int;
+            readonly readAt: Schema.NullOr<Schema.Int>;
+        }>;
+    }>>;
+}>;
+export type DueDelivery = typeof DueDelivery.Type;
+declare const NotificationInputInvalid_base: Schema.Class<NotificationInputInvalid, Schema.TaggedStruct<"NotificationInputInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotificationInputInvalid extends NotificationInputInvalid_base {
+}
+declare const NotificationNotFound_base: Schema.Class<NotificationNotFound, Schema.TaggedStruct<"NotificationNotFound", {
+    readonly kind: Schema.tag<"not_found">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotificationNotFound extends NotificationNotFound_base {
+}
+declare const NotificationForbidden_base: Schema.Class<NotificationForbidden, Schema.TaggedStruct<"NotificationForbidden", {
+    readonly kind: Schema.tag<"forbidden">;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotificationForbidden extends NotificationForbidden_base {
+}
+declare const NotificationStoreUnavailable_base: Schema.Class<NotificationStoreUnavailable, Schema.TaggedStruct<"NotificationStoreUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class NotificationStoreUnavailable extends NotificationStoreUnavailable_base {
+    get message(): string;
+}
+export {};

package/dist/notification/notification.js

@@ -0,0 +1,108 @@
+import { errorKind } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+export const Recipient = Schema.Struct({ kind: Schema.NonEmptyString, id: Schema.NonEmptyString });
+export const Channel = Schema.Literals(["inapp", "push", "email"]);
+export const DeliveryMode = Schema.Literals(["immediate", "hourly", "daily", "off"]);
+export const LocalTime = Schema.String.check(Schema.isPattern(/^([01]\d|2[0-3]):[0-5]\d$/));
+export const TimeZone = Schema.NonEmptyString.check(Schema.makeFilter((zone) => {
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}));
+export const QuietHours = Schema.Struct({
+    start: LocalTime,
+    end: LocalTime,
+}).check(Schema.makeFilter((hours) => hours.start !== hours.end));
+export const Notification = Schema.Struct({
+    id: Schema.NonEmptyString,
+    recipient: Recipient,
+    category: Schema.NonEmptyString,
+    title: Schema.NonEmptyString,
+    body: Schema.String,
+    data: Schema.Json,
+    createdAt: Schema.Int,
+    readAt: Schema.NullOr(Schema.Int),
+});
+export const NotifyInput = Schema.Struct({
+    recipients: Schema.Array(Recipient).check(Schema.isMinLength(1)),
+    category: Schema.NonEmptyString,
+    title: Schema.NonEmptyString,
+    body: Schema.String,
+    data: Schema.Json,
+});
+export const NotificationCreated = Schema.Struct({
+    kind: Schema.Literal("NotificationCreated"),
+    notificationId: Schema.NonEmptyString,
+    recipient: Recipient,
+    channels: Schema.Array(Channel),
+});
+export const NotificationRead = Schema.Struct({
+    kind: Schema.Literal("NotificationRead"),
+    notificationId: Schema.NonEmptyString,
+    recipient: Recipient,
+});
+export const NotifyResult = Schema.Struct({
+    notifications: Schema.Array(Notification),
+    events: Schema.Array(NotificationCreated),
+});
+export const ReadResult = Schema.Struct({
+    notifications: Schema.Array(Notification),
+    events: Schema.Array(NotificationRead),
+});
+export const NotificationCursor = Schema.Struct({
+    createdAt: Schema.Int,
+    id: Schema.NonEmptyString,
+});
+export const NotificationPage = Schema.Struct({
+    size: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0))),
+    cursor: Schema.optionalKey(NotificationCursor),
+});
+export const NotificationList = Schema.Struct({
+    notifications: Schema.Array(Notification),
+    next: Schema.optionalKey(NotificationCursor),
+});
+export const Preference = Schema.Struct({
+    category: Schema.NonEmptyString,
+    channel: Channel,
+    mode: DeliveryMode,
+});
+export const MyPreferences = Schema.Struct({
+    preferences: Schema.Array(Preference),
+    quietHours: Schema.NullOr(QuietHours),
+    timeZone: Schema.NullOr(TimeZone),
+});
+export const Delivery = Schema.Struct({
+    id: Schema.NonEmptyString,
+    notificationId: Schema.NonEmptyString,
+    recipient: Recipient,
+    channel: Channel,
+    mode: Schema.Literals(["immediate", "hourly", "daily"]),
+    state: Schema.Literals(["pending", "held", "sent", "failed", "cancelled"]),
+    dueAt: Schema.Int,
+    retryAt: Schema.NullOr(Schema.Int),
+    sentAt: Schema.NullOr(Schema.Int),
+    attempts: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+    lastError: Schema.NullOr(Schema.String),
+});
+export const DeliveryItem = Schema.Struct({ delivery: Delivery, notification: Notification });
+export const DueDelivery = Schema.Struct({
+    recipient: Recipient,
+    channel: Channel,
+    mode: Delivery.fields.mode,
+    deliveries: Schema.Array(DeliveryItem),
+});
+export class NotificationInputInvalid extends Schema.TaggedError()("NotificationInputInvalid", { kind: errorKind("invalid"), message: Schema.String }) {
+}
+export class NotificationNotFound extends Schema.TaggedError()("NotificationNotFound", { kind: errorKind("not_found"), message: Schema.String }) {
+}
+export class NotificationForbidden extends Schema.TaggedError()("NotificationForbidden", { kind: errorKind("forbidden"), message: Schema.String }) {
+}
+export class NotificationStoreUnavailable extends Schema.TaggedError()("NotificationStoreUnavailable", { kind: errorKind("unavailable"), cause: Schema.Defect() }) {
+    get message() {
+        return "Notifications are unavailable. Try again shortly.";
+    }
+}