Shopify Shop

This page documents the Shopify Shop model.

Data Shape

Gadget's database stores Shopify Shop records by storing and retrieving each of the fields defined on the model in the Gadget Editor to a managed database. Gadget has generated a GraphQL type matching the configured fields for Shopify Shop:

Shopify Shop Schema
1export interface ShopifyShop {
2 __typename: "ShopifyShop";
3
4 /** The globally unique, unchanging identifier for this record. Assigned and managed by Shopify. */
5 id: Scalars["GadgetID"];
6
7 /** The time at which this record was first created. Set once upon record creation and never changed. Managed by Gadget. */
8 createdAt: Scalars["DateTime"];
9
10 /** The time at which this record was last changed. Set each time the record is successfully acted upon by an action. Managed by Gadget. */
11 updatedAt: Scalars["DateTime"];
12
13 /** The current state this record is in. Changed by invoking actions. Managed by Gadget. */
14 state: Scalars["RecordState"];
15
16 customers: ShopifyCustomerConnection;
17
18 syncs: ShopifySyncConnection;
19
20 gdprRequests: ShopifyGdprRequestConnection;
21
22 accessToken: Scalars["String"] | null;
23
24 address1: Scalars["String"] | null;
25
26 address2: Scalars["String"] | null;
27
28 checkoutApiSupported: Scalars["Boolean"] | null;
29
30 city: Scalars["String"] | null;
31
32 cookieConsentLevel: Scalars["String"] | null;
33
34 country: Scalars["String"] | null;
35
36 countryCode: Scalars["String"] | null;
37
38 countryName: Scalars["String"] | null;
39
40 countyTaxes: Scalars["JSON"] | null;
41
42 shopifyCreatedAt: Scalars["DateTime"] | null;
43
44 currency: Scalars["String"] | null;
45
46 customerEmail: Scalars["String"] | null;
47
48 domain: Scalars["String"] | null;
49
50 eligibleForCardReaderGiveaway: Scalars["Boolean"] | null;
51
52 eligibleForPayments: Scalars["Boolean"] | null;
53
54 email: Scalars["String"] | null;
55
56 enabledPresentmentCurrencies: Scalars["JSON"] | null;
57
58 finances: Scalars["Boolean"] | null;
59
60 forceSsl: Scalars["Boolean"] | null;
61
62 googleAppsDomain: Scalars["String"] | null;
63
64 googleAppsLoginEnabled: Scalars["Boolean"] | null;
65
66 grantedScopes: Scalars["JSON"] | null;
67
68 hasDiscounts: Scalars["Boolean"] | null;
69
70 hasGiftCards: Scalars["Boolean"] | null;
71
72 hasStorefront: Scalars["Boolean"] | null;
73
74 ianaTimezone: Scalars["String"] | null;
75
76 installedViaApiKey: Scalars["String"] | null;
77
78 latitude: Scalars["Float"] | null;
79
80 longitude: Scalars["Float"] | null;
81
82 moneyFormat: Scalars["String"] | null;
83
84 moneyInEmailsFormat: Scalars["String"] | null;
85
86 moneyWithCurrencyFormat: Scalars["String"] | null;
87
88 moneyWithCurrencyInEmailsFormat: Scalars["String"] | null;
89
90 multiLocationEnabled: Scalars["Boolean"] | null;
91
92 myshopifyDomain: Scalars["String"] | null;
93
94 name: Scalars["String"] | null;
95
96 passwordEnabled: Scalars["Boolean"] | null;
97
98 phone: Scalars["String"] | null;
99
100 planDisplayName: Scalars["String"] | null;
101
102 planName: Scalars["String"] | null;
103
104 preLaunchEnabled: Scalars["Boolean"] | null;
105
106 primaryLocale: Scalars["String"] | null;
107
108 province: Scalars["String"] | null;
109
110 provinceCode: Scalars["String"] | null;
111
112 products: ShopifyProductConnection;
113
114 productVariants: ShopifyProductVariantConnection;
115
116 registeredWebhooks: Scalars["JSON"] | null;
117
118 requiresExtraPaymentsAgreement: Scalars["Boolean"] | null;
119
120 setupRequired: Scalars["Boolean"] | null;
121
122 shopOwner: Scalars["String"] | null;
123
124 source: Scalars["String"] | null;
125
126 taxShipping: Scalars["Boolean"] | null;
127
128 taxesIncluded: Scalars["Boolean"] | null;
129
130 timezone: Scalars["String"] | null;
131
132 shopifyUpdatedAt: Scalars["DateTime"] | null;
133
134 weightUnit: Scalars["String"] | null;
135
136 zipCode: Scalars["String"] | null;
137
138 tasks: TaskConnection;
139
140 marketingSmsContentEnabledAtCheckout: Scalars["Boolean"] | null;
141
142 transactionalSmsDisabled: Scalars["Boolean"] | null;
143
144 /** Get all the fields for this record. Useful for not having to list out all the fields you want to retrieve, but slower. */
145 _all: Scalars["JSONObject"];
146}
1type ShopifyShop {
2 """
3 The globally unique, unchanging identifier for this record. Assigned and managed by Shopify.
4 """
5 id: GadgetID!
6
7 """
8 The time at which this record was first created. Set once upon record creation and never changed. Managed by Gadget.
9 """
10 createdAt: DateTime!
11
12 """
13 The time at which this record was last changed. Set each time the record is successfully acted upon by an action. Managed by Gadget.
14 """
15 updatedAt: DateTime!
16
17 """
18 The current state this record is in. Changed by invoking actions. Managed by Gadget.
19 """
20 state: RecordState!
21 customers(
22 """
23 Returns the items in the list that come after the specified cursor.
24 """
25 after: String
26
27 """
28 Returns the first n items from the list.
29 """
30 first: Int
31
32 """
33 Returns the items in the list that come before the specified cursor.
34 """
35 before: String
36
37 """
38 Returns the last n items from the list.
39 """
40 last: Int
41
42 """
43 A list of sort orders to return the results in
44 """
45 sort: [ShopifyCustomerSort!]
46
47 """
48 A list of filters to refine the results by
49 """
50 filter: [ShopifyCustomerFilter!]
51
52 """
53 A free form text search query to find records matching
54 """
55 search: String
56 ): ShopifyCustomerConnection!
57 syncs(
58 """
59 Returns the items in the list that come after the specified cursor.
60 """
61 after: String
62
63 """
64 Returns the first n items from the list.
65 """
66 first: Int
67
68 """
69 Returns the items in the list that come before the specified cursor.
70 """
71 before: String
72
73 """
74 Returns the last n items from the list.
75 """
76 last: Int
77
78 """
79 A list of sort orders to return the results in
80 """
81 sort: [ShopifySyncSort!]
82
83 """
84 A list of filters to refine the results by
85 """
86 filter: [ShopifySyncFilter!]
87
88 """
89 A free form text search query to find records matching
90 """
91 search: String
92 ): ShopifySyncConnection!
93 gdprRequests(
94 """
95 Returns the items in the list that come after the specified cursor.
96 """
97 after: String
98
99 """
100 Returns the first n items from the list.
101 """
102 first: Int
103
104 """
105 Returns the items in the list that come before the specified cursor.
106 """
107 before: String
108
109 """
110 Returns the last n items from the list.
111 """
112 last: Int
113
114 """
115 A list of sort orders to return the results in
116 """
117 sort: [ShopifyGdprRequestSort!]
118
119 """
120 A list of filters to refine the results by
121 """
122 filter: [ShopifyGdprRequestFilter!]
123
124 """
125 A free form text search query to find records matching
126 """
127 search: String
128 ): ShopifyGdprRequestConnection!
129 accessToken: String
130 address1: String
131 address2: String
132 checkoutApiSupported: Boolean
133 city: String
134 cookieConsentLevel: String
135 country: String
136 countryCode: String
137 countryName: String
138 countyTaxes: JSON
139 shopifyCreatedAt: DateTime
140 currency: String
141 customerEmail: String
142 domain: String
143 eligibleForCardReaderGiveaway: Boolean
144 eligibleForPayments: Boolean
145 email: String
146 enabledPresentmentCurrencies: JSON
147 finances: Boolean
148 forceSsl: Boolean
149 googleAppsDomain: String
150 googleAppsLoginEnabled: Boolean
151 grantedScopes: JSON
152 hasDiscounts: Boolean
153 hasGiftCards: Boolean
154 hasStorefront: Boolean
155 ianaTimezone: String
156 installedViaApiKey: String
157 latitude: Float
158 longitude: Float
159 moneyFormat: String
160 moneyInEmailsFormat: String
161 moneyWithCurrencyFormat: String
162 moneyWithCurrencyInEmailsFormat: String
163 multiLocationEnabled: Boolean
164 myshopifyDomain: String
165 name: String
166 passwordEnabled: Boolean
167 phone: String
168 planDisplayName: String
169 planName: String
170 preLaunchEnabled: Boolean
171 primaryLocale: String
172 province: String
173 provinceCode: String
174 products(
175 """
176 Returns the items in the list that come after the specified cursor.
177 """
178 after: String
179
180 """
181 Returns the first n items from the list.
182 """
183 first: Int
184
185 """
186 Returns the items in the list that come before the specified cursor.
187 """
188 before: String
189
190 """
191 Returns the last n items from the list.
192 """
193 last: Int
194
195 """
196 A list of sort orders to return the results in
197 """
198 sort: [ShopifyProductSort!]
199
200 """
201 A list of filters to refine the results by
202 """
203 filter: [ShopifyProductFilter!]
204
205 """
206 A free form text search query to find records matching
207 """
208 search: String
209 ): ShopifyProductConnection!
210 productVariants(
211 """
212 Returns the items in the list that come after the specified cursor.
213 """
214 after: String
215
216 """
217 Returns the first n items from the list.
218 """
219 first: Int
220
221 """
222 Returns the items in the list that come before the specified cursor.
223 """
224 before: String
225
226 """
227 Returns the last n items from the list.
228 """
229 last: Int
230
231 """
232 A list of sort orders to return the results in
233 """
234 sort: [ShopifyProductVariantSort!]
235
236 """
237 A list of filters to refine the results by
238 """
239 filter: [ShopifyProductVariantFilter!]
240
241 """
242 A free form text search query to find records matching
243 """
244 search: String
245 ): ShopifyProductVariantConnection!
246 registeredWebhooks: JSON
247 requiresExtraPaymentsAgreement: Boolean
248 setupRequired: Boolean
249 shopOwner: String
250 source: String
251 taxShipping: Boolean
252 taxesIncluded: Boolean
253 timezone: String
254 shopifyUpdatedAt: DateTime
255 weightUnit: String
256 zipCode: String
257 tasks(
258 """
259 Returns the items in the list that come after the specified cursor.
260 """
261 after: String
262
263 """
264 Returns the first n items from the list.
265 """
266 first: Int
267
268 """
269 Returns the items in the list that come before the specified cursor.
270 """
271 before: String
272
273 """
274 Returns the last n items from the list.
275 """
276 last: Int
277
278 """
279 A list of sort orders to return the results in
280 """
281 sort: [TaskSort!]
282
283 """
284 A list of filters to refine the results by
285 """
286 filter: [TaskFilter!]
287
288 """
289 A free form text search query to find records matching
290 """
291 search: String
292 ): TaskConnection!
293 marketingSmsContentEnabledAtCheckout: Boolean
294 transactionalSmsDisabled: Boolean
295
296 """
297 Get all the fields for this record. Useful for not having to list out all the fields you want to retrieve, but slower.
298 """
299 _all: JSONObject!
300}

You can preview what a real record's shape looks like by fetching it using the example-app API Playground.

Any fetched Shopify Shop record will have this same ShopifyShop type, and expose the same data by default, regardless of if it's fetched by ID or as part of a findMany. This means you can select any of the record's fields wherever you like in a GraphQL query according to the use case at hand.

Retrieving one Shopify Shop record

Individual Shopify Shop records can be retrieved using the "find by ID" API endpoint. You can also return only some fields, or extra fields beyond what Gadget retrieves by default, using the select option.

The findOne function throws an error if no matching record is found, which you will need to catch and handle. Alternatively, you can use the maybeFindOne function, which returns null if no record is found, without throwing an error.

Similarly, the useFindOne React hook returns (but does not throw) an error when no matching record is found, while the useMaybeFindOne hook simply returns null if no record is found, without also returning an error.

Get one Shopify Shop
const shopifyShopRecord = await api.shopifyShop.findOne("some-id");
console.log(shopifyShopRecord.id); //=> a string
console.log(shopifyShopRecord.createdAt); //=> a Date object
const [result, refresh] = useFindOne(api.shopifyShop, "some-id");
const { data, error, fetching } = result;
console.log(data?.id); //=> a string
console.log(data?.createdAt); //=> a Date object
1query GetOneShopifyShop($id: GadgetID!) {
2 shopifyShop(id: $id) {
3 __typename
4 id
5 state
6 accessToken
7 address1
8 address2
9 checkoutApiSupported
10 city
11 cookieConsentLevel
12 country
13 countryCode
14 countryName
15 countyTaxes
16 createdAt
17 currency
18 customerEmail
19 domain
20 eligibleForCardReaderGiveaway
21 eligibleForPayments
22 email
23 enabledPresentmentCurrencies
24 finances
25 forceSsl
26 googleAppsDomain
27 googleAppsLoginEnabled
28 grantedScopes
29 hasDiscounts
30 hasGiftCards
31 hasStorefront
32 ianaTimezone
33 installedViaApiKey
34 latitude
35 longitude
36 marketingSmsContentEnabledAtCheckout
37 moneyFormat
38 moneyInEmailsFormat
39 moneyWithCurrencyFormat
40 moneyWithCurrencyInEmailsFormat
41 multiLocationEnabled
42 myshopifyDomain
43 name
44 passwordEnabled
45 phone
46 planDisplayName
47 planName
48 preLaunchEnabled
49 primaryLocale
50 province
51 provinceCode
52 registeredWebhooks
53 requiresExtraPaymentsAgreement
54 setupRequired
55 shopOwner
56 shopifyCreatedAt
57 shopifyUpdatedAt
58 source
59 taxShipping
60 taxesIncluded
61 timezone
62 transactionalSmsDisabled
63 updatedAt
64 weightUnit
65 zipCode
66 }
67}
Variables
json
{ "id": "some-id" }

Retrieving the first of many Shopify Shop records

The first record from a list of records can be retrieved using the "find first" API endpoint. The source list of records can be filtered using the filter option, sorted using the sort option, searched using the search option, though no pagination options are available on this endpoint. You can also return only some fields, or extra fields beyond what Gadget retrieves by default using the select option.

The findFirst function throws an error if no matching record is found, which you will need to catch and handle. Alternatively, you can use the maybeFindFirst function, which returns null if no record is found, without throwing an error.

Similarly, the useFindFirst React hook returns (but does not throw) an error when no matching record is found, while the useMaybeFindFirst hook simply returns null if no record is found, without also returning an error.

Get one Shopify Shop
const shopifyShopRecord = await api.shopifyShop.findFirst();
console.log(shopifyShopRecord.id); //=> a string
console.log(shopifyShopRecord.createdAt); //=> a Date object
const [result, refresh] = useFindFirst(api.shopifyShop);
const { data, error, fetching } = result;
console.log(data?.id); //=> a string
console.log(data?.createdAt); //=> a Date object
1query FindManyShopifyShops(
2 $first: Int
3 $search: String
4 $sort: [ShopifyShopSort!]
5 $filter: [ShopifyShopFilter!]
6) {
7 shopifyShops(first: $first, search: $search, sort: $sort, filter: $filter) {
8 edges {
9 node {
10 __typename
11 id
12 state
13 accessToken
14 address1
15 address2
16 checkoutApiSupported
17 city
18 cookieConsentLevel
19 country
20 countryCode
21 countryName
22 countyTaxes
23 createdAt
24 currency
25 customerEmail
26 domain
27 eligibleForCardReaderGiveaway
28 eligibleForPayments
29 email
30 enabledPresentmentCurrencies
31 finances
32 forceSsl
33 googleAppsDomain
34 googleAppsLoginEnabled
35 grantedScopes
36 hasDiscounts
37 hasGiftCards
38 hasStorefront
39 ianaTimezone
40 installedViaApiKey
41 latitude
42 longitude
43 marketingSmsContentEnabledAtCheckout
44 moneyFormat
45 moneyInEmailsFormat
46 moneyWithCurrencyFormat
47 moneyWithCurrencyInEmailsFormat
48 multiLocationEnabled
49 myshopifyDomain
50 name
51 passwordEnabled
52 phone
53 planDisplayName
54 planName
55 preLaunchEnabled
56 primaryLocale
57 province
58 provinceCode
59 registeredWebhooks
60 requiresExtraPaymentsAgreement
61 setupRequired
62 shopOwner
63 shopifyCreatedAt
64 shopifyUpdatedAt
65 source
66 taxShipping
67 taxesIncluded
68 timezone
69 transactionalSmsDisabled
70 updatedAt
71 weightUnit
72 zipCode
73 }
74 }
75 }
76}
Variables
json
{ "first": 1 }

Retrieving many Shopify Shop records

Pages of Shopify Shop records can be retrieved by using the "find many" API endpoint. The returned records can be filtered using the filter option, sorted using the sort option, searched using the search option, and paginated using standard Relay-style pagination options. You can also return only some fields, or extra fields beyond what Gadget retrieves by default using the select option.

This GraphQL endpoint returns records in the Relay Connection style (as a list of edges with nodes and cursors) so they can be paginated. The shopifyShops GraphQL endpoint works with any Relay-compatible caching client, or you can use Gadget's JS client for pagination with the findMany function.

Find a page of Shopify Shops

Fetch a page of records with the shopifyShop.findMany JS method or the shopifyShops GraphQL field. No options are required. The records returned will be implicitly sorted by ID ascending.

Find many Shopify Shops
const shopifyShopRecords = await api.shopifyShop.findMany();
console.log(shopifyShopRecords.length); //=> a number
console.log(shopifyShopRecords[0].id); //=> a string
const [result, refresh] = useFindMany(api.shopifyShop);
const { data, error, fetching } = result;
console.log(data?.length); //=> a number
console.log(data?.[0].length); //=> a string
1query FindManyShopifyShops {
2 shopifyShops {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{}

Sorting

Records can be sorted in the database to retrieve them in a certain order. Records are always implicitly sorted by ID ascending unless an explicit sort on the id field is defined. The GraphQL type ShopifyShopSort defines which fields can be sorted by.

Records can be sorted by multiple different fields and in multiple different directions by passing a list of ShopifyShopSort instead of just one.

GraphQL
1input ShopifyShopSort {
2 id: SortOrder
3 createdAt: SortOrder
4 updatedAt: SortOrder
5 state: SortOrder
6 accessToken: SortOrder
7 address1: SortOrder
8 address2: SortOrder
9 checkoutApiSupported: SortOrder
10 city: SortOrder
11 cookieConsentLevel: SortOrder
12 country: SortOrder
13 countryCode: SortOrder
14 countryName: SortOrder
15 countyTaxes: SortOrder
16 shopifyCreatedAt: SortOrder
17 currency: SortOrder
18 customerEmail: SortOrder
19 domain: SortOrder
20 eligibleForCardReaderGiveaway: SortOrder
21 eligibleForPayments: SortOrder
22 email: SortOrder
23 enabledPresentmentCurrencies: SortOrder
24 finances: SortOrder
25 forceSsl: SortOrder
26 googleAppsDomain: SortOrder
27 googleAppsLoginEnabled: SortOrder
28 grantedScopes: SortOrder
29 hasDiscounts: SortOrder
30 hasGiftCards: SortOrder
31 hasStorefront: SortOrder
32 ianaTimezone: SortOrder
33 installedViaApiKey: SortOrder
34 latitude: SortOrder
35 longitude: SortOrder
36 moneyFormat: SortOrder
37 moneyInEmailsFormat: SortOrder
38 moneyWithCurrencyFormat: SortOrder
39 moneyWithCurrencyInEmailsFormat: SortOrder
40 multiLocationEnabled: SortOrder
41 myshopifyDomain: SortOrder
42 name: SortOrder
43 passwordEnabled: SortOrder
44 phone: SortOrder
45 planDisplayName: SortOrder
46 planName: SortOrder
47 preLaunchEnabled: SortOrder
48 primaryLocale: SortOrder
49 province: SortOrder
50 provinceCode: SortOrder
51 registeredWebhooks: SortOrder
52 requiresExtraPaymentsAgreement: SortOrder
53 setupRequired: SortOrder
54 shopOwner: SortOrder
55 source: SortOrder
56 taxShipping: SortOrder
57 taxesIncluded: SortOrder
58 timezone: SortOrder
59 shopifyUpdatedAt: SortOrder
60 weightUnit: SortOrder
61 zipCode: SortOrder
62 marketingSmsContentEnabledAtCheckout: SortOrder
63 transactionalSmsDisabled: SortOrder
64}

Pass the sort option to the JS client, or the sort variable to a GraphQL query to sort the records returned.

Sort Shopify Shop by most recently created
const shopifyShopRecords = await api.shopifyShop.findMany({
sort: { createdAt: "Descending" },
});
const [result, refresh] = useFindMany(api.shopifyShop, {
sort: { createdAt: "Descending" },
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($sort: [ShopifyShopSort!]) {
2 shopifyShops(sort: $sort) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "sort": { "createdAt": "Descending" } }

Sort by multiple fields by passing an array of { [field]: "Ascending" | "Descending" } objects.

Sort Shopify Shop by multiple fields
const shopifyShopRecords = await api.shopifyShop.findMany({
sort: [{ state: "Descending" }, { createdAt: "Ascending" }],
});
const [result, refresh] = useFindMany(api.shopifyShop, {
sort: [{ state: "Descending" }, { createdAt: "Ascending" }],
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($sort: [ShopifyShopSort!]) {
2 shopifyShops(sort: $sort) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "sort": [{ "state": "Descending" }, { "createdAt": "Ascending" }] }

All primitive field types in Gadget are sortable so you are able to sort by fields you have added to a model as well.

Sort Shopify Shops by ID descending
const shopifyShopRecords = await api.shopifyShop.findMany({
sort: { id: "Descending" },
});
const [result, refresh] = useFindMany(api.shopifyShop, {
sort: { id: "Descending" },
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($sort: [ShopifyShopSort!]) {
2 shopifyShops(sort: $sort) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "sort": { "id": "Descending" } }

Searching

Shopify Shop records can be searched using Gadget's built in full text search functionality. Gadget search is appropriate for powering autocompletes, searchable tables, or other experiences where humans are writing search queries. It's typo tolerant, synonym aware and supports simple search operators like ! to exclude search terms.

Search Shopify Shops by passing the search parameter with a search query string.

Search isn't field specific in Gadget -- all String or RichText field types are searched with the built in search functionality.

Full text search Shopify Shops
const shopifyShopRecords = await api.shopifyShop.findMany({
search: "a specific phrase to search for",
});
const [result, refresh] = useFindMany(api.shopifyShop, {
search: "a specific phrase to search for",
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($search: String) {
2 shopifyShops(search: $search) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "search": "a specific phrase to search for" }

Filtering

Shopify Shop records can be filtered to return only the appropriate records. Records can be filtered on any field, including those managed by Gadget or fields added by developers. Filters can be combined with sorts, searches and paginated using cursor-based Relay pagination.

Filter Shopify Shops by passing the filter parameter with a filter object. Filter objects are nestable boolean conditions expressed as JS objects capturing a key, an operator, and usually a value.

The GraphQL type ShopifyShopFilter defines which fields can be filtered on.

Records can be filtered by multiple different fields. If you want to combine filters using boolean logic, nest them under the AND, OR, or NOT keys of a parent filter. Filters can be nested deeply by passing multiple levels boolean condition filters.

You can also pass a list of filters to the filter parameter which will be implicitly ANDed with one another such that they all need to match for a record to be returned.

Available filters
GraphQL
1input ShopifyShopFilter {
2 AND: [ShopifyShopFilter]
3 OR: [ShopifyShopFilter]
4 NOT: [ShopifyShopFilter]
5 id: IDFilter
6 createdAt: DateTimeFilter
7 updatedAt: DateTimeFilter
8 state: StateFilter
9 accessToken: StringFilter
10 address1: StringFilter
11 address2: StringFilter
12 checkoutApiSupported: BooleanFilter
13 city: StringFilter
14 cookieConsentLevel: StringFilter
15 country: StringFilter
16 countryCode: StringFilter
17 countryName: StringFilter
18 countyTaxes: JSONFilter
19 shopifyCreatedAt: DateTimeFilter
20 currency: StringFilter
21 customerEmail: StringFilter
22 domain: StringFilter
23 eligibleForCardReaderGiveaway: BooleanFilter
24 eligibleForPayments: BooleanFilter
25 email: StringFilter
26 enabledPresentmentCurrencies: JSONFilter
27 finances: BooleanFilter
28 forceSsl: BooleanFilter
29 googleAppsDomain: StringFilter
30 googleAppsLoginEnabled: BooleanFilter
31 grantedScopes: JSONFilter
32 hasDiscounts: BooleanFilter
33 hasGiftCards: BooleanFilter
34 hasStorefront: BooleanFilter
35 ianaTimezone: StringFilter
36 installedViaApiKey: StringFilter
37 latitude: FloatFilter
38 longitude: FloatFilter
39 moneyFormat: StringFilter
40 moneyInEmailsFormat: StringFilter
41 moneyWithCurrencyFormat: StringFilter
42 moneyWithCurrencyInEmailsFormat: StringFilter
43 multiLocationEnabled: BooleanFilter
44 myshopifyDomain: StringFilter
45 name: StringFilter
46 passwordEnabled: BooleanFilter
47 phone: StringFilter
48 planDisplayName: StringFilter
49 planName: StringFilter
50 preLaunchEnabled: BooleanFilter
51 primaryLocale: StringFilter
52 province: StringFilter
53 provinceCode: StringFilter
54 registeredWebhooks: JSONFilter
55 requiresExtraPaymentsAgreement: BooleanFilter
56 setupRequired: BooleanFilter
57 shopOwner: StringFilter
58 source: StringFilter
59 taxShipping: BooleanFilter
60 taxesIncluded: BooleanFilter
61 timezone: StringFilter
62 shopifyUpdatedAt: DateTimeFilter
63 weightUnit: StringFilter
64 zipCode: StringFilter
65 marketingSmsContentEnabledAtCheckout: BooleanFilter
66 transactionalSmsDisabled: BooleanFilter
67}
Find Shopify Shops created in the last day
const yesterday = new Date(Date.now() - 864e5);
const shopifyShopRecords = await api.shopifyShop.findMany({
filter: { createdAt: { greaterThan: yesterday } },
});
const yesterday = new Date(Date.now() - 864e5);
const [result, refresh] = useFindMany(api.shopifyShop, {
filter: { createdAt: { greaterThan: yesterday } },
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($filter: [ShopifyShopFilter!]) {
2 shopifyShops(filter: $filter) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "filter": { "createdAt": { "greaterThan": "2023-02-05T00:50:26.216Z" } } }
Shopify Shops created this week or updated today
1const yesterday = new Date(Date.now() - 86400000);
2const oneWeekAgo = new Date(Date.now() - 604800000);
3const shopifyShopRecords = await api.shopifyShop.findMany({
4 filter: {
5 OR: [
6 {
7 createdAt: { greaterThan: oneWeekAgo },
8 },
9 {
10 updated: { greaterThan: yesterday },
11 },
12 ],
13 },
14});
1const yesterday = new Date(Date.now() - 86400000);
2const oneWeekAgo = new Date(Date.now() - 604800000);
3const [result, refresh] = useFindMany(api.shopifyShop, {
4 filter: {
5 OR: [
6 {
7 createdAt: { greaterThan: oneWeekAgo },
8 },
9 {
10 updated: { greaterThan: yesterday },
11 },
12 ],
13 },
14});
15const { data, error, fetching } = result;
1query FindManyShopifyShops($filter: [ShopifyShopFilter!]) {
2 shopifyShops(filter: $filter) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
1{
2 "filter": {
3 "OR": [
4 { "createdAt": { "greaterThan": "2023-01-30T00:50:26.216Z" } },
5 { "updated": { "greaterThan": "2023-02-05T00:50:26.217Z" } }
6 ]
7 }
8}
Filter records that are in the installed state
const shopifyShopRecords = await api.shopifyShop.findMany({
filter: {
state: { inState: "created.installed" },
},
});
1const [result, refresh] = useFindMany(api.shopifyShop, {
2 filter: {
3 state: { inState: "created.installed" },
4 },
5});
6const { data, error, fetching } = result;
1query FindManyShopifyShops($filter: [ShopifyShopFilter!]) {
2 shopifyShops(filter: $filter) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "filter": { "state": { "inState": "created.installed" } } }

Most field types in Gadget are filterable, so you are able to filter by fields you have added to a model as well.

const shopifyShopRecords = await api.shopifyShop.findMany({
filter: {
id: { isSet: true },
},
});
1const [result, refresh] = useFindMany(api.shopifyShop, {
2 filter: {
3 id: { isSet: true },
4 },
5});
6const { data, error, fetching } = result;
1query FindManyShopifyShops($filter: [ShopifyShopFilter!]) {
2 shopifyShops(filter: $filter) {
3 edges {
4 node {
5 __typename
6 id
7 state
8 # ...
9 createdAt
10 updatedAt
11 }
12 }
13 }
14}
Variables
json
{ "filter": { "id": { "isSet": true } } }

Pagination

All Gadget record lists, including the top level Shopify Shop finder as well as associations to Shopify Shop, are structured as GraphQL connections. GraphQL connections are the de facto standard for querying lists and support cursor-based forward and backward pagination. When querying via GraphQL, you must select the edges field and then the node field to get the Shopify Shop record. When querying using a Gadget API client, the GraphQL queries are generated for you and the records are unwrapped and returned as a GadgetRecordList ready for use.

Shopify Shop pagination supports the standard GraphQL connection pagination arguments: first + after, or last + before. Pagination is done using cursors, which you can retrieve from the edge.cursor field or the pageInfo.startCursor properties.

Get the first page of 25 Shopify Shops
const shopifyShopRecords = await api.shopifyShop.findMany({ first: 25 });
console.log(shopifyShopRecords.length); //=> no greater than 25
const [result, refresh] = useFindMany(api.shopifyShop, { first: 25 });
const { data, error, fetching } = result;
console.log(data?.length); //=> no greater than 25
1query FindManyShopifyShops($first: Int, $after: String) {
2 shopifyShops(first: $first, after: $after) {
3 edges {
4 cursor
5 node {
6 __typename
7 id
8 state
9 # ...
10 createdAt
11 updatedAt
12 }
13 }
14 pageInfo {
15 endCursor
16 hasNextPage
17 hasPreviousPage
18 startCursor
19 }
20 }
21}
Variables
json
{ "first": 25 }

The after cursor used in this example data won't return any records if used in a real API request.

Next 25 Shopify Shop records after cursor
const shopifyShopRecords = await api.shopifyShop.findMany({
after: "abcdefg",
first: 25,
});
const [result, refresh] = useFindMany(api.shopifyShop, {
after: "abcdefg",
first: 25,
});
const { data, error, fetching } = result;
1query FindManyShopifyShops($first: Int, $after: String) {
2 shopifyShops(first: $first, after: $after) {
3 edges {
4 cursor
5 node {
6 __typename
7 id
8 state
9 # ...
10 createdAt
11 updatedAt
12 }
13 }
14 pageInfo {
15 endCursor
16 hasNextPage
17 hasPreviousPage
18 startCursor
19 }
20 }
21}
Variables
json
{ "first": 25, "after": "abcdefg" }

Pagination Limits

Root-level record finders like shopifyShops support a maximum page size of 250 records and a default page size of 50 records. The page size is controlled using the first or last GraphQL field arguments.

Related record finders that access lists of records through a has many or has many field support a maximum page size of 100 records and a default page size of 50 records.

Get the next or previous page

When using the generated JavaScript API client, including the api parameter in a Gadget code effect, the record lists returned from findMany calls can be paginated using the nextPage() or previousPage() option.

Both nextPage() and previousPage() will throw an error if the corresponding hasNextPage or hasPreviousPage is false.

JavaScript
1const shopifyShopRecords = await api.shopifyShop.findMany();
2if (shopifyShopRecords.hasNextPage) {
3 const nextPage = await shopifyShopRecords.nextPage();
4}
5if (shopifyShopRecords.hasPreviousPage) {
6 const prevPage = await shopifyShopRecords.previousPage();
7}

When using React and paging through records, you can use cursors to get the previous or next pages of records. This is an example of a React component that pages forward and backward through 2 records at a time for props.model.name.

React
1import { api } from "../api"; // your Gadget project's API Client
2import { useFindMany } from "@gadgetinc/react";
3import { useCallback, useState } from "react";
4
5export default function TestComponent() {
6 const NUM_ON_PAGE = 2; // the number of records per page
7
8 const [cursor, setCursor] = useState({ first: NUM_ON_PAGE });
9 // using Gadget React hooks to fetch records of shopifyShop
10 const [{ data, fetching, error }] = useFindMany(api.shopifyShop, {
11 ...cursor,
12 });
13
14 const getNextPage = useCallback(() => {
15 // use first + after to page forwards
16 setCursor({ first: NUM_ON_PAGE, after: data.endCursor });
17 }, [data]);
18
19 const getPreviousPage = useCallback(() => {
20 // use last + before to page backwards
21 setCursor({ last: NUM_ON_PAGE, before: data.startCursor });
22 }, [data]);
23
24 return (
25 <div>
26 <button onClick={getPreviousPage} disabled={!data?.hasPreviousPage}>
27 Previous page
28 </button>
29 <button onClick={getNextPage} disabled={!data?.hasNextPage}>
30 Next page
31 </button>
32 {!fetching && data.map((d) => <div>{d.id}</div>)}
33 </div>
34 );
35}

Get all records

If you need to get all available data for Shopify Shop, you will need to paginate through all pages of data. If you have a large amount of data, this can take a long time. Make sure you need to collect all data at once before writing a pagination loop that reads all records! If you are querying records for display in a UI and cannot display all your records at once, we don't recommend fetching all the data beforehand - instead, use the cursor to read additional data when the user needs it.

If you need all data for analytics applications or to collect some statistics on your data, consider options like intermediate models and pre-defined data rollups.

If you have determined that you need all your data, you can fetch it using cursors and a loop. We also suggest using select so that you only grab fields that are needed, in addition to applying a filter, if possible. Using first with the maximum allowable value will also allow you to grab the maximum number of records you can at once.

Page through all records
JavaScript
1const allRecords = []; // use allRecords to store all records
2let records = await api.shopifyShop.findMany({
3 first: 250,
4 select: {
5 id: true,
6 },
7 filter: {
8 // add filter conditions, if possible
9 },
10});
11
12allRecords.push(...records);
13
14// loop through additional pages to get all protected orders
15while (records.hasNextPage) {
16 // paginate
17 records = await records.nextPage();
18 allRecords.push(...records);
19}

Selecting fields, and fields of fields

When using the JavaScript client, all of findOne, maybeFindOne, findMany, findFirst, maybeFindFirst, and various action functions, allow requesting specific fields of a Shopify Shop and its relationships. The select option controls which fields are selected in the generated GraphQL query sent to the Gadget API. Pass each field you want to select in an object, with true as the value for scalar fields, and a nested object of the same shape for nested fields.

Gadget has a default selection that will retrieve all of the scalar fields for a Shopify Shop. If you don't pass a select option to a record finder, this default selection will be used.

Select only some Shopify Shop fields
1// fetch only the id, state, and createdAt field
2const shopifyShopRecords = await api.shopifyShop.findMany({
3 select: { id: true, state: true, createdAt: true },
4});
5// fetch all the scalar fields for the model, but no relationship fields
6const shopifyShopRecords = await api.shopifyShop.findMany();
1// fetch only the id, state, and createdAt field
2const [result, refresh] = useFindMany(api.shopifyShop, {
3 select: { id: true, state: true, createdAt: true },
4});
5const { data, error, fetching } = result;
6// fetch all the scalar fields for the model, but no relationship fields
7const [result, refresh] = useFindMany(api.shopifyShop);
8const { data, error, fetching } = result;
Type Safety

The select option is fully type safe if you're using TypeScript. The returned GadgetRecord type will have a <Shape> exactly matching the fields and nested fields you selected. For more information, see Type Safety .

This behavior of selecting only some fields is built right into GraphQL. If you want to limit or expand what you retrieve from a GraphQL query, include or exclude those fields in your GraphQL query. For more information on executing GraphQL queries, see GraphQL.

Select nested Shopify Shop fields
1// fetch the id, state, and createdAt field, and fetch some nested fields from an example relationship field named `someRelatedObject`
2const shopifyShopRecords = await api.shopifyShop.findMany({
3 select: {
4 id: true,
5 state: true,
6 createdAt: true,
7 someRelatedObject: { id: true, createdAt: true },
8 },
9});
1// fetch the id, state, and createdAt field, and fetch some nested fields from an example relationship field named `someRelatedObject`
2const [result, refresh] = useFindMany(api.shopifyShop, {
3 select: {
4 id: true,
5 state: true,
6 createdAt: true,
7 someRelatedObject: { id: true, createdAt: true },
8 },
9});
10const { data, error, fetching } = result;

Combining parameters

Sort, search, filtering, selection, and pagination parameters can be combined to access the exact set of records needed for your use case.

Combining Parameters
1const shopifyShopRecords = await api.shopifyShop.findMany({
2 search: "<some search query>",
3 sort: { createdAt: "Descending" },
4 filter: { updatedAt: { greaterThan: new Date(Date.now() - 864e5) } },
5 select: { id: true, createdAt: true },
6 first: 25,
7 after: "abcdefg",
8});
1const [result, refresh] = useFindMany(api.shopifyShop, {
2 search: "<some search query>",
3 sort: { createdAt: "Descending" },
4 filter: { updatedAt: { greaterThan: new Date(Date.now() - 864e5) } },
5 select: { id: true, createdAt: true },
6 first: 25,
7 after: "abcdefg",
8});
9const { data, error, fetching } = result;
1query FindManyShopifyShops(
2 $after: String
3 $before: String
4 $first: Int
5 $last: Int
6 $search: String
7 $sort: [ShopifyShopSort!]
8 $filter: [ShopifyShopFilter!]
9) {
10 shopifyShops(
11 after: $after
12 before: $before
13 first: $first
14 last: $last
15 search: $search
16 sort: $sort
17 filter: $filter
18 ) {
19 edges {
20 cursor
21 node {
22 __typename
23 id
24 state
25 accessToken
26 address1
27 address2
28 checkoutApiSupported
29 city
30 cookieConsentLevel
31 country
32 countryCode
33 countryName
34 countyTaxes
35 createdAt
36 currency
37 customerEmail
38 domain
39 eligibleForCardReaderGiveaway
40 eligibleForPayments
41 email
42 enabledPresentmentCurrencies
43 finances
44 forceSsl
45 googleAppsDomain
46 googleAppsLoginEnabled
47 grantedScopes
48 hasDiscounts
49 hasGiftCards
50 hasStorefront
51 ianaTimezone
52 installedViaApiKey
53 latitude
54 longitude
55 marketingSmsContentEnabledAtCheckout
56 moneyFormat
57 moneyInEmailsFormat
58 moneyWithCurrencyFormat
59 moneyWithCurrencyInEmailsFormat
60 multiLocationEnabled
61 myshopifyDomain
62 name
63 passwordEnabled
64 phone
65 planDisplayName
66 planName
67 preLaunchEnabled
68 primaryLocale
69 province
70 provinceCode
71 registeredWebhooks
72 requiresExtraPaymentsAgreement
73 setupRequired
74 shopOwner
75 shopifyCreatedAt
76 shopifyUpdatedAt
77 source
78 taxShipping
79 taxesIncluded
80 timezone
81 transactionalSmsDisabled
82 updatedAt
83 weightUnit
84 zipCode
85 }
86 }
87 pageInfo {
88 endCursor
89 hasNextPage
90 hasPreviousPage
91 startCursor
92 }
93 }
94}
Variables
json
1{
2 "search": "<some search query>",
3 "sort": { "createdAt": "Descending" },
4 "filter": { "updatedAt": { "greaterThan": "2023-02-05T00:50:26.424Z" } },
5 "first": 25,
6 "after": "abcdefg"
7}

Invoking Actions

Shopify Shop records are changed by invoking Actions. Actions are the things that "do" stuff -- update records, make API calls, call backend code, etc. Actions with a GraphQL API trigger each have one corresponding GraphQL mutation and a corresponding function available in the API client libraries. Nested Actions can also be invoked with the API client, by providing the actions as input to any relationship fields.

Action Result format

Each API action returns results in the same format that includes a success indicator, errors, and the actual result if the action succeeded. The result is the record that was acted on for a model action, or a list of records for a bulk action, or a JSON blob for Global Actions. Model actions that delete the record don't return the record.

The success field returns a boolean indicating if the action executed as expected. Any execution errors are returned in the errors object, which will always be null if success is true or contain ExecutionError objects if success is false.

ExecutionError objects always have a message describing what error prevented the action from succeeding, as well as a code attribute that gives a stable, searchable, human readable error class code for referencing this specific error. Details on each error code can be found in the Errors documentation. All ExecutionError object types returned by the GraphQL object can be one of many types of error, where some types have extra data that is useful for remedying the error. All error types will always have message and code properties, but some, like InvalidRecordError have extra fields for use by clients.

Errors when using the generated client

The generated JavaScript client automatically interprets errors from invoking actions and throws JavaScript Error instances if the action didn't succeed. The Error objects it throws are rich, and expose extra error properties beyond just message and code if they exist.

Errors thrown by the JavaScript client are easiest to catch by using a try/catch statement around an await, like so:

JavaScript
1import {
2 GadgetOperationError,
3 InvalidRecordError,
4} from "@gadget-client/example-app";
5
6// must be in an async function to use `await` syntax
7const runAction = async () => {
8 try {
9 return await api.exampleModel.create({
10 exampleModel: { name: "example record name" },
11 });
12 } catch (error) {
13 if (error instanceof GadgetOperationError) {
14 // a recognized general error has occurred, retry the operation or inspect error.code`
15 console.error(error);
16 } else if (error instanceof InvalidRecordError) {
17 // the submitted input data for the action was invalid, inspect the invalid fields which `InvalidRecordError` exposes
18 console.error(error.validationErrors);
19 } else {
20 // an unrecognized error occurred, like an HTTP connection interrupted error or a syntax error. Re-throw it because it's not clear what to do to fix ti
21 throw error;
22 }
23 }
24};

For more information on error codes, consult the Errors documentation.

Shopify Shop create

Input

create accepts the following input parameters:

create Input Data
1export interface CreateShopifyShopInput {
2 id?: (Scalars["GadgetID"] | null) | null;
3
4 customers?: (ShopifyCustomerHasManyInput | null)[];
5
6 syncs?: (ShopifySyncHasManyInput | null)[];
7
8 gdprRequests?: (ShopifyGdprRequestHasManyInput | null)[];
9
10 address1?: (Scalars["String"] | null) | null;
11
12 address2?: (Scalars["String"] | null) | null;
13
14 checkoutApiSupported?: (Scalars["Boolean"] | null) | null;
15
16 city?: (Scalars["String"] | null) | null;
17
18 cookieConsentLevel?: (Scalars["String"] | null) | null;
19
20 country?: (Scalars["String"] | null) | null;
21
22 countryCode?: (Scalars["String"] | null) | null;
23
24 countryName?: (Scalars["String"] | null) | null;
25
26 countyTaxes?: (Scalars["JSON"] | null) | null;
27
28 shopifyCreatedAt?: Date | Scalars["ISO8601DateString"] | null;
29
30 currency?: (Scalars["String"] | null) | null;
31
32 customerEmail?: (Scalars["String"] | null) | null;
33
34 domain?: (Scalars["String"] | null) | null;
35
36 eligibleForCardReaderGiveaway?: (Scalars["Boolean"] | null) | null;
37
38 eligibleForPayments?: (Scalars["Boolean"] | null) | null;
39
40 email?: (Scalars["String"] | null) | null;
41
42 enabledPresentmentCurrencies?: (Scalars["JSON"] | null) | null;
43
44 finances?: (Scalars["Boolean"] | null) | null;
45
46 forceSsl?: (Scalars["Boolean"] | null) | null;
47
48 googleAppsDomain?: (Scalars["String"] | null) | null;
49
50 googleAppsLoginEnabled?: (Scalars["Boolean"] | null) | null;
51
52 hasDiscounts?: (Scalars["Boolean"] | null) | null;
53
54 hasGiftCards?: (Scalars["Boolean"] | null) | null;
55
56 hasStorefront?: (Scalars["Boolean"] | null) | null;
57
58 ianaTimezone?: (Scalars["String"] | null) | null;
59
60 latitude?: (Scalars["Float"] | null) | null;
61
62 longitude?: (Scalars["Float"] | null) | null;
63
64 moneyFormat?: (Scalars["String"] | null) | null;
65
66 moneyInEmailsFormat?: (Scalars["String"] | null) | null;
67
68 moneyWithCurrencyFormat?: (Scalars["String"] | null) | null;
69
70 moneyWithCurrencyInEmailsFormat?: (Scalars["String"] | null) | null;
71
72 multiLocationEnabled?: (Scalars["Boolean"] | null) | null;
73
74 myshopifyDomain?: (Scalars["String"] | null) | null;
75
76 name?: (Scalars["String"] | null) | null;
77
78 passwordEnabled?: (Scalars["Boolean"] | null) | null;
79
80 phone?: (Scalars["String"] | null) | null;
81
82 planDisplayName?: (Scalars["String"] | null) | null;
83
84 planName?: (Scalars["String"] | null) | null;
85
86 preLaunchEnabled?: (Scalars["Boolean"] | null) | null;
87
88 primaryLocale?: (Scalars["String"] | null) | null;
89
90 province?: (Scalars["String"] | null) | null;
91
92 provinceCode?: (Scalars["String"] | null) | null;
93
94 products?: (ShopifyProductHasManyInput | null)[];
95
96 productVariants?: (ShopifyProductVariantHasManyInput | null)[];
97
98 requiresExtraPaymentsAgreement?: (Scalars["Boolean"] | null) | null;
99
100 setupRequired?: (Scalars["Boolean"] | null) | null;
101
102 shopOwner?: (Scalars["String"] | null) | null;
103
104 source?: (Scalars["String"] | null) | null;
105
106 taxShipping?: (Scalars["Boolean"] | null) | null;
107
108 taxesIncluded?: (Scalars["Boolean"] | null) | null;
109
110 timezone?: (Scalars["String"] | null) | null;
111
112 shopifyUpdatedAt?: Date | Scalars["ISO8601DateString"] | null;
113
114 weightUnit?: (Scalars["String"] | null) | null;
115
116 zipCode?: (Scalars["String"] | null) | null;
117
118 tasks?: (TaskHasManyInput | null)[];
119
120 marketingSmsContentEnabledAtCheckout?: (Scalars["Boolean"] | null) | null;
121
122 transactionalSmsDisabled?: (Scalars["Boolean"] | null) | null;
123}
124
125export interface CreateShopifyShopArguments {
126 shopifyShop?: CreateShopifyShopInput | null;
127}
1input CreateShopifyShopInput {
2 id: GadgetID
3 customers: [ShopifyCustomerHasManyInput]
4 syncs: [ShopifySyncHasManyInput]
5 gdprRequests: [ShopifyGdprRequestHasManyInput]
6 address1: String
7 address2: String
8 checkoutApiSupported: Boolean
9 city: String
10 cookieConsentLevel: String
11 country: String
12 countryCode: String
13 countryName: String
14 countyTaxes: JSON
15 shopifyCreatedAt: DateTime
16 currency: String
17 customerEmail: String
18 domain: String
19 eligibleForCardReaderGiveaway: Boolean
20 eligibleForPayments: Boolean
21 email: String
22 enabledPresentmentCurrencies: JSON
23 finances: Boolean
24 forceSsl: Boolean
25 googleAppsDomain: String
26 googleAppsLoginEnabled: Boolean
27 hasDiscounts: Boolean
28 hasGiftCards: Boolean
29 hasStorefront: Boolean
30 ianaTimezone: String
31 latitude: Float
32 longitude: Float
33 moneyFormat: String
34 moneyInEmailsFormat: String
35 moneyWithCurrencyFormat: String
36 moneyWithCurrencyInEmailsFormat: String
37 multiLocationEnabled: Boolean
38 myshopifyDomain: String
39 name: String
40 passwordEnabled: Boolean
41 phone: String
42 planDisplayName: String
43 planName: String
44 preLaunchEnabled: Boolean
45 primaryLocale: String
46 province: String
47 provinceCode: String
48 products: [ShopifyProductHasManyInput]
49 productVariants: [ShopifyProductVariantHasManyInput]
50 requiresExtraPaymentsAgreement: Boolean
51 setupRequired: Boolean
52 shopOwner: String
53 source: String
54 taxShipping: Boolean
55 taxesIncluded: Boolean
56 timezone: String
57 shopifyUpdatedAt: DateTime
58 weightUnit: String
59 zipCode: String
60 tasks: [TaskHasManyInput]
61 marketingSmsContentEnabledAtCheckout: Boolean
62 transactionalSmsDisabled: Boolean
63}
64
65input CreateShopifyShopArguments {
66 shopifyShop: CreateShopifyShopInput
67}
Example create Invocation
1const shopifyShopRecord = await api.shopifyShop.create({
2 shopifyShop: {
3 // field values for Shopify Shop
4 },
5});
6console.log(shopifyShopRecord.id); //=> a string
1const [result, createShopifyShop] = useAction(api.shopifyShop.create);
2const { data, error, fetching } = result;
3await createShopifyShop({
4 shopifyShop: {
5 // field values for Shopify Shop
6 },
7});
8console.log(data?.id); //=> a string
1mutation ($shopifyShop: CreateShopifyShopInput) {
2 createShopifyShop(shopifyShop: $shopifyShop) {
3 success
4 errors {
5 message
6 ... on InvalidRecordError {
7 validationErrors {
8 apiIdentifier
9 message
10 }
11 record
12 model {
13 apiIdentifier
14 }
15 }
16 }
17 shopifyShop {
18 __typename
19 id
20 state
21 accessToken
22 address1
23 address2
24 checkoutApiSupported
25 city
26 cookieConsentLevel
27 country
28 countryCode
29 countryName
30 countyTaxes
31 createdAt
32 currency
33 customerEmail
34 domain
35 eligibleForCardReaderGiveaway
36 eligibleForPayments
37 email
38 enabledPresentmentCurrencies
39 finances
40 forceSsl
41 googleAppsDomain
42 googleAppsLoginEnabled
43 grantedScopes
44 hasDiscounts
45 hasGiftCards
46 hasStorefront
47 ianaTimezone
48 installedViaApiKey
49 latitude
50 longitude
51 marketingSmsContentEnabledAtCheckout
52 moneyFormat
53 moneyInEmailsFormat
54 moneyWithCurrencyFormat
55 moneyWithCurrencyInEmailsFormat
56 multiLocationEnabled
57 myshopifyDomain
58 name
59 passwordEnabled
60 phone
61 planDisplayName
62 planName
63 preLaunchEnabled
64 primaryLocale
65 province
66 provinceCode
67 registeredWebhooks
68 requiresExtraPaymentsAgreement
69 setupRequired
70 shopOwner
71 shopifyCreatedAt
72 shopifyUpdatedAt
73 source
74 taxShipping
75 taxesIncluded
76 timezone
77 transactionalSmsDisabled
78 updatedAt
79 weightUnit
80 zipCode
81 }
82 }
83}
Variables
json
{ "shopifyShop": {} }
Output

create returns the Shopify Shop. In the JS client, the fields returned can be controlled with the select option. In GraphQL, the return format is the action result format, which includes the record if the action was successful. You can include or exclude the fields you need right in the mutation itself.

create Output Data
type CreateShopifyShopResult {
success: Boolean!
errors: [ExecutionError!]
shopifyShop: ShopifyShop
}

Shopify Shop update

Input

update operates on one Shopify Shop in particular, identified by the id variable.update accepts the following input parameters:

update Input Data
1export interface UpdateShopifyShopInput {
2 id?: (Scalars["GadgetID"] | null) | null;
3
4 customers?: (ShopifyCustomerHasManyInput | null)[];
5
6 syncs?: (ShopifySyncHasManyInput | null)[];
7
8 gdprRequests?: (ShopifyGdprRequestHasManyInput | null)[];
9
10 address1?: (Scalars["String"] | null) | null;
11
12 address2?: (Scalars["String"] | null) | null;
13
14 checkoutApiSupported?: (Scalars["Boolean"] | null) | null;
15
16 city?: (Scalars["String"] | null) | null;
17
18 cookieConsentLevel?: (Scalars["String"] | null) | null;
19
20 country?: (Scalars["String"] | null) | null;
21
22 countryCode?: (Scalars["String"] | null) | null;
23
24 countryName?: (Scalars["String"] | null) | null;
25
26 countyTaxes?: (Scalars["JSON"] | null) | null;
27
28 shopifyCreatedAt?: Date | Scalars["ISO8601DateString"] | null;
29
30 currency?: (Scalars["String"] | null) | null;
31
32 customerEmail?: (Scalars["String"] | null) | null;
33
34 domain?: (Scalars["String"] | null) | null;
35
36 eligibleForCardReaderGiveaway?: (Scalars["Boolean"] | null) | null;
37
38 eligibleForPayments?: (Scalars["Boolean"] | null) | null;
39
40 email?: (Scalars["String"] | null) | null;
41
42 enabledPresentmentCurrencies?: (Scalars["JSON"] | null) | null;
43
44 finances?: (Scalars["Boolean"] | null) | null;
45
46 forceSsl?: (Scalars["Boolean"] | null) | null;
47
48 googleAppsDomain?: (Scalars["String"] | null) | null;
49
50 googleAppsLoginEnabled?: (Scalars["Boolean"] | null) | null;
51
52 hasDiscounts?: (Scalars["Boolean"] | null) | null;
53
54 hasGiftCards?: (Scalars["Boolean"] | null) | null;
55
56 hasStorefront?: (Scalars["Boolean"] | null) | null;
57
58 ianaTimezone?: (Scalars["String"] | null) | null;
59
60 latitude?: (Scalars["Float"] | null) | null;
61
62 longitude?: (Scalars["Float"] | null) | null;
63
64 moneyFormat?: (Scalars["String"] | null) | null;
65
66 moneyInEmailsFormat?: (Scalars["String"] | null) | null;
67
68 moneyWithCurrencyFormat?: (Scalars["String"] | null) | null;
69
70 moneyWithCurrencyInEmailsFormat?: (Scalars["String"] | null) | null;
71
72 multiLocationEnabled?: (Scalars["Boolean"] | null) | null;
73
74 myshopifyDomain?: (Scalars["String"] | null) | null;
75
76 name?: (Scalars["String"] | null) | null;
77
78 passwordEnabled?: (Scalars["Boolean"] | null) | null;
79
80 phone?: (Scalars["String"] | null) | null;
81
82 planDisplayName?: (Scalars["String"] | null) | null;
83
84 planName?: (Scalars["String"] | null) | null;
85
86 preLaunchEnabled?: (Scalars["Boolean"] | null) | null;
87
88 primaryLocale?: (Scalars["String"] | null) | null;
89
90 province?: (Scalars["String"] | null) | null;
91
92 provinceCode?: (Scalars["String"] | null) | null;
93
94 products?: (ShopifyProductHasManyInput | null)[];
95
96 productVariants?: (ShopifyProductVariantHasManyInput | null)[];
97
98 requiresExtraPaymentsAgreement?: (Scalars["Boolean"] | null) | null;
99
100 setupRequired?: (Scalars["Boolean"] | null) | null;
101
102 shopOwner?: (Scalars["String"] | null) | null;
103
104 source?: (Scalars["String"] | null) | null;
105
106 taxShipping?: (Scalars["Boolean"] | null) | null;
107
108 taxesIncluded?: (Scalars["Boolean"] | null) | null;
109
110 timezone?: (Scalars["String"] | null) | null;
111
112 shopifyUpdatedAt?: Date | Scalars["ISO8601DateString"] | null;
113
114 weightUnit?: (Scalars["String"] | null) | null;
115
116 zipCode?: (Scalars["String"] | null) | null;
117
118 tasks?: (TaskHasManyInput | null)[];
119
120 marketingSmsContentEnabledAtCheckout?: (Scalars["Boolean"] | null) | null;
121
122 transactionalSmsDisabled?: (Scalars["Boolean"] | null) | null;
123}
124
125export interface UpdateShopifyShopArguments {
126 shopifyShop?: UpdateShopifyShopInput | null;
127}
1input UpdateShopifyShopInput {
2 id: GadgetID
3 customers: [ShopifyCustomerHasManyInput]
4 syncs: [ShopifySyncHasManyInput]
5 gdprRequests: [ShopifyGdprRequestHasManyInput]
6 address1: String
7 address2: String
8 checkoutApiSupported: Boolean
9 city: String
10 cookieConsentLevel: String
11 country: String
12 countryCode: String
13 countryName: String
14 countyTaxes: JSON
15 shopifyCreatedAt: DateTime
16 currency: String
17 customerEmail: String
18 domain: String
19 eligibleForCardReaderGiveaway: Boolean
20 eligibleForPayments: Boolean
21 email: String
22 enabledPresentmentCurrencies: JSON
23 finances: Boolean
24 forceSsl: Boolean
25 googleAppsDomain: String
26 googleAppsLoginEnabled: Boolean
27 hasDiscounts: Boolean
28 hasGiftCards: Boolean
29 hasStorefront: Boolean
30 ianaTimezone: String
31 latitude: Float
32 longitude: Float
33 moneyFormat: String
34 moneyInEmailsFormat: String
35 moneyWithCurrencyFormat: String
36 moneyWithCurrencyInEmailsFormat: String
37 multiLocationEnabled: Boolean
38 myshopifyDomain: String
39 name: String
40 passwordEnabled: Boolean
41 phone: String
42 planDisplayName: String
43 planName: String
44 preLaunchEnabled: Boolean
45 primaryLocale: String
46 province: String
47 provinceCode: String
48 products: [ShopifyProductHasManyInput]
49 productVariants: [ShopifyProductVariantHasManyInput]
50 requiresExtraPaymentsAgreement: Boolean
51 setupRequired: Boolean
52 shopOwner: String
53 source: String
54 taxShipping: Boolean
55 taxesIncluded: Boolean
56 timezone: String
57 shopifyUpdatedAt: DateTime
58 weightUnit: String
59 zipCode: String
60 tasks: [TaskHasManyInput]
61 marketingSmsContentEnabledAtCheckout: Boolean
62 transactionalSmsDisabled: Boolean
63}
64
65input UpdateShopifyShopArguments {
66 shopifyShop: UpdateShopifyShopInput
67}
Example update Invocation
1const shopifyShopRecord = await api.shopifyShop.update("some-id", {
2 shopifyShop: {
3 // field values for Shopify Shop
4 },
5});
6console.log(shopifyShopRecord.id); //=> a string
1const [result, updateShopifyShop] = useAction(api.shopifyShop.update);
2const { data, error, fetching } = result;
3await updateShopifyShop({
4 id: "some-id",
5 shopifyShop: {
6 // field values for Shopify Shop
7 },
8});
9console.log(data?.id); //=> a string
1mutation ($id: GadgetID!, $shopifyShop: UpdateShopifyShopInput) {
2 updateShopifyShop(id: $id, shopifyShop: $shopifyShop) {
3 success
4 errors {
5 message
6 ... on InvalidRecordError {
7 validationErrors {
8 apiIdentifier
9 message
10 }
11 record
12 model {
13 apiIdentifier
14 }
15 }
16 }
17 shopifyShop {
18 __typename
19 id
20 state
21 accessToken
22 address1
23 address2
24 checkoutApiSupported
25 city
26 cookieConsentLevel
27 country
28 countryCode
29 countryName
30 countyTaxes
31 createdAt
32 currency
33 customerEmail
34 domain
35 eligibleForCardReaderGiveaway
36 eligibleForPayments
37 email
38 enabledPresentmentCurrencies
39 finances
40 forceSsl
41 googleAppsDomain
42 googleAppsLoginEnabled
43 grantedScopes
44 hasDiscounts
45 hasGiftCards
46 hasStorefront
47 ianaTimezone
48 installedViaApiKey
49 latitude
50 longitude
51 marketingSmsContentEnabledAtCheckout
52 moneyFormat
53 moneyInEmailsFormat
54 moneyWithCurrencyFormat
55 moneyWithCurrencyInEmailsFormat
56 multiLocationEnabled
57 myshopifyDomain
58 name
59 passwordEnabled
60 phone
61 planDisplayName
62 planName
63 preLaunchEnabled
64 primaryLocale
65 province
66 provinceCode
67 registeredWebhooks
68 requiresExtraPaymentsAgreement
69 setupRequired
70 shopOwner
71 shopifyCreatedAt
72 shopifyUpdatedAt
73 source
74 taxShipping
75 taxesIncluded
76 timezone
77 transactionalSmsDisabled
78 updatedAt
79 weightUnit
80 zipCode
81 }
82 }
83}
Variables
json
{ "id": "some-id", "shopifyShop": {} }
Output

update returns the Shopify Shop. In the JS client, the fields returned can be controlled with the select option. In GraphQL, the return format is the action result format, which includes the record if the action was successful. You can include or exclude the fields you need right in the mutation itself.

update Output Data
type UpdateShopifyShopResult {
success: Boolean!
errors: [ExecutionError!]
shopifyShop: ShopifyShop
}

Shopify Shop delete

The delete action destroys the record.

Input

delete operates on one Shopify Shop in particular, identified by the id variable.

Example delete Invocation
await api.shopifyShop.delete("some-id");
const [result, deleteShopifyShop] = useAction(api.shopifyShop.delete);
const { data, error, fetching } = result;
await deleteShopifyShop({
id: "some-id",
});
1mutation ($id: GadgetID!) {
2 deleteShopifyShop(id: $id) {
3 success
4 errors {
5 message
6 ... on InvalidRecordError {
7 validationErrors {
8 apiIdentifier