@unchainedshop/core-enrollments 5.0.0-alpha.1 → 5.0.0-alpha.11

package/README.md

@@ -13,97 +13,23 @@ npm install @unchainedshop/core-enrollments
 
 ## Usage
 
-```typescript
-import { configureEnrollmentsModule, EnrollmentStatus } from '@unchainedshop/core-enrollments';
+The platform initializes this module as `platform.unchainedAPI.modules.enrollments`.
 
-const enrollmentsModule = await configureEnrollmentsModule({ db });
+```typescript
+import { EnrollmentStatus } from '@unchainedshop/core-enrollments';
 
-// Create an enrollment
-const enrollmentId = await enrollmentsModule.create({
+const { enrollments } = platform.unchainedAPI.modules;
+const activeEnrollments = await enrollments.findEnrollments({
+  status: [EnrollmentStatus.ACTIVE],
   userId: 'user-123',
-  productId: 'plan-product-456',
-  quantity: 1,
-});
-
-// Activate enrollment
-await enrollmentsModule.activate(enrollmentId);
-
-// Find active enrollments
-const enrollments = await enrollmentsModule.findEnrollments({
-  status: EnrollmentStatus.ACTIVE,
 });
 ```
 
-## API Overview
-
-### Module Configuration
-
-| Export | Description |
-|--------|-------------|
-| `configureEnrollmentsModule` | Configure and return the enrollments module |
-
-### Queries
-
-| Method | Description |
-|--------|-------------|
-| `findEnrollment` | Find enrollment by ID |
-| `findEnrollments` | Find enrollments with filtering and pagination |
-| `count` | Count enrollments matching query |
-| `enrollmentExists` | Check if enrollment exists |
-
-### Mutations
-
-| Method | Description |
-|--------|-------------|
-| `create` | Create a new enrollment |
-| `update` | Update enrollment data |
-| `delete` | Delete an enrollment |
-| `activate` | Activate an enrollment |
-| `terminate` | Terminate an enrollment |
-
-### Period Management
-
-| Method | Description |
-|--------|-------------|
-| `addPeriod` | Add a billing period |
-| `findPeriod` | Find a specific period |
-| `isExpired` | Check if enrollment is expired |
-
-### Utilities
-
-| Export | Description |
-|--------|-------------|
-| `addToDate` | Add time interval to date |
-
-### Constants
-
-| Export | Description |
-|--------|-------------|
-| `EnrollmentStatus` | Status values (INITIAL, ACTIVE, PAUSED, TERMINATED) |
-
-### Settings
-
-| Export | Description |
-|--------|-------------|
-| `enrollmentsSettings` | Access enrollment module settings |
-
-### Types
-
-| Export | Description |
-|--------|-------------|
-| `Enrollment` | Enrollment document type |
-| `EnrollmentPeriod` | Period document type |
-| `EnrollmentsModule` | Module interface type |
+Status filters accept arrays. Enrollment lifecycle operations and recurring order generation are coordinated by `unchainedAPI.services.enrollments` and the registered enrollment and worker plugins. The module stores enrollments and their periods (`addEnrollmentPeriod`) together with the lifecycle fields the services maintain: `expires` (when the enrollment ends), `resumeAt`, `contractStartDate`, `minimumCommitmentEnd` and the cancellation reason.
 
-## Events
+`EnrollmentStatus` covers `INITIAL`, `ACTIVE`, `PAUSED`, `SUSPENDED` and `TERMINATED`; `EnrollmentTerminationReason` lists the cancellation reasons. Emitted events: `ENROLLMENT_CREATE`, `ENROLLMENT_UPDATE`, `ENROLLMENT_REMOVE`, `ENROLLMENT_ADD_PERIOD`, `ENROLLMENT_SUSPEND`, `ENROLLMENT_RESUME`, `ENROLLMENT_PLAN_CHANGE` and `ENROLLMENT_TRIAL_ENDING`.
 
-| Event | Description |
-|-------|-------------|
-| `ENROLLMENT_CREATE` | Enrollment created |
-| `ENROLLMENT_UPDATE` | Enrollment updated |
-| `ENROLLMENT_REMOVE` | Enrollment deleted |
-| `ENROLLMENT_ACTIVATE` | Enrollment activated |
-| `ENROLLMENT_TERMINATE` | Enrollment terminated |
+See the [module guide](https://docs.unchained.shop/platform-configuration/modules/enrollments), [public exports](src/enrollments-index.ts), and [module implementation](src/module/configureEnrollmentsModule.ts).
 
 ## License
 

package/lib/db/EnrollmentsCollection.d.ts

@@ -5,9 +5,10 @@ export interface EnrollmentPeriod {
     end: Date;
     orderId?: string;
     isTrial?: boolean;
+    trialEndingNotifiedAt?: Date;
 }
 export interface EnrollmentPlan {
-    configuration: {
+    configuration?: {
         key: string;
         value: string;
     }[] | null;
@@ -18,8 +19,17 @@ export declare const EnrollmentStatus: {
     readonly INITIAL: "INITIAL";
     readonly ACTIVE: "ACTIVE";
     readonly PAUSED: "PAUSED";
+    readonly SUSPENDED: "SUSPENDED";
     readonly TERMINATED: "TERMINATED";
 };
+export declare const EnrollmentTerminationReason: {
+    readonly USER_REQUESTED: "USER_REQUESTED";
+    readonly PAYMENT_FAILED: "PAYMENT_FAILED";
+    readonly EXPIRED: "EXPIRED";
+    readonly ADMIN_ACTION: "ADMIN_ACTION";
+    readonly OTHER: "OTHER";
+};
+export type EnrollmentTerminationReason = (typeof EnrollmentTerminationReason)[keyof typeof EnrollmentTerminationReason];
 export type EnrollmentStatus = (typeof EnrollmentStatus)[keyof typeof EnrollmentStatus];
 export interface EnrollmentOrderPositionTemplate {
     context?: any;
@@ -50,6 +60,11 @@ export type Enrollment = {
     enrollmentNumber?: string;
     orderIdForFirstPeriod?: string;
     expires?: Date;
+    resumeAt?: Date;
+    contractStartDate?: Date;
+    minimumCommitmentEnd?: Date;
+    cancellationReason?: EnrollmentTerminationReason;
+    cancellationComment?: string;
     meta?: any;
     payment?: {
         paymentProviderId: string;

package/lib/db/EnrollmentsCollection.js

@@ -1,41 +1,48 @@
-import { mongodb, buildDbIndexes, isDocumentDBCompatModeEnabled } from '@unchainedshop/mongodb';
+import { mongodb, buildDbIndexes } from '@unchainedshop/mongodb';
 import {} from '@unchainedshop/mongodb';
 export const EnrollmentStatus = {
     INITIAL: 'INITIAL',
     ACTIVE: 'ACTIVE',
     PAUSED: 'PAUSED',
+    SUSPENDED: 'SUSPENDED',
     TERMINATED: 'TERMINATED',
 };
+export const EnrollmentTerminationReason = {
+    USER_REQUESTED: 'USER_REQUESTED',
+    PAYMENT_FAILED: 'PAYMENT_FAILED',
+    EXPIRED: 'EXPIRED',
+    ADMIN_ACTION: 'ADMIN_ACTION',
+    OTHER: 'OTHER',
+};
 export const EnrollmentsCollection = async (db) => {
     const Enrollments = db.collection('enrollments');
-    if (!isDocumentDBCompatModeEnabled()) {
-        await buildDbIndexes(Enrollments, [
-            {
-                index: {
-                    _id: 'text',
-                    userId: 'text',
-                    enrollmentNumber: 'text',
-                    status: 'text',
-                    'contact.telNumber': 'text',
-                    'contact.emailAddress': 'text',
-                },
-                options: {
-                    weights: {
-                        _id: 8,
-                        userId: 3,
-                        enrollmentNumber: 6,
-                        'contact.telNumber': 5,
-                        'contact.emailAddress': 4,
-                        status: 1,
-                    },
-                    name: 'enrollment_fulltext_search',
+    await buildDbIndexes(Enrollments, [
+        {
+            index: {
+                _id: 'text',
+                userId: 'text',
+                enrollmentNumber: 'text',
+                status: 'text',
+                'contact.telNumber': 'text',
+                'contact.emailAddress': 'text',
+            },
+            options: {
+                weights: {
+                    _id: 8,
+                    userId: 3,
+                    enrollmentNumber: 6,
+                    'contact.telNumber': 5,
+                    'contact.emailAddress': 4,
+                    status: 1,
                 },
+                name: 'enrollment_fulltext_search',
             },
-        ]);
-    }
+        },
+    ]);
     await buildDbIndexes(Enrollments, [
-        { index: { userId: 1 } },
-        { index: { productId: 1 } },
+        { index: { 'periods.orderId': 1 } },
+        { index: { userId: 1, status: 1 } },
+        { index: { productId: 1, status: 1 } },
         { index: { status: 1 } },
         { index: { enrollmentNumber: 1 } },
     ]);

package/lib/enrollments-settings.d.ts

@@ -12,6 +12,7 @@ export interface ScheduleData {
 export interface EnrollmentSettings {
     autoSchedulingSchedule: ScheduleData;
     enrollmentNumberHashFn: (enrollment: Enrollment, index: number) => string;
+    trialEndingNoticeDays: number;
     configureSettings: (options?: EnrollmentsSettingsOptions) => void;
 }
 export type EnrollmentsSettingsOptions = Omit<Partial<EnrollmentSettings>, 'configureSettings'>;

package/lib/enrollments-settings.js

@@ -5,8 +5,10 @@ const everyHourSchedule = {
 export const enrollmentsSettings = {
     autoSchedulingSchedule: everyHourSchedule,
     enrollmentNumberHashFn: generateRandomHash,
-    configureSettings({ autoSchedulingSchedule, enrollmentNumberHashFn } = {}) {
+    trialEndingNoticeDays: 3,
+    configureSettings({ autoSchedulingSchedule, enrollmentNumberHashFn, trialEndingNoticeDays } = {}) {
         this.autoSchedulingSchedule = autoSchedulingSchedule || everyHourSchedule;
         this.enrollmentNumberHashFn = enrollmentNumberHashFn || generateRandomHash;
+        this.trialEndingNoticeDays = trialEndingNoticeDays ?? 3;
     },
 };

package/lib/migrations/20260625120100-normalize-contact-phone.d.ts

@@ -0,0 +1,2 @@
+import type { MigrationRepository } from '@unchainedshop/mongodb';
+export default function normalizeContactPhone(repository: MigrationRepository): void;

package/lib/migrations/20260625120100-normalize-contact-phone.js

@@ -0,0 +1,27 @@
+import { normalizePhoneNumber } from '@unchainedshop/utils';
+import { EnrollmentsCollection } from "../db/EnrollmentsCollection.js";
+export default function normalizeContactPhone(repository) {
+    repository?.register({
+        id: 20260625120100,
+        name: 'Normalize enrollment.contact.telNumber to E.164 format',
+        up: async ({ logger }) => {
+            const Enrollments = await EnrollmentsCollection(repository.db);
+            const enrollments = await Enrollments.find({ 'contact.telNumber': { $exists: true, $nin: [null, ''] } }, { projection: { _id: true, contact: true, billingAddress: true, countryCode: true } }).toArray();
+            let changed = 0;
+            let skipped = 0;
+            for (const enrollment of enrollments) {
+                const current = enrollment.contact?.telNumber;
+                const defaultCountry = enrollment.billingAddress?.countryCode || enrollment.countryCode;
+                const normalized = normalizePhoneNumber(current, defaultCountry);
+                if (!normalized || normalized === current) {
+                    if (!normalized)
+                        skipped += 1;
+                    continue;
+                }
+                await Enrollments.updateOne({ _id: enrollment._id }, { $set: { 'contact.telNumber': normalized } });
+                changed += 1;
+            }
+            logger?.info(`Normalize enrollment.contact.telNumber: ${changed} updated, ${skipped} left unchanged (unparseable)`);
+        },
+    });
+}

package/lib/module/configureEnrollmentsModule.d.ts

@@ -1,5 +1,5 @@
 import { type SortOption } from '@unchainedshop/utils';
-import { type Enrollment, type EnrollmentPeriod, type EnrollmentPlan, EnrollmentStatus } from '../db/EnrollmentsCollection.ts';
+import { type Enrollment, type EnrollmentPeriod, type EnrollmentPlan, type EnrollmentTerminationReason, EnrollmentStatus } from '../db/EnrollmentsCollection.ts';
 import { mongodb, type Address, type Contact, type ModuleInput } from '@unchainedshop/mongodb';
 import { type EnrollmentsSettingsOptions } from '../enrollments-settings.ts';
 export interface EnrollmentQuery {
@@ -8,7 +8,7 @@ export interface EnrollmentQuery {
     queryString?: string;
 }
 export declare const buildFindSelector: ({ queryString, status, userId }: EnrollmentQuery) => mongodb.Filter<Enrollment>;
-export declare const configureEnrollmentsModule: ({ db, options: enrollmentOptions, }: ModuleInput<EnrollmentsSettingsOptions>) => Promise<{
+export declare const configureEnrollmentsModule: ({ db, migrationRepository, options: enrollmentOptions, }: ModuleInput<EnrollmentsSettingsOptions>) => Promise<{
     count: (query: EnrollmentQuery) => Promise<number>;
     openEnrollmentWithProduct: ({ productId }: {
         productId: string;
@@ -18,6 +18,9 @@ export declare const configureEnrollmentsModule: ({ db, options: enrollmentOptio
     } | {
         orderId: string;
     }, options?: mongodb.FindOptions) => Promise<Enrollment | null>;
+    findEnrollmentsByOrderIds: ({ orderIds }: {
+        orderIds: string[];
+    }, options?: mongodb.FindOptions) => Promise<Enrollment[]>;
     findEnrollments: ({ limit, offset, sort, ...query }: EnrollmentQuery & {
         limit?: number;
         offset?: number;
@@ -28,11 +31,12 @@ export declare const configureEnrollmentsModule: ({ db, options: enrollmentOptio
         referenceDate?: Date;
     }) => boolean;
     addEnrollmentPeriod: (enrollmentId: string, period: EnrollmentPeriod) => Promise<mongodb.WithId<Enrollment> | null>;
+    markEnrollmentTrialEndingNotified: (enrollmentId: string, { start, end }: EnrollmentPeriod) => Promise<mongodb.WithId<Enrollment> | null>;
     create: ({ countryCode, currencyCode, ...enrollmentData }: Omit<Enrollment, "status" | "periods" | "log" | "_id" | "created"> & Pick<Partial<Enrollment>, "_id" | "created">) => Promise<Enrollment>;
     delete: (enrollmentId: string) => Promise<number>;
     removeEnrollmentPeriodByOrderId: (enrollmentId: string, orderId: string) => Promise<mongodb.WithId<Enrollment> | null>;
     updateBillingAddress: (enrollmentId: string, fieldValue: Address) => Promise<mongodb.WithId<Enrollment> | null>;
-    updateContact: (enrollmentId: string, fieldValue: Contact) => Promise<mongodb.WithId<Enrollment> | null>;
+    updateContact: (enrollmentId: string, contact: Contact) => Promise<mongodb.WithId<Enrollment> | null>;
     updateContext: (enrollmentId: string, fieldValue: any) => Promise<mongodb.WithId<Enrollment> | null>;
     updateDelivery: (enrollmentId: string, fieldValue: {
         deliveryProviderId?: string;
@@ -42,6 +46,16 @@ export declare const configureEnrollmentsModule: ({ db, options: enrollmentOptio
         paymentProviderId: string;
         context?: any;
     } | undefined) => Promise<mongodb.WithId<Enrollment> | null>;
+    updateExpiry: (enrollmentId: string, fieldValue: Date | null) => Promise<mongodb.WithId<Enrollment> | null>;
+    updateResumeAt: (enrollmentId: string, fieldValue: Date) => Promise<mongodb.WithId<Enrollment> | null>;
+    updateCommitment: (enrollmentId: string, { contractStartDate, minimumCommitmentEnd, }: {
+        contractStartDate: Date;
+        minimumCommitmentEnd: Date;
+    }) => Promise<mongodb.WithId<Enrollment> | null>;
+    updateCancellation: (enrollmentId: string, params: {
+        reason?: EnrollmentTerminationReason;
+        comment?: string;
+    }) => Promise<mongodb.WithId<Enrollment> | null>;
     updatePlan: (enrollmentId: string, plan: EnrollmentPlan) => Promise<mongodb.WithId<Enrollment> | null>;
     updateStatus: (enrollmentId: string, { status, info }: {
         status: EnrollmentStatus;

package/lib/module/configureEnrollmentsModule.js

@@ -1,15 +1,28 @@
-import { SortDirection } from '@unchainedshop/utils';
+import { SortDirection, normalizePhoneNumber } from '@unchainedshop/utils';
 import { EnrollmentStatus, } from "../db/EnrollmentsCollection.js";
 import { emit, registerEvents } from '@unchainedshop/events';
-import { generateDbFilterById, buildSortOptions, mongodb, generateDbObjectId, assertDocumentDBCompatMode, } from '@unchainedshop/mongodb';
+import { generateDbFilterById, buildSortOptions, mongodb, generateDbObjectId, } from '@unchainedshop/mongodb';
 import { EnrollmentsCollection } from "../db/EnrollmentsCollection.js";
 import { enrollmentsSettings } from "../enrollments-settings.js";
+import normalizeContactPhoneMigration from "../migrations/20260625120100-normalize-contact-phone.js";
 const ENROLLMENT_EVENTS = [
     'ENROLLMENT_ADD_PERIOD',
     'ENROLLMENT_CREATE',
     'ENROLLMENT_REMOVE',
     'ENROLLMENT_UPDATE',
+    'ENROLLMENT_SUSPEND',
+    'ENROLLMENT_RESUME',
+    'ENROLLMENT_PLAN_CHANGE',
+    'ENROLLMENT_TRIAL_ENDING',
 ];
+const normalizeContactPhone = (contact, defaultCountry) => {
+    if (!contact?.telNumber)
+        return contact;
+    return {
+        ...contact,
+        telNumber: normalizePhoneNumber(contact.telNumber, defaultCountry) || contact.telNumber,
+    };
+};
 export const buildFindSelector = ({ queryString, status, userId }) => {
     const selector = {
         deleted: null,
@@ -19,12 +32,12 @@ export const buildFindSelector = ({ queryString, status, userId }) => {
     if (userId)
         selector.userId = userId;
     if (queryString) {
-        assertDocumentDBCompatMode();
         selector.$text = { $search: queryString };
     }
     return selector;
 };
-export const configureEnrollmentsModule = async ({ db, options: enrollmentOptions = {}, }) => {
+export const configureEnrollmentsModule = async ({ db, migrationRepository, options: enrollmentOptions = {}, }) => {
+    normalizeContactPhoneMigration(migrationRepository);
     registerEvents(ENROLLMENT_EVENTS);
     enrollmentsSettings.configureSettings(enrollmentOptions);
     const Enrollments = await EnrollmentsCollection(db);
@@ -62,18 +75,30 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
         };
         switch (status) {
             case EnrollmentStatus.ACTIVE:
-                modifier.$set.enrollmentNumber = await findNewEnrollmentNumber(enrollment);
+                modifier.$set.enrollmentNumber =
+                    enrollment.enrollmentNumber || (await findNewEnrollmentNumber(enrollment));
                 break;
-            case EnrollmentStatus.TERMINATED:
-                modifier.$set.expires = enrollment.periods?.pop()?.end || new Date();
+            case EnrollmentStatus.TERMINATED: {
+                const periodEnds = (enrollment.periods || []).map(({ end }) => new Date(end).getTime());
+                modifier.$set.expires =
+                    enrollment.expires || (periodEnds.length ? new Date(Math.max(...periodEnds)) : date);
                 break;
+            }
             default:
                 break;
         }
+        if (enrollment.status === EnrollmentStatus.SUSPENDED)
+            modifier.$unset = { resumeAt: 1 };
         const updatedEnrollment = await Enrollments.findOneAndUpdate(selector, modifier, {
             returnDocument: 'after',
         });
         await emit('ENROLLMENT_UPDATE', { enrollment, field: 'status' });
+        if (status === EnrollmentStatus.SUSPENDED) {
+            await emit('ENROLLMENT_SUSPEND', { enrollment: updatedEnrollment });
+        }
+        else if (enrollment.status === EnrollmentStatus.SUSPENDED && status === EnrollmentStatus.ACTIVE) {
+            await emit('ENROLLMENT_RESUME', { enrollment: updatedEnrollment });
+        }
         return updatedEnrollment;
     };
     const updateEnrollmentField = (fieldKey) => async (enrollmentId, fieldValue) => {
@@ -93,7 +118,9 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
         },
         openEnrollmentWithProduct: async ({ productId }) => {
             const selector = { productId };
-            selector.status = { $in: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED] };
+            selector.status = {
+                $in: [EnrollmentStatus.ACTIVE, EnrollmentStatus.PAUSED, EnrollmentStatus.SUSPENDED],
+            };
             return Enrollments.findOne(selector);
         },
         findEnrollment: async (params, options) => {
@@ -102,6 +129,11 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
             }
             return Enrollments.findOne({ 'periods.orderId': params.orderId, deleted: null }, options);
         },
+        findEnrollmentsByOrderIds: async ({ orderIds }, options) => {
+            if (!orderIds?.length)
+                return [];
+            return Enrollments.find({ 'periods.orderId': { $in: orderIds }, deleted: null }, options).toArray();
+        },
         findEnrollments: async ({ limit, offset, sort, ...query }) => {
             const defaultSortOption = [{ key: 'created', value: SortDirection.ASC }];
             const enrollments = Enrollments.find(buildFindSelector(query), {
@@ -140,6 +172,16 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
             await emit('ENROLLMENT_ADD_PERIOD', { enrollment });
             return enrollment;
         },
+        markEnrollmentTrialEndingNotified: async (enrollmentId, { start, end }) => {
+            const enrollment = await Enrollments.findOneAndUpdate({
+                ...generateDbFilterById(enrollmentId),
+                periods: { $elemMatch: { start, end, trialEndingNotifiedAt: null } },
+            }, { $set: { 'periods.$.trialEndingNotifiedAt': new Date(), updated: new Date() } }, { returnDocument: 'after' });
+            if (!enrollment)
+                return null;
+            await emit('ENROLLMENT_UPDATE', { enrollment, field: 'periods' });
+            return enrollment;
+        },
         create: async ({ countryCode, currencyCode, ...enrollmentData }) => {
             const { insertedId: enrollmentId } = await Enrollments.insertOne({
                 _id: generateDbObjectId(),
@@ -149,6 +191,7 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
                 periods: [],
                 currencyCode,
                 countryCode,
+                contact: normalizeContactPhone(enrollmentData.contact, enrollmentData.billingAddress?.countryCode || countryCode),
                 configuration: enrollmentData.configuration || [],
                 log: [],
             });
@@ -179,10 +222,34 @@ export const configureEnrollmentsModule = async ({ db, options: enrollmentOption
             }, { returnDocument: 'after' });
         },
         updateBillingAddress: updateEnrollmentField('billingAddress'),
-        updateContact: updateEnrollmentField('contact'),
+        updateContact: async (enrollmentId, contact) => {
+            const existing = await Enrollments.findOne(generateDbFilterById(enrollmentId), {
+                projection: { billingAddress: true, countryCode: true },
+            });
+            const defaultCountry = existing?.billingAddress?.countryCode || existing?.countryCode;
+            return updateEnrollmentField('contact')(enrollmentId, normalizeContactPhone(contact, defaultCountry));
+        },
         updateContext: updateEnrollmentField('meta'),
         updateDelivery: updateEnrollmentField('delivery'),
         updatePayment: updateEnrollmentField('payment'),
+        updateExpiry: updateEnrollmentField('expires'),
+        updateResumeAt: updateEnrollmentField('resumeAt'),
+        updateCommitment: async (enrollmentId, { contractStartDate, minimumCommitmentEnd, }) => {
+            const enrollment = await Enrollments.findOneAndUpdate(generateDbFilterById(enrollmentId), { $set: { updated: new Date(), contractStartDate, minimumCommitmentEnd } }, { returnDocument: 'after' });
+            await emit('ENROLLMENT_UPDATE', { enrollment, field: 'commitment' });
+            return enrollment;
+        },
+        updateCancellation: async (enrollmentId, params) => {
+            const enrollment = await Enrollments.findOneAndUpdate(generateDbFilterById(enrollmentId), {
+                $set: {
+                    updated: new Date(),
+                    ...(params.reason && { cancellationReason: params.reason }),
+                    ...(params.comment !== undefined && { cancellationComment: params.comment }),
+                },
+            }, { returnDocument: 'after' });
+            await emit('ENROLLMENT_UPDATE', { enrollment, field: 'cancellation' });
+            return enrollment;
+        },
         updatePlan: async (enrollmentId, plan) => {
             const enrollment = await Enrollments.findOneAndUpdate(generateDbFilterById(enrollmentId), {
                 $set: {

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@unchainedshop/core-enrollments",
   "description": "Subscription and recurring billing module for the Unchained Engine",
-  "version": "5.0.0-alpha.1",
+  "version": "5.0.0-alpha.11",
+  "files": [
+    "lib"
+  ],
   "main": "lib/enrollments-index.js",
   "types": "lib/enrollments-index.d.ts",
   "type": "module",
@@ -35,12 +38,12 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "^5.0.0-alpha.1",
-    "@unchainedshop/logger": "^5.0.0-alpha.1",
-    "@unchainedshop/utils": "^5.0.0-alpha.1"
+    "@unchainedshop/events": "^5.0.0-alpha.11",
+    "@unchainedshop/mongodb": "^5.0.0-alpha.11",
+    "@unchainedshop/utils": "^5.0.0-alpha.11"
   },
   "devDependencies": {
-    "@types/node": "^25.0.0",
-    "typescript": "^5.8.3"
+    "@types/node": "^26.2.0",
+    "typescript": "^6.0.3"
   }
 }