@shopify/shopify-app-remix 4.1.1 → 4.2.0

package/src/server/authenticate/admin/billing/check.ts

@@ -0,0 +1,41 @@
+import {HttpResponseError, Session} from '@shopify/shopify-api';
+
+import type {BasicParams} from '../../../types';
+import {redirectToAuthPage} from '../helpers';
+import type {AppConfigArg} from '../../../config-types';
+import {invalidateAccessToken} from '../../helpers';
+
+import type {CheckBillingOptions} from './types';
+
+export function checkBillingFactory<Config extends AppConfigArg>(
+  params: BasicParams,
+  request: Request,
+  session: Session,
+) {
+  return async function checkBilling(
+    options: CheckBillingOptions<Config> = {},
+  ) {
+    const {api, logger} = params;
+
+    logger.debug('Checking billing plans', {shop: session.shop, ...options});
+
+    try {
+      return await api.billing.check({
+        session,
+        plans: options.plans as string[],
+        isTest: options.isTest,
+        returnObject: true,
+      });
+    } catch (error) {
+      if (error instanceof HttpResponseError && error.response.code === 401) {
+        logger.debug('API token was invalid, redirecting to OAuth', {
+          shop: session.shop,
+        });
+        await invalidateAccessToken(params, session);
+        throw await redirectToAuthPage(params, request, session.shop);
+      } else {
+        throw error;
+      }
+    }
+  };
+}

package/src/server/authenticate/admin/billing/create-usage-record.ts

@@ -0,0 +1,36 @@
+import {HttpResponseError, Session} from '@shopify/shopify-api';
+
+import type {BasicParams} from '../../../types';
+import {redirectToAuthPage} from '../helpers';
+import {invalidateAccessToken} from '../../helpers';
+
+import type {CreateUsageRecordOptions} from './types';
+
+export function createUsageRecordFactory(
+  params: BasicParams,
+  request: Request,
+  session: Session,
+) {
+  return async function createUsageRecord(options: CreateUsageRecordOptions) {
+    const {api, logger} = params;
+
+    logger.debug('Create usage record', {shop: session.shop, ...options});
+
+    try {
+      return await api.billing.createUsageRecord({
+        ...options,
+        session,
+      });
+    } catch (error) {
+      if (error instanceof HttpResponseError && error.response.code === 401) {
+        logger.debug('API token was invalid, redirecting to OAuth', {
+          shop: session.shop,
+        });
+        await invalidateAccessToken(params, session);
+        throw await redirectToAuthPage(params, request, session.shop);
+      } else {
+        throw error;
+      }
+    }
+  };
+}

package/src/server/authenticate/admin/billing/helpers.ts

@@ -0,0 +1,42 @@
+import {redirect} from '@remix-run/server-runtime';
+
+import {BasicParams} from '../../../types';
+import {getAppBridgeHeaders} from '../helpers';
+
+export function redirectOutOfApp(
+  params: BasicParams,
+  request: Request,
+  url: string,
+  shop: string,
+): never {
+  const {config, logger} = params;
+
+  logger.debug('Redirecting out of app', {shop, url});
+
+  const requestUrl = new URL(request.url);
+  const isEmbeddedRequest = requestUrl.searchParams.get('embedded') === '1';
+  const isXhrRequest = request.headers.get('authorization');
+
+  if (isXhrRequest) {
+    // eslint-disable-next-line no-warning-comments
+    // TODO Check this with the beta flag disabled (with the bounce page)
+    // Remix is not including the X-Shopify-API-Request-Failure-Reauthorize-Url when throwing a Response
+    // https://github.com/remix-run/remix/issues/5356
+    throw new Response(undefined, {
+      status: 401,
+      statusText: 'Unauthorized',
+      headers: getAppBridgeHeaders(url),
+    });
+  } else if (isEmbeddedRequest) {
+    const params = new URLSearchParams({
+      shop,
+      host: requestUrl.searchParams.get('host')!,
+      exitIframe: url,
+    });
+
+    throw redirect(`${config.auth.exitIframePath}?${params.toString()}`);
+  } else {
+    // This will only ever happen for non-embedded apps, because the authenticator will stop before reaching this point
+    throw redirect(url);
+  }
+}

package/src/server/authenticate/admin/billing/index.ts

@@ -0,0 +1,6 @@
+export {cancelBillingFactory} from './cancel';
+export {requireBillingFactory} from './require';
+export {requestBillingFactory} from './request';
+export {checkBillingFactory} from './check';
+export {createUsageRecordFactory} from './create-usage-record';
+export {updateUsageCappedAmountFactory} from './update-usage-subscription-capped-amount';

package/src/server/authenticate/admin/billing/request.ts

@@ -0,0 +1,64 @@
+import {
+  BillingRequestResponseObject,
+  HttpResponseError,
+  Session,
+} from '@shopify/shopify-api';
+
+import {AppConfigArg} from '../../../config-types';
+import {BasicParams} from '../../../types';
+import {redirectToAuthPage} from '../helpers';
+import {invalidateAccessToken} from '../../helpers';
+
+import {redirectOutOfApp} from './helpers';
+import type {RequestBillingOptions} from './types';
+
+export function requestBillingFactory<Config extends AppConfigArg>(
+  params: BasicParams,
+  request: Request,
+  session: Session,
+) {
+  return async function requestBilling({
+    plan,
+    isTest,
+    returnUrl,
+    ...overrides
+  }: RequestBillingOptions<Config>): Promise<never> {
+    const {api, logger} = params;
+
+    logger.info('Requesting billing', {
+      shop: session.shop,
+      plan,
+      isTest,
+      returnUrl,
+    });
+
+    let result: BillingRequestResponseObject;
+    try {
+      result = await api.billing.request({
+        plan: plan as string,
+        session,
+        isTest,
+        returnUrl,
+        returnObject: true,
+        ...overrides,
+      });
+    } catch (error) {
+      if (error instanceof HttpResponseError && error.response.code === 401) {
+        logger.debug('API token was invalid, redirecting to OAuth', {
+          shop: session.shop,
+        });
+        await invalidateAccessToken(params, session);
+        throw await redirectToAuthPage(params, request, session.shop);
+      } else {
+        throw error;
+      }
+    }
+
+    throw redirectOutOfApp(
+      params,
+      request,
+      result.confirmationUrl,
+      session.shop,
+    );
+  };
+}

package/src/server/authenticate/admin/billing/require.ts

@@ -0,0 +1,58 @@
+import {
+  BillingCheckResponseObject,
+  HttpResponseError,
+  Session,
+} from '@shopify/shopify-api';
+
+import type {BasicParams} from '../../../types';
+import type {AppConfigArg} from '../../../config-types';
+import {redirectToAuthPage} from '../helpers';
+import {invalidateAccessToken} from '../../helpers';
+
+import type {RequireBillingOptions} from './types';
+
+export function requireBillingFactory<Config extends AppConfigArg>(
+  params: BasicParams,
+  request: Request,
+  session: Session,
+) {
+  const {api, logger} = params;
+
+  return async function requireBilling(options: RequireBillingOptions<Config>) {
+    const logContext = {
+      shop: session.shop,
+      plans: options.plans,
+      isTest: options.isTest,
+    };
+
+    logger.debug('Checking billing for the shop', logContext);
+
+    let data: BillingCheckResponseObject;
+    try {
+      data = await api.billing.check({
+        session,
+        plans: options.plans as string[],
+        isTest: options.isTest,
+        returnObject: true,
+      });
+    } catch (error) {
+      if (error instanceof HttpResponseError && error.response.code === 401) {
+        logger.debug('API token was invalid, redirecting to OAuth', logContext);
+
+        await invalidateAccessToken(params, session);
+        throw await redirectToAuthPage(params, request, session.shop);
+      } else {
+        throw error;
+      }
+    }
+
+    if (!data.hasActivePayment) {
+      logger.debug('Billing check failed', logContext);
+      throw await options.onFailure(new Error('Billing check failed'));
+    }
+
+    logger.debug('Billing check succeeded', logContext);
+
+    return data;
+  };
+}