@lssm/example.crm-pipeline 0.0.0-canary-20251217060834 → 0.0.0-canary-20251217072406

package/dist/modules/notifications/dist/contracts/index.js

@@ -0,0 +1,436 @@
+import { defineEnum } from "../libs/schema/dist/EnumType.js";
+import { ScalarTypeEnum } from "../libs/schema/dist/ScalarTypeEnum.js";
+import "../libs/schema/dist/index.js";
+import { defineSchemaModel } from "../libs/contracts/dist/schema/dist/SchemaModel.js";
+import { defineCommand, defineQuery } from "../libs/contracts/dist/spec.js";
+import "../libs/contracts/dist/index.js";
+
+//#region ../../modules/notifications/dist/contracts/index.js
+const OWNERS = ["platform.notifications"];
+const NotificationStatusSchemaEnum = defineEnum("NotificationStatus", [
+	"PENDING",
+	"SENT",
+	"DELIVERED",
+	"READ",
+	"FAILED",
+	"CANCELLED"
+]);
+const NotificationChannelSchemaEnum = defineEnum("NotificationChannel", [
+	"EMAIL",
+	"IN_APP",
+	"PUSH",
+	"WEBHOOK"
+]);
+const NotificationFilterEnum = defineEnum("NotificationFilter", [
+	"unread",
+	"read",
+	"all"
+]);
+const 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
+		}
+	}
+});
+const 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
+		}
+	}
+});
+const 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
+		}
+	}
+});
+const 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
+		}
+	}
+});
+const 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
+		}
+	}
+});
+const 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
+		}
+	}
+});
+/**
+* Send a notification.
+*/
+const SendNotificationContract = defineCommand({
+	meta: {
+		name: "notifications.send",
+		version: 1,
+		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: [{
+		name: "notification.sent",
+		version: 1,
+		when: "Notification is sent",
+		payload: NotificationModel
+	}] }
+});
+/**
+* List notifications for current user.
+*/
+const ListNotificationsContract = defineQuery({
+	meta: {
+		name: "notifications.list",
+		version: 1,
+		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" }
+});
+/**
+* Mark notification as read.
+*/
+const MarkNotificationReadContract = defineCommand({
+	meta: {
+		name: "notifications.markRead",
+		version: 1,
+		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" }
+});
+/**
+* Mark all notifications as read.
+*/
+const MarkAllNotificationsReadContract = defineCommand({
+	meta: {
+		name: "notifications.markAllRead",
+		version: 1,
+		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" }
+});
+/**
+* Get notification preferences.
+*/
+const GetNotificationPreferencesContract = defineQuery({
+	meta: {
+		name: "notifications.preferences.get",
+		version: 1,
+		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" }
+});
+/**
+* Update notification preferences.
+*/
+const UpdateNotificationPreferencesContract = defineCommand({
+	meta: {
+		name: "notifications.preferences.update",
+		version: 1,
+		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" }
+});
+/**
+* Delete a notification.
+*/
+const DeleteNotificationContract = defineCommand({
+	meta: {
+		name: "notifications.delete",
+		version: 1,
+		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" }
+});
+
+//#endregion
+export { ListNotificationsInputModel, ListNotificationsOutputModel, NotificationFilterEnum, NotificationModel, NotificationPreferenceModel, SendNotificationInputModel, UpdatePreferencesInputModel };

package/dist/modules/notifications/dist/entities/index.js

@@ -0,0 +1,254 @@
+import { defineEntity, defineEntityEnum, field, index } from "../libs/schema/dist/entity/defineEntity.js";
+import "../libs/schema/dist/index.js";
+
+//#region ../../modules/notifications/dist/entities/index.js
+/**
+* Notification status enum.
+*/
+const NotificationStatusEnum = defineEntityEnum({
+	name: "NotificationStatus",
+	values: [
+		"PENDING",
+		"SENT",
+		"DELIVERED",
+		"READ",
+		"FAILED",
+		"CANCELLED"
+	],
+	schema: "lssm_notifications",
+	description: "Status of a notification."
+});
+/**
+* Notification channel enum.
+*/
+const NotificationChannelEnum = defineEntityEnum({
+	name: "NotificationChannel",
+	values: [
+		"EMAIL",
+		"IN_APP",
+		"PUSH",
+		"WEBHOOK",
+		"SMS"
+	],
+	schema: "lssm_notifications",
+	description: "Delivery channel for notifications."
+});
+/**
+* Notification entity - individual notification instance.
+*/
+const 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]
+});
+/**
+* Notification priority enum.
+*/
+const NotificationPriorityEnum = defineEntityEnum({
+	name: "NotificationPriority",
+	values: [
+		"LOW",
+		"NORMAL",
+		"HIGH",
+		"URGENT"
+	],
+	schema: "lssm_notifications",
+	description: "Priority level of a notification."
+});
+/**
+* NotificationTemplate entity - reusable notification templates.
+*/
+const 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]
+});
+/**
+* NotificationPreference entity - user notification preferences.
+*/
+const 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"])]
+});
+/**
+* DeliveryLog entity - track delivery attempts per channel.
+*/
+const 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"])]
+});
+/**
+* All notification entities for schema composition.
+*/
+const notificationEntities = [
+	NotificationEntity,
+	NotificationTemplateEntity,
+	NotificationPreferenceEntity,
+	DeliveryLogEntity
+];
+/**
+* Module schema contribution for notifications.
+*/
+const notificationsSchemaContribution = {
+	moduleId: "@lssm/module.notifications",
+	entities: notificationEntities,
+	enums: [
+		NotificationStatusEnum,
+		NotificationChannelEnum,
+		NotificationPriorityEnum
+	]
+};
+
+//#endregion
+export { DeliveryLogEntity, NotificationChannelEnum, NotificationEntity, NotificationPreferenceEntity, NotificationPriorityEnum, NotificationStatusEnum, NotificationTemplateEntity, notificationEntities, notificationsSchemaContribution };

package/dist/modules/notifications/dist/index.js

@@ -0,0 +1,3 @@
+import { DeliveryLogEntity, NotificationChannelEnum, NotificationEntity, NotificationPreferenceEntity, NotificationPriorityEnum, NotificationStatusEnum, NotificationTemplateEntity, notificationEntities, notificationsSchemaContribution } from "./entities/index.js";
+import { ListNotificationsInputModel, ListNotificationsOutputModel, NotificationFilterEnum, NotificationModel, NotificationPreferenceModel, SendNotificationInputModel, UpdatePreferencesInputModel } from "./contracts/index.js";
+import { defineTemplate } from "./templates/index.js";

package/dist/modules/notifications/dist/libs/contracts/dist/capabilities/openbanking.js

@@ -0,0 +1,10 @@
+import { StabilityEnum } from "../ownership.js";
+
+//#region ../../modules/notifications/dist/libs/contracts/dist/capabilities/openbanking.js
+const OWNERS = ["platform.finance"];
+const TAGS = ["open-banking", "finance"];
+[...OWNERS], [...TAGS], StabilityEnum.Experimental;
+[...OWNERS], [...TAGS], StabilityEnum.Experimental;
+[...OWNERS], [...TAGS], StabilityEnum.Experimental;
+
+//#endregion

package/dist/modules/notifications/dist/libs/contracts/dist/client/index.js

@@ -0,0 +1,5 @@
+'use client';
+
+import "./react/feature-render.js";
+import "./react/form-render.js";
+import "./react/index.js";

package/dist/modules/notifications/dist/libs/contracts/dist/client/react/feature-render.js

@@ -0,0 +1,2 @@
+import "../../presentations.v2.js";
+import "react";