mobilyflow-react-native-sdk 0.0.1

package/src/entities/mobily-customer-entitlement.ts

@@ -0,0 +1,37 @@
+import { ProductType } from '../enums/product-type';
+import { MobilyProduct } from './mobily-product';
+import { Platform } from '../enums/platform';
+import { objectTransformer } from '../utils/object-transformer';
+
+export class ItemEntitlement {
+  quantity: number;
+}
+
+export class SubscriptionEntitlement {
+  startDate: Date;
+  expirationDate: Date;
+  autoRenewEnable: boolean;
+  platform: Platform;
+  isManagedByThisStoreAccount: boolean;
+
+  static parseFromAPI(obj: SubscriptionEntitlement) {
+    return objectTransformer(obj, { dates: ['startDate', 'expirationDate'] });
+  }
+}
+
+export class MobilyCustomerEntitlement {
+  type: ProductType;
+  product: MobilyProduct;
+  platformOriginalTransactionId: string;
+  item?: ItemEntitlement;
+  subscription?: SubscriptionEntitlement;
+
+  static parseFromAPI(obj: MobilyCustomerEntitlement) {
+    return objectTransformer(obj, {
+      mapping: {
+        product: MobilyProduct.parseFromAPI,
+        subscription: SubscriptionEntitlement.parseFromAPI,
+      },
+    });
+  }
+}

package/src/entities/mobily-one-time-product.ts

@@ -0,0 +1,11 @@
+import type { ProductStatus } from '../enums/product-status';
+
+export class MobilyOneTimeProduct {
+  price: number;
+  currencyCode: string;
+  priceFormatted: string;
+  isConsumable: boolean;
+  isNonRenewableSub: boolean;
+  isMultiQuantity: boolean;
+  status: ProductStatus;
+}

package/src/entities/mobily-product.ts

@@ -0,0 +1,34 @@
+import { ProductType } from '../enums/product-type';
+import type { ProductStatus } from '../enums/product-status';
+import type { MobilyOneTimeProduct } from './mobily-one-time-product';
+import type { MobilySubscriptionProduct } from './mobily-subscription-product';
+import { objectTransformer } from '../utils/object-transformer';
+
+export class MobilyProduct {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+  deletedAt?: Date;
+
+  identifier: string;
+  appId: string;
+
+  name: string;
+  description: string;
+  ios_sku: string;
+  android_sku: string;
+
+  type: ProductType;
+  extras: any;
+
+  status: ProductStatus;
+
+  oneTimeProduct?: MobilyOneTimeProduct;
+  subscriptionProduct?: MobilySubscriptionProduct;
+
+  static parseFromAPI(obj: MobilyProduct) {
+    return objectTransformer(obj, {
+      dates: ['createdAt', 'updatedAt', 'deletedAt'],
+    });
+  }
+}

package/src/entities/mobily-subscription-group.ts

@@ -0,0 +1,20 @@
+import { MobilyProduct } from './mobily-product';
+import { objectTransformer } from '../utils/object-transformer';
+
+export class MobilySubscriptionGroup {
+  id: string;
+  identifier: string;
+  name: string;
+  description: string;
+  ios_groupId: string;
+  extras: any;
+  products: MobilyProduct[];
+
+  static parseFromAPI(obj: MobilySubscriptionGroup) {
+    return objectTransformer(obj, {
+      mapping: {
+        products: MobilyProduct.parseFromAPI,
+      },
+    });
+  }
+}

package/src/entities/mobily-subscription-offer.ts

@@ -0,0 +1,16 @@
+import type { ProductStatus } from '../enums/product-status';
+import type { PeriodUnit } from '../enums/period-unit';
+
+export class MobilySubscriptionOffer {
+  id: string;
+  name: string;
+  price: number;
+  currencyCode: string;
+  priceFormatted: string;
+  isFreeTrial: boolean;
+  periodCount: number;
+  periodUnit: PeriodUnit;
+  ios_offerId: string;
+  extras: any;
+  status: ProductStatus;
+}

package/src/entities/mobily-subscription-product.ts

@@ -0,0 +1,14 @@
+import type { ProductStatus } from '../enums/product-status';
+import { MobilySubscriptionOffer } from './mobily-subscription-offer';
+import { MobilySubscriptionGroup } from './mobily-subscription-group';
+
+export class MobilySubscriptionProduct {
+  baseOffer: MobilySubscriptionOffer;
+  freeTrial: MobilySubscriptionOffer;
+  promotionalOffers: MobilySubscriptionOffer[];
+  status: ProductStatus;
+
+  groupLevel: number;
+  subscriptionGroupId: string;
+  subscriptionGroup: MobilySubscriptionGroup;
+}

package/src/enums/mobily-environment.ts

@@ -0,0 +1,5 @@
+export enum MobilyEnvironment {
+  DEVELOPMENT = 0,
+  STAGING = 1,
+  PRODUCTION = 2,
+}

package/src/enums/period-unit.ts

@@ -0,0 +1,5 @@
+export enum PeriodUnit {
+  WEEK = 0,
+  MONTH = 1,
+  YEAR = 2,
+}

package/src/enums/platform.ts

@@ -0,0 +1,4 @@
+export enum Platform {
+  IOS = 0,
+  ANDROID = 1,
+}

package/src/enums/product-status.ts

@@ -0,0 +1,5 @@
+export enum ProductStatus {
+  INVALID = 0,
+  unavailable = 1,
+  available = 2,
+}

package/src/enums/product-type.ts

@@ -0,0 +1,4 @@
+export enum ProductType {
+  ONE_TIME = 'one_time',
+  SUBSCRIPTION = 'subscription',
+}

package/src/enums/webhook-status.ts

@@ -0,0 +1,5 @@
+export enum WebhookStatus {
+  PENDING = 0,
+  ERROR = 1,
+  SUCCESS = 2,
+}

package/src/errors/mobily-error.ts

@@ -0,0 +1,18 @@
+export class MobilyError extends Error {
+  constructor(
+    public readonly type: MobilyError.Type,
+    public readonly message: string,
+    public readonly nativeStack?: any
+  ) {
+    super(message);
+  }
+}
+
+export namespace MobilyError {
+  export enum Type {
+    STORE_UNAVAILABLE,
+    SERVER_UNAVAILABLE,
+    NO_CUSTOMER_LOGGED,
+    UNKNOWN_ERROR,
+  }
+}

package/src/errors/mobily-purchase-error.ts

@@ -0,0 +1,30 @@
+export class MobilyPurchaseError extends Error {
+  constructor(
+    public readonly type: MobilyPurchaseError.Type,
+    public readonly message: string,
+    public readonly nativeStack?: any
+  ) {
+    super(message);
+  }
+}
+
+export namespace MobilyPurchaseError {
+  export enum Type {
+    PURCHASE_ALREADY_PENDING,
+
+    PRODUCT_UNAVAILABLE,
+    NETWORK_UNAVAILABLE,
+
+    WEBHOOK_NOT_PRECESSED,
+    WEBHOOK_FAILED,
+
+    ALREADY_PURCHASED,
+    NOT_MANAGED_BY_THIS_STORE_ACCOUNT,
+    STORE_ACCOUNT_ALREADY_HAVE_PURCHASE,
+    RENEW_ALREADY_ON_THIS_PLAN,
+
+    USER_CANCELED,
+    FAILED,
+    PENDING,
+  }
+}

package/src/errors/mobily-transfer-ownership-error.ts

@@ -0,0 +1,20 @@
+export class MobilyTransferOwnershipError extends Error {
+  constructor(
+    public readonly type: MobilyTransferOwnershipError.Type,
+    public readonly message: string,
+    public readonly nativeStack?: any
+  ) {
+    super(message);
+  }
+}
+
+export namespace MobilyTransferOwnershipError {
+  export enum Type {
+    NOTHING_TO_TRANSFER,
+    TRANSFER_TO_SAME_CUSTOMER,
+    ALREADY_PENDING,
+
+    WEBHOOK_NOT_PROCESSED,
+    WEBHOOK_FAILED,
+  }
+}

package/src/index.tsx

@@ -0,0 +1,153 @@
+import MobilyflowReactNativeSdk, { type MobilyPurchaseSDKOptions } from './NativeMobilyflowReactNativeSdk';
+import { MobilyProduct } from './entities/mobily-product';
+import type { WebhookStatus } from './enums/webhook-status';
+import type { MobilySubscriptionOffer } from './entities/mobily-subscription-offer';
+import { MobilySubscriptionGroup } from './entities/mobily-subscription-group';
+import { MobilyCustomerEntitlement } from './entities/mobily-customer-entitlement';
+import { Platform as RNPlatform } from 'react-native';
+import { MobilyError } from './errors/mobily-error';
+import { MobilyPurchaseError } from './errors/mobily-purchase-error';
+import { MobilyTransferOwnershipError } from './errors/mobily-transfer-ownership-error';
+
+export type PurchaseOptions = {
+  offer?: MobilySubscriptionOffer;
+  quantity?: number;
+};
+
+export class MobilyPurchaseSDK {
+  private _uuid: string;
+
+  constructor(appId: string, apiKey: string, environment: number, options?: MobilyPurchaseSDKOptions) {
+    this._uuid = MobilyflowReactNativeSdk.instantiate(appId, apiKey, environment, options ?? {});
+  }
+
+  private throwError(error: any) {
+    if (RNPlatform.OS === 'android') {
+      switch (error.name) {
+        case 'com.mobilyflow.mobilypurchasesdk.Exceptions.MobilyException':
+          return new MobilyError(parseInt(error.code, 10), error.message, error.nativeStackAndroid);
+        case 'com.mobilyflow.mobilypurchasesdk.Exceptions.MobilyPurchaseException':
+          return new MobilyPurchaseError(parseInt(error.code, 10), error.message, error.nativeStackAndroid);
+        case 'com.mobilyflow.mobilypurchasesdk.Exceptions.MobilyTransferOwnershipException':
+          return new MobilyTransferOwnershipError(parseInt(error.code, 10), error.message, error.nativeStackAndroid);
+      }
+    } else {
+      switch (error.domain) {
+        case 'MobilyflowSDK.MobilyError':
+          return new MobilyError(parseInt(error.code, 10), error.message, error.nativeStackIOS);
+        case 'MobilyflowSDK.MobilyPurchaseError':
+          return new MobilyPurchaseError(parseInt(error.code, 10), error.message, error.nativeStackIOS);
+        case 'MobilyflowSDK.MobilyTransferOwnershipError':
+          return new MobilyTransferOwnershipError(parseInt(error.code, 10), error.message, error.nativeStackIOS);
+      }
+    }
+
+    return error;
+  }
+
+  close() {
+    try {
+      MobilyflowReactNativeSdk.close(this._uuid);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async login(externalId: string) {
+    try {
+      await MobilyflowReactNativeSdk.login(this._uuid, externalId);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getProducts(identifiers?: string[]) {
+    try {
+      const products = await MobilyflowReactNativeSdk.getProducts(this._uuid, identifiers);
+      return products.map(MobilyProduct.parseFromAPI);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getSubscriptionGroups(identifiers?: string[]) {
+    try {
+      const groups = await MobilyflowReactNativeSdk.getSubscriptionGroups(this._uuid, identifiers);
+      return groups.map(MobilySubscriptionGroup.parseFromAPI);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getEntitlementForSubscription(subscriptionGroupId: string) {
+    try {
+      const entitlement = await MobilyflowReactNativeSdk.getEntitlementForSubscription(this._uuid, subscriptionGroupId);
+      return MobilyCustomerEntitlement.parseFromAPI(entitlement);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getEntitlement(productId: string) {
+    try {
+      const entitlement = await MobilyflowReactNativeSdk.getEntitlement(this._uuid, productId);
+      return MobilyCustomerEntitlement.parseFromAPI(entitlement);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getEntitlements(productIds: string[]) {
+    try {
+      const entitlements = await MobilyflowReactNativeSdk.getEntitlements(this._uuid, productIds);
+      return entitlements.map(MobilyCustomerEntitlement.parseFromAPI);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async requestTransferOwnership() {
+    try {
+      return await MobilyflowReactNativeSdk.requestTransferOwnership(this._uuid);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async openManageSubscription() {
+    try {
+      return await MobilyflowReactNativeSdk.openManageSubscription(this._uuid);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  // openRefundDialog(transactionId: string): Promise<void>;
+
+  async purchaseProduct(product: MobilyProduct, options?: PurchaseOptions): Promise<WebhookStatus> {
+    try {
+      return await MobilyflowReactNativeSdk.purchaseProduct(this._uuid, product.id, {
+        offerId: options?.offer?.id || null,
+        quantity: options?.quantity || null,
+      });
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  sendDiagnotic() {
+    try {
+      return MobilyflowReactNativeSdk.sendDiagnotic(this._uuid);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+
+  async getStoreCountry() {
+    try {
+      return await MobilyflowReactNativeSdk.getStoreCountry(this._uuid);
+    } catch (error: any) {
+      throw this.throwError(error);
+    }
+  }
+}

package/src/utils/object-transformer.ts

@@ -0,0 +1,60 @@
+export type ObjectTransformer = {
+  dates?: string[];
+  mapping?: {
+    [key in string]: (obj: any) => any;
+  };
+};
+
+/**
+ * Transform object following the transformer.
+ * Note: The function is safe, take care of the real type of each field and perform null checks.
+ *
+ * ```
+ * // Example:
+ * objectTransformer(
+ *     {
+ *       date_start: '2023-04-12',
+ *       date_end: '2023-04-13',
+ *       user_array: [
+ *         { name: 'Greg', created_date: '2023-05-12' },
+ *         { name: 'Antoine', created_date: '2023-06-12' },
+ *       ],
+ *       single_user: { name: 'Greg', created_date: '2023-05-12' },
+ *     },
+ *     {
+ *       dates: ['date_start', 'date_end'],
+ *       mapping: {
+ *         user_array: parseUser,
+ *         single_user: parseUser,
+ *       },
+ *     },
+ *   );
+ * // Return an object with parsed dates & mapped user.
+ * ```
+ * @param obj
+ * @param tranformer
+ */
+export const objectTransformer = <T extends any>(obj: T, tranformer: ObjectTransformer) => {
+  const anyObj = obj as any;
+
+  if (tranformer.dates) {
+    for (const date of tranformer.dates) {
+      if (anyObj[date] && (typeof anyObj[date] === 'string' || typeof anyObj[date] === 'number')) {
+        anyObj[date] = new Date(anyObj[date]);
+      }
+    }
+  }
+
+  if (tranformer.mapping) {
+    for (const mapKey of Object.keys(tranformer.mapping)) {
+      if (anyObj[mapKey]) {
+        if (Array.isArray(anyObj[mapKey])) {
+          anyObj[mapKey] = anyObj[mapKey].map(tranformer.mapping[mapKey]);
+        } else {
+          anyObj[mapKey] = tranformer.mapping[mapKey](anyObj[mapKey]);
+        }
+      }
+    }
+  }
+  return anyObj as T;
+};