@shopify/shopify-api 12.2.0 → 13.0.0

package/lib/billing/request.ts

@@ -0,0 +1,338 @@
+import {ConfigInterface, ConfigParams} from '../base-types';
+import {BillingInterval} from '../types';
+import {BillingError} from '../error';
+import {buildEmbeddedAppUrl} from '../auth/get-embedded-app-url';
+import {GraphqlClient, graphqlClientClass} from '../clients/admin';
+import {hashString} from '../../runtime/crypto';
+import {HashFormat} from '../../runtime/crypto/types';
+import {FutureFlagOptions} from '../../future/flags';
+
+import {
+  BillingConfigOneTimePlan,
+  BillingRequestParams,
+  BillingRequestResponse,
+  RecurringPaymentResponse,
+  RequestResponseData,
+  SinglePaymentResponse,
+  BillingConfigSubscriptionLineItemPlan,
+  RequestConfigLineItemOverrides,
+  BillingRequest,
+  APP_SUBSCRIPTION_FRAGMENT,
+} from './types';
+
+const RECURRING_PURCHASE_MUTATION = `
+  ${APP_SUBSCRIPTION_FRAGMENT}
+  mutation AppSubscriptionCreate(
+    $name: String!
+    $returnUrl: URL!
+    $test: Boolean
+    $trialDays: Int
+    $replacementBehavior: AppSubscriptionReplacementBehavior
+    $lineItems: [AppSubscriptionLineItemInput!]!
+  ) {
+    appSubscriptionCreate(
+      name: $name
+      returnUrl: $returnUrl
+      test: $test
+      trialDays: $trialDays
+      replacementBehavior: $replacementBehavior
+      lineItems: $lineItems
+    ) {
+      appSubscription {
+        ...AppSubscriptionFragment
+      }
+      confirmationUrl
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+
+const ONE_TIME_PURCHASE_MUTATION = `
+  mutation test(
+    $name: String!
+    $price: MoneyInput!
+    $returnUrl: URL!
+    $test: Boolean
+  ) {
+    appPurchaseOneTimeCreate(
+      name: $name
+      price: $price
+      returnUrl: $returnUrl
+      test: $test
+    ) {
+      appPurchaseOneTime {
+        id
+        name
+        test
+      }
+      confirmationUrl
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+
+interface RequestInternalParams {
+  client: GraphqlClient;
+  plan: string;
+  returnUrl: string;
+  isTest: boolean;
+}
+
+interface RequestOneTimePaymentInternalParams extends RequestInternalParams {
+  billingConfig: BillingConfigOneTimePlan;
+}
+
+interface RequestSubscriptionParams extends RequestInternalParams {
+  billingConfig: BillingConfigSubscriptionLineItemPlan;
+}
+
+export function request<
+  Config extends ConfigInterface<Params>,
+  Params extends ConfigParams<any, Future>,
+  Future extends FutureFlagOptions,
+>(config: Config): BillingRequest {
+  return async function <Params extends BillingRequestParams>({
+    session,
+    plan,
+    isTest = true,
+    returnUrl: returnUrlParam,
+    returnObject = false,
+    ...overrides
+  }: Params): Promise<BillingRequestResponse<Params>> {
+    if (!config.billing || !config.billing[plan]) {
+      throw new BillingError({
+        message: `Could not find plan ${plan} in billing settings`,
+        errorData: [],
+      });
+    }
+
+    const billingConfig = {
+      ...config.billing[plan],
+    };
+    const filteredOverrides = Object.fromEntries(
+      Object.entries(overrides).filter(([_key, value]) => value !== undefined),
+    );
+
+    const cleanShopName = session.shop.replace('.myshopify.com', '');
+    const embeddedAppUrl = buildEmbeddedAppUrl(config)(
+      hashString(`admin.shopify.com/store/${cleanShopName}`, HashFormat.Base64),
+    );
+
+    const appUrl = `${config.hostScheme}://${config.hostName}?shop=${session.shop}`;
+
+    // if provided a return URL, use it, otherwise use the embedded app URL or hosted app URL
+    const returnUrl =
+      returnUrlParam || (config.isEmbeddedApp ? embeddedAppUrl : appUrl);
+
+    const GraphqlClient = graphqlClientClass({config});
+    const client = new GraphqlClient({session});
+
+    function isLineItemPlan(
+      billingConfig: any,
+    ): billingConfig is BillingConfigSubscriptionLineItemPlan {
+      return 'lineItems' in billingConfig;
+    }
+
+    function isOneTimePlan(
+      billingConfig: any,
+    ): billingConfig is BillingConfigOneTimePlan {
+      return billingConfig.interval === BillingInterval.OneTime;
+    }
+
+    let data: RequestResponseData;
+    if (isLineItemPlan(billingConfig)) {
+      const mergedBillingConfigs = mergeBillingConfigs(
+        billingConfig,
+        filteredOverrides,
+      );
+      const mutationRecurringResponse = await requestSubscriptionPayment({
+        billingConfig: mergedBillingConfigs,
+        plan,
+        client,
+        returnUrl,
+        isTest,
+      });
+
+      data = mutationRecurringResponse.appSubscriptionCreate!;
+    } else if (isOneTimePlan(billingConfig)) {
+      const mutationOneTimeResponse = await requestSinglePayment({
+        billingConfig: {...billingConfig, ...filteredOverrides},
+        plan,
+        client,
+        returnUrl,
+        isTest,
+      });
+      data = mutationOneTimeResponse.appPurchaseOneTimeCreate!;
+    } else {
+      throw new BillingError({
+        message: `Invalid billing configuration for plan ${plan}. Must be either a one-time plan or a subscription plan with line items.`,
+        errorData: [],
+      });
+    }
+
+    if (data.userErrors?.length) {
+      throw new BillingError({
+        message: 'Error while billing the store',
+        errorData: data.userErrors,
+      });
+    }
+
+    if (returnObject) {
+      return data as Omit<
+        RequestResponseData,
+        'userErrors'
+      > as BillingRequestResponse<Params>;
+    } else {
+      return data.confirmationUrl as BillingRequestResponse<Params>;
+    }
+  };
+}
+
+async function requestSubscriptionPayment({
+  billingConfig,
+  plan,
+  client,
+  returnUrl,
+  isTest,
+}: RequestSubscriptionParams): Promise<RecurringPaymentResponse> {
+  const lineItems = billingConfig.lineItems.map((item) => {
+    if (
+      item.interval === BillingInterval.Every30Days ||
+      item.interval === BillingInterval.Annual
+    ) {
+      const appRecurringPricingDetails: any = {
+        interval: item.interval,
+        price: {
+          amount: item.amount,
+          currencyCode: item.currencyCode,
+        },
+      };
+
+      if (item.discount) {
+        appRecurringPricingDetails.discount = {
+          durationLimitInIntervals: item.discount.durationLimitInIntervals,
+          value: {
+            amount: item.discount.value.amount,
+            percentage: item.discount.value.percentage,
+          },
+        };
+      }
+
+      return {
+        plan: {
+          appRecurringPricingDetails,
+        },
+      };
+    } else if (item.interval === BillingInterval.Usage) {
+      const appUsagePricingDetails = {
+        terms: item.terms,
+        cappedAmount: {
+          amount: item.amount,
+          currencyCode: item.currencyCode,
+        },
+      };
+
+      return {
+        plan: {
+          appUsagePricingDetails,
+        },
+      };
+    } else {
+      throw new BillingError({
+        message: 'Invalid interval provided',
+        errorData: [item],
+      });
+    }
+  });
+
+  const mutationResponse = await client.request<RecurringPaymentResponse>(
+    RECURRING_PURCHASE_MUTATION,
+    {
+      variables: {
+        name: plan,
+        trialDays: billingConfig.trialDays,
+        replacementBehavior: billingConfig.replacementBehavior,
+        returnUrl,
+        test: isTest,
+        lineItems,
+      },
+    },
+  );
+
+  if (mutationResponse.errors) {
+    throw new BillingError({
+      message: 'Error while billing the store',
+      errorData: mutationResponse.errors,
+    });
+  }
+
+  return mutationResponse.data!;
+}
+
+async function requestSinglePayment({
+  billingConfig,
+  plan,
+  client,
+  returnUrl,
+  isTest,
+}: RequestOneTimePaymentInternalParams): Promise<SinglePaymentResponse> {
+  const mutationResponse = await client.request<SinglePaymentResponse>(
+    ONE_TIME_PURCHASE_MUTATION,
+    {
+      variables: {
+        name: plan,
+        returnUrl,
+        test: isTest,
+        price: {
+          amount: billingConfig.amount,
+          currencyCode: billingConfig.currencyCode,
+        },
+      },
+    },
+  );
+
+  if (mutationResponse.errors) {
+    throw new BillingError({
+      message: 'Error while billing the store',
+      errorData: mutationResponse.errors,
+    });
+  }
+
+  return mutationResponse.data!;
+}
+
+function mergeBillingConfigs(
+  billingConfig: BillingConfigSubscriptionLineItemPlan,
+  overrides: RequestConfigLineItemOverrides,
+): BillingConfigSubscriptionLineItemPlan {
+  const mergedConfig = {...billingConfig, ...overrides};
+  const mergedLineItems = [];
+
+  if (billingConfig.lineItems && overrides.lineItems) {
+    for (const i of billingConfig.lineItems) {
+      let found = false;
+
+      for (const j of overrides.lineItems) {
+        if (i.interval === j!.interval) {
+          mergedLineItems.push({...i, ...j});
+          found = true;
+          break;
+        }
+      }
+
+      if (!found) {
+        mergedLineItems.push(i);
+      }
+    }
+
+    mergedConfig.lineItems = mergedLineItems;
+  }
+
+  return mergedConfig as BillingConfigSubscriptionLineItemPlan;
+}

package/lib/billing/subscriptions.ts

@@ -0,0 +1,58 @@
+import {BillingError} from '../error';
+import {ConfigInterface} from '../base-types';
+import {graphqlClientClass} from '../clients/admin';
+
+import {
+  ActiveSubscriptions,
+  BillingSubscriptionParams,
+  BillingSubscriptions,
+  SubscriptionResponse,
+  APP_SUBSCRIPTION_FRAGMENT,
+} from './types';
+import {convertLineItems} from './utils';
+
+const SUBSCRIPTION_QUERY = `
+${APP_SUBSCRIPTION_FRAGMENT}
+query appSubscription {
+  currentAppInstallation {
+    activeSubscriptions {
+      ...AppSubscriptionFragment
+    }
+  }
+}
+`;
+
+export function subscriptions(config: ConfigInterface): BillingSubscriptions {
+  return async function ({
+    session,
+  }: BillingSubscriptionParams): Promise<ActiveSubscriptions> {
+    if (!config.future?.unstable_managedPricingSupport && !config.billing) {
+      throw new BillingError({
+        message: 'Attempted to look for purchases without billing configs',
+        errorData: [],
+      });
+    }
+
+    const GraphqlClient = graphqlClientClass({config});
+    const client = new GraphqlClient({session});
+
+    const response =
+      await client.request<SubscriptionResponse>(SUBSCRIPTION_QUERY);
+
+    if (!response.data?.currentAppInstallation?.activeSubscriptions) {
+      return {activeSubscriptions: []};
+    }
+
+    const activeSubscriptions =
+      response.data.currentAppInstallation.activeSubscriptions;
+    activeSubscriptions.forEach((subscription) => {
+      if (subscription.lineItems) {
+        subscription.lineItems = convertLineItems(subscription.lineItems);
+      }
+    });
+
+    return {
+      activeSubscriptions,
+    };
+  };
+}