@shopify/shopify-app-remix 1.0.4 → 1.2.0

package/build/cjs/{auth → server/authenticate}/helpers/validate-session-token.js

@@ -5,10 +5,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 async function validateSessionToken({
   api,
   logger
-}, token) {
+}, token, {
+  checkAudience = true
+} = {}) {
   logger.debug('Validating session token');
   try {
-    const payload = await api.session.decodeSessionToken(token);
+    const payload = await api.session.decodeSessionToken(token, {
+      checkAudience
+    });
     logger.debug('Session token is valid', {
       payload: JSON.stringify(payload)
     });

package/build/cjs/{auth → server/authenticate}/login/login.js

@@ -26,7 +26,7 @@ function loginFactory(params) {
         shop: types.LoginErrorType.MissingShop
       };
     }
-    const shopWithoutProtocol = shop.replace(/^https?:\/\//, '');
+    const shopWithoutProtocol = shop.replace(/^https?:\/\//, '').replace(/\/$/, '');
     const shopWithDomain = (shop === null || shop === void 0 ? void 0 : shop.indexOf('.')) === -1 ? `${shopWithoutProtocol}.myshopify.com` : shopWithoutProtocol;
     const sanitizedShop = api.utils.sanitizeShop(shopWithDomain);
     if (!sanitizedShop) {

package/build/cjs/server/authenticate/public/appProxy/authenticate.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var factory = require('../../../clients/admin/factory.js');
+
+function authenticateAppProxyFactory(params) {
+  const {
+    api,
+    config,
+    logger
+  } = params;
+  return async function authenticate(request) {
+    logger.info('Authenticating app proxy request');
+    const {
+      searchParams
+    } = new URL(request.url);
+    const query = Object.fromEntries(searchParams.entries());
+    let isValid = false;
+    try {
+      isValid = await api.utils.validateHmac(query, {
+        signator: 'appProxy'
+      });
+    } catch (error) {
+      logger.info(error.message);
+      throw new Response(undefined, {
+        status: 400,
+        statusText: 'Bad Request'
+      });
+    }
+    if (!isValid) {
+      logger.info('App proxy request has invalid signature');
+      throw new Response(undefined, {
+        status: 400,
+        statusText: 'Bad Request'
+      });
+    }
+    const shop = searchParams.get('shop');
+    const sessionId = api.session.getOfflineId(shop);
+    const session = await config.sessionStorage.loadSession(sessionId);
+    if (!session) {
+      const context = {
+        liquid,
+        session: undefined,
+        admin: undefined
+      };
+      return context;
+    }
+    const context = {
+      liquid,
+      session,
+      admin: factory.adminClientFactory({
+        params,
+        session
+      })
+    };
+    return context;
+  };
+}
+const liquid = (body, initAndOptions) => {
+  if (typeof initAndOptions !== 'object') {
+    return new Response(body, {
+      status: initAndOptions || 200,
+      headers: {
+        'Content-Type': 'application/liquid'
+      }
+    });
+  }
+  const {
+    layout,
+    ...responseInit
+  } = initAndOptions || {};
+  const responseBody = layout === false ? `{% layout none %} ${body}` : body;
+  const headers = new Headers(responseInit.headers);
+  headers.set('Content-Type', 'application/liquid');
+  return new Response(responseBody, {
+    ...responseInit,
+    headers
+  });
+};
+
+exports.authenticateAppProxyFactory = authenticateAppProxyFactory;

package/build/cjs/server/authenticate/public/checkout/authenticate.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ensureCorsHeaders = require('../../helpers/ensure-cors-headers.js');
+var validateSessionToken = require('../../helpers/validate-session-token.js');
+var getSessionTokenHeader = require('../../helpers/get-session-token-header.js');
+var rejectBotRequest = require('../../helpers/reject-bot-request.js');
+var respondToOptionsRequest = require('../../helpers/respond-to-options-request.js');
+
+function authenticateCheckoutFactory(params) {
+  return async function authenticateCheckout(request, options = {}) {
+    var _options$corsHeaders;
+    const {
+      logger
+    } = params;
+    const corsHeaders = (_options$corsHeaders = options.corsHeaders) !== null && _options$corsHeaders !== void 0 ? _options$corsHeaders : [];
+    rejectBotRequest.rejectBotRequest(params, request);
+    respondToOptionsRequest.respondToOptionsRequest(params, request, corsHeaders);
+    const sessionTokenHeader = getSessionTokenHeader.getSessionTokenHeader(request);
+    logger.info('Authenticating checkout request');
+    if (!sessionTokenHeader) {
+      logger.debug('Request did not contain a session token');
+      throw new Response(undefined, {
+        status: 401,
+        statusText: 'Unauthorized'
+      });
+    }
+    return {
+      sessionToken: await validateSessionToken.validateSessionToken(params, sessionTokenHeader, {
+        checkAudience: false
+      }),
+      cors: ensureCorsHeaders.ensureCORSHeadersFactory(params, request, corsHeaders)
+    };
+  };
+}
+
+exports.authenticateCheckoutFactory = authenticateCheckoutFactory;

package/build/cjs/server/authenticate/public/factory.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var authenticate$1 = require('./checkout/authenticate.js');
+var authenticate = require('./appProxy/authenticate.js');
+
+function authenticatePublicFactory(params) {
+  const {
+    logger
+  } = params;
+  const authenticateCheckout = authenticate$1.authenticateCheckoutFactory(params);
+  const authenticatePublic = (request, options) => {
+    logger.deprecated('2.0.0', 'authenticate.public() will be deprecated in v2. Use authenticate.public.checkout() instead.');
+    return authenticateCheckout(request, options);
+  };
+  authenticatePublic.checkout = authenticateCheckout;
+  authenticatePublic.appProxy = authenticate.authenticateAppProxyFactory(params);
+  return authenticatePublic;
+}
+
+exports.authenticatePublicFactory = authenticatePublicFactory;

package/build/cjs/{boundary → server/boundary}/error.js

@@ -2,9 +2,15 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var jsxRuntime = require('react/jsx-runtime');
+
 function errorBoundary(error) {
   if (error.constructor.name === 'ErrorResponse') {
-    return 'Handling response';
+    return /*#__PURE__*/jsxRuntime.jsx("div", {
+      dangerouslySetInnerHTML: {
+        __html: error.data || 'Handling response'
+      }
+    });
   }
   throw error;
 }

package/build/cjs/server/boundary/index.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var headers = require('./headers.js');
+var error = require('./error.js');
+
+/**
+ * A collection of functions that handle the necessary code for error boundaries in routes using authenticate.admin.
+ */
+const boundary = {
+  /**
+   * A function that handles errors or thrown responses.
+   *
+   * @example
+   * Catching errors in a route
+   * ```ts
+   * // app/routes/admin/widgets.ts
+   * import { boundary } from "@shopify/shopify-app-remix";
+   *
+   * export function ErrorBoundary() {
+   *   return boundary.error(useRouteError());
+   * }
+   * ```
+   */
+  error: error.errorBoundary,
+  /**
+   * A function that sets the appropriate document repsonse headers.
+   *
+   * @example
+   * Catching errors in a route
+   * ```ts
+   * // app/routes/admin/widgets.ts
+   * import { boundary } from "@shopify/shopify-app-remix";
+   *
+   * export const headers = (headersArgs) => {
+   *   return boundary.headers(headersArgs);
+   * };
+   * ```
+   */
+  headers: headers.headersBoundary
+};
+
+exports.boundary = boundary;

package/build/cjs/server/clients/admin/factory.js

@@ -0,0 +1,27 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var graphql = require('./graphql.js');
+var rest = require('./rest.js');
+
+function adminClientFactory({
+  params,
+  handleClientError,
+  session
+}) {
+  return {
+    rest: rest.restClientFactory({
+      params,
+      session,
+      handleClientError
+    }),
+    graphql: graphql.graphqlClientFactory({
+      params,
+      session,
+      handleClientError
+    })
+  };
+}
+
+exports.adminClientFactory = adminClientFactory;

package/build/cjs/{auth/admin/graphql-client.js → server/clients/admin/graphql.js}

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var runtime = require('@shopify/shopify-api/runtime');
-var handleClientError = require('../helpers/handle-client-error.js');
 
 // eslint-disable-next-line no-warning-comments
 // TODO: This is actually just a call through to the Shopify API client, but with a different API. We should eventually
@@ -11,17 +10,12 @@ var handleClientError = require('../helpers/handle-client-error.js');
 // client request calls.
 function graphqlClientFactory({
   params,
-  request,
+  handleClientError,
   session
 }) {
   return async function query(query, options) {
     var _options;
-    const {
-      api,
-      config,
-      logger
-    } = params;
-    const client = new api.clients.Graphql({
+    const client = new params.api.clients.Graphql({
       session,
       apiVersion: (_options = options) === null || _options === void 0 ? void 0 : _options.apiVersion
     });
@@ -40,16 +34,14 @@ function graphqlClientFactory({
         headers: runtime.flatHeaders(apiResponse.headers)
       });
     } catch (error) {
-      throw await handleClientError.handleClientError({
-        params: {
-          api,
-          config,
-          logger
-        },
-        request,
-        error,
-        shop: session.shop
-      });
+      if (handleClientError) {
+        throw await handleClientError({
+          error,
+          params,
+          session
+        });
+      }
+      throw error;
     }
   };
 }

package/build/cjs/{auth/admin/rest-client.js → server/clients/admin/rest.js}

@@ -2,22 +2,48 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('@remix-run/server-runtime');
-require('isbot');
-var handleClientError = require('../helpers/handle-client-error.js');
-
+function restClientFactory({
+  params,
+  handleClientError,
+  session
+}) {
+  const {
+    api
+  } = params;
+  const client = new RemixRestClient({
+    params,
+    handleClientError,
+    session
+  });
+  if (api.rest) {
+    client.resources = {};
+    const RestResourceClient = restResourceClientFactory({
+      params,
+      handleClientError,
+      session
+    });
+    Object.entries(api.rest).forEach(([name, resource]) => {
+      class RemixResource extends resource {}
+      RemixResource.Client = RestResourceClient;
+      Reflect.defineProperty(RemixResource, 'name', {
+        value: name
+      });
+      Reflect.set(client.resources, name, RemixResource);
+    });
+  }
+  return client;
+}
 class RemixRestClient {
   constructor({
     params,
-    request,
-    session
+    session,
+    handleClientError
   }) {
     this.session = void 0;
-    this.resources = void 0;
     this.params = void 0;
-    this.request = void 0;
+    this.handleClientError = void 0;
     this.params = params;
-    this.request = request;
+    this.handleClientError = handleClientError;
     this.session = session;
   }
 
@@ -74,28 +100,27 @@ class RemixRestClient {
         headers: apiResponse.headers
       });
     } catch (error) {
-      throw await handleClientError.handleClientError({
-        params: this.params,
-        request: this.request,
-        shop: this.session.shop,
-        error
-      });
+      if (this.handleClientError) {
+        throw await this.handleClientError({
+          error,
+          session: this.session,
+          params: this.params
+        });
+      } else throw new Error(error);
     }
   }
 }
 function restResourceClientFactory({
   params,
-  request,
+  handleClientError,
   session
 }) {
   const {
-    api,
-    config,
-    logger
+    api
   } = params;
   const ApiClient = api.clients.Rest;
   return class RestResourceClient extends ApiClient {
-    async request(params) {
+    async request(requestParams) {
       const originalClient = new api.clients.Rest({
         session
       });
@@ -103,22 +128,18 @@ function restResourceClientFactory({
       try {
         // We just call through to the API library client, and handle the error response here, so that data parsing
         // behaves the same way.
-        return await originalRequest.call(originalClient, params);
+        return await originalRequest.call(originalClient, requestParams);
       } catch (error) {
-        throw await handleClientError.handleClientError({
-          params: {
-            api,
-            config,
-            logger
-          },
-          request,
-          shop: session.shop,
-          error
-        });
+        if (handleClientError) {
+          throw await handleClientError({
+            error,
+            params,
+            session
+          });
+        } else throw new Error(error);
       }
     }
   };
 }
 
-exports.RemixRestClient = RemixRestClient;
-exports.restResourceClientFactory = restResourceClientFactory;
+exports.restClientFactory = restClientFactory;

package/build/cjs/server/index.js

@@ -0,0 +1,39 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('@shopify/shopify-api/adapters/web-api');
+var runtime = require('@shopify/shopify-api/runtime');
+var shopifyApi = require('@shopify/shopify-api');
+var types = require('./types.js');
+var index = require('./boundary/index.js');
+var shopifyApp = require('./shopify-app.js');
+
+runtime.setAbstractRuntimeString(() => {
+  return `Remix`;
+});
+
+Object.defineProperty(exports, 'ApiVersion', {
+  enumerable: true,
+  get: function () { return shopifyApi.ApiVersion; }
+});
+Object.defineProperty(exports, 'BillingInterval', {
+  enumerable: true,
+  get: function () { return shopifyApi.BillingInterval; }
+});
+Object.defineProperty(exports, 'DeliveryMethod', {
+  enumerable: true,
+  get: function () { return shopifyApi.DeliveryMethod; }
+});
+Object.defineProperty(exports, 'LATEST_API_VERSION', {
+  enumerable: true,
+  get: function () { return shopifyApi.LATEST_API_VERSION; }
+});
+Object.defineProperty(exports, 'LogSeverity', {
+  enumerable: true,
+  get: function () { return shopifyApi.LogSeverity; }
+});
+exports.AppDistribution = types.AppDistribution;
+exports.LoginErrorType = types.LoginErrorType;
+exports.boundary = index.boundary;
+exports.shopifyApp = shopifyApp.shopifyApp;

package/build/cjs/{index.js → server/shopify-app.js}

@@ -4,24 +4,17 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 require('@shopify/shopify-api/adapters/web-api');
 var shopifyApi = require('@shopify/shopify-api');
-var runtime = require('@shopify/shopify-api/runtime');
 var types = require('./types.js');
 var version = require('./version.js');
-var register = require('./auth/webhooks/register.js');
-var authenticate$2 = require('./auth/admin/authenticate.js');
-var authenticate$1 = require('./auth/webhooks/authenticate.js');
-var authenticate = require('./auth/public/authenticate.js');
+var register = require('./authenticate/webhooks/register.js');
+var authenticate$1 = require('./authenticate/admin/authenticate.js');
+var authenticate = require('./authenticate/webhooks/authenticate.js');
 var overrideLogger = require('./override-logger.js');
-var addResponseHeaders = require('./auth/helpers/add-response-headers.js');
-require('@remix-run/server-runtime');
+var addResponseHeaders = require('./authenticate/helpers/add-response-headers.js');
 require('isbot');
-var login = require('./auth/login/login.js');
-var headers = require('./boundary/headers.js');
-var error = require('./boundary/error.js');
-
-runtime.setAbstractRuntimeString(() => {
-  return `Remix`;
-});
+var login = require('./authenticate/login/login.js');
+var factory$1 = require('./unauthenticated/admin/factory.js');
+var factory = require('./authenticate/public/factory.js');
 
 /**
  * Creates an object your app will use to interact with Shopify.
@@ -55,15 +48,18 @@ function shopifyApp(appConfig) {
     config,
     logger
   };
-  const oauth = new authenticate$2.AuthStrategy(params);
+  const oauth = new authenticate$1.AuthStrategy(params);
   const shopify = {
     sessionStorage: config.sessionStorage,
     addDocumentResponseHeaders: addResponseHeaders.addDocumentResponseHeadersFactory(params),
     registerWebhooks: register.registerWebhooksFactory(params),
     authenticate: {
       admin: oauth.authenticateAdmin.bind(oauth),
-      public: authenticate.authenticatePublicFactory(params),
-      webhook: authenticate$1.authenticateWebhookFactory(params)
+      public: factory.authenticatePublicFactory(params),
+      webhook: authenticate.authenticateWebhookFactory(params)
+    },
+    unauthenticated: {
+      admin: factory$1.unauthenticatedAdminContextFactory(params)
     }
   };
   if (isAppStoreApp(shopify, appConfig) || isSingleMerchantApp(shopify, appConfig)) {
@@ -71,42 +67,6 @@ function shopifyApp(appConfig) {
   }
   return shopify;
 }
-
-/**
- * A collection of functions that handle the necessary code for error boundaries in routes using authenticate.admin.
- */
-const boundary = {
-  /**
-   * A function that handles errors or thrown responses.
-   *
-   * @example
-   * Catching errors in a route
-   * ```ts
-   * // app/routes/admin/widgets.ts
-   * import { boundary } from "@shopify/shopify-app-remix";
-   *
-   * export function ErrorBoundary() {
-   *   return boundary.error(useRouteError());
-   * }
-   * ```
-   */
-  error: error.errorBoundary,
-  /**
-   * A function that sets the appropriate document repsonse headers.
-   *
-   * @example
-   * Catching errors in a route
-   * ```ts
-   * // app/routes/admin/widgets.ts
-   * import { boundary } from "@shopify/shopify-app-remix";
-   *
-   * export const headers = (headersArgs) => {
-   *   return boundary.headers(headersArgs);
-   * };
-   * ```
-   */
-  headers: headers.headersBoundary
-};
 function isAppStoreApp(_shopify, config) {
   return config.distribution === types.AppDistribution.AppStore;
 }
@@ -167,27 +127,4 @@ function deriveConfig(appConfig, apiConfig) {
   };
 }
 
-Object.defineProperty(exports, 'ApiVersion', {
-  enumerable: true,
-  get: function () { return shopifyApi.ApiVersion; }
-});
-Object.defineProperty(exports, 'BillingInterval', {
-  enumerable: true,
-  get: function () { return shopifyApi.BillingInterval; }
-});
-Object.defineProperty(exports, 'DeliveryMethod', {
-  enumerable: true,
-  get: function () { return shopifyApi.DeliveryMethod; }
-});
-Object.defineProperty(exports, 'LATEST_API_VERSION', {
-  enumerable: true,
-  get: function () { return shopifyApi.LATEST_API_VERSION; }
-});
-Object.defineProperty(exports, 'LogSeverity', {
-  enumerable: true,
-  get: function () { return shopifyApi.LogSeverity; }
-});
-exports.AppDistribution = types.AppDistribution;
-exports.LoginErrorType = types.LoginErrorType;
-exports.boundary = boundary;
 exports.shopifyApp = shopifyApp;

package/build/cjs/server/unauthenticated/admin/factory.js

@@ -0,0 +1,25 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var shopifyApi = require('@shopify/shopify-api');
+var factory = require('../../clients/admin/factory.js');
+
+function unauthenticatedAdminContextFactory(params) {
+  return async shop => {
+    const offlineSessionId = params.api.session.getOfflineId(shop);
+    const session = await params.config.sessionStorage.loadSession(offlineSessionId);
+    if (!session) {
+      throw new shopifyApi.ShopifyError(`Could not find a session for shop ${shop} when creating unauthenticated admin context`);
+    }
+    return {
+      session,
+      admin: factory.adminClientFactory({
+        params,
+        session
+      })
+    };
+  };
+}
+
+exports.unauthenticatedAdminContextFactory = unauthenticatedAdminContextFactory;

package/build/cjs/{version.js → server/version.js}

@@ -2,6 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const SHOPIFY_REMIX_LIBRARY_VERSION = '1.0.4';
+const SHOPIFY_REMIX_LIBRARY_VERSION = '1.2.0';
 
 exports.SHOPIFY_REMIX_LIBRARY_VERSION = SHOPIFY_REMIX_LIBRARY_VERSION;