zibri 2.2.0 → 2.3.0

package/src/plugin/mailing-list/models/mailing-list-subscriber.model.ts

@@ -0,0 +1,28 @@
+import { MailingList } from './mailing-list.model';
+import { BaseEntity } from '../../../entity/base-entity.model';
+import { Entity } from '../../../entity/decorators/entity.decorator';
+import { Property } from '../../../entity/decorators/property.decorator';
+
+/**
+ * Defines a subscriber to a single or multiple mailing lists.
+ */
+@Entity({ allowOrphan: true })
+export class MailingListSubscriber extends BaseEntity {
+    /**
+     * The optional name of the subscriber.
+     */
+    @Property.string({ required: false })
+    name?: string;
+
+    /**
+     * The email of the subscriber.
+     */
+    @Property.string({ format: 'email' })
+    email!: string;
+
+    /**
+     * The mailing lists that the subscriber is subscribed to.
+     */
+    @Property.manyToMany({ target: () => MailingList, inverseSide: 'subscribers', joinTable: false })
+    mailingLists!: MailingList[];
+}

package/src/plugin/mailing-list/models/mailing-list-subscription-confirmation-token.model.ts

@@ -0,0 +1,45 @@
+import { BaseEntity } from '../../../entity/base-entity.model';
+import { Entity } from '../../../entity/decorators/entity.decorator';
+import { Property } from '../../../entity/decorators/property.decorator';
+import { OmitClass } from '../../../entity/omit-class.model';
+
+/**
+ * A short lived token used to confirm a mailing list subscription.
+ */
+@Entity({ allowOrphan: true })
+export class MailingListSubscriptionConfirmationToken extends BaseEntity {
+    /**
+     * The expiration date of the confirmation token.
+     */
+    @Property.date()
+    expirationDate!: Date;
+
+    /**
+     * The actual token value.
+     */
+    @Property.string()
+    value!: string;
+
+    /**
+     * The email of the new subscriber that this token belongs to.
+     */
+    @Property.string({ format: 'email' })
+    email!: string;
+
+    /**
+     * The optional name of the new subscriber that this token belongs to.
+     */
+    @Property.string({ required: false })
+    name?: string;
+
+    /**
+     * The id of the mailing list that this token belongs to.
+     */
+    @Property.string({ format: 'uuid' })
+    listId!: string;
+}
+
+/**
+ * The data to create a new mailing list subscription confirmation token.
+ */
+export class MailingListSubscriptionConfirmationTokenCreateData extends OmitClass(MailingListSubscriptionConfirmationToken, ['id']) {}

package/src/plugin/mailing-list/models/mailing-list-unsubscribe-confirmation-page-template.model.ts

@@ -0,0 +1,26 @@
+import { MailingListSubscriber } from './mailing-list-subscriber.model';
+import { MailingList } from './mailing-list.model';
+import { PreactComponent } from '../../../preact/preact-component.model';
+
+/**
+ * Properties of a mailing list unsubscribe confirmation page component.
+ */
+type MailingListUnsubscribeConfirmationPageTemplateProps = {
+    /**
+     * The subscriber that just unsubscribed.
+     */
+    subscriber: MailingListSubscriber,
+    /**
+     * The mailing list that was just unsubscribed from.
+     */
+    mailingList: MailingList,
+    /**
+     * The link to the manage preferences page.
+     */
+    managePreferencesLink: string
+};
+
+/**
+ * Definition for a mailing list unsubscribe confirmation page template.
+ */
+export type MailingListUnsubscribeConfirmationPageTemplate = PreactComponent<MailingListUnsubscribeConfirmationPageTemplateProps>;

package/src/plugin/mailing-list/models/mailing-list.model.ts

@@ -0,0 +1,22 @@
+import { MailingListSubscriber } from './mailing-list-subscriber.model';
+import { BaseEntity } from '../../../entity/base-entity.model';
+import { Entity } from '../../../entity/decorators/entity.decorator';
+import { Property } from '../../../entity/decorators/property.decorator';
+
+/**
+ * A mailing list like a newsletter that people can easily subscribe and unsubscribe to.
+ */
+@Entity({ allowOrphan: true })
+export class MailingList extends BaseEntity {
+    /**
+     * The name of the mailing list.
+     */
+    @Property.string({ unique: true })
+    name!: string;
+
+    /**
+     * The subscribers of the mailing list.
+     */
+    @Property.manyToMany({ target: () => MailingListSubscriber, inverseSide: 'mailingLists', joinTable: true })
+    subscribers!: MailingListSubscriber[];
+}

package/src/plugin/mailing-list/models/update-mailing-list-preferences.model.ts

@@ -0,0 +1,12 @@
+import { Property } from '../../../entity/decorators/property.decorator';
+
+/**
+ * The data required for updating mailing list preferences.
+ */
+export class UpdateMailingListPreferences {
+    /**
+     * The ids of the mailing lists that should be subscribed to.
+     */
+    @Property.array({ items: { type: 'string' } })
+    mailingListIds!: string[];
+}

package/src/plugin/mailing-list/services/mailing-list-service.interface.ts

@@ -0,0 +1,75 @@
+import { QueueEmailData } from '../../../email/models/create-email-data.model';
+import { OmitClass } from '../../../entity/omit-class.model';
+import { Route } from '../../../routing/controller-route-configuration.model';
+import { OmitStrict } from '../../../types/omit-strict.type';
+import { MailingListTemplateData } from '../models/mailing-list-base-email-template.model';
+import { MailingListSubscriber } from '../models/mailing-list-subscriber.model';
+
+/**
+ * The data required to queue a new mailing list email.
+ */
+export type MailingListQueueEmailData<T> = OmitStrict<
+    QueueEmailData,
+    'bcc' | 'cc' | 'recipients' | 'userId' | 'priority' | 'html'
+> & {
+    /**
+     * The title used in the template. Defaults to the subject.
+     */
+    title?: string,
+    /**
+     * The template. Can be a template string, html or anything else, like a TSX component function.
+     */
+    template: T,
+    /**
+     * A function that compiles the given template.
+     */
+    compile: (template: T, data: MailingListTemplateData) => string | Promise<string>
+};
+
+/**
+ * The required data to create a new mailing list subscriber.
+ */
+export class MailingListSubscriberCreateData extends OmitClass(MailingListSubscriber, ['id']) {}
+
+/**
+ * Interface for a mailing list service.
+ */
+export interface MailingListServiceInterface {
+    /**
+     * The base route for everything regarding mailing lists.
+     */
+    readonly mailingListBaseRoute: Route,
+    /**
+     * Queues a new email for the mailing list with the provided id.
+     */
+    queueEmailForList: <T>(listId: string, data: MailingListQueueEmailData<T>) => Promise<void>,
+    /**
+     * Requests for a new subscriber to the be added to the mailing list with the provided id.
+     * This should initialize a two step process required by the GDPR.
+     */
+    requestSubscribeToList: <T>(
+        listId: string,
+        subscriber: MailingListSubscriberCreateData,
+        emailData: OmitStrict<MailingListQueueEmailData<T>, 'template' | 'compile'>
+    ) => Promise<void>,
+    /**
+     * Confirms that a new subscriber is added to the mailing list.
+     */
+    confirmSubscribeToList: (confirmationTokenValue: string) => Promise<MailingListSubscriber>,
+    /**
+     * Removes a subscriber with the given id from the mailing list with the provided id.
+     */
+    unsubscribeFromList: (listId: string, subscriberId: string) => Promise<void>,
+    /**
+     * Gets the subscribe confirmation link for the list with the given id and the confirmationToken.
+     */
+    getSubscribeConfirmationLink: (listId: string, confirmationToken: string) => string,
+    /**
+     * Gets the unsubscribe link for the list with the given id and the subscriber with the given id.
+     */
+    getUnsubscribeLink: (listId: string, subscriberId: string) => string,
+    /**
+     * Gets the link to the manage preferences page for the subscriber with the given id.
+     */
+    getManagePreferencesLink: (subscriberId: string) => string
+}

package/src/plugin/mailing-list/services/mailing-list.service.ts

@@ -0,0 +1,192 @@
+import { randomBytes } from 'crypto';
+
+import { MailingListSubscriberCreateData, MailingListQueueEmailData, MailingListServiceInterface } from './mailing-list-service.interface';
+import { type AssetServiceInterface } from '../../../assets/asset-service.interface';
+import { Repository } from '../../../data-source/repository';
+import { InjectRepository } from '../../../di/decorators/inject-repository.decorator';
+import { Inject } from '../../../di/decorators/inject.decorator';
+import { Injectable } from '../../../di/decorators/injectable.decorator';
+import { ZIBRI_DI_TOKENS } from '../../../di/default/zibri-di-tokens.default';
+import { inject } from '../../../di/inject.function';
+import { type EmailServiceInterface } from '../../../email/email-service.interface';
+import { EmailPriority } from '../../../email/models/email-priority.enum';
+import { GlobalRegistry } from '../../../global/global-registry';
+import { OnAppInit } from '../../../global/on-app-init.interface';
+import { PreactUtilities } from '../../../preact/preact.utilities';
+import { Route } from '../../../routing/controller-route-configuration.model';
+import { OmitStrict } from '../../../types/omit-strict.type';
+import { PromiseUtilities } from '../../../utilities/promise.utilities';
+import { ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS } from '../mailing-list.tokens';
+import { type MailingListBaseEmailTemplate } from '../models/mailing-list-base-email-template.model';
+import { type MailingListSubscribeConfirmationEmailTemplate } from '../models/mailing-list-subscribe-confirmation-email-template.model';
+import { MailingListSubscriber } from '../models/mailing-list-subscriber.model';
+import { MailingListSubscriptionConfirmationToken, MailingListSubscriptionConfirmationTokenCreateData } from '../models/mailing-list-subscription-confirmation-token.model';
+import { MailingList } from '../models/mailing-list.model';
+
+/**
+ * Default mailing list service implementation of Zibri.
+ */
+@Injectable({ register: 'onUse' })
+export class MailingListService implements MailingListServiceInterface, OnAppInit {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    readonly mailingListBaseRoute: Route = '/mailing-lists';
+
+    constructor(
+        @Inject(ZIBRI_DI_TOKENS.EMAIL_SERVICE)
+        protected readonly emailService: EmailServiceInterface,
+        @Inject(ZIBRI_DI_TOKENS.ASSET_SERVICE)
+        protected readonly assetService: AssetServiceInterface,
+        @Inject(ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.CONFIRMATION_TOKEN_EXPIRES_IN_MS)
+        protected readonly mailingListSubscriptionConfirmationTokenExpiresInMs: number,
+        @InjectRepository(MailingList)
+        protected readonly mailingListRepository: Repository<MailingList>,
+        @InjectRepository(MailingListSubscriber)
+        protected readonly subscriberRepository: Repository<MailingListSubscriber, MailingListSubscriberCreateData>,
+        @InjectRepository(MailingListSubscriptionConfirmationToken)
+        protected readonly confirmationTokenRepository: Repository<
+            MailingListSubscriptionConfirmationToken,
+            MailingListSubscriptionConfirmationTokenCreateData
+        >,
+        @Inject(ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.SUBSCRIBE_CONFIRMATION_EMAIL_TEMPLATE)
+        protected readonly MailingListSubscribeConfirmationEmail: MailingListSubscribeConfirmationEmailTemplate,
+        @Inject(ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.BASE_EMAIL_TEMPLATE)
+        protected readonly MailingListBaseEmail: MailingListBaseEmailTemplate
+    ) {}
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    onAppInit(): void {
+        if (inject(ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.SUBSCRIBE_CONFIRMATION_EMAIL_TEMPLATE) == undefined) {
+            throw new Error([
+                'The builtin MailingListService requires that a value for',
+                'ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.SUBSCRIBE_CONFIRMATION_EMAIL_TEMPLATE is provided.'
+            ].join(' '));
+        }
+        if (inject(ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.BASE_EMAIL_TEMPLATE) == undefined) {
+            throw new Error([
+                'The builtin MailingListService requires that a value for',
+                'ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS.BASE_EMAIL_TEMPLATE is provided.'
+            ].join(' '));
+        }
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getSubscribeConfirmationLink(listId: string, confirmationToken: string): string {
+        const baseUrl: string = GlobalRegistry.getAppData('baseUrl') ?? '';
+        return `${baseUrl}${this.mailingListBaseRoute}/${listId}/subscribe/${confirmationToken}`;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getUnsubscribeLink(listId: string, subscriberId: string): string {
+        const baseUrl: string = GlobalRegistry.getAppData('baseUrl') ?? '';
+        return `${baseUrl}${this.mailingListBaseRoute}/${listId}/unsubscribe?subscriberId=${subscriberId}`;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    getManagePreferencesLink(subscriberId: string): string {
+        const baseUrl: string = GlobalRegistry.getAppData('baseUrl') ?? '';
+        return `${baseUrl}${this.mailingListBaseRoute}/preferences?subscriberId=${subscriberId}`;
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async queueEmailForList<T>(listId: string, data: MailingListQueueEmailData<T>): Promise<void> {
+        const list: MailingList = await this.mailingListRepository.findById(listId);
+        await PromiseUtilities.allChunked(
+            list.subscribers,
+            async subscriber => {
+                const content: string = await data.compile(data.template, { subscriber, list });
+
+                const html: string = PreactUtilities.renderEmail(
+                    this.MailingListBaseEmail,
+                    {
+                        list,
+                        subscriber,
+                        html: content,
+                        title: data.title ?? data.subject
+                    }
+                );
+
+                await this.emailService.queue({
+                    html,
+                    priority: EmailPriority.LOW,
+                    recipients: [subscriber.email],
+                    persist: false,
+                    ...data
+                });
+            }
+        );
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async requestSubscribeToList<T>(
+        listId: string,
+        subscriber: MailingListSubscriberCreateData,
+        emailData: OmitStrict<MailingListQueueEmailData<T>, 'template' | 'compile'>
+    ): Promise<void> {
+
+        const foundSubscriber: MailingListSubscriber | undefined = await this.subscriberRepository.findOne(
+            { where: { email: subscriber.email } },
+            false
+        );
+        const list: MailingList = await this.mailingListRepository.findById(listId);
+        if (foundSubscriber) {
+            await this.subscriberRepository.updateById(foundSubscriber.id, { mailingLists: [...foundSubscriber.mailingLists, list] });
+            return;
+        }
+
+        const token: MailingListSubscriptionConfirmationToken = await this.confirmationTokenRepository.create({
+            email: subscriber.email,
+            value: randomBytes(16).toString('hex'),
+            expirationDate: new Date(Date.now() + this.mailingListSubscriptionConfirmationTokenExpiresInMs),
+            name: subscriber.name,
+            listId
+        });
+
+        const html: string = PreactUtilities.renderEmail(
+            this.MailingListSubscribeConfirmationEmail,
+            {
+                subscriber,
+                mailingList: list,
+                confirmEmailLink: this.getSubscribeConfirmationLink(listId, token.value)
+            }
+        );
+
+        await this.emailService.queue({ ...emailData, html, recipients: [subscriber.email] });
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async confirmSubscribeToList(confirmationTokenValue: string): Promise<MailingListSubscriber> {
+        const foundToken: MailingListSubscriptionConfirmationToken = await this.confirmationTokenRepository.findOne(
+            { where: { value: confirmationTokenValue } }
+        );
+        const mailingList: MailingList = await this.mailingListRepository.findById(foundToken.listId);
+        const foundSubscriber: MailingListSubscriber | undefined = await this.subscriberRepository.findOne(
+            { where: { email: foundToken.email }, relations: ['mailingLists'] },
+            false
+        );
+        if (!foundSubscriber) {
+            return await this.subscriberRepository.create({ email: foundToken.email, name: foundToken.name, mailingLists: [mailingList] });
+        }
+        if (foundSubscriber.mailingLists.find(l => l.id === mailingList.id)) {
+            // already subscribed, do nothing
+            return foundSubscriber;
+        }
+        return await this.subscriberRepository.updateById(
+            foundSubscriber.id,
+            { mailingLists: [...foundSubscriber.mailingLists, mailingList] }
+        );
+    }
+
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    async unsubscribeFromList(listId: string, subscriberId: string): Promise<void> {
+        await this.mailingListRepository.findById(listId);
+        const foundSubscriber: MailingListSubscriber = await this.subscriberRepository.findOne(
+            { where: { id: subscriberId }, relations: ['mailingLists'] }
+        );
+        if (!foundSubscriber.mailingLists.find(l => l.id === listId)) {
+            // Is not subscribed to the mailing list.
+            return;
+        }
+        const newMailingLists: MailingList[] = foundSubscriber.mailingLists.filter(l => l.id !== listId);
+        await this.subscriberRepository.updateById(subscriberId, { mailingLists: newMailingLists });
+    }
+}

package/src/plugin/payment/models/payment-plugin-options-input.model.ts

@@ -1,23 +1,11 @@
-import { AnyObject } from '../../../entity';
-import { PaymentProviderInterface } from '../providers';
 import { PaymentMethod } from './payment-method.model';
 import { PaymentPluginOptions } from './payment-plugin-options.model';
+import { AnyPaymentProviderInterface } from '../providers/payment-provider.interface';
 
 /**
  * Input for configuring the payment plugin.
  */
 export type PaymentPluginOptionsInput<
     M extends readonly PaymentMethod[],
-    P extends readonly PaymentProviderInterface<
-        M[number][],
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        Record<M[number], AnyObject & { transactionId: string }>,
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        Record<M[number], AnyObject & { transactionId: string }>,
-        Record<M[number], AnyObject>,
-        Record<M[number], AnyObject>,
-        Record<M[number], boolean>,
-        Record<M[number], boolean>,
-        Record<M[number], boolean>
-    >[]
+    P extends readonly AnyPaymentProviderInterface[]
 > = PaymentPluginOptions<M, P>;

package/src/plugin/payment/models/payment-plugin-options.model.ts

@@ -1,24 +1,12 @@
-import { AnyObject } from '../../../entity';
-import { PaymentProviderInterface } from '../providers';
 import { PaymentMethod } from './payment-method.model';
+import { AnyPaymentProviderInterface } from '../providers/payment-provider.interface';
 
 /**
  * Configuration for the payment plugin.
  */
 export type PaymentPluginOptions<
     M extends readonly PaymentMethod[],
-    P extends readonly PaymentProviderInterface<
-        M[number][],
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        Record<M[number], AnyObject & { transactionId: string }>,
-        // eslint-disable-next-line jsdoc/require-jsdoc
-        Record<M[number], AnyObject & { transactionId: string }>,
-        Record<M[number], AnyObject>,
-        Record<M[number], AnyObject>,
-        Record<M[number], boolean>,
-        Record<M[number], boolean>,
-        Record<M[number], boolean>
-    >[]
+    P extends readonly AnyPaymentProviderInterface[]
 > = {
     /**
      * The payment methods to use (credit card, bank transfer etc.).

package/src/plugin/payment/models/payment.model.ts

@@ -1,19 +1,26 @@
 import { type PaymentMethod } from './payment-method.model';
 import { PaymentStatus } from './payment-status.enum';
-import { AnyObject, Entity, Property } from '../../../entity';
+import { AnyObject } from '../../../entity/any-object.model';
 import { BaseEntity } from '../../../entity/base-entity.model';
-import { type CurrencyCode } from '../../../localization';
+import { Entity } from '../../../entity/decorators/entity.decorator';
+import { Property } from '../../../entity/decorators/property.decorator';
+import { type CurrencyCode } from '../../../localization/models/currency-code.model';
 
 /**
  * Entity for an payment that has been made.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class Payment<M extends PaymentMethod, Data extends AnyObject> extends BaseEntity {
     /**
      * The transactionId, should be provided eg. From the client side of a checkout to prevent duplicate payments.
      */
     @Property.string({ format: 'uuid', unique: true })
     transactionId!: string;
+    /**
+     * The createdAt date. Is set to now by default.
+     */
+    @Property.date({ default: () => new Date() })
+    createdAt!: Date;
     /**
      * The status of the payment.
      */

package/src/plugin/payment/payment.plugin.ts

@@ -1,18 +1,26 @@
-import { Payment, PaymentMethod, PaymentPluginOptions, PaymentPluginOptionsInput } from './models';
-import { DefaultPaymentProviderArray, ZIBRI_PAYMENT_DI_TOKENS } from './payment.tokens';
-import { DiProvider, DiTokenProviderRecord, inject, NoProviderError, providersFromTokenRecord } from '../../di';
-import { validateEntitiesRegistered } from '../../utilities';
+import { PaymentMethod } from './models/payment-method.model';
+import { PaymentPluginOptionsInput } from './models/payment-plugin-options-input.model';
+import { PaymentPluginOptions } from './models/payment-plugin-options.model';
+import { Payment } from './models/payment.model';
+import { DefaultPaymentProviderArray, ZIBRI_PAYMENT_PLUGIN_DI_TOKENS } from './payment.tokens';
+import { ZibriApplication } from '../../application';
+import { NoProviderError } from '../../di/errors/no-provider.error';
+import { inject } from '../../di/inject.function';
+import { DiProvider } from '../../di/models/di-provider.model';
+import { DiTokenProviderRecord, providersFromTokenRecord } from '../../di/models/di-token.model';
+import { validateEntitiesRegistered } from '../../utilities/validate-entities-registered.function';
 import { ZibriPlugin } from '../plugin.model';
+import { PaymentService } from './services/payment.service';
+import { validateTokensRegistered } from '../../utilities/validate-tokens-registered.function';
 
 /**
  * Plugin that includes everything for handling payments.
  */
 export class ZibriPaymentPlugin extends ZibriPlugin {
-
-    private readonly defaultDiProviders: DiTokenProviderRecord<typeof ZIBRI_PAYMENT_DI_TOKENS> = {
+    private readonly defaultDiProviders: DiTokenProviderRecord<typeof ZIBRI_PAYMENT_PLUGIN_DI_TOKENS> = {
         OPTIONS_INPUT: {
             useFactory: () => {
-                throw new NoProviderError(ZIBRI_PAYMENT_DI_TOKENS.OPTIONS_INPUT, []);
+                throw new NoProviderError(ZIBRI_PAYMENT_PLUGIN_DI_TOKENS.OPTIONS_INPUT, []);
             }
         },
         OPTIONS: {
@@ -20,30 +28,48 @@ export class ZibriPaymentPlugin extends ZibriPlugin {
                 const input: PaymentPluginOptionsInput<
                     PaymentMethod[],
                     DefaultPaymentProviderArray
-                > = inject(ZIBRI_PAYMENT_DI_TOKENS.OPTIONS_INPUT);
+                > = inject(ZIBRI_PAYMENT_PLUGIN_DI_TOKENS.OPTIONS_INPUT);
                 const res: PaymentPluginOptions<PaymentMethod[], DefaultPaymentProviderArray> = {
                     ...input
                 };
                 return res;
             }
+        },
+        PAYMENT_SERVICE: {
+            useClass: PaymentService
         }
     };
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    providers: DiProvider<unknown>[] = providersFromTokenRecord(ZIBRI_PAYMENT_DI_TOKENS, this.defaultDiProviders);
+    providers: DiProvider<unknown>[] = providersFromTokenRecord(ZIBRI_PAYMENT_PLUGIN_DI_TOKENS, this.defaultDiProviders);
 
     // eslint-disable-next-line jsdoc/require-jsdoc
-    validate(): void {
-        validateEntitiesRegistered(this.constructor.name, Payment);
-        const options: PaymentPluginOptions<PaymentMethod[], DefaultPaymentProviderArray> = inject(ZIBRI_PAYMENT_DI_TOKENS.OPTIONS);
+    validate(app: ZibriApplication): void {
+        validateEntitiesRegistered(this.constructor.name, app, Payment);
+        validateTokensRegistered(this.constructor.name, ZIBRI_PAYMENT_PLUGIN_DI_TOKENS);
 
+        const options: PaymentPluginOptions<PaymentMethod[], DefaultPaymentProviderArray> = inject(ZIBRI_PAYMENT_PLUGIN_DI_TOKENS.OPTIONS);
         const allNames: string[] = options.paymentProviders.map(p => p.name);
-        if (allNames.length >= [...new Set(allNames)].length) {
-            throw new Error('There are duplicate payment provider names');
+        const duplicateNames: string[] = allNames.filter(name => allNames.filter(n => name === n).length > 1);
+        if (duplicateNames.length) {
+            throw new Error(
+                [
+                    'There are duplicate payment provider names:',
+                    [...new Set(duplicateNames)].map(n => `- ${n}`)
+                ].join('\n')
+            );
         }
 
-        if (options.paymentMethods.length >= [...new Set(options.paymentMethods)].length) {
-            throw new Error('There are duplicate payment methods');
+        const duplicatePaymentMethods: string[] = options.paymentMethods.filter(
+            method => options.paymentMethods.filter(m => method === m).length > 1
+        );
+        if (duplicatePaymentMethods.length) {
+            throw new Error(
+                [
+                    'There are duplicate payment methods:',
+                    [...new Set(duplicatePaymentMethods)].map(m => `- ${m}`)
+                ].join('\n')
+            );
         }
     }
 }

package/src/plugin/payment/payment.tokens.ts

@@ -1,27 +1,33 @@
 /* eslint-disable jsdoc/require-jsdoc */
-import { PaymentMethod, PaymentPluginOptionsInput } from './models';
-import { PaymentProviderInterface } from './providers';
-import { InjectionToken, TokenRecord } from '../../di';
-import { AnyObject } from '../../entity';
+import { PaymentMethod } from './models/payment-method.model';
+import { PaymentPluginOptionsInput } from './models/payment-plugin-options-input.model';
+import { PaymentPluginOptions } from './models/payment-plugin-options.model';
+import { AnyPaymentProviderInterface } from './providers/payment-provider.interface';
+import { PaymentServiceInterface } from './services/payment-service.interface';
+import { TokenRecord } from '../../di/models/di-token.model';
+import { InjectionToken } from '../../di/models/injection-token.model';
 
-export type DefaultPaymentProviderArray = PaymentProviderInterface<
-    PaymentMethod[],
-    Record<PaymentMethod, AnyObject & { transactionId: string }>,
-    Record<PaymentMethod, AnyObject & { transactionId: string }>,
-    Record<PaymentMethod, AnyObject>,
-    Record<PaymentMethod, AnyObject>,
-    Record<PaymentMethod, boolean>,
-    Record<PaymentMethod, boolean>,
-    Record<PaymentMethod, boolean>
->[];
+export type DefaultPaymentProviderArray = readonly AnyPaymentProviderInterface[];
 
 /**
  * The dependency injection tokens used by the ZibriPaymentPlugin.
  */
 // eslint-disable-next-line typescript/typedef
-export const ZIBRI_PAYMENT_DI_TOKENS = {
+export const ZIBRI_PAYMENT_PLUGIN_DI_TOKENS = {
     OPTIONS_INPUT: paymentToken<PaymentPluginOptionsInput<PaymentMethod[], DefaultPaymentProviderArray>>('zi.payment.options_input'),
-    OPTIONS: paymentToken<PaymentPluginOptionsInput<PaymentMethod[], DefaultPaymentProviderArray>>('zi.payment.options')
+    OPTIONS: paymentToken<PaymentPluginOptions<PaymentMethod[], DefaultPaymentProviderArray>>('zi.payment.options'),
+    /**
+     * Inject with explicit type parameters to get full type safety.
+     * @example
+     * inject<
+     *     PaymentServiceInterface<
+     *         [KnownPaymentMethod.PAY_PAL],
+     *         [PayPalPaymentProvider]
+     *     >
+     * >(ZIBRI_PAYMENT_DI_TOKENS.PAYMENT_SERVICE)
+     */
+    // eslint-disable-next-line typescript/no-explicit-any
+    PAYMENT_SERVICE: paymentToken<PaymentServiceInterface<any, any, any>>('zi.payment.payment_service')
 } as const satisfies TokenRecord;
 
 function paymentToken<T = never>(k: `zi.payment.${string}`): InjectionToken<T> {