@shopify/shopify-api 6.0.0-rc7 → 6.0.0-rc9

package/docs/usage/rest.md

@@ -1,179 +0,0 @@
-# REST Admin API client
-
-Once OAuth is complete, we can use this library to interact with the Admin REST API.
-It can do that in two different ways:
-
-1. [Using the client class](#using-the-client-class)
-1. [Using REST resources](#using-rest-resources)
-
-For detailed information on individual endpoints, please visit our [REST API reference](https://shopify.dev/api/admin-rest).
-
-## Using the client class
-
-The simplest way to interact with the API is using an instance of `shopify.clients.Rest`. To create a client, you'll need a session, for example:
-
-```ts
-// Requests to /my-endpoint must be made with authenticatedFetch for embedded apps
-app.get('/my-endpoint', async (req, res) => {
-  const session = await shopify.session.getCurrent({
-    isOnline: true,
-    rawRequest: req,
-    rawResponse: res,
-  });
-
-  const client = new shopify.clients.Rest({
-    domain: session.shop,
-    accessToken: session.accessToken,
-  });
-});
-```
-
-Once you've constructed a client, you can use it to call API endpoints by their methods:
-
-- `client.get`
-- `client.post`
-- `client.put`
-- `client.delete`
-
-For example, this is how you can make `GET` and `POST` requests to the `/products.json` endpoint using the client created above:
-
-```ts
-const response = await client.get({
-  path: 'products',
-});
-console.log(response.headers, response.body);
-
-const response = await client.post({
-  path: 'products',
-  data: {
-    title: 'My product title',
-  },
-});
-console.log(response.headers, response.body);
-```
-
-Note that if you're using TypeScript, you can also pass in a type argument to cast the response body:
-
-```ts
-interface MyResponseBodyType {
-  products: {
-    /* ... */
-  };
-}
-
-const response = await client.get<MyResponseBodyType>({
-  path: 'products',
-});
-
-// response.body will be of type MyResponseBodyType
-console.log(response.body.products);
-```
-
-The `get`, `post`, `put`, and `delete` methods accept the following arguments:
-
-| Parameter      | Type                                |   Required?   |  Default Value  | Notes                                                                                                                                                                                                                                                                                    |
-| -------------- | ----------------------------------- | :-----------: | :-------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `path`         | `string`                            |      Yes      |        -        | The requested API endpoint path. This can be one of two formats:<ul><li>The path starting after the `/admin/api/{version}/` prefix, such as `'products'`, which executes `/admin/api/{version}/products.json`</li><li>The full path, such as `/admin/oauth/access_scopes.json`</li></ul> |
-| `data`         | `Record<string, unknown> \| string` | `post`, `put` |        -        | The request payload                                                                                                                                                                                                                                                                      |
-| `query`        | `Record<string, string \| number>`  |      No       |        -        | An optional query argument object to append to the request URL                                                                                                                                                                                                                           |
-| `extraHeaders` | `Record<string, string \| number>`  |      No       |        -        | Add custom headers to the request                                                                                                                                                                                                                                                        |
-| `type`         | `DataType`                          |      No       | `DataType.JSON` | The `Content-Type` for the request (`JSON`, `GraphQL`, `URLEncoded`)                                                                                                                                                                                                                     |
-| `tries`        | `number`                            |      No       |       `1`       | The maximum number of times to retry the request _(must be >= 0)_                                                                                                                                                                                                                        |
-
-They will return an object containing the response `headers` and `body` from Shopify.
-
-## Using REST resources
-
-The Admin API has a lot of endpoints, and the differences between them can be subtle.
-To make it easier to interact with the API, this library provides resource classes, which map these endpoints to OO code and can make API queries feel more natural.
-
-**Note**: we provide auto-generated resources for all **_stable_** API versions, so your app must include the appropriate set (see [mounting REST resources](#mounting-rest-resources) below), matching your `apiVersion` configuration. The library will throw an error if the versions don't match.
-
-Below is an example of how REST resources can make it easier to fetch the first product and update it:
-
-<div>With a plain REST client:
-
-```ts
-// App must provide response types
-interface ProductResponse {
-  product: {
-    id: number;
-    title: string;
-    // ...
-  };
-}
-
-const session = await shopify.session.getCurrent({
-  rawRequest: req,
-  rawResponse: res,
-});
-const client = new shopify.clients.Rest({
-  domain: session.shop,
-  accessToken: session.accessToken,
-});
-
-// The following line sends a HTTP GET request to this constructed URL:
-// https://${session.shop}/admin/api/${shopify.config.api_version}/products.json?limit=1
-const response = await client.get<ProductResponse>({
-  path: 'products',
-  query: {limit: 1},
-});
-
-// Apps needs to dig into the response body to find the object
-response.body.product.title = 'A new title';
-
-// The following sends a HTTP PUT request to this constructed URL...
-// https://${session.shop}/admin/api/${shopify.config.api_version}/products/${response.body.product.id}.json
-// ... with this body
-// {"product":{"id":response.body.product.id,"title":"A new title"}}
-await client.put({
-  path: `products/${response.body.product.id}`,
-  data: response.body.product,
-});
-```
-
-</div><div>With REST resources:
-
-```ts
-const session = await shopify.session.getCurrent({
-  rawRequest: req,
-  rawResponse: res,
-});
-
-// Has type Product[], an OO representation of API products
-const products = await shopify.rest.Product.all({session, limit: 1});
-
-products[0].title = 'A new title';
-await products[0].save();
-```
-
-</div>
-
-The resource classes provide representations of all endpoints for the API resource they cover. A few examples:
-
-1. `GET /products.json` maps to `Product.all()`
-1. `POST /products.json` maps to `product.save()` (as an instance method)
-1. `GET /products/count.json` maps to `Product.count()`
-
-Please visit our [REST API reference documentation](https://shopify.dev/api/admin-rest) for detailed instructions on how to call each of the endpoints.
-
-### Mounting REST resources
-
-The library doesn't include all available resources automatically to make loading it more efficient, since there are hundreds of resource classes.
-To use REST resources, you can import the desired version and mount it onto your `shopify` object when creating it:
-
-```ts
-import {shopifyApi} from '@shopify/shopify-api';
-import {restResources} from '@shopify/shopify-api/rest/admin/2022-07';
-
-const shopify = shopifyApi({
-  ...,
-  apiVersion: ApiVersion.July22,
-  restResources,
-});
-```
-
-This will automatically load all REST resources onto `shopify.rest`, as per the example above.
-From this point, you can start using the resources to interact with the API.
-
-[Back to guide index](../../README.md#features)

package/docs/usage/runtimes.md

@@ -1,54 +0,0 @@
-# Adding custom runtimes
-
-This package provides support for a set of JavaScript runtimes, but it won't cover all possible use cases.
-It's designed in a way that can support any runtime, as long as an adapter provides the implementations for runtime-specific functionality.
-
-**Note**: this is an advanced feature, so using TypeScript and an IDE with intellisense is strongly recommended to help guide you through the implementation.
-
-See the [available adapters](../../adapters/) for some implementation examples.
-In general, an adapter needs to teach the library to convert the runtime's own request / response objects into the `NormalizedRequest` and `NormalizedResponse` objects used by the library, and to define some reasonable defaults for the runtime, like a session storage strategy.
-
-To create an adapter, you'll need to import the runtime functions to provide implementations.
-These are the functions you'll need to create:
-
-- `setAbstractFetchFunc`
-- `setAbstractConvertRequestFunc`
-- `setAbstractConvertResponseFunc`
-- `setAbstractConvertHeadersFunc`
-- `setAbstractCreateDefaultStorage`
-- `setAbstractRuntimeString`
-- `setCrypto`
-
-Below is a _very_ simplified example with some functions:
-
-```ts
-import {
-  setAbstractConvertHeadersFunc,
-  setAbstractRuntimeString,
-  AbstractRuntimeStringFunc,
-  AbstractConvertHeadersFunc,
-  Headers,
-  AdapterArgs,
-} from '@shopify/shopify-api/runtime';
-
-type MyRequestType = any;
-type MyResponseType = any;
-
-interface MyRuntimeAdapterArgs extends AdapterArgs {
-  rawRequest: MyRequestType;
-  rawResponse?: MyResponseType;
-}
-
-const myRuntimeStringFunc: AbstractRuntimeStringFunc = () => {
-  return `My runtime adapter ${myAdapterVersion}`;
-};
-setAbstractRuntimeString(myRuntimeStringFunc);
-
-const myRuntimeHeaderFunc: AbstractConvertHeadersFunc = async (
-  headers: Headers,
-  adapterArgs: MyRuntimeAdapterArgs,
-) => {
-  return magicHeaderConversion(headers);
-};
-setAbstractConvertHeadersFunc(myRuntimeHeaderFunc);
-```

package/docs/usage/storefront.md

@@ -1,72 +0,0 @@
-# GraphQL Storefront API client
-
-The library also allows you to send GraphQL requests to the [Shopify Storefront API](https://shopify.dev/docs/storefront-api). To do that, you can use `shopify.clients.Storefront` with the current shop URL and a storefront-specific `accessToken`.
-
-⚠️ This API limits request rates based on the IP address that calls it, which will be your server's address for all requests made by the library. The API uses a leaky bucket algorithm, with a default bucket size of 60 seconds of request processing time (minimum 0.5s per request), with a leak rate of 1/s. Learn more about [rate limits](https://shopify.dev/api/usage/rate-limits).
-
-## Requirements
-
-You can create Storefront API access tokens for both **private apps** and **sales channels**, but you **must use offline access tokens** for sales channels. Please read [our documentation](https://shopify.dev/docs/storefront-api/getting-started) to learn more about Storefront Access Tokens.
-
-If you are building a private app, you can set a default Storefront Access Token for all `Storefront` client instances by setting the `config.privateAppStorefrontAccessToken` property.
-
-## Creating and using tokens
-
-The `Storefront` client extends the `Graphql` client, so it supports the same parameters. Please refer to the [Graphql client documentation](graphql.md) for details.
-
-Below is a (simplified) example of how you may create a token (see [REST](https://shopify.dev/api/admin-rest/2022-07/resources/storefrontaccesstoken) or [GraphQL](https://shopify.dev/api/admin-graphql/2022-07/mutations/storefrontAccessTokenCreate) Admin API reference) and make a request:
-
-```ts
-app.get('/my-endpoint', async (req, res) => {
-  const session = await shopify.session.getCurrent({
-    isOnline: true,
-    rawRequest: req,
-    rawResponse: res,
-  });
-
-  // Create a new storefront access token using the REST Admin API (you can also use the GraphQL API)
-  const adminApiClient = new shopify.clients.Rest({
-    domain: session.shop,
-    accessToken: session.accessToken,
-  });
-  const storefrontTokenResponse = await adminApiClient.post({
-    path: 'storefront_access_tokens',
-    data: {
-      storefront_access_token: {
-        title: 'This is my test access token',
-      },
-    },
-  });
-
-  const storefrontAccessToken =
-    storefrontTokenResponse.body.storefront_access_token.access_token;
-
-  // For simplicity, this example creates a token every time it's called, but that is not ideal.
-  // You can fetch existing Storefront access tokens using the Admin API clients.
-  const storefrontClient = new shopify.clients.Storefront({
-    domain: session.shop,
-    accessToken: storefrontAccessToken,
-  });
-
-  const products = await client.query({
-    data: `{
-      products (first: 10) {
-        edges {
-          node {
-            id
-            title
-            descriptionHtml
-          }
-        }
-      }
-    }`,
-  });
-
-  // do something with the returned data
-});
-```
-
-Once you've created your access token, you can query the Storefront API based on the `unauthenticated_*` scopes your app requests.
-See the [API reference documentation](https://shopify.dev/api/storefront) for detailed instructions on each component.
-
-[Back to guide index](../../README.md#features)

package/docs/usage/utils.md

@@ -1,30 +0,0 @@
-# utils
-
-## Get the application URL for embedded apps using `getEmbeddedAppUrl`
-
-If you need to redirect a request to your embedded app URL you can use `getEmbeddedAppUrl`
-
-```ts
-const redirectURL = Shopify.Utils.getEmbeddedAppUrl(request);
-res.redirect(redirectURL);
-```
-
-Using this utility ensures that embedded app URL is properly constructed and brings the merchant to the right place. It is more reliable than using the shop param.
-
-This utility relies on the host query param being a Base 64 encoded string. All requests from Shopify should include this param in the correct format.
-
-## Sanitize a Shopify shop domain and host address
-
-When receiving input from users, like in URL query arguments, you should always make sure to sanitize that data.
-To make it easier to do that, this library provides the following methods:
-
-```ts
-const shop = Shopify.Utils.sanitizeShop(req.query.shop, true);
-const host = Shopify.Utils.sanitizeHost(req.query.host, true);
-```
-
-Both of these return the string itself if it's valid, or `null` otherwise.
-You can also optionally set the method to throw an exception if the validation fails.
-If you're using custom shop domains for testing, you can add them to the `config.customShopDomains` setting.
-
-[Back to guide index](../../README.md#features)

package/docs/usage/webhooks.md

@@ -1,225 +0,0 @@
-# Webhooks
-
-If your application's functionality depends on knowing when events occur on a given shop, you need to register a webhook. You need an access token to register webhooks, so you must complete the OAuth process beforehand.
-
-The Shopify library enables you to handle all webhooks in a single endpoint (see [Webhook processing](#webhook-processing)
-) below), but you are not restricted to a single endpoint.
-You can register multiple handlers for each topic, and the library will add, remove, and update the handlers with Shopify based on the app's configuration.
-
-To subscribe to webhooks using this library, there are 3 main steps to take:
-
-1. [Load your handlers](#load-your-handlers)
-1. [Register webhooks with Shopify](#webhook-registration)
-1. [Process incoming webhooks](#webhook-processing)
-
-## Load your handlers
-
-The first step to process webhooks in your app is telling the library how you expect to handle them. To do that, you can call the `shopify.webhooks.addHandlers` method to inform Shopify of the events you wish to track.
-
-For example, you can load one or more handlers when setting up your app's `config` (or any other location, as long as it happens before the call to `shopify.webhooks.register`) by running:
-
-```typescript
-import {shopifyApi, DeliveryMethod} from '@shopify/shopify-api';
-const shopify = shopifyApi({apiKey: '...' /* ... */});
-
-const handleWebhookRequest = async (
-  topic: string,
-  shop: string,
-  webhookRequestBody: string,
-) => {
-  // handler triggered when a webhook is sent by the Shopify platform to your application
-};
-
-shopify.webhooks.addHandlers({
-  PRODUCTS_CREATE: [
-    {
-      deliveryMethod: DeliveryMethod.Http,
-      callbackUrl: '/webhooks',
-      callback: handleWebhookRequest,
-    },
-    {
-      deliveryMethod: DeliveryMethod.Http,
-      callbackUrl: '/webhooks',
-      callback: handleWebhookRequestPart2,
-    },
-  ],
-});
-```
-
-> **Note**: you can only register multiple handlers with the same address when the delivery method is HTTP - the library will automatically chain the requests together when handling events.
-> The library will fail when trying to add duplicate paths for other delivery methods.
-
-See the documentation for [the full list](https://shopify.dev/api/admin-graphql/latest/enums/WebhookSubscriptionTopic) of accepted topics.
-
-This method accepts an object indexed by topic. Each topic can map to an object or an array of objects with format:
-
-| Parameter                    | Type                     | Restrictions  | Default Value | Notes                                                                                                                |
-| ---------------------------- | ------------------------ | :-----------: | :-----------: | -------------------------------------------------------------------------------------------------------------------- |
-| `deliveryMethod`             | `DeliveryMethod`         |  All methods  |  _Required_   | The delivery method for this handler. Different fields for this object are allowed depending on the method.          |
-| `callbackUrl`                | `string`                 |    `Http`     |  _Required_   | The path for this handler within your app.                                                                           |
-| `callback`                   | `WebhookHandlerFunction` |    `Http`     |  _Required_   | The `async` callback to call when a shop triggers a `topic` event.                                                   |
-| `arn`                        | `string`                 | `EventBridge` |  _Required_   | The [ARN address](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_EventSource.html) for the handler. |
-| `pubSubProject`              | `string`                 |   `PubSub`    |  _Required_   | The Pub-Sub project for your handler.                                                                                |
-| `pubSubTopic`                | `string`                 |   `PubSub`    |  _Required_   | The Pub-Sub topic for your handler.                                                                                  |
-| `includeFields`              | `string[]`               |       -       |     `[]`      | Fields to be included in the callback.                                                                               |
-| `metafieldNamespaces`        | `string[]`               |       -       |     `[]`      | Namespaces to be included in the callback.                                                                           |
-| `privateMetafieldNamespaces` | `string[]`               |    `Http`     |     `[]`      | Namespaces to be included in the callback.                                                                           |
-
-When a shop triggers an event you subscribed to, the `process` method [below](#webhook-processing) will call your `Http` callbacks with the following arguments:
-
-| Parameter            | Type     | Notes                                            |
-| -------------------- | -------- | ------------------------------------------------ |
-| `topic`              | `string` | The webhook topic.                               |
-| `shop`               | `string` | The shop for which the webhook was triggered.    |
-| `webhookRequestBody` | `string` | The payload of the POST request made by Shopify. |
-
-## Get webhook registry information
-
-To see topics loaded in the registry, `shopify.webhooks.getTopicsAdded` returns an array of topics names, as strings, or an empty array if there are no topics and handlers loaded.
-
-```typescript
-shopify.webhooks.addHandlers({
-  PRODUCTS_CREATE: {
-    /* ... */
-  },
-  PRODUCTS_DELETE: [
-    {
-      /* ... */
-    },
-  ],
-});
-
-const topics = shopify.webhooks.getTopicsAdded();
-// topics = ['PRODUCTS_CREATE', 'PRODUCTS_DELETE']
-```
-
-To retrieve the handler information for a given topic, `shopify.webhooks.getHandlers()` takes a topic string as an argument and returns the list of handlers for that topic.
-
-```typescript
-shopify.webhooks.addHandlers({
-  PRODUCTS_CREATE: {
-    /* ... */
-  },
-});
-const handlers = shopify.webhooks.getHandlers('PRODUCTS');
-```
-
-## Webhook Registration
-
-After loading your handlers, you need to register which topics you want your app to listen to with Shopify. This can only happen after the merchant has installed your app, so the best place to register webhooks is after OAuth completes.
-
-In your OAuth callback action, you can use the `shopify.webhooks.register` method to subscribe to any topic allowed by your app's scopes. You can safely call this method every time a shop logs in, as it will add, update, or remove subscriptions as necessary.
-
-The parameters this method accepts are:
-
-| Parameter     | Type     | Required? | Default Value | Notes                                 |
-| :------------ | :------- | :-------: | :-----------: | :------------------------------------ |
-| `shop`        | `string` |    Yes    |       -       | The shop to use for requests.         |
-| `accessToken` | `string` |    Yes    |       -       | The access token to use for requests. |
-
-This method will return a `RegisterReturn` object, which is a list of results indexed by topic. Each item in the lists has format. This object will only contain results for a handler if any of its information was updated with Shopify.
-
-| Method    | Return type | Notes                                                      |
-| --------- | ----------- | ---------------------------------------------------------- |
-| `success` | `bool`      | Whether the registration was successful.                   |
-| `result`  | `array`     | The body from the Shopify request to register the webhook. |
-
-For example, to subscribe to the `PRODUCTS_CREATE` event, you can run this code in your OAuth callback action:
-
-```ts
-shopify.webhooks.addHandlers({
-  PRODUCTS_CREATE: {
-    deliveryMethod: DeliveryMethod.Http,
-    callbackUrl: '/webhooks',
-    callback: async (topic, shop, body) => {},
-  },
-});
-
-// Register webhooks after OAuth completes
-app.get('/auth/callback', async (req, res) => {
-  try {
-    const callbackResponse = await shopify.auth.callback({
-      isOnline: true,
-      rawRequest: req,
-      rawResponse: res,
-    });
-
-    const response = await shopify.webhooks.register({
-      accessToken: callbackResponse.session.accessToken,
-      shop: callbackResponse.session.shop,
-    });
-
-    if (!response['PRODUCTS_CREATE'][0].success) {
-      console.log(
-        `Failed to register PRODUCTS_CREATE webhook: ${response['PRODUCTS_CREATE'].result}`,
-      );
-    }
-  } catch (error) {
-    console.error(error); // in practice these should be handled more gracefully
-  }
-  return res.redirect('/'); // or wherever you want your user to end up after OAuth completes
-});
-```
-
-## Webhook Processing
-
-To process an HTTPS webhook, you need to listen on the route(s) you provided for `Http` handlers during the webhook registration process, then call the appropriate handler.
-The library provides a convenient method that acts as a middleware to handle webhooks.
-It takes care of validating the request, and calling the correct handler for registered webhook topics.
-
-The `process` method will handle extracting the necessary information from your request and response objects, and triggering the appropriate handler with the parameters detailed above.
-If it can't find a handler for a topic, it will raise an error.
-
-**Important**: In Node, the `process` method will always respond to Shopify, even if your call throws an error. You can catch and log errors, but you can't change the response.
-
-```typescript
-app.post('/webhooks', express.text({type: '*/*'}), async (req, res) => {
-  try {
-    // Note: the express.text() given above is an Express middleware that will read
-    // in the body as a string, and make it available at req.body, for this path only.
-    await shopify.webhooks.process({
-      rawBody: req.body, // is a string
-      rawRequest: req,
-      rawResponse: res,
-    });
-  } catch (error) {
-    console.log(error.message);
-  }
-});
-```
-
-**Important**: In a worker environment, e.g., CloudFlare Workers, the return value of the `process` method can be used to reply to Shopify. If the `process` call throws an error, the response will be contained in the thrown error, in `error.response`. This will enable the calling method in a worker environment to return a suitable response to Shopify.
-
-```typescript
-let response;
-
-try {
-  response = await shopify.webhooks.process({
-    rawBody: req.body,
-    rawRequest: req,
-    rawResponse: res,
-  });
-} catch (error) {
-  console.log(error.message);
-  response = error.response;
-}
-return response;
-```
-
-### Note regarding use of body parsers
-
-Unlike `v5` and earlier versions of this library, `shopify.webhooks.process()` now expects to receive the body content (in string format) as a parameter and no longer reads in the request body directly.
-
-This allows for the use of body-parsers in your code.
-
-To use Express as an example, if you wish to use the `express.json()` middleware in your app, the webhook processing can now occur after calling `app.use(express.json())`. For any path that's a webhooks path, `express.text({type: '*/*'})` should be used so that `req.body` is a string that `shopify.webhooks.process()` expects:
-
-```typescript
-await shopify.webhooks.process({
-  rawBody: req.body,
-  rawRequest: req,
-  rawResponse: res,
-});
-```
-
-[Back to guide index](../../README.md#features)

package/docs/usage/withsession.md

@@ -1,74 +0,0 @@
-# Create a Client using `withSession`
-
-This library provides a utility method `withSession` that you can use to create either a REST or GraphQL client, with
-either the current active online session, or a specific offline session. The method will return both the requested
-client, and the session with which that client will be authenticated.
-
-This method accepts a `withSessionParams` object as its argument, which accepts options for the fields: `clientType`,
-`isOnline`, `req`, `res`, and `shop`.
-
-| Parameter    | Type                   | Notes                                                                |
-| ------------ | ---------------------- | -------------------------------------------------------------------- |
-| `clientType` | string                 | must be either `graphql` or `rest`                                   |
-| `isOnline`   | boolean                | optional parameters needed are based on the value of `isOnline`      |
-| `req`        | `http.IncomingMessage` | required if `isOnline`                                               |
-| `res`        | `http.ServerResponse`  | required if `isOnline`                                               |
-| `shop`       | string                 | required if `!isOnline` and should be passed without protocol prefix |
-
-## Code Usage Examples
-
-The following are specific examples of GraphQL/online session, and REST/offline session, but any combination of `clientType` and `isOnline` is valid.
-
-<details>
-<summary>Example: GraphQL Client with online Session</summary>
-
-```ts
-// create a `WithSessionParams` object with the necessary information to pass to `withSession`
-const clientWithSessionParams: WithSessionParams = {
-  clientType: 'graphql',
-  isOnline: true,
-  req: request, // http.IncomingMessage object
-  res: response, // http.ServerResponse object
-};
-
-const {client, session} = (await Shopify.Utils.withSession(
-  clientWithSessionParams,
-)) as GraphqlWithSession;
-
-// now you can make requests to the API using this client:
-const shopName = await client.query({
-  data: `{
-      shop {
-        name
-      }
-    }`,
-});
-
-// you can also introspect on the returned Session, if you need to
-const currentSessionUser = session.onlineAccessInfo.associated_user;
-```
-
-</details>
-
-<details>
-<summary>Example: REST Client with offline session</summary>
-
-```ts
-const clientWithSessionParams: WithSessionParams = {
-  clientType: 'rest',
-  isOnline: false,
-  shop: SHOP, // Shopify store url, without protocol, ie: "{shop}.myshopify.com"
-};
-
-const {client, session} = (await Shopify.Utils.withSession(
-  clientWithSessionParams,
-)) as RestWithSession;
-
-const products = await client.get({path: 'products'});
-
-const currentSessionScope = session.scope;
-```
-
-</details>
-
-[Back to guide index](../../README.md#features)

package/lib/session/delete-current.d.ts

@@ -1,4 +0,0 @@
-import { ConfigInterface } from '../base-types';
-import { SessionDeleteCurrentParams } from './types';
-export declare function createDeleteCurrent(config: ConfigInterface): ({ isOnline, ...adapterArgs }: SessionDeleteCurrentParams) => Promise<boolean>;
-//# sourceMappingURL=delete-current.d.ts.map

package/lib/session/delete-current.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"delete-current.d.ts","sourceRoot":"","sources":["delete-current.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AAI9C,OAAO,EAAC,0BAA0B,EAAC,MAAM,SAAS,CAAC;AAGnD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,eAAe,kCAItD,0BAA0B,KAAG,QAAQ,OAAO,CAAC,CAYjD"}