@contractspec/module.notifications 1.56.1 → 1.58.0

package/dist/browser/channels/index.js

@@ -0,0 +1,124 @@
+// src/channels/index.ts
+class InAppChannel {
+  channelId = "IN_APP";
+  async send(_notification) {
+    return {
+      success: true,
+      responseMessage: "Stored in database"
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+
+class ConsoleChannel {
+  channelId = "CONSOLE";
+  async send(notification) {
+    console.log(`\uD83D\uDCEC [${notification.id}] ${notification.title}`);
+    console.log(`   ${notification.body}`);
+    if (notification.actionUrl) {
+      console.log(`   Action: ${notification.actionUrl}`);
+    }
+    return {
+      success: true,
+      responseMessage: "Logged to console"
+    };
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+
+class EmailChannel {
+  channelId = "EMAIL";
+  async isAvailable() {
+    return true;
+  }
+}
+
+class PushChannel {
+  channelId = "PUSH";
+  async isAvailable() {
+    return true;
+  }
+}
+
+class WebhookChannel {
+  channelId = "WEBHOOK";
+  async send(notification) {
+    if (!notification.webhook?.url) {
+      return {
+        success: false,
+        responseMessage: "No webhook URL configured"
+      };
+    }
+    try {
+      const response = await fetch(notification.webhook.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...notification.webhook.headers
+        },
+        body: JSON.stringify({
+          id: notification.id,
+          title: notification.title,
+          body: notification.body,
+          actionUrl: notification.actionUrl,
+          metadata: notification.metadata
+        })
+      });
+      return {
+        success: response.ok,
+        responseCode: String(response.status),
+        responseMessage: response.statusText
+      };
+    } catch (error) {
+      return {
+        success: false,
+        responseMessage: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async isAvailable() {
+    return true;
+  }
+}
+
+class ChannelRegistry {
+  channels = new Map;
+  register(channel) {
+    this.channels.set(channel.channelId, channel);
+  }
+  get(channelId) {
+    return this.channels.get(channelId);
+  }
+  getAll() {
+    return Array.from(this.channels.values());
+  }
+  async getAvailable() {
+    const available = [];
+    for (const channel of this.channels.values()) {
+      if (await channel.isAvailable()) {
+        available.push(channel);
+      }
+    }
+    return available;
+  }
+}
+function createChannelRegistry() {
+  const registry = new ChannelRegistry;
+  registry.register(new InAppChannel);
+  registry.register(new ConsoleChannel);
+  registry.register(new WebhookChannel);
+  return registry;
+}
+export {
+  createChannelRegistry,
+  WebhookChannel,
+  PushChannel,
+  InAppChannel,
+  EmailChannel,
+  ConsoleChannel,
+  ChannelRegistry
+};

package/dist/browser/contracts/index.js

@@ -0,0 +1,340 @@
+// src/contracts/index.ts
+import {
+  defineCommand,
+  defineQuery,
+  defineSchemaModel
+} from "@contractspec/lib.contracts";
+import { ScalarTypeEnum, defineEnum } from "@contractspec/lib.schema";
+var OWNERS = ["platform.notifications"];
+var NotificationStatusSchemaEnum = defineEnum("NotificationStatus", [
+  "PENDING",
+  "SENT",
+  "DELIVERED",
+  "READ",
+  "FAILED",
+  "CANCELLED"
+]);
+var NotificationChannelSchemaEnum = defineEnum("NotificationChannel", [
+  "EMAIL",
+  "IN_APP",
+  "PUSH",
+  "WEBHOOK"
+]);
+var NotificationFilterEnum = defineEnum("NotificationFilter", [
+  "unread",
+  "read",
+  "all"
+]);
+var NotificationModel = defineSchemaModel({
+  name: "Notification",
+  description: "A notification sent to a user",
+  fields: {
+    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    body: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    type: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    status: { type: NotificationStatusSchemaEnum, isOptional: false },
+    channels: {
+      type: NotificationChannelSchemaEnum,
+      isArray: true,
+      isOptional: false
+    },
+    actionUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    readAt: { type: ScalarTypeEnum.DateTime(), isOptional: true },
+    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+  }
+});
+var NotificationPreferenceModel = defineSchemaModel({
+  name: "NotificationPreference",
+  description: "User notification preferences",
+  fields: {
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    globalEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    channelPreferences: {
+      type: ScalarTypeEnum.JSONObject(),
+      isOptional: false
+    },
+    typePreferences: { type: ScalarTypeEnum.JSONObject(), isOptional: false },
+    quietHoursStart: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    quietHoursEnd: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timezone: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    digestEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: false },
+    digestFrequency: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    }
+  }
+});
+var SendNotificationInputModel = defineSchemaModel({
+  name: "SendNotificationInput",
+  description: "Input for sending a notification",
+  fields: {
+    userId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    templateId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    title: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    body: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    type: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    channels: {
+      type: NotificationChannelSchemaEnum,
+      isArray: true,
+      isOptional: true
+    },
+    actionUrl: { type: ScalarTypeEnum.URL(), isOptional: true },
+    variables: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    metadata: { type: ScalarTypeEnum.JSONObject(), isOptional: true }
+  }
+});
+var ListNotificationsInputModel = defineSchemaModel({
+  name: "ListNotificationsInput",
+  description: "Input for listing notifications",
+  fields: {
+    status: { type: NotificationFilterEnum, isOptional: true },
+    type: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    limit: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 20
+    },
+    offset: {
+      type: ScalarTypeEnum.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 0
+    }
+  }
+});
+var ListNotificationsOutputModel = defineSchemaModel({
+  name: "ListNotificationsOutput",
+  description: "Output for listing notifications",
+  fields: {
+    notifications: {
+      type: NotificationModel,
+      isArray: true,
+      isOptional: false
+    },
+    total: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    unreadCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+  }
+});
+var UpdatePreferencesInputModel = defineSchemaModel({
+  name: "UpdateNotificationPreferencesInput",
+  description: "Input for updating notification preferences",
+  fields: {
+    globalEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    channelPreferences: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    typePreferences: { type: ScalarTypeEnum.JSONObject(), isOptional: true },
+    quietHoursStart: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    quietHoursEnd: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timezone: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    digestEnabled: { type: ScalarTypeEnum.Boolean(), isOptional: true },
+    digestFrequency: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    }
+  }
+});
+var SendNotificationContract = defineCommand({
+  meta: {
+    key: "notifications.send",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "send"],
+    description: "Send a notification to a user.",
+    goal: "Deliver notifications across multiple channels.",
+    context: "Called by services when events require user notification."
+  },
+  io: {
+    input: SendNotificationInputModel,
+    output: NotificationModel,
+    errors: {
+      USER_NOT_FOUND: {
+        description: "Target user does not exist",
+        http: 404,
+        gqlCode: "USER_NOT_FOUND",
+        when: "User ID is invalid"
+      },
+      TEMPLATE_NOT_FOUND: {
+        description: "Notification template does not exist",
+        http: 404,
+        gqlCode: "TEMPLATE_NOT_FOUND",
+        when: "Template ID is invalid"
+      }
+    }
+  },
+  policy: {
+    auth: "user"
+  },
+  sideEffects: {
+    emits: [
+      {
+        key: "notification.sent",
+        version: "1.0.0",
+        when: "Notification is sent",
+        payload: NotificationModel
+      }
+    ]
+  }
+});
+var ListNotificationsContract = defineQuery({
+  meta: {
+    key: "notifications.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "list"],
+    description: "List notifications for the current user.",
+    goal: "Show user their notifications.",
+    context: "Notification center UI."
+  },
+  io: {
+    input: ListNotificationsInputModel,
+    output: ListNotificationsOutputModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var MarkNotificationReadContract = defineCommand({
+  meta: {
+    key: "notifications.markRead",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "read"],
+    description: "Mark a notification as read.",
+    goal: "Track which notifications user has seen.",
+    context: "User clicks on a notification."
+  },
+  io: {
+    input: defineSchemaModel({
+      name: "MarkNotificationReadInput",
+      fields: {
+        notificationId: {
+          type: ScalarTypeEnum.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: NotificationModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var MarkAllNotificationsReadContract = defineCommand({
+  meta: {
+    key: "notifications.markAllRead",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "read"],
+    description: "Mark all notifications as read.",
+    goal: "Clear notification badge.",
+    context: 'User clicks "mark all as read".'
+  },
+  io: {
+    input: null,
+    output: defineSchemaModel({
+      name: "MarkAllNotificationsReadOutput",
+      fields: {
+        markedCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false }
+      }
+    })
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var GetNotificationPreferencesContract = defineQuery({
+  meta: {
+    key: "notifications.preferences.get",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "preferences", "get"],
+    description: "Get notification preferences for current user.",
+    goal: "Show user their notification settings.",
+    context: "Notification settings page."
+  },
+  io: {
+    input: null,
+    output: NotificationPreferenceModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var UpdateNotificationPreferencesContract = defineCommand({
+  meta: {
+    key: "notifications.preferences.update",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "preferences", "update"],
+    description: "Update notification preferences.",
+    goal: "Allow user to control notification delivery.",
+    context: "Notification settings page."
+  },
+  io: {
+    input: UpdatePreferencesInputModel,
+    output: NotificationPreferenceModel
+  },
+  policy: {
+    auth: "user"
+  }
+});
+var DeleteNotificationContract = defineCommand({
+  meta: {
+    key: "notifications.delete",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS],
+    tags: ["notifications", "delete"],
+    description: "Delete a notification.",
+    goal: "Allow user to remove unwanted notifications.",
+    context: "User dismisses a notification."
+  },
+  io: {
+    input: defineSchemaModel({
+      name: "DeleteNotificationInput",
+      fields: {
+        notificationId: {
+          type: ScalarTypeEnum.String_unsecure(),
+          isOptional: false
+        }
+      }
+    }),
+    output: defineSchemaModel({
+      name: "DeleteNotificationOutput",
+      fields: {
+        success: { type: ScalarTypeEnum.Boolean(), isOptional: false }
+      }
+    })
+  },
+  policy: {
+    auth: "user"
+  }
+});
+export {
+  UpdatePreferencesInputModel,
+  UpdateNotificationPreferencesContract,
+  SendNotificationInputModel,
+  SendNotificationContract,
+  NotificationPreferenceModel,
+  NotificationModel,
+  NotificationFilterEnum,
+  MarkNotificationReadContract,
+  MarkAllNotificationsReadContract,
+  ListNotificationsOutputModel,
+  ListNotificationsInputModel,
+  ListNotificationsContract,
+  GetNotificationPreferencesContract,
+  DeleteNotificationContract
+};

package/dist/browser/entities/index.js

@@ -0,0 +1,223 @@
+// src/entities/index.ts
+import {
+  defineEntity,
+  defineEntityEnum,
+  field,
+  index
+} from "@contractspec/lib.schema";
+var NotificationStatusEnum = defineEntityEnum({
+  name: "NotificationStatus",
+  values: [
+    "PENDING",
+    "SENT",
+    "DELIVERED",
+    "READ",
+    "FAILED",
+    "CANCELLED"
+  ],
+  schema: "lssm_notifications",
+  description: "Status of a notification."
+});
+var NotificationChannelEnum = defineEntityEnum({
+  name: "NotificationChannel",
+  values: ["EMAIL", "IN_APP", "PUSH", "WEBHOOK", "SMS"],
+  schema: "lssm_notifications",
+  description: "Delivery channel for notifications."
+});
+var NotificationEntity = defineEntity({
+  name: "Notification",
+  description: "An individual notification to be delivered to a user.",
+  schema: "lssm_notifications",
+  map: "notification",
+  fields: {
+    id: field.id({ description: "Unique notification ID" }),
+    userId: field.foreignKey({ description: "Target user ID" }),
+    orgId: field.string({
+      isOptional: true,
+      description: "Organization context"
+    }),
+    templateId: field.string({
+      isOptional: true,
+      description: "Template used"
+    }),
+    title: field.string({ description: "Notification title" }),
+    body: field.string({ description: "Notification body" }),
+    actionUrl: field.string({ isOptional: true, description: "Action URL" }),
+    imageUrl: field.string({ isOptional: true, description: "Image URL" }),
+    type: field.string({
+      description: "Notification type (e.g., mention, update)"
+    }),
+    category: field.string({
+      isOptional: true,
+      description: "Notification category"
+    }),
+    priority: field.enum("NotificationPriority", { default: "NORMAL" }),
+    channels: field.string({
+      isArray: true,
+      description: "Target delivery channels"
+    }),
+    status: field.enum("NotificationStatus", { default: "PENDING" }),
+    sentAt: field.dateTime({ isOptional: true }),
+    deliveredAt: field.dateTime({ isOptional: true }),
+    readAt: field.dateTime({ isOptional: true }),
+    metadata: field.json({
+      isOptional: true,
+      description: "Additional metadata"
+    }),
+    variables: field.json({
+      isOptional: true,
+      description: "Template variables used"
+    }),
+    triggeredBy: field.string({
+      isOptional: true,
+      description: "Event/action that triggered"
+    }),
+    sourceId: field.string({
+      isOptional: true,
+      description: "Source entity ID"
+    }),
+    sourceType: field.string({
+      isOptional: true,
+      description: "Source entity type"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    expiresAt: field.dateTime({
+      isOptional: true,
+      description: "Notification expiry"
+    }),
+    deliveryLogs: field.hasMany("DeliveryLog")
+  },
+  indexes: [
+    index.on(["userId", "status", "createdAt"]),
+    index.on(["userId", "readAt"]),
+    index.on(["orgId", "createdAt"]),
+    index.on(["type", "createdAt"])
+  ],
+  enums: [NotificationStatusEnum, NotificationChannelEnum]
+});
+var NotificationPriorityEnum = defineEntityEnum({
+  name: "NotificationPriority",
+  values: ["LOW", "NORMAL", "HIGH", "URGENT"],
+  schema: "lssm_notifications",
+  description: "Priority level of a notification."
+});
+var NotificationTemplateEntity = defineEntity({
+  name: "NotificationTemplate",
+  description: "Reusable notification template.",
+  schema: "lssm_notifications",
+  map: "notification_template",
+  fields: {
+    id: field.id(),
+    templateId: field.string({
+      isUnique: true,
+      description: "Template identifier"
+    }),
+    name: field.string({ description: "Template display name" }),
+    description: field.string({ isOptional: true }),
+    emailSubject: field.string({ isOptional: true }),
+    emailBody: field.string({ isOptional: true }),
+    inAppTitle: field.string({ isOptional: true }),
+    inAppBody: field.string({ isOptional: true }),
+    pushTitle: field.string({ isOptional: true }),
+    pushBody: field.string({ isOptional: true }),
+    defaultChannels: field.string({ isArray: true }),
+    category: field.string({ isOptional: true }),
+    priority: field.enum("NotificationPriority", { default: "NORMAL" }),
+    variablesSchema: field.json({
+      isOptional: true,
+      description: "JSON schema for variables"
+    }),
+    enabled: field.boolean({ default: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt()
+  },
+  enums: [NotificationPriorityEnum]
+});
+var NotificationPreferenceEntity = defineEntity({
+  name: "NotificationPreference",
+  description: "User notification preferences by type and channel.",
+  schema: "lssm_notifications",
+  map: "notification_preference",
+  fields: {
+    id: field.id(),
+    userId: field.foreignKey(),
+    globalEnabled: field.boolean({ default: true }),
+    quietHoursStart: field.string({
+      isOptional: true,
+      description: "Quiet hours start (HH:MM)"
+    }),
+    quietHoursEnd: field.string({
+      isOptional: true,
+      description: "Quiet hours end (HH:MM)"
+    }),
+    timezone: field.string({ default: '"UTC"' }),
+    channelPreferences: field.json({
+      description: "Channel-level preferences"
+    }),
+    typePreferences: field.json({ description: "Type-level preferences" }),
+    digestEnabled: field.boolean({ default: false }),
+    digestFrequency: field.string({
+      isOptional: true,
+      description: "daily, weekly, etc."
+    }),
+    digestTime: field.string({
+      isOptional: true,
+      description: "Digest send time (HH:MM)"
+    }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt()
+  },
+  indexes: [index.unique(["userId"])]
+});
+var DeliveryLogEntity = defineEntity({
+  name: "DeliveryLog",
+  description: "Log of notification delivery attempts.",
+  schema: "lssm_notifications",
+  map: "delivery_log",
+  fields: {
+    id: field.id(),
+    notificationId: field.foreignKey(),
+    channel: field.enum("NotificationChannel"),
+    status: field.enum("NotificationStatus"),
+    attemptedAt: field.dateTime(),
+    deliveredAt: field.dateTime({ isOptional: true }),
+    responseCode: field.string({ isOptional: true }),
+    responseMessage: field.string({ isOptional: true }),
+    externalId: field.string({
+      isOptional: true,
+      description: "Provider message ID"
+    }),
+    metadata: field.json({ isOptional: true }),
+    notification: field.belongsTo("Notification", ["notificationId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index.on(["notificationId", "channel"])]
+});
+var notificationEntities = [
+  NotificationEntity,
+  NotificationTemplateEntity,
+  NotificationPreferenceEntity,
+  DeliveryLogEntity
+];
+var notificationsSchemaContribution = {
+  moduleId: "@contractspec/module.notifications",
+  entities: notificationEntities,
+  enums: [
+    NotificationStatusEnum,
+    NotificationChannelEnum,
+    NotificationPriorityEnum
+  ]
+};
+export {
+  notificationsSchemaContribution,
+  notificationEntities,
+  NotificationTemplateEntity,
+  NotificationStatusEnum,
+  NotificationPriorityEnum,
+  NotificationPreferenceEntity,
+  NotificationEntity,
+  NotificationChannelEnum,
+  DeliveryLogEntity
+};