@reeboot/strapi-payment-plugin 0.0.9 → 0.0.11

package/dist/server/src/index.d.ts

@@ -20,6 +20,13 @@ declare const _default: {
             index(ctx: any): void;
         };
         stripe: {
+            createSubscription(ctx: import("koa").Context): Promise<import("koa").Context>;
+            cancelSubscription(ctx: import("koa").Context): Promise<void>;
+            updateSubscription(ctx: import("koa").Context): Promise<void>;
+            getSubscriptionDetails(ctx: import("koa").Context): Promise<import("koa").Context>;
+            listSubscriptions(ctx: import("koa").Context): Promise<void>;
+            adminListSubscriptions(ctx: import("koa").Context): Promise<void>;
+            adminCancelSubscription(ctx: import("koa").Context): Promise<void>;
             createPaymentIntent(ctx: import("koa").Context): Promise<import("koa").Context>;
             confirmPayment(ctx: import("koa").Context): Promise<import("koa").Context>;
             createCustomer(ctx: import("koa").Context): Promise<import("koa").Context>;
@@ -155,6 +162,12 @@ declare const _default: {
                         target: string;
                         mappedBy: string;
                     };
+                    subscriptions: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        mappedBy: string;
+                    };
                 };
             };
         };
@@ -234,9 +247,6 @@ declare const _default: {
                 };
             };
         };
-        /**
-         * Plugin server methods
-         */
         payment: {
             schema: {
                 kind: string;
@@ -305,14 +315,97 @@ declare const _default: {
                 };
             };
         };
+        subscription: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                    description: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                attributes: {
+                    stripe_subscription_id: {
+                        type: string;
+                        unique: boolean;
+                        required: boolean;
+                        configurable: boolean;
+                    };
+                    stripe_customer_id: {
+                        type: string;
+                        required: boolean;
+                        configurable: boolean;
+                    };
+                    stripe_price_id: {
+                        type: string;
+                        required: boolean;
+                        configurable: boolean;
+                    };
+                    stripe_product_id: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    status: {
+                        type: string;
+                        enum: string[];
+                        required: boolean;
+                        default: string;
+                        configurable: boolean;
+                    };
+                    current_period_start: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    current_period_end: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    cancel_at_period_end: {
+                        type: string;
+                        default: boolean;
+                        configurable: boolean;
+                    };
+                    canceled_at: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    trial_start: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    trial_end: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    latest_invoice_id: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    metadata: {
+                        type: string;
+                        configurable: boolean;
+                    };
+                    customer: {
+                        type: string;
+                        relation: string;
+                        target: string;
+                        inversedBy: string;
+                    };
+                };
+            };
+        };
     };
     policies: {
         isAuthenticated: (ctx: any) => boolean;
     };
     middlewares: {
-        'webhook-validator': (ctx: import("koa").Context, next: () => Promise<any>) => Promise<import("koa").Context>;
-        rateLimiter: (ctx: import("koa").Context, next: () => Promise<any>) => Promise<any>;
-        inputSanitizer: (ctx: import("koa").Context, next: () => Promise<any>) => Promise<void>;
+        'webhook-validator': (ctx: import("koa").Context, next: () => Promise<void>) => Promise<import("koa").Context>;
+        rateLimiter: (ctx: import("koa").Context, next: () => Promise<void>) => Promise<any>;
+        inputSanitizer: (ctx: import("koa").Context, next: () => Promise<void>) => Promise<void>;
     };
 };
 export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -7,14 +7,14 @@ declare const _default: {
     /**
      * Webhook signature validator
      */
-    'webhook-validator': (ctx: Context, next: () => Promise<any>) => Promise<Context>;
+    'webhook-validator': (ctx: Context, next: () => Promise<void>) => Promise<Context>;
     /**
      * Rate limiter middleware for sensitive operations
      */
-    rateLimiter: (ctx: Context, next: () => Promise<any>) => Promise<any>;
+    rateLimiter: (ctx: Context, next: () => Promise<void>) => Promise<any>;
     /**
      * Input sanitization middleware
      */
-    inputSanitizer: (ctx: Context, next: () => Promise<any>) => Promise<void>;
+    inputSanitizer: (ctx: Context, next: () => Promise<void>) => Promise<void>;
 };
 export default _default;

package/dist/server/src/services/stripe.d.ts

@@ -311,10 +311,12 @@
 /// <reference types="stripe/types/net/net" />
 import Stripe from 'stripe';
 import type { Core } from '@strapi/strapi';
+import type { OrderInput, CustomerInput, SubscriptionInput } from './types';
+import { type StripeAddress, type OrderItem } from '../types/plugin-config';
 interface PaymentIntentParams {
     amount: number;
     currency: string;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, string>;
     customer?: string;
     orderId?: string;
     customerId?: string;
@@ -326,15 +328,46 @@ interface CreateCustomerParams {
     firstName: string;
     lastName: string;
     phone?: string;
-    address?: Record<string, any>;
-    metadata?: Record<string, any>;
+    address?: StripeAddress;
+    metadata?: Record<string, string>;
     strapiCustomerId?: string;
 }
 interface RefundParams {
     paymentIntentId: string;
     amount?: number;
     reason?: Stripe.RefundCreateParams.Reason;
-    metadata?: Record<string, any>;
+    metadata?: Record<string, string>;
+}
+interface InitializePaymentFlowParams {
+    amount: number;
+    currency: string;
+    email: string;
+    firstName: string;
+    lastName: string;
+    items?: OrderItem[];
+    metadata?: Record<string, string>;
+    confirm?: boolean;
+    payment_method?: string;
+    orderNumber?: string;
+}
+type CreateOrderData = Omit<OrderInput, 'order_status' | 'payment_status'> & {
+    order_status?: OrderInput['order_status'];
+    payment_status?: OrderInput['payment_status'];
+};
+export interface CreateSubscriptionParams {
+    strapiCustomerId: string;
+    stripeCustomerId: string;
+    priceId: string;
+    trialPeriodDays?: number;
+    metadata?: Record<string, string>;
+    defaultPaymentMethod?: string;
+}
+export interface UpdateSubscriptionParams {
+    priceId?: string;
+    cancelAtPeriodEnd?: boolean;
+    trialEnd?: number | 'now';
+    metadata?: Record<string, string>;
+    defaultPaymentMethod?: string;
 }
 export interface StripeService {
     initializeStripe(): Promise<Stripe>;
@@ -345,13 +378,20 @@ export interface StripeService {
     createRefund(params: RefundParams): Promise<Stripe.Refund>;
     handleWebhook(event: Stripe.Event): Promise<void>;
     constructEvent(payload: string | Buffer, signature: string): Promise<Stripe.Event>;
-    updateStrapiOrder(orderId: string, data: any): Promise<void>;
-    updateStrapiCustomer(customerId: string, data: any): Promise<void>;
-    createStrapiPaymentRecord(paymentIntent: Stripe.PaymentIntent): Promise<any>;
-    createCustomerRecord(data: any): Promise<any>;
-    createOrderRecord(data: any): Promise<any>;
-    initializePaymentFlow(params: any): Promise<any>;
+    updateStrapiOrder(orderId: string, data: Partial<OrderInput>): Promise<void>;
+    updateStrapiCustomer(customerId: string, data: Partial<CustomerInput>): Promise<void>;
+    createStrapiPaymentRecord(paymentIntent: Stripe.PaymentIntent): Promise<unknown>;
+    createCustomerRecord(data: CustomerInput): Promise<unknown>;
+    createOrderRecord(data: CreateOrderData): Promise<unknown>;
+    initializePaymentFlow(params: InitializePaymentFlowParams): Promise<unknown>;
     getStripe(): Stripe | null;
+    setStripe(instance: Stripe): void;
+    createSubscription(params: CreateSubscriptionParams): Promise<Stripe.Subscription>;
+    cancelSubscription(stripeSubscriptionId: string, cancelAtPeriodEnd?: boolean): Promise<Stripe.Subscription>;
+    updateSubscription(stripeSubscriptionId: string, params: UpdateSubscriptionParams): Promise<Stripe.Subscription>;
+    retrieveSubscription(stripeSubscriptionId: string): Promise<Stripe.Subscription>;
+    createStrapiSubscriptionRecord(subscription: Stripe.Subscription, strapiCustomerId?: string): Promise<unknown>;
+    updateStrapiSubscription(stripeSubscriptionId: string, data: Partial<SubscriptionInput>): Promise<void>;
 }
 declare const stripeService: ({ strapi }: {
     strapi: Core.Strapi;

package/dist/server/src/services/types/api.d.ts

@@ -1,12 +1,15 @@
+import type { StripeAddress, OrderItem } from '../../types/plugin-config';
 export type PaymentStatus = 'pending' | 'succeeded' | 'failed' | 'canceled' | 'refunded';
 export type OrderStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'refunded';
+export type SubscriptionStatus = 'active' | 'canceled' | 'incomplete' | 'incomplete_expired' | 'past_due' | 'paused' | 'trialing' | 'unpaid';
+export type StripeMetadata = Record<string, string>;
 export interface PaymentInput {
     stripe_payment_intent_id: string;
     amount: number;
     currency: string;
     payment_status: PaymentStatus;
     payment_method?: string;
-    metadata?: Record<string, any>;
+    metadata?: StripeMetadata;
     customer?: string;
     order?: string;
 }
@@ -17,8 +20,8 @@ export interface OrderInput {
     order_status: OrderStatus;
     payment_status: 'unpaid' | 'paid' | 'partially_paid' | 'refunded';
     customer?: string;
-    items: Record<string, any>;
-    metadata?: Record<string, any>;
+    items: OrderItem[];
+    metadata?: StripeMetadata;
 }
 export interface CustomerInput {
     email: string;
@@ -26,6 +29,22 @@ export interface CustomerInput {
     first_name: string;
     last_name: string;
     phone?: string;
-    address?: Record<string, any>;
-    metadata?: Record<string, any>;
+    address?: StripeAddress;
+    metadata?: StripeMetadata;
+}
+export interface SubscriptionInput {
+    stripe_subscription_id: string;
+    stripe_customer_id: string;
+    stripe_price_id: string;
+    stripe_product_id?: string;
+    status: SubscriptionStatus;
+    current_period_start?: string;
+    current_period_end?: string;
+    cancel_at_period_end?: boolean;
+    canceled_at?: string | null;
+    trial_start?: string | null;
+    trial_end?: string | null;
+    latest_invoice_id?: string;
+    metadata?: StripeMetadata;
+    customer?: string;
 }