zibri 2.2.1 → 2.4.0

package/src/plugin/mailing-list/mailing-list.tokens.ts

@@ -0,0 +1,37 @@
+import { MailingListBaseEmailTemplate } from './models/mailing-list-base-email-template.model';
+import { MailingListPreferencesPageTemplate } from './models/mailing-list-preferences-page-template.model';
+import { MailingListSubscribeConfirmationEmailTemplate } from './models/mailing-list-subscribe-confirmation-email-template.model';
+import { MailingListSubscribeSuccessPageTemplate } from './models/mailing-list-subscribe-success-page-template.model';
+import { MailingListUnsubscribeConfirmationPageTemplate } from './models/mailing-list-unsubscribe-confirmation-page-template.model';
+import { MailingListServiceInterface } from './services/mailing-list-service.interface';
+import { TokenRecord } from '../../di/models/di-token.model';
+import { InjectionToken } from '../../di/models/injection-token.model';
+
+/**
+ * The dependency injection tokens used by the ZibriMailingListPlugin.
+ */
+// eslint-disable-next-line typescript/typedef
+export const ZIBRI_MAILING_LIST_PLUGIN_DI_TOKENS = {
+    MAILING_LIST_SERVICE: mailingListToken<MailingListServiceInterface>('zi.mailing_list.mailing_list_service'),
+    CONFIRMATION_TOKEN_EXPIRES_IN_MS: mailingListToken<number>('zi.mailing_list.subscription_confirmation_token_expires_in_ms'),
+    SUBSCRIBE_CONFIRMATION_EMAIL_TEMPLATE: mailingListToken<MailingListSubscribeConfirmationEmailTemplate | undefined>(
+        'zi.mailing_list.subscribe_confirmation_email_template'
+    ),
+    PREFERENCES_PAGE_TEMPLATE: mailingListToken<MailingListPreferencesPageTemplate | undefined>(
+        'zi.mailing_list.preferences_page_template'
+    ),
+    UNSUBSCRIBE_CONFIRMATION_PAGE_TEMPLATE: mailingListToken<MailingListUnsubscribeConfirmationPageTemplate | undefined>(
+        'zi.mailing_list.unsubscribe_confirmation_page_template'
+    ),
+    SUBSCRIBE_SUCCESS_PAGE_TEMPLATE: mailingListToken<MailingListSubscribeSuccessPageTemplate | undefined>(
+        'zi.mailing_list.subscribe_success_page_template'
+    ),
+    BASE_EMAIL_TEMPLATE: mailingListToken<MailingListBaseEmailTemplate | undefined>(
+        'zi.mailing_list.base_email_template'
+    )
+} as const satisfies TokenRecord;
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function mailingListToken<T = never>(k: `zi.mailing_list.${string}`): InjectionToken<T> {
+    return new InjectionToken<T>(k);
+}

package/src/plugin/mailing-list/models/mailing-list-base-email-template.model.ts

@@ -0,0 +1,36 @@
+import { MailingListSubscriber } from './mailing-list-subscriber.model';
+import { MailingList } from './mailing-list.model';
+import { PreactEmailComponent } from '../../../preact/preact-email-component.model';
+
+/**
+ * Data about the mailing list that this email belongs to.
+ */
+export type MailingListTemplateData = {
+    /**
+     * The subscriber if the email belongs to a mailing list.
+     */
+    subscriber: MailingListSubscriber,
+    /**
+     * The mailing list that the email belongs to, if any.
+     */
+    list: MailingList
+};
+
+/**
+ * Properties of a mailing list base email.
+ */
+type MailingListBaseEmailTemplateProps = MailingListTemplateData & {
+    /**
+     * The title of the email.
+     */
+    title: string,
+    /**
+     * The html content.
+     */
+    html: string
+};
+
+/**
+ * Definition for a mailing list base email template.
+ */
+export type MailingListBaseEmailTemplate = PreactEmailComponent<MailingListBaseEmailTemplateProps>;

package/src/plugin/mailing-list/models/mailing-list-preferences-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 preferences page component.
+ */
+type MailingListPreferencesPageTemplateProps = {
+    /**
+     * The subscriber to render the page for.
+     */
+    subscriber: MailingListSubscriber,
+    /**
+     * All mailing lists that can be managed.
+     */
+    mailingLists: MailingList[],
+    /**
+     * The api url to update/patch the preferences.
+     */
+    managePreferencesApiUrl: string
+};
+
+/**
+ * Definition for a mailing list preferences page template.
+ */
+export type MailingListPreferencesPageTemplate = PreactComponent<MailingListPreferencesPageTemplateProps>;

package/src/plugin/mailing-list/models/mailing-list-subscribe-confirmation-email-template.model.ts

@@ -0,0 +1,26 @@
+import { MailingList } from './mailing-list.model';
+import { PreactEmailComponent } from '../../../preact/preact-email-component.model';
+import { MailingListSubscriberCreateData } from '../services/mailing-list-service.interface';
+
+/**
+ * Properties of a mailing list subscribe confirmation email.
+ */
+type MailingListSubscribeConfirmationEmailTemplateProps = {
+    /**
+     * The (to be created) subscriber that needs to confirm.
+     */
+    subscriber: MailingListSubscriberCreateData,
+    /**
+     * The link to confirm the email.
+     */
+    confirmEmailLink: string,
+    /**
+     * The mailing list for wich this confirmation has been triggered.
+     */
+    mailingList: MailingList
+};
+
+/**
+ * Definition for a mailing list subscribe confirmation email template.
+ */
+export type MailingListSubscribeConfirmationEmailTemplate = PreactEmailComponent<MailingListSubscribeConfirmationEmailTemplateProps>;

package/src/plugin/mailing-list/models/mailing-list-subscribe-success-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 subscribe success page.
+ */
+type MailingListSubscribeSuccessPageTemplateProps = {
+    /**
+     * The mailing list for which the subscription was successful.
+     */
+    mailingList: MailingList,
+    /**
+     * The subscriber that confirmed the subscription.
+     */
+    subscriber: MailingListSubscriber,
+    /**
+     * The link to the manage preferences page.
+     */
+    managePreferencesLink: string
+};
+
+/**
+ * Definition for a mailing list subscribe success page template.
+ */
+export type MailingListSubscribeSuccessPageTemplate = PreactComponent<MailingListSubscribeSuccessPageTemplateProps>;

package/src/{email → plugin}/mailing-list/models/mailing-list-subscriber.model.ts

@@ -6,7 +6,7 @@ import { Property } from '../../../entity/decorators/property.decorator';
 /**
  * Defines a subscriber to a single or multiple mailing lists.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class MailingListSubscriber extends BaseEntity {
     /**
      * The optional name of the subscriber.

package/src/{email → plugin}/mailing-list/models/mailing-list-subscription-confirmation-token.model.ts

@@ -6,7 +6,7 @@ import { OmitClass } from '../../../entity/omit-class.model';
 /**
  * A short lived token used to confirm a mailing list subscription.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class MailingListSubscriptionConfirmationToken extends BaseEntity {
     /**
      * The expiration date of the confirmation token.

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/{email → plugin}/mailing-list/models/mailing-list.model.ts

@@ -6,7 +6,7 @@ import { Property } from '../../../entity/decorators/property.decorator';
 /**
  * A mailing list like a newsletter that people can easily subscribe and unsubscribe to.
  */
-@Entity()
+@Entity({ allowOrphan: true })
 export class MailingList extends BaseEntity {
     /**
      * The name of the mailing list.

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 { PaymentMethod } from './payment-method.model';
 import { PaymentPluginOptions } from './payment-plugin-options.model';
-import { AnyObject } from '../../../entity/any-object.model';
-import { PaymentProviderInterface } from '../providers/payment-provider.interface';
+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 { PaymentMethod } from './payment-method.model';
-import { AnyObject } from '../../../entity/any-object.model';
-import { PaymentProviderInterface } from '../providers/payment-provider.interface';
+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

@@ -9,13 +9,18 @@ import { type CurrencyCode } from '../../../localization/models/currency-code.mo
 /**
  * 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

@@ -2,23 +2,25 @@ 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_DI_TOKENS } from './payment.tokens';
+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: {
@@ -26,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')
+            );
         }
     }
 }