@wepublish/api/src/lib/memberContext.d.ts

API core for we.publish.

import { Invoice, MetadataProperty, Payment, PaymentMethod, PaymentPeriodicity, PaymentProviderCustomer, PrismaClient, Subscription, SubscriptionDeactivationReason, SubscriptionEvent, User } from '@prisma/client';
import { DataLoaderContext } from './context';
import { InvoiceWithItems } from "../../payment-api/src";
import { MemberPlanWithPaymentMethods } from './db/memberPlan';
import { SubscriptionWithRelations } from './db/subscription';
import { MailContext } from "../../mail-api/src";
import { PaymentProvider } from "../../payment-api/src";
import { Action, LookupActionInput } from "../../membership-api/src";
export interface HandleSubscriptionChangeProps {
    subscription: SubscriptionWithRelations;
}
export interface RenewSubscriptionForUserProps {
    subscription: SubscriptionWithRelations;
}
export interface ChargeInvoiceProps {
    user: User;
    invoice: InvoiceWithItems;
    paymentMethodID: string;
    customer: PaymentProviderCustomer;
}
export interface DeactivateSubscriptionForUserProps {
    subscription: Subscription;
    deactivationReason?: SubscriptionDeactivationReason;
}
export interface MemberContext {
    prisma: PrismaClient;
    loaders: DataLoaderContext;
    paymentProviders: PaymentProvider[];
    mailContext: MailContext;
    getLoginUrlForUser(user: User): string;
    handleSubscriptionChange(props: HandleSubscriptionChangeProps): Promise<Subscription>;
    renewSubscriptionForUser(props: RenewSubscriptionForUserProps): Promise<Invoice | null>;
    chargeInvoice(props: ChargeInvoiceProps): Promise<boolean | Payment>;
    deactivateSubscription(props: DeactivateSubscriptionForUserProps): Promise<Subscription>;
}
export interface MemberContextProps {
    readonly prisma: PrismaClient;
    readonly loaders: DataLoaderContext;
    readonly paymentProviders: PaymentProvider[];
    readonly mailContext: MailContext;
    getLoginUrlForUser(user: User): string;
}
export declare function getNextDateForPeriodicity(start: Date, periodicity: PaymentPeriodicity): Date;
export declare function calculateAmountForPeriodicity(monthlyAmount: number, periodicity: PaymentPeriodicity): number;
export declare class MemberContext implements MemberContext {
    loaders: DataLoaderContext;
    paymentProviders: PaymentProvider[];
    mailContext: MailContext;
    getLoginUrlForUser: (user: User) => string;
    constructor(props: MemberContextProps);
    private getOffSessionPaymentProviderIDs;
    cancelInvoicesForSubscription(subscriptionID: string): Promise<void>;
    cancelRemoteSubscription({ subscriptionId, reason }: {
        subscriptionId: string;
        reason: SubscriptionDeactivationReason;
    }): Promise<void>;
    /**
     * Function used to
     * @param memberPlanID
     * @param memberPlanSlug
     * @param paymentMethodID
     * @param paymentMethodSlug
     */
    validateInputParamsCreateSubscription(memberPlanID: string | null, memberPlanSlug: string | null, paymentMethodID: string | null, paymentMethodSlug: string | null): Promise<void>;
    getMemberPlanByIDOrSlug(loaders: DataLoaderContext, memberPlanSlug: string, memberPlanID: string): Promise<MemberPlanWithPaymentMethods>;
    getPaymentMethodByIDOrSlug(loaders: DataLoaderContext, paymentMethodSlug: string, paymentMethodID: string): Promise<import("@prisma/client/runtime/library").GetResult<{
        id: string;
        createdAt: Date;
        modifiedAt: Date;
        name: string;
        slug: string;
        description: string;
        paymentProviderID: string;
        active: boolean;
    }, unknown> & {}>;
    validateSubscriptionPaymentConfiguration(memberPlan: MemberPlanWithPaymentMethods, autoRenew: boolean, paymentPeriodicity: PaymentPeriodicity, paymentMethod: PaymentMethod): Promise<void>;
    processSubscriptionProperties(subscriptionProperties: Omit<MetadataProperty, 'public'>[]): Promise<Pick<MetadataProperty, 'public' | 'key' | 'value'>[]>;
    createSubscription(subscriptionClient: PrismaClient['subscription'], userID: string, paymentMethodId: string, paymentPeriodicity: PaymentPeriodicity, monthlyAmount: number, memberPlanId: string, properties: Pick<MetadataProperty, 'key' | 'value' | 'public'>[], autoRenew: boolean, startsAt?: Date | string): Promise<{
        subscription: SubscriptionWithRelations;
        invoice: InvoiceWithItems;
    }>;
    getSubscriptionTemplateIdentifier(subscription: Subscription, subscriptionEvent: SubscriptionEvent): Promise<string | undefined>;
    getActionsForSubscriptions(query: LookupActionInput): Promise<Action[]>;
    sendSubscriptionDeactivationMail(subscription: Subscription, deactivation: SubscriptionDeactivationReason): Promise<void>;
    sendMailForSubscriptionEvent(subscriptionEvent: SubscriptionEvent, subscription: Subscription, optionalData: Record<string, any>): Promise<void>;
}