@keystrokehq/shopify 0.0.1

package/dist/collections.mjs

@@ -0,0 +1,209 @@
+import { shopifyCollectionSchema, shopifyConnectionNodesSchema, shopifyGlobalIdSchema, shopifyJobSchema, shopifyUserErrorSchema } from "./schemas.mjs";
+import { createShopifyClient } from "./client.mjs";
+import { t as shopifyOperation } from "./factory-DC-gY8L0.mjs";
+import { i as shopifyProductIdsInputSchema, n as omitUndefined, r as shopifyPageInputSchema, t as assertNoUserErrors } from "./operation-helpers-CKEDIx0o.mjs";
+import { z } from "zod";
+
+//#region src/collections.ts
+const collectionSelection = `
+  id
+  title
+  handle
+  descriptionHtml
+  updatedAt
+  image {
+    url
+    altText
+  }
+  seo {
+    title
+    description
+  }
+`;
+const collectionMutationInputSchema = z.object({
+	title: z.string().min(1).optional(),
+	handle: z.string().min(1).optional(),
+	descriptionHtml: z.string().optional(),
+	seo: z.object({
+		title: z.string().optional(),
+		description: z.string().optional()
+	}).optional()
+});
+const collectionMutationResponseSchema = z.object({
+	collection: shopifyCollectionSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listCollectionsResponseSchema = z.object({ collections: shopifyConnectionNodesSchema(shopifyCollectionSchema) });
+const getCollectionResponseSchema = z.object({ collection: shopifyCollectionSchema.nullable() });
+const deleteCollectionResponseSchema = z.object({
+	deletedCollectionId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const removeProductsResponseSchema = z.object({
+	job: shopifyJobSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listCollections = shopifyOperation({
+	id: "list_shopify_collections",
+	name: "List Shopify Collections",
+	description: "List collections from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyCollectionSchema),
+	run: async (input, credentials) => {
+		return (await createShopifyClient(credentials).graphql(`
+        query ListCollections($first: Int!, $after: String, $query: String) {
+          collections(first: $first, after: $after, query: $query) {
+            nodes {
+              ${collectionSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listCollectionsResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).collections;
+	}
+});
+const getCollection = shopifyOperation({
+	id: "get_shopify_collection",
+	name: "Get Shopify Collection",
+	description: "Retrieve a single Shopify collection by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyCollectionSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetCollection($id: ID!) {
+          collection(id: $id) {
+            ${collectionSelection}
+          }
+        }
+      `, getCollectionResponseSchema, { variables: { id: input.id } });
+		if (!response.collection) throw new Error(`Shopify collection not found: ${input.id}`);
+		return response.collection;
+	}
+});
+const createCollection = shopifyOperation({
+	id: "create_shopify_collection",
+	name: "Create Shopify Collection",
+	description: "Create a collection in the connected Shopify store.",
+	needsApproval: true,
+	input: collectionMutationInputSchema.extend({ title: z.string().min(1) }),
+	output: shopifyCollectionSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation CreateCollection($input: CollectionInput!) {
+          collectionCreate(input: $input) {
+            collection {
+              ${collectionSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionCreate: collectionMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.collectionCreate.userErrors);
+		if (!response.collectionCreate.collection) throw new Error("Shopify did not return the created collection.");
+		return response.collectionCreate.collection;
+	}
+});
+const deleteCollection = shopifyOperation({
+	id: "delete_shopify_collection",
+	name: "Delete Shopify Collection",
+	description: "Delete a Shopify collection by its global ID.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedCollectionId: shopifyGlobalIdSchema }),
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation DeleteCollection($input: CollectionDeleteInput!) {
+          collectionDelete(input: $input) {
+            deletedCollectionId
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionDelete: deleteCollectionResponseSchema }), { variables: { input: { id: input.id } } });
+		assertNoUserErrors(response.collectionDelete.userErrors);
+		if (!response.collectionDelete.deletedCollectionId) throw new Error(`Shopify did not confirm collection deletion: ${input.id}`);
+		return { deletedCollectionId: response.collectionDelete.deletedCollectionId };
+	}
+});
+const addProductsToCollection = shopifyOperation({
+	id: "add_products_to_shopify_collection",
+	name: "Add Products To Shopify Collection",
+	description: "Add products to a manual Shopify collection.",
+	needsApproval: true,
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		productIds: shopifyProductIdsInputSchema
+	}),
+	output: shopifyCollectionSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation AddProductsToCollection($id: ID!, $productIds: [ID!]!) {
+          collectionAddProducts(id: $id, productIds: $productIds) {
+            collection {
+              ${collectionSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionAddProducts: collectionMutationResponseSchema }), { variables: {
+			id: input.id,
+			productIds: input.productIds
+		} });
+		assertNoUserErrors(response.collectionAddProducts.userErrors);
+		if (!response.collectionAddProducts.collection) throw new Error(`Shopify did not return the updated collection: ${input.id}`);
+		return response.collectionAddProducts.collection;
+	}
+});
+const removeProductsFromCollection = shopifyOperation({
+	id: "remove_products_from_shopify_collection",
+	name: "Remove Products From Shopify Collection",
+	description: "Remove products from a manual Shopify collection.",
+	needsApproval: true,
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		productIds: shopifyProductIdsInputSchema
+	}),
+	output: shopifyJobSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation RemoveProductsFromCollection($id: ID!, $productIds: [ID!]!) {
+          collectionRemoveProducts(id: $id, productIds: $productIds) {
+            job {
+              id
+              done
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ collectionRemoveProducts: removeProductsResponseSchema }), { variables: {
+			id: input.id,
+			productIds: input.productIds
+		} });
+		assertNoUserErrors(response.collectionRemoveProducts.userErrors);
+		if (!response.collectionRemoveProducts.job) throw new Error(`Shopify did not return a removal job for collection: ${input.id}`);
+		return response.collectionRemoveProducts.job;
+	}
+});
+
+//#endregion
+export { addProductsToCollection, createCollection, deleteCollection, getCollection, listCollections, removeProductsFromCollection };

package/dist/connection.d.mts

@@ -0,0 +1,2 @@
+import { n as shopify, t as ShopifyCredentials } from "./integration-BwDBsGX-.mjs";
+export { type ShopifyCredentials, shopify };

package/dist/connection.mjs

@@ -0,0 +1,3 @@
+import { t as shopify } from "./integration-BN3pjCz4.mjs";
+
+export { shopify };

package/dist/customers.d.mts

@@ -0,0 +1,161 @@
+import { z } from "zod";
+import * as _keystrokehq_core0 from "@keystrokehq/core";
+import * as _keystrokehq_core_credential_set0 from "@keystrokehq/core/credential-set";
+
+//#region src/customers.d.ts
+declare const listCustomers: _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;
+    displayName: z.ZodString;
+    firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+  }, 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<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getCustomer: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  displayName: z.ZodString;
+  firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+  phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  createdAt: z.ZodOptional<z.ZodISODateTime>;
+  updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const createCustomer: _keystrokehq_core0.Operation<z.ZodObject<{
+  email: z.ZodOptional<z.ZodEmail>;
+  firstName: z.ZodOptional<z.ZodString>;
+  lastName: z.ZodOptional<z.ZodString>;
+  phone: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  displayName: z.ZodString;
+  firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+  phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  createdAt: z.ZodOptional<z.ZodISODateTime>;
+  updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const updateCustomer: _keystrokehq_core0.Operation<z.ZodObject<{
+  email: z.ZodOptional<z.ZodEmail>;
+  firstName: z.ZodOptional<z.ZodString>;
+  lastName: z.ZodOptional<z.ZodString>;
+  phone: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  displayName: z.ZodString;
+  firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+  phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  createdAt: z.ZodOptional<z.ZodISODateTime>;
+  updatedAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const deleteCustomer: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  deletedCustomerId: z.ZodString;
+}, z.core.$strip>, readonly [_keystrokehq_core0.CredentialSet<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+declare const getCustomerOrders: _keystrokehq_core0.Operation<z.ZodObject<{
+  id: z.ZodString;
+  first: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  after: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodISODateTime>;
+    updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodNullable<z.ZodISODateTime>>;
+    email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    displayFinancialStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    displayFulfillmentStatus: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    currentTotalPriceSet: z.ZodOptional<z.ZodObject<{
+      shopMoney: z.ZodObject<{
+        amount: z.ZodString;
+        currencyCode: z.ZodString;
+      }, z.core.$strip>;
+      presentmentMoney: z.ZodOptional<z.ZodObject<{
+        amount: z.ZodString;
+        currencyCode: z.ZodString;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    customer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+      id: z.ZodString;
+      displayName: z.ZodString;
+      firstName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      lastName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+      phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      createdAt: z.ZodOptional<z.ZodISODateTime>;
+      updatedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strip>>>;
+  }, 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<"shopify", z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>, readonly _keystrokehq_core_credential_set0.CredentialConnection<z.ZodObject<{
+  SHOPIFY_STORE_DOMAIN: z.ZodString;
+  SHOPIFY_ACCESS_TOKEN: z.ZodString;
+}, z.core.$strip>>[] | undefined>], undefined>;
+//#endregion
+export { createCustomer, deleteCustomer, getCustomer, getCustomerOrders, listCustomers, updateCustomer };

package/dist/customers.mjs

@@ -0,0 +1,225 @@
+import { shopifyConnectionNodesSchema, shopifyCustomerSchema, shopifyGlobalIdSchema, shopifyOrderSchema, shopifyUserErrorSchema } from "./schemas.mjs";
+import { createShopifyClient } from "./client.mjs";
+import { t as shopifyOperation } from "./factory-DC-gY8L0.mjs";
+import { n as omitUndefined, r as shopifyPageInputSchema, t as assertNoUserErrors } from "./operation-helpers-CKEDIx0o.mjs";
+import { z } from "zod";
+
+//#region src/customers.ts
+const customerSelection = `
+  id
+  displayName
+  firstName
+  lastName
+  email
+  phone
+  createdAt
+  updatedAt
+`;
+const orderSelection = `
+  id
+  name
+  createdAt
+  updatedAt
+  cancelledAt
+  email
+  note
+  tags
+  displayFinancialStatus
+  displayFulfillmentStatus
+  currentTotalPriceSet {
+    shopMoney {
+      amount
+      currencyCode
+    }
+  }
+  customer {
+    id
+    displayName
+    firstName
+    lastName
+    email
+    phone
+    createdAt
+    updatedAt
+  }
+`;
+const customerMutationInputSchema = z.object({
+	email: z.email().optional(),
+	firstName: z.string().optional(),
+	lastName: z.string().optional(),
+	phone: z.string().optional(),
+	note: z.string().optional(),
+	tags: z.array(z.string()).optional()
+});
+const customerMutationResponseSchema = z.object({
+	customer: shopifyCustomerSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const listCustomersResponseSchema = z.object({ customers: shopifyConnectionNodesSchema(shopifyCustomerSchema) });
+const getCustomerResponseSchema = z.object({ customer: shopifyCustomerSchema.nullable() });
+const customerDeleteResponseSchema = z.object({
+	deletedCustomerId: shopifyGlobalIdSchema.nullable(),
+	userErrors: z.array(shopifyUserErrorSchema)
+});
+const customerOrdersResponseSchema = z.object({ customer: z.object({ orders: shopifyConnectionNodesSchema(shopifyOrderSchema) }).nullable() });
+const listCustomers = shopifyOperation({
+	id: "list_shopify_customers",
+	name: "List Shopify Customers",
+	description: "List customers from the connected Shopify store.",
+	input: shopifyPageInputSchema,
+	output: shopifyConnectionNodesSchema(shopifyCustomerSchema),
+	run: async (input, credentials) => {
+		return (await createShopifyClient(credentials).graphql(`
+        query ListCustomers($first: Int!, $after: String, $query: String) {
+          customers(first: $first, after: $after, query: $query) {
+            nodes {
+              ${customerSelection}
+            }
+            pageInfo {
+              hasNextPage
+              hasPreviousPage
+              startCursor
+              endCursor
+            }
+          }
+        }
+      `, listCustomersResponseSchema, { variables: {
+			first: input.first,
+			...input.after ? { after: input.after } : {},
+			...input.query ? { query: input.query } : {}
+		} })).customers;
+	}
+});
+const getCustomer = shopifyOperation({
+	id: "get_shopify_customer",
+	name: "Get Shopify Customer",
+	description: "Retrieve a single Shopify customer by its global ID.",
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: shopifyCustomerSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetCustomer($id: ID!) {
+          customer(id: $id) {
+            ${customerSelection}
+          }
+        }
+      `, getCustomerResponseSchema, { variables: { id: input.id } });
+		if (!response.customer) throw new Error(`Shopify customer not found: ${input.id}`);
+		return response.customer;
+	}
+});
+const createCustomer = shopifyOperation({
+	id: "create_shopify_customer",
+	name: "Create Shopify Customer",
+	description: "Create a customer in the connected Shopify store.",
+	needsApproval: true,
+	input: customerMutationInputSchema.refine((input) => input.email !== void 0 || input.phone !== void 0 || input.firstName !== void 0, { message: "At least one identifying customer field must be provided." }),
+	output: shopifyCustomerSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation CreateCustomer($input: CustomerInput!) {
+          customerCreate(input: $input) {
+            customer {
+              ${customerSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerCreate: customerMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.customerCreate.userErrors);
+		if (!response.customerCreate.customer) throw new Error("Shopify did not return the created customer.");
+		return response.customerCreate.customer;
+	}
+});
+const updateCustomer = shopifyOperation({
+	id: "update_shopify_customer",
+	name: "Update Shopify Customer",
+	description: "Update a Shopify customer by its global ID.",
+	needsApproval: true,
+	input: customerMutationInputSchema.extend({ id: shopifyGlobalIdSchema }),
+	output: shopifyCustomerSchema,
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation UpdateCustomer($input: CustomerInput!) {
+          customerUpdate(input: $input) {
+            customer {
+              ${customerSelection}
+            }
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerUpdate: customerMutationResponseSchema }), { variables: { input: omitUndefined(input) } });
+		assertNoUserErrors(response.customerUpdate.userErrors);
+		if (!response.customerUpdate.customer) throw new Error(`Shopify did not return the updated customer: ${input.id}`);
+		return response.customerUpdate.customer;
+	}
+});
+const deleteCustomer = shopifyOperation({
+	id: "delete_shopify_customer",
+	name: "Delete Shopify Customer",
+	description: "Delete a Shopify customer who has no placed orders.",
+	needsApproval: true,
+	input: z.object({ id: shopifyGlobalIdSchema }),
+	output: z.object({ deletedCustomerId: shopifyGlobalIdSchema }),
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        mutation DeleteCustomer($id: ID!) {
+          customerDelete(input: { id: $id }) {
+            deletedCustomerId
+            userErrors {
+              field
+              message
+            }
+          }
+        }
+      `, z.object({ customerDelete: customerDeleteResponseSchema }), { variables: { id: input.id } });
+		assertNoUserErrors(response.customerDelete.userErrors);
+		if (!response.customerDelete.deletedCustomerId) throw new Error(`Shopify did not confirm customer deletion: ${input.id}`);
+		return { deletedCustomerId: response.customerDelete.deletedCustomerId };
+	}
+});
+const getCustomerOrders = shopifyOperation({
+	id: "get_shopify_customer_orders",
+	name: "Get Shopify Customer Orders",
+	description: "Retrieve orders for a specific Shopify customer.",
+	input: z.object({
+		id: shopifyGlobalIdSchema,
+		first: z.number().int().min(1).max(100).optional().default(25),
+		after: z.string().optional()
+	}),
+	output: shopifyConnectionNodesSchema(shopifyOrderSchema),
+	run: async (input, credentials) => {
+		const response = await createShopifyClient(credentials).graphql(`
+        query GetCustomerOrders($id: ID!, $first: Int!, $after: String) {
+          customer(id: $id) {
+            orders(first: $first, after: $after) {
+              nodes {
+                ${orderSelection}
+              }
+              pageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+              }
+            }
+          }
+        }
+      `, customerOrdersResponseSchema, { variables: {
+			id: input.id,
+			first: input.first,
+			...input.after ? { after: input.after } : {}
+		} });
+		if (!response.customer) throw new Error(`Shopify customer not found for orders lookup: ${input.id}`);
+		return response.customer.orders;
+	}
+});
+
+//#endregion
+export { createCustomer, deleteCustomer, getCustomer, getCustomerOrders, listCustomers, updateCustomer };