@revenuecat/purchases-js 0.0.11 → 0.0.12

package/README.md

@@ -55,9 +55,10 @@ By downloading the current Offerings you can easily build a Paywall page using t
 associated `rcBillingProduct` and price.
 
 ```typescript
+const appUserId = "the unique id of the user in your systems";
 const purchases = new Purchases("your RC_PUBLISHABLE_API_KEY");
 
-purchases.getOfferings().then((offerings) => {
+purchases.getOfferings(appUserId).then((offerings) => {
   // Get current offering
   console.log(offerings.current);
   // Or a dictionary of all offerings
@@ -127,6 +128,17 @@ const App = () => (
 );
 ```
 
+If you need further information about the user's entitlements, you can use the `getCustomerInfo` method:
+
+```ts
+const customerInfo = await purchases.getCustomerInfo(appUserId);
+```
+
+### Important note
+
+Please be aware that the information about the entitlements can be manipulated by malicious actors, so make sure
+you protect your apps against attacks that modify the entitlements by validating access through your servers.
+
 ## Subscribe a User to an entitlement and allow payment with Stripe
 
 RCBilling allows you to use your payment gateway for payments.
@@ -136,88 +148,28 @@ In this example we will show Stripe, more will be supported soon!
 
 You built your paywall, and your user just clicked on the offer they want to subscribe to.
 
-### 1. Call the .subscribe method to initialise the process
-
 ```tsx
 const purchases = new Purchases("your RC_PUBLISHABLE_API_KEY");
-// You can retrieve this from the offerings you downloaded, as example:
-// offerings.current.packages[0].rcBillingProduct.identifier
-const rcBillingProductIndentifier =
-  "the Product Identifier the user wants to buy";
+// You can retrieve the package from the offerings through `getOfferings`:
+const rcBillingPackage = offerings.current.packages[0];
 const appUserId =
   "the unique id of the user that wants to subscribe to your product";
+const entitlementIdToCheck =
+  "the entitlementId you set up in RC for your product"; // TODO: remove once this is not needed
 
-purchase.subscribe(appUserId, rcBillingProductIndentifier).then((response) => {
-  if (response.nextAction === "collect_payment_info") {
-    // Use the clientSecret to show the StripeElements payment components
-    showStripeElements({
-      setupIntentClientSecret: response.data.clientSecret,
-    });
+purchase.purchasePackage(appUserId, rcBillingPackage).then((response) => {
+  const isEntitled =
+    entitlementIdToCheck in response.customerInfo.entitlements.active;
+  if (isEntitled == true) {
+    console.log(`User ${appUserID} is entitled to ${entitlementId}`);
   } else {
-    // No need to collect payment info, just wait for the entitlement to be granted
+    console.log(
+      `User ${appUserID} is not entitled to ${entitlementId}, even after ${numberOfAttempts} attempts`,
+    );
   }
 });
 ```
 
-### 2. [If nextAction === 'collect_payment_info'] Show the Stripe Elements to collect payment
-
-```tsx
-// Set up stripe as shown in their docs
-const stripePromise = loadStripe(
-  import.meta.env.VITE_RC_STRIPE_PK_KEY as string,
-  { stripeAccount: import.meta.env.VITE_RC_STRIPE_ACCOUNT_ID as string },
-);
-
-// Use the clientSecret obtained in the step 1. Call the .subscribe method to initialise the process
-const PaymentForm = ({ clientSecret }) => {
-  const handleSubmit = async (e: SyntheticEvent) => {
-    e.preventDefault();
-    stripe
-      .confirmSetup({
-        elements,
-        clientSecret,
-        confirmParams: {
-          return_url: `${window.location.origin}/success`,
-        },
-        redirect: "if_required",
-      })
-      .then((response) => {
-        // All is done you can now wait for the entitlement to be granted.
-      });
-  };
-
-  return (
-    <form id="payment-form" onSubmit={handleSubmit}>
-      <PaymentElement id="payment-element" options={paymentElementOptions} />
-    </form>
-  );
-};
-```
-
-### 3. Wait for the entitlement to be granted
-
-You can use the `.waitForEntitlement` method.
-
-```tsx
-const appUserId = "the unique id of the user in your systems";
-const entitlementId = "the entitlementId you set up in RC";
-
-const purchases = new Purchases("your RC_PUBLISHABLE_API_KEY");
-const numberOfAttempts = 10;
-
-purchases
-  .waitForEntitlement(appUserId, entitlementId, numberOfAttempts)
-  .then((isEntitled) => {
-    if (isEntitled == true) {
-      console.log(`User ${appUserID} is entitled to ${entitlementId}`);
-    } else {
-      console.log(
-        `User ${appUserID} is not entitled to ${entitlementId}, even after ${numberOfAttempts} attempts`,
-      );
-    }
-  });
-```
-
 # Development
 
 ## Install the library in a local project

package/dist/Purchases.es.d.ts

@@ -1,93 +1,207 @@
+declare enum BackendErrorCode {
+    BackendInvalidPlatform = 7000,
+    BackendStoreProblem = 7101,
+    BackendCannotTransferPurchase = 7102,
+    BackendInvalidReceiptToken = 7103,
+    BackendInvalidAppStoreSharedSecret = 7104,
+    BackendInvalidPaymentModeOrIntroPriceNotProvided = 7105,
+    BackendProductIdForGoogleReceiptNotProvided = 7106,
+    BackendInvalidPlayStoreCredentials = 7107,
+    BackendInternalServerError = 7110,
+    BackendEmptyAppUserId = 7220,
+    BackendInvalidAuthToken = 7224,
+    BackendInvalidAPIKey = 7225,
+    BackendBadRequest = 7226,
+    BackendPlayStoreQuotaExceeded = 7229,
+    BackendPlayStoreInvalidPackageName = 7230,
+    BackendPlayStoreGenericError = 7231,
+    BackendUserIneligibleForPromoOffer = 7232,
+    BackendInvalidAppleSubscriptionKey = 7234,
+    BackendInvalidSubscriberAttributes = 7263,
+    BackendInvalidSubscriberAttributesBody = 7264,
+    BackendProductIDsMalformed = 7662
+}
+
 export declare type CustomerInfo = CustomerInfo_2;
 
 declare interface CustomerInfo_2 {
-    entitlements: EntitlementInfos;
-    managementURL: string | null;
-    requestDate: Date;
-    firstSeenDate: Date;
-    originalPurchaseDate: Date | null;
+    readonly entitlements: EntitlementInfos;
+    readonly allExpirationDatesByProduct: {
+        [productIdentifier: string]: Date | null;
+    };
+    readonly allPurchaseDatesByProduct: {
+        [productIdentifier: string]: Date;
+    };
+    readonly activeSubscriptions: Set<string>;
+    readonly managementURL: string | null;
+    readonly requestDate: Date;
+    readonly firstSeenDate: Date;
+    readonly originalPurchaseDate: Date | null;
+    readonly originalAppUserId: string;
 }
 
 export declare interface EntitlementInfo {
-    identifier: string;
-    isActive: boolean;
-    originalPurchaseDate: Date;
-    expirationDate: Date;
-    productIdentifier: string;
+    readonly identifier: string;
+    readonly isActive: boolean;
+    readonly willRenew: boolean;
+    readonly store: Store;
+    readonly originalPurchaseDate: Date;
+    readonly expirationDate: Date | null;
+    readonly productIdentifier: string;
+    readonly unsubscribeDetectedAt: Date | null;
+    readonly billingIssueDetectedAt: Date | null;
+    readonly isSandbox: boolean;
+    readonly periodType: PeriodType;
 }
 
 export declare interface EntitlementInfos {
-    all: {
+    readonly all: {
         [entitlementId: string]: EntitlementInfo;
     };
-    active: {
+    readonly active: {
         [entitlementId: string]: EntitlementInfo;
     };
 }
 
+export declare enum ErrorCode {
+    UnknownError = 0,
+    UserCancelledError = 1,
+    StoreProblemError = 2,
+    PurchaseNotAllowedError = 3,
+    PurchaseInvalidError = 4,
+    ProductNotAvailableForPurchaseError = 5,
+    ProductAlreadyPurchasedError = 6,
+    ReceiptAlreadyInUseError = 7,
+    InvalidReceiptError = 8,
+    MissingReceiptFileError = 9,
+    NetworkError = 10,
+    InvalidCredentialsError = 11,
+    UnexpectedBackendResponseError = 12,
+    InvalidAppUserIdError = 14,
+    OperationAlreadyInProgressError = 15,
+    UnknownBackendError = 16,
+    InvalidAppleSubscriptionKeyError = 17,
+    IneligibleError = 18,
+    InsufficientPermissionsError = 19,
+    PaymentPendingError = 20,
+    InvalidSubscriberAttributesError = 21,
+    LogOutWithAnonymousUserError = 22,
+    ConfigurationError = 23,
+    UnsupportedError = 24,
+    EmptySubscriberAttributesError = 25,
+    CustomerInfoError = 28,
+    SignatureVerificationError = 36
+}
+
 export declare type Offering = Offering_2;
 
 declare interface Offering_2 {
-    id: string;
-    identifier: string;
-    displayName: string;
-    packages: Package_2[];
+    readonly id: string;
+    readonly identifier: string;
+    readonly displayName: string;
+    readonly metadata: {
+        [key: string]: unknown;
+    } | null;
+    readonly packages: {
+        [key: string]: Package_2;
+    };
+    readonly lifetimePackage: Package_2 | null;
+    readonly annualPackage: Package_2 | null;
+    readonly sixMonthPackage: Package_2 | null;
+    readonly threeMonthPackage: Package_2 | null;
+    readonly twoMonthPackage: Package_2 | null;
+    readonly monthlyPackage: Package_2 | null;
+    readonly weeklyPackage: Package_2 | null;
 }
 
 export declare type Offerings = Offerings_2;
 
 declare interface Offerings_2 {
-    all: {
+    readonly all: {
         [offeringId: string]: Offering_2;
     };
-    current: Offering_2 | null;
+    readonly current: Offering_2 | null;
 }
 
 export declare type Package = Package_2;
 
 declare interface Package_2 {
-    id: string;
-    identifier: string;
-    rcBillingProduct: Product;
+    readonly id: string;
+    readonly identifier: string;
+    readonly rcBillingProduct: Product;
+    readonly packageType: PackageType;
 }
 
-declare type PaymentProvider = "stripe";
-
-declare type PaymentProviderConfigModels = {
-    stripe?: {
-        publishableKey: string;
-        accountId: string;
-    };
-};
+declare enum PackageType {
+    Unknown = "unknown",
+    Custom = "custom",
+    Lifetime = "$rc_lifetime",
+    Annual = "$rc_annual",
+    SixMonth = "$rc_six_month",
+    ThreeMonth = "$rc_three_month",
+    TwoMonth = "$rc_two_month",
+    Monthly = "$rc_monthly",
+    Weekly = "$rc_weekly"
+}
 
-declare type PaymentProviderSettings = Record<PaymentProvider, PaymentProviderConfigModels[PaymentProvider]>;
+export declare type PeriodType = "normal" | "intro" | "trial";
 
 declare interface Price {
-    amount: number;
-    currency: string;
+    readonly amount: number;
+    readonly currency: string;
 }
 
 declare interface Product {
-    id: string;
-    displayName: string;
-    identifier: string;
-    currentPrice: Price | null;
-    normalPeriodDuration: string | null;
+    readonly id: string;
+    readonly displayName: string;
+    readonly identifier: string;
+    readonly currentPrice: Price | null;
+    readonly normalPeriodDuration: string | null;
+    readonly presentedOfferingIdentifier: string;
+}
+
+declare class PurchaseFlowError extends Error {
+    readonly errorCode: PurchaseFlowErrorCode;
+    readonly underlyingErrorMessage?: string | null | undefined;
+    constructor(errorCode: PurchaseFlowErrorCode, message?: string, underlyingErrorMessage?: string | null | undefined);
+}
+
+declare enum PurchaseFlowErrorCode {
+    ErrorSettingUpPurchase = 0,
+    ErrorChargingPayment = 1,
+    UnknownError = 2,
+    NetworkError = 3,
+    StripeError = 4,
+    MissingEmailError = 5
 }
 
 export declare class Purchases {
-    constructor(apiKey: string, paymentProviderSettings: PaymentProviderSettings);
+    private readonly backend;
+    private readonly purchaseOperationHelper;
+    constructor(apiKey: string);
     private toOfferings;
     getOfferings(appUserId: string): Promise<Offerings>;
     isEntitledTo(appUserId: string, entitlementIdentifier: string): Promise<boolean>;
-    purchasePackage(appUserId: string, rcPackage: Package, entitlementId: string, // TODO: Remove this parameter once we don't have to poll for entitlements
-        { customerEmail, htmlTarget, }?: {
+    purchasePackage(appUserId: string, rcPackage: Package, { customerEmail, htmlTarget, }?: {
         customerEmail?: string;
         htmlTarget?: HTMLElement;
-    }): Promise<boolean>;
+    }): Promise<{
+        customerInfo: CustomerInfo;
+    }>;
     getCustomerInfo(appUserId: string): Promise<CustomerInfo>;
     private logMissingProductIds;
     isSandbox(): boolean;
 }
 
+export declare class PurchasesError extends Error {
+    readonly errorCode: ErrorCode;
+    readonly underlyingErrorMessage?: string | null | undefined;
+    static getForBackendError(backendErrorCode: BackendErrorCode, backendErrorMessage: string | null): PurchasesError;
+    static getForPurchasesFlowError(purchasesFlowError: PurchaseFlowError): PurchasesError;
+    constructor(errorCode: ErrorCode, message?: string, underlyingErrorMessage?: string | null | undefined);
+    toString: () => string;
+}
+
+export declare type Store = "app_store" | "mac_app_store" | "play_store" | "amazon" | "stripe" | "rc_billing" | "promotional" | "unknown";
+
 export { }