@keystrokehq/shopify 0.0.15 → 0.0.16-integration-id-canonicalization.0

package/dist/articles.mjs

@@ -1,252 +0,0 @@
-import { shopifyArticleSchema, shopifyConnectionNodesSchema, shopifyGlobalIdSchema, shopifyUserErrorSchema } from "./schemas.mjs";
-import { createShopifyClient } from "./client.mjs";
-import { t as shopifyOperation } from "./factory-DwZJl9JC.mjs";
-import { n as omitUndefined, r as shopifyPageInputSchema, t as assertNoUserErrors } from "./operation-helpers-CKEDIx0o.mjs";
-import { z } from "zod";
-
-//#region src/articles.ts
-const articleSelection = `
-  id
-  title
-  handle
-  blog {
-    
-  id
-  title
-  handle
-  createdAt
-  updatedAt
-  commentPolicy
-  templateSuffix
-
-  }
-  author {
-    name
-  }
-  body
-  summary
-  tags
-  image {
-    url
-    altText
-  }
-  publishedAt
-  updatedAt
-`;
-const articleMutationInputSchema = z.object({
-	blogId: shopifyGlobalIdSchema.optional(),
-	title: z.string().min(1).optional(),
-	handle: z.string().min(1).optional(),
-	body: z.string().optional(),
-	summary: z.string().optional(),
-	authorName: z.string().optional(),
-	isPublished: z.boolean().optional(),
-	publishDate: z.iso.datetime().optional(),
-	tags: z.array(z.string()).optional()
-});
-const articleResponseSchema = z.object({
-	id: shopifyGlobalIdSchema,
-	title: z.string(),
-	handle: z.string(),
-	blog: z.object({
-		id: shopifyGlobalIdSchema,
-		title: z.string(),
-		handle: z.string(),
-		createdAt: z.iso.datetime().optional(),
-		updatedAt: z.iso.datetime().optional(),
-		commentPolicy: z.string().nullable().optional(),
-		templateSuffix: z.string().nullable().optional()
-	}).nullable().optional(),
-	author: z.object({ name: z.string().nullable().optional() }).nullable().optional(),
-	body: z.string().nullable().optional(),
-	summary: z.string().nullable().optional(),
-	tags: z.array(z.string()).optional(),
-	image: z.object({
-		url: z.url(),
-		altText: z.string().nullable().optional()
-	}).nullable().optional(),
-	publishedAt: z.iso.datetime().nullable().optional(),
-	updatedAt: z.iso.datetime().optional()
-});
-const articleMutationPayloadSchema = z.object({
-	article: articleResponseSchema.nullable(),
-	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
-});
-const listArticlesResponseSchema = z.object({ articles: shopifyConnectionNodesSchema(articleResponseSchema) });
-const getArticleResponseSchema = z.object({ article: articleResponseSchema.nullable() });
-const deleteArticleResponseSchema = z.object({
-	deletedArticleId: shopifyGlobalIdSchema.nullable(),
-	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
-});
-function normalizeArticle(article) {
-	return {
-		id: article.id,
-		title: article.title,
-		handle: article.handle,
-		blog: article.blog ?? null,
-		author: article.author?.name ?? null,
-		body: article.body ?? null,
-		summary: article.summary ?? null,
-		tags: article.tags,
-		image: article.image ?? null,
-		publishedAt: article.publishedAt ?? null,
-		updatedAt: article.updatedAt
-	};
-}
-function buildArticleInput(input) {
-	return omitUndefined({
-		blogId: input.blogId,
-		title: input.title,
-		handle: input.handle,
-		body: input.body,
-		summary: input.summary,
-		author: input.authorName ? { name: input.authorName } : void 0,
-		isPublished: input.isPublished,
-		publishDate: input.publishDate,
-		tags: input.tags
-	});
-}
-const listArticles = shopifyOperation({
-	id: "shopify.list-shopify-articles",
-	name: "List Shopify Articles",
-	description: "List blog articles from the connected Shopify store.",
-	input: shopifyPageInputSchema,
-	output: shopifyConnectionNodesSchema(shopifyArticleSchema),
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        query ListArticles($first: Int!, $after: String, $query: String) {
-          articles(first: $first, after: $after, query: $query) {
-            nodes {
-              ${articleSelection}
-            }
-            pageInfo {
-              hasNextPage
-              hasPreviousPage
-              startCursor
-              endCursor
-            }
-          }
-        }
-      `, listArticlesResponseSchema, { variables: {
-			first: input.first,
-			...input.after ? { after: input.after } : {},
-			...input.query ? { query: input.query } : {}
-		} });
-		return {
-			nodes: response.articles.nodes.map(normalizeArticle),
-			pageInfo: response.articles.pageInfo
-		};
-	}
-});
-const getArticle = shopifyOperation({
-	id: "shopify.get-shopify-article",
-	name: "Get Shopify Article",
-	description: "Retrieve a single Shopify article by its global ID.",
-	input: z.object({ id: shopifyGlobalIdSchema }),
-	output: shopifyArticleSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        query GetArticle($id: ID!) {
-          article(id: $id) {
-            ${articleSelection}
-          }
-        }
-      `, getArticleResponseSchema, { variables: { id: input.id } });
-		if (!response.article) throw new Error(`Shopify article not found: ${input.id}`);
-		return normalizeArticle(response.article);
-	}
-});
-const createArticle = shopifyOperation({
-	id: "shopify.create-shopify-article",
-	name: "Create Shopify Article",
-	description: "Create an article in the connected Shopify store.",
-	needsApproval: true,
-	input: articleMutationInputSchema.extend({
-		blogId: shopifyGlobalIdSchema,
-		title: z.string().min(1)
-	}),
-	output: shopifyArticleSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation CreateArticle($article: ArticleCreateInput!) {
-          articleCreate(article: $article) {
-            article {
-              ${articleSelection}
-            }
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ articleCreate: articleMutationPayloadSchema }), { variables: { article: buildArticleInput(input) } });
-		assertNoUserErrors(response.articleCreate.userErrors);
-		if (!response.articleCreate.article) throw new Error("Shopify did not return the created article.");
-		return normalizeArticle(response.articleCreate.article);
-	}
-});
-const updateArticle = shopifyOperation({
-	id: "shopify.update-shopify-article",
-	name: "Update Shopify Article",
-	description: "Update a Shopify article by its global ID.",
-	needsApproval: true,
-	input: articleMutationInputSchema.extend({
-		id: shopifyGlobalIdSchema,
-		redirectNewHandle: z.boolean().optional()
-	}),
-	output: shopifyArticleSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation UpdateArticle($id: ID!, $article: ArticleUpdateInput!) {
-          articleUpdate(id: $id, article: $article) {
-            article {
-              ${articleSelection}
-            }
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ articleUpdate: articleMutationPayloadSchema }), { variables: {
-			id: input.id,
-			article: omitUndefined({
-				...buildArticleInput(input),
-				redirectNewHandle: input.redirectNewHandle
-			})
-		} });
-		assertNoUserErrors(response.articleUpdate.userErrors);
-		if (!response.articleUpdate.article) throw new Error(`Shopify did not return the updated article: ${input.id}`);
-		return normalizeArticle(response.articleUpdate.article);
-	}
-});
-const deleteArticle = shopifyOperation({
-	id: "shopify.delete-shopify-article",
-	name: "Delete Shopify Article",
-	description: "Delete a Shopify article by its global ID.",
-	needsApproval: true,
-	input: z.object({ id: shopifyGlobalIdSchema }),
-	output: z.object({ deletedArticleId: shopifyGlobalIdSchema }),
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation DeleteArticle($id: ID!) {
-          articleDelete(id: $id) {
-            deletedArticleId
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ articleDelete: deleteArticleResponseSchema }), { variables: { id: input.id } });
-		assertNoUserErrors(response.articleDelete.userErrors);
-		if (!response.articleDelete.deletedArticleId) throw new Error(`Shopify did not confirm article deletion: ${input.id}`);
-		return { deletedArticleId: response.articleDelete.deletedArticleId };
-	}
-});
-
-//#endregion
-export { createArticle, deleteArticle, getArticle, listArticles, updateArticle };

package/dist/blogs.d.mts

@@ -1,97 +0,0 @@
-import { z } from "zod";
-import * as _keystrokehq_core0 from "@keystrokehq/core";
-
-//#region src/blogs.d.ts
-declare const listBlogs: _keystrokehq_core0.Operation<z.ZodObject<{
-  first: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-  after: z.ZodOptional<z.ZodString>;
-  query: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>, z.ZodObject<{
-  nodes: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    handle: z.ZodString;
-    createdAt: z.ZodOptional<z.ZodISODateTime>;
-    updatedAt: z.ZodOptional<z.ZodISODateTime>;
-    commentPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    templateSuffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  }, z.core.$strip>>;
-  pageInfo: z.ZodObject<{
-    hasNextPage: z.ZodBoolean;
-    hasPreviousPage: z.ZodOptional<z.ZodBoolean>;
-    startCursor: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    endCursor: z.ZodNullable<z.ZodString>;
-  }, z.core.$strip>;
-}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"keystroke:shopify", z.ZodObject<{
-  SHOPIFY_STORE_DOMAIN: z.ZodString;
-  SHOPIFY_ACCESS_TOKEN: z.ZodString;
-}, z.core.$strip>>], undefined>;
-declare const getBlog: _keystrokehq_core0.Operation<z.ZodObject<{
-  id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  id: z.ZodString;
-  title: z.ZodString;
-  handle: z.ZodString;
-  createdAt: z.ZodOptional<z.ZodISODateTime>;
-  updatedAt: z.ZodOptional<z.ZodISODateTime>;
-  commentPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  templateSuffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"keystroke:shopify", z.ZodObject<{
-  SHOPIFY_STORE_DOMAIN: z.ZodString;
-  SHOPIFY_ACCESS_TOKEN: z.ZodString;
-}, z.core.$strip>>], undefined>;
-declare const createBlog: _keystrokehq_core0.Operation<z.ZodObject<{
-  handle: z.ZodOptional<z.ZodString>;
-  templateSuffix: z.ZodOptional<z.ZodString>;
-  commentPolicy: z.ZodOptional<z.ZodEnum<{
-    DISABLED: "DISABLED";
-    HIDDEN: "HIDDEN";
-    MODERATED: "MODERATED";
-    OPEN: "OPEN";
-  }>>;
-  title: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  id: z.ZodString;
-  title: z.ZodString;
-  handle: z.ZodString;
-  createdAt: z.ZodOptional<z.ZodISODateTime>;
-  updatedAt: z.ZodOptional<z.ZodISODateTime>;
-  commentPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  templateSuffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"keystroke:shopify", z.ZodObject<{
-  SHOPIFY_STORE_DOMAIN: z.ZodString;
-  SHOPIFY_ACCESS_TOKEN: z.ZodString;
-}, z.core.$strip>>], undefined>;
-declare const updateBlog: _keystrokehq_core0.Operation<z.ZodObject<{
-  title: z.ZodOptional<z.ZodString>;
-  handle: z.ZodOptional<z.ZodString>;
-  templateSuffix: z.ZodOptional<z.ZodString>;
-  commentPolicy: z.ZodOptional<z.ZodEnum<{
-    DISABLED: "DISABLED";
-    HIDDEN: "HIDDEN";
-    MODERATED: "MODERATED";
-    OPEN: "OPEN";
-  }>>;
-  id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  id: z.ZodString;
-  title: z.ZodString;
-  handle: z.ZodString;
-  createdAt: z.ZodOptional<z.ZodISODateTime>;
-  updatedAt: z.ZodOptional<z.ZodISODateTime>;
-  commentPolicy: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-  templateSuffix: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"keystroke:shopify", z.ZodObject<{
-  SHOPIFY_STORE_DOMAIN: z.ZodString;
-  SHOPIFY_ACCESS_TOKEN: z.ZodString;
-}, z.core.$strip>>], undefined>;
-declare const deleteBlog: _keystrokehq_core0.Operation<z.ZodObject<{
-  id: z.ZodString;
-}, z.core.$strip>, z.ZodObject<{
-  deletedBlogId: z.ZodString;
-}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"keystroke:shopify", z.ZodObject<{
-  SHOPIFY_STORE_DOMAIN: z.ZodString;
-  SHOPIFY_ACCESS_TOKEN: z.ZodString;
-}, z.core.$strip>>], undefined>;
-//#endregion
-export { createBlog, deleteBlog, getBlog, listBlogs, updateBlog };

package/dist/blogs.mjs

@@ -1,174 +0,0 @@
-import { shopifyBlogSchema, shopifyConnectionNodesSchema, shopifyGlobalIdSchema, shopifyUserErrorSchema } from "./schemas.mjs";
-import { createShopifyClient } from "./client.mjs";
-import { t as shopifyOperation } from "./factory-DwZJl9JC.mjs";
-import { n as omitUndefined, r as shopifyPageInputSchema, t as assertNoUserErrors } from "./operation-helpers-CKEDIx0o.mjs";
-import { z } from "zod";
-
-//#region src/blogs.ts
-const blogSelection = `
-  id
-  title
-  handle
-  createdAt
-  updatedAt
-  commentPolicy
-  templateSuffix
-`;
-const blogCommentPolicySchema = z.enum([
-	"DISABLED",
-	"HIDDEN",
-	"MODERATED",
-	"OPEN"
-]);
-const blogMutationInputSchema = z.object({
-	title: z.string().min(1).optional(),
-	handle: z.string().min(1).optional(),
-	templateSuffix: z.string().optional(),
-	commentPolicy: blogCommentPolicySchema.optional()
-});
-const blogMutationResponseSchema = z.object({
-	blog: shopifyBlogSchema.nullable(),
-	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
-});
-const listBlogsResponseSchema = z.object({ blogs: shopifyConnectionNodesSchema(shopifyBlogSchema) });
-const getBlogResponseSchema = z.object({ blog: shopifyBlogSchema.nullable() });
-const deleteBlogResponseSchema = z.object({
-	deletedBlogId: shopifyGlobalIdSchema.nullable(),
-	userErrors: z.array(shopifyUserErrorSchema.extend({ code: z.string().optional() }))
-});
-const listBlogs = shopifyOperation({
-	id: "shopify.list-shopify-blogs",
-	name: "List Shopify Blogs",
-	description: "List blogs from the connected Shopify store.",
-	input: shopifyPageInputSchema,
-	output: shopifyConnectionNodesSchema(shopifyBlogSchema),
-	run: async (input, credentials) => {
-		return (await createShopifyClient(credentials).graphql(`
-        query ListBlogs($first: Int!, $after: String, $query: String) {
-          blogs(first: $first, after: $after, query: $query) {
-            nodes {
-              ${blogSelection}
-            }
-            pageInfo {
-              hasNextPage
-              hasPreviousPage
-              startCursor
-              endCursor
-            }
-          }
-        }
-      `, listBlogsResponseSchema, { variables: {
-			first: input.first,
-			...input.after ? { after: input.after } : {},
-			...input.query ? { query: input.query } : {}
-		} })).blogs;
-	}
-});
-const getBlog = shopifyOperation({
-	id: "shopify.get-shopify-blog",
-	name: "Get Shopify Blog",
-	description: "Retrieve a single Shopify blog by its global ID.",
-	input: z.object({ id: shopifyGlobalIdSchema }),
-	output: shopifyBlogSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        query GetBlog($id: ID!) {
-          blog(id: $id) {
-            ${blogSelection}
-          }
-        }
-      `, getBlogResponseSchema, { variables: { id: input.id } });
-		if (!response.blog) throw new Error(`Shopify blog not found: ${input.id}`);
-		return response.blog;
-	}
-});
-const createBlog = shopifyOperation({
-	id: "shopify.create-shopify-blog",
-	name: "Create Shopify Blog",
-	description: "Create a blog in the connected Shopify store.",
-	needsApproval: true,
-	input: blogMutationInputSchema.extend({ title: z.string().min(1) }),
-	output: shopifyBlogSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation CreateBlog($blog: BlogCreateInput!) {
-          blogCreate(blog: $blog) {
-            blog {
-              ${blogSelection}
-            }
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ blogCreate: blogMutationResponseSchema }), { variables: { blog: omitUndefined(input) } });
-		assertNoUserErrors(response.blogCreate.userErrors);
-		if (!response.blogCreate.blog) throw new Error("Shopify did not return the created blog.");
-		return response.blogCreate.blog;
-	}
-});
-const updateBlog = shopifyOperation({
-	id: "shopify.update-shopify-blog",
-	name: "Update Shopify Blog",
-	description: "Update a Shopify blog by its global ID.",
-	needsApproval: true,
-	input: blogMutationInputSchema.extend({ id: shopifyGlobalIdSchema }),
-	output: shopifyBlogSchema,
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation UpdateBlog($id: ID!, $blog: BlogUpdateInput!) {
-          blogUpdate(id: $id, blog: $blog) {
-            blog {
-              ${blogSelection}
-            }
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ blogUpdate: blogMutationResponseSchema }), { variables: {
-			id: input.id,
-			blog: omitUndefined({
-				title: input.title,
-				handle: input.handle,
-				templateSuffix: input.templateSuffix,
-				commentPolicy: input.commentPolicy
-			})
-		} });
-		assertNoUserErrors(response.blogUpdate.userErrors);
-		if (!response.blogUpdate.blog) throw new Error(`Shopify did not return the updated blog: ${input.id}`);
-		return response.blogUpdate.blog;
-	}
-});
-const deleteBlog = shopifyOperation({
-	id: "shopify.delete-shopify-blog",
-	name: "Delete Shopify Blog",
-	description: "Delete a Shopify blog by its global ID.",
-	needsApproval: true,
-	input: z.object({ id: shopifyGlobalIdSchema }),
-	output: z.object({ deletedBlogId: shopifyGlobalIdSchema }),
-	run: async (input, credentials) => {
-		const response = await createShopifyClient(credentials).graphql(`
-        mutation DeleteBlog($id: ID!) {
-          blogDelete(id: $id) {
-            deletedBlogId
-            userErrors {
-              code
-              field
-              message
-            }
-          }
-        }
-      `, z.object({ blogDelete: deleteBlogResponseSchema }), { variables: { id: input.id } });
-		assertNoUserErrors(response.blogDelete.userErrors);
-		if (!response.blogDelete.deletedBlogId) throw new Error(`Shopify did not confirm blog deletion: ${input.id}`);
-		return { deletedBlogId: response.blogDelete.deletedBlogId };
-	}
-});
-
-//#endregion
-export { createBlog, deleteBlog, getBlog, listBlogs, updateBlog };

package/dist/client.d.mts

@@ -1,22 +0,0 @@
-import { t as ShopifyCredentials } from "./integration-DrHCkXco.mjs";
-import { z } from "zod";
-import { ClientResponse, SearchParams } from "@shopify/admin-api-client";
-
-//#region src/client.d.ts
-type ShopifyRestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE';
-interface ShopifyGraphqlRequestOptions {
-  readonly variables?: Record<string, unknown>;
-}
-interface ShopifyRestRequestOptions {
-  readonly data?: Record<string, unknown> | string;
-  readonly searchParams?: SearchParams;
-  readonly headers?: Record<string, string | number | string[]>;
-}
-interface ShopifyClient {
-  rawGraphql<TData>(query: string, variables?: Record<string, unknown>): Promise<ClientResponse<TData>>;
-  graphql<TSchema extends z.ZodTypeAny>(query: string, schema: TSchema, options?: ShopifyGraphqlRequestOptions): Promise<z.output<TSchema>>;
-  rest<TSchema extends z.ZodTypeAny>(method: ShopifyRestMethod, path: string, schema: TSchema, options?: ShopifyRestRequestOptions): Promise<z.output<TSchema>>;
-}
-declare function createShopifyClient(credentials: ShopifyCredentials): ShopifyClient;
-//#endregion
-export { ShopifyClient, ShopifyGraphqlRequestOptions, ShopifyRestMethod, ShopifyRestRequestOptions, createShopifyClient };

package/dist/client.mjs

@@ -1,90 +0,0 @@
-import { t as shopify } from "./integration-B5LK_0eR.mjs";
-import { shopifyGraphqlErrorSchema } from "./schemas.mjs";
-import { CredentialRevokedError } from "@keystrokehq/core/errors";
-import { createAdminApiClient, createAdminRestApiClient } from "@shopify/admin-api-client";
-
-//#region src/client.ts
-const DEFAULT_SHOPIFY_API_VERSION = "2025-01";
-function normalizeShopifyError(error, methodPath) {
-	if (error instanceof CredentialRevokedError) return error;
-	if (error instanceof Error) {
-		const maybeStatus = error;
-		const status = maybeStatus.status ?? maybeStatus.response?.status;
-		if (status === 401 || status === 403) return new CredentialRevokedError(shopify.id, `Shopify authentication failed while calling \`${methodPath}\`. The stored credentials for ${shopify.id} may be revoked or expired.`);
-		if (status === 429) return new Error(`Shopify API throttled while calling \`${methodPath}\`: ${error.message}`, { cause: error });
-		return new Error(`Shopify API call failed while calling \`${methodPath}\`: ${error.message}`, { cause: error });
-	}
-	return /* @__PURE__ */ new Error(`Shopify API call failed while calling \`${methodPath}\`.`);
-}
-function createShopifyCredentialError(methodPath) {
-	return new CredentialRevokedError(shopify.id, `Shopify authentication failed while calling \`${methodPath}\`. The stored credentials for ${shopify.id} may be revoked or expired.`);
-}
-function assertGraphqlSuccess(response, methodPath) {
-	const status = response.errors?.networkStatusCode;
-	if (status === 401 || status === 403) throw createShopifyCredentialError(methodPath);
-	if (status === 429) throw new Error(`Shopify API throttled while calling \`${methodPath}\`: ${response.errors?.message ?? "rate limited"}`);
-	if (response.errors?.graphQLErrors?.length) {
-		const messages = response.errors.graphQLErrors.map((error) => shopifyGraphqlErrorSchema.parse(error).message).join("; ");
-		throw new Error(`Shopify GraphQL errors while calling \`${methodPath}\`: ${messages}`);
-	}
-	if (response.errors?.message) throw new Error(`Shopify API call failed while calling \`${methodPath}\`: ${response.errors.message}`);
-	if (response.data === void 0) throw new Error(`Shopify API call returned no data while calling \`${methodPath}\`.`);
-}
-async function parseRestResponse(response, schema, methodPath) {
-	if (response.status === 401 || response.status === 403) throw createShopifyCredentialError(methodPath);
-	if (response.status === 429) throw new Error(`Shopify API throttled while calling \`${methodPath}\`.`);
-	const payload = response.status === 204 ? null : await response.json();
-	if (!response.ok) throw new Error(`Shopify REST API call failed while calling \`${methodPath}\`: HTTP ${response.status}`);
-	return schema.parse(payload);
-}
-function createShopifyClient(credentials) {
-	const graphqlClient = createAdminApiClient({
-		storeDomain: credentials.SHOPIFY_STORE_DOMAIN,
-		accessToken: credentials.SHOPIFY_ACCESS_TOKEN,
-		apiVersion: DEFAULT_SHOPIFY_API_VERSION
-	});
-	const restClient = createAdminRestApiClient({
-		storeDomain: credentials.SHOPIFY_STORE_DOMAIN,
-		accessToken: credentials.SHOPIFY_ACCESS_TOKEN,
-		apiVersion: DEFAULT_SHOPIFY_API_VERSION
-	});
-	async function rawGraphql(query, variables) {
-		try {
-			return await graphqlClient.request(query, { variables });
-		} catch (error) {
-			throw normalizeShopifyError(error, "graphql");
-		}
-	}
-	async function graphql(query, schema, options) {
-		const response = await rawGraphql(query, options?.variables);
-		assertGraphqlSuccess(response, "graphql");
-		return schema.parse(response.data);
-	}
-	async function rest(method, path, schema, options) {
-		const methodPath = `${method} ${path}`;
-		try {
-			switch (method) {
-				case "GET": return await parseRestResponse(await restClient.get(path, options), schema, methodPath);
-				case "POST": return await parseRestResponse(await restClient.post(path, {
-					...options,
-					data: options?.data ?? {}
-				}), schema, methodPath);
-				case "PUT": return await parseRestResponse(await restClient.put(path, {
-					...options,
-					data: options?.data ?? {}
-				}), schema, methodPath);
-				case "DELETE": return await parseRestResponse(await restClient.delete(path, options), schema, methodPath);
-			}
-		} catch (error) {
-			throw normalizeShopifyError(error, methodPath);
-		}
-	}
-	return {
-		rawGraphql,
-		graphql,
-		rest
-	};
-}
-
-//#endregion
-export { createShopifyClient };