@ehrenkind/shopify-lib 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -31,19 +31,35 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   ShopifyUserError: () => ShopifyUserError,
+  bulkUpdateProductVariants: () => bulkUpdateProductVariants,
+  calculateRefund: () => calculateRefund,
   cancelOrderById: () => cancelOrderById,
+  createFile: () => createFile,
+  createFulfillment: () => createFulfillment,
+  createMetaobjectDefinition: () => createMetaobjectDefinition,
+  createRefund: () => createRefund,
   deleteCustomerById: () => deleteCustomerById,
+  deleteFilesByIds: () => deleteFilesByIds,
+  getAllProductVariants: () => getAllProductVariants,
+  getCustomerSegmentMembers: () => getCustomerSegmentMembers,
+  getCustomersByEmail: () => getCustomersByEmail,
+  getFulfillmentById: () => getFulfillmentById,
+  getFulfillmentOrdersByOrderId: () => getFulfillmentOrdersByOrderId,
+  getFulfillmentTrackingIds: () => getFulfillmentTrackingIds,
   getLeanProductVariants: () => getLeanProductVariants,
+  getMetaobjectByHandle: () => getMetaobjectByHandle,
   getOrderById: () => getOrderById,
   getOrderByName: () => getOrderByName,
+  getOrderCancellationInfoByName: () => getOrderCancellationInfoByName,
   getOrderPaymentDetailsById: () => getOrderPaymentDetailsById,
-  parseGid: () => parseGid
+  getOrdersByCustomerId: () => getOrdersByCustomerId,
+  getProductVariantsBySkus: () => getProductVariantsBySkus,
+  parseGid: () => parseGid,
+  updateFulfillmentTracking: () => updateFulfillmentTracking,
+  upsertMetaobject: () => upsertMetaobject
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/mutations/customers/deleteCustomerById.ts
-var import_zod3 = __toESM(require("zod"), 1);
-
 // src/utils/logger.ts
 var { env } = process;
 var gql = String.raw;
@@ -92,11 +108,16 @@ var logger = {
 };
 
 // src/utils/shopifyClient.ts
-var import_shopify_api = require("@shopify/shopify-api");
+var import_shopify_api2 = require("@shopify/shopify-api");
 var import_node = require("@shopify/shopify-api/adapters/node");
 var import_dotenv = __toESM(require("dotenv"), 1);
 var import_zod = require("zod");
+
+// src/utils/apiVersion.ts
+var import_shopify_api = require("@shopify/shopify-api");
 var SHOPIFY_API_VERSION = import_shopify_api.ApiVersion.April25;
+
+// src/utils/shopifyClient.ts
 import_dotenv.default.config();
 var envSchema = import_zod.z.object({
   SHOPIFY_API_KEY: import_zod.z.string({
@@ -116,23 +137,23 @@ var envSchema = import_zod.z.object({
 var mapLogLevelToShopifySeverity = (level) => {
   switch (level) {
     case "silent":
-      return import_shopify_api.LogSeverity.Error;
+      return import_shopify_api2.LogSeverity.Error;
     case "debug":
-      return import_shopify_api.LogSeverity.Debug;
+      return import_shopify_api2.LogSeverity.Debug;
     case "info":
-      return import_shopify_api.LogSeverity.Info;
+      return import_shopify_api2.LogSeverity.Info;
     case "warn":
-      return import_shopify_api.LogSeverity.Warning;
+      return import_shopify_api2.LogSeverity.Warning;
     case "error":
-      return import_shopify_api.LogSeverity.Error;
+      return import_shopify_api2.LogSeverity.Error;
     default:
-      return import_shopify_api.LogSeverity.Info;
+      return import_shopify_api2.LogSeverity.Info;
   }
 };
 var shopifyGraphqlClient;
 try {
   const env2 = envSchema.parse(process.env);
-  const shopify = (0, import_shopify_api.shopifyApi)({
+  const shopify = (0, import_shopify_api2.shopifyApi)({
     apiKey: env2.SHOPIFY_API_KEY,
     apiSecretKey: env2.SHOPIFY_API_SECRET,
     hostName: env2.SHOPIFY_API_HOSTNAME,
@@ -145,7 +166,7 @@ try {
       unstable_managedPricingSupport: false
     }
   });
-  const shopifySession = new import_shopify_api.Session({
+  const shopifySession = new import_shopify_api2.Session({
     id: `custom-session-${env2.SHOPIFY_API_HOSTNAME}`,
     shop: env2.SHOPIFY_API_HOSTNAME,
     state: "authenticated",
@@ -171,10 +192,11 @@ function convertIdIntoGid(id, type) {
   return `gid://shopify/${type}/${id}`;
 }
 var ShopifyUserError = class extends Error {
+  errors;
   constructor(message, errors) {
     super(message);
-    this.errors = errors;
     this.name = "ShopifyUserError";
+    this.errors = errors;
   }
 };
 async function fetchShopifyGraphql(params) {
@@ -237,27 +259,9 @@ async function makeRequest(query, variables) {
   return response.data;
 }
 
-// src/utils/zod.ts
-var import_zod2 = __toESM(require("zod"), 1);
-async function returnOutputParsed(data, Model) {
-  const parsed = await Model.safeParseAsync(data);
-  if (!parsed.success) {
-    if (parsed.error instanceof import_zod2.default.ZodError) {
-      const msg = JSON.stringify(parsed.error.format(), null, 2);
-      logger.error(msg);
-    } else {
-      logger.error("Failed to parse:", parsed.error);
-    }
-    throw new Error("Failed to parse product variants");
-  }
-  logger.info("Parsed data successfully");
-  return parsed.data;
-}
-
 // src/mutations/customers/deleteCustomerById.ts
-var DeleteCustomerByIdReturn = import_zod3.default.string().nullable();
 async function deleteCustomerById(customerId) {
-  const mutation2 = gql`#graphql
+  const mutation9 = gql`#graphql
     mutation customerDelete($input: CustomerDeleteInput!) {
       customerDelete(input: $input) {
         deletedCustomerId
@@ -272,7 +276,7 @@ async function deleteCustomerById(customerId) {
     input: { id: customerId }
   };
   const response = await fetchShopifyGraphql({
-    query: mutation2,
+    query: mutation9,
     variables,
     dataExtractor: (data) => {
       if (!data.customerDelete) {
@@ -286,14 +290,368 @@ async function deleteCustomerById(customerId) {
       };
     }
   });
-  return returnOutputParsed(
-    response[0]?.deletedCustomerId ?? null,
-    DeleteCustomerByIdReturn
+  return response[0]?.deletedCustomerId ?? void 0;
+}
+
+// src/mutations/files/deleteFilesByIds.ts
+async function deleteFilesByIds(fileIds) {
+  if (fileIds.length === 0) {
+    return [];
+  }
+  const mutation9 = gql`#graphql
+    mutation fileDelete($fileIds: [ID!]!) {
+      fileDelete(fileIds: $fileIds) {
+        deletedFileIds
+        userErrors {
+          code
+          field
+          message
+        }
+      }
+    }
+  `;
+  const variables = { fileIds };
+  const response = await fetchShopifyGraphql({
+    query: mutation9,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.fileDelete) {
+        throw new Error("GraphQL response missing 'fileDelete' field");
+      }
+      return {
+        nodes: [{ deletedFileIds: data.fileDelete.deletedFileIds ?? [] }],
+        userErrors: data.fileDelete.userErrors
+      };
+    }
+  });
+  return response[0]?.deletedFileIds ?? [];
+}
+
+// src/mutations/files/createFile.ts
+var mutation = gql`#graphql
+  mutation createFile($files: [FileCreateInput!]!) {
+    fileCreate(files: $files) {
+      files {
+        id
+      }
+      userErrors {
+        code
+        field
+        message
+      }
+    }
+  }
+`;
+async function createFile(url, altText, filename) {
+  if (!url.startsWith("https://")) {
+    throw new Error(
+      `Not a valid public URL (https://) provided for file (url: ${url}).`
+    );
+  }
+  logger.debug(`Creating file: ${filename}`);
+  const variables = {
+    files: [
+      {
+        originalSource: url,
+        alt: altText,
+        filename
+      }
+    ]
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.fileCreate) {
+        throw new Error("GraphQL response missing 'fileCreate' field");
+      }
+      const file = data.fileCreate.files?.[0];
+      return {
+        nodes: file ? [{ id: file.id }] : [],
+        userErrors: data.fileCreate.userErrors
+      };
+    }
+  });
+  const fileId = result[0]?.id;
+  if (!fileId) {
+    throw new Error("File creation returned no result");
+  }
+  logger.debug(`Successfully created file ${fileId}`);
+  return fileId;
+}
+
+// src/mutations/metaobjectDefinitions/createMetaobjectDefinition.ts
+var mutation2 = gql`#graphql
+  mutation createMetaobjectDefinition($definition: MetaobjectDefinitionCreateInput!) {
+    metaobjectDefinitionCreate(definition: $definition) {
+      metaobjectDefinition {
+        id
+        name
+        type
+      }
+      userErrors {
+        code
+        field
+        message
+      }
+    }
+  }
+`;
+async function createMetaobjectDefinition(input) {
+  logger.debug(`Creating metaobject definition with type: ${input.type}`);
+  const variables = {
+    definition: {
+      type: input.type,
+      name: input.name,
+      description: input.description,
+      displayNameKey: input.displayNameKey,
+      fieldDefinitions: input.fieldDefinitions
+    }
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation2,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.metaobjectDefinitionCreate) {
+        throw new Error(
+          "GraphQL response missing 'metaobjectDefinitionCreate' field"
+        );
+      }
+      const metaobjectDefinition = data.metaobjectDefinitionCreate.metaobjectDefinition;
+      if (!metaobjectDefinition) {
+        return {
+          nodes: [],
+          userErrors: data.metaobjectDefinitionCreate.userErrors
+        };
+      }
+      return {
+        nodes: [
+          {
+            id: metaobjectDefinition.id,
+            name: metaobjectDefinition.name,
+            type: metaobjectDefinition.type
+          }
+        ],
+        userErrors: data.metaobjectDefinitionCreate.userErrors
+      };
+    }
+  });
+  const definitionResult = result[0];
+  if (!definitionResult) {
+    throw new Error("Metaobject definition creation returned no result");
+  }
+  logger.debug(
+    `Successfully created metaobject definition ${definitionResult.id}`
+  );
+  return definitionResult;
+}
+
+// src/mutations/fulfillments/createFulfillment.ts
+var mutation3 = gql`#graphql
+  mutation createFulfillment($fulfillment: FulfillmentInput!) {
+    fulfillmentCreate(fulfillment: $fulfillment) {
+      fulfillment {
+        id
+        status
+        trackingInfo {
+          company
+          number
+        }
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+function toGid(id, type) {
+  if (typeof id === "string" && id.startsWith("gid://")) {
+    return id;
+  }
+  return `gid://shopify/${type}/${id}`;
+}
+async function createFulfillment(fulfillmentOrderId, fulfillmentOrderLineItems, options = {}) {
+  const {
+    trackingNumber,
+    carrier,
+    trackingUrl,
+    notifyCustomer = true
+  } = options;
+  const fulfillmentOrderGid = toGid(fulfillmentOrderId, "FulfillmentOrder");
+  logger.debug(`Creating fulfillment for order ${fulfillmentOrderGid}`);
+  const lineItems = fulfillmentOrderLineItems.map((item) => ({
+    id: toGid(item.id, "FulfillmentOrderLineItem"),
+    quantity: item.quantity
+  }));
+  const variables = {
+    fulfillment: {
+      lineItemsByFulfillmentOrder: [
+        {
+          fulfillmentOrderId: fulfillmentOrderGid,
+          ...lineItems.length > 0 ? { fulfillmentOrderLineItems: lineItems } : {}
+        }
+      ],
+      notifyCustomer,
+      ...trackingNumber ? {
+        trackingInfo: {
+          number: trackingNumber,
+          ...carrier ? { company: carrier } : {},
+          ...trackingUrl ? { url: trackingUrl } : {}
+        }
+      } : {}
+    }
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation3,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.fulfillmentCreate) {
+        throw new Error("GraphQL response missing 'fulfillmentCreate' field");
+      }
+      const fulfillment = data.fulfillmentCreate.fulfillment;
+      if (!fulfillment) {
+        return {
+          nodes: [],
+          userErrors: data.fulfillmentCreate.userErrors
+        };
+      }
+      return {
+        nodes: [
+          {
+            id: fulfillment.id,
+            status: fulfillment.status,
+            trackingInfo: fulfillment.trackingInfo.map((info) => ({
+              company: info.company ?? null,
+              number: info.number ?? null
+            }))
+          }
+        ],
+        userErrors: data.fulfillmentCreate.userErrors
+      };
+    }
+  });
+  const fulfillmentResult = result[0];
+  if (!fulfillmentResult) {
+    throw new Error("Fulfillment creation returned no result");
+  }
+  logger.debug(`Successfully created fulfillment ${fulfillmentResult.id}`);
+  return fulfillmentResult;
+}
+
+// src/queries/fulfillments/getFulfillmentTrackingIds.queries.ts
+var queryFulfillmentTrackingIds = gql`#graphql
+  query fulfillmentTrackingIds($id: ID!) {
+    fulfillment(id: $id) {
+      id
+      trackingInfo(first: 50) {
+        company
+        number
+      }
+    }
+  }
+`;
+
+// src/queries/fulfillments/getFulfillmentTrackingIds.ts
+async function getFulfillmentTrackingIds(id) {
+  const gid = typeof id === "string" ? id : convertIdIntoGid(
+    typeof id === "number" ? BigInt(id) : id,
+    "Fulfillment"
+  );
+  const variables = { id: gid };
+  const response = await fetchShopifyGraphql({
+    query: queryFulfillmentTrackingIds,
+    variables
+  });
+  if (!response.fulfillment) {
+    logger.debug(`No fulfillment found with ID: ${id}`);
+    return void 0;
+  }
+  const trackingInfo = response.fulfillment.trackingInfo;
+  const trackingNumbers = trackingInfo.map((info) => info.number).filter((num) => num != null);
+  const trackingCompany = trackingInfo[0]?.company ?? null;
+  return {
+    trackingNumbers,
+    trackingCompany
+  };
+}
+
+// src/mutations/fulfillments/updateFulfillmentTracking.ts
+var mutation4 = gql`#graphql
+  mutation updateFulfillmentTracking(
+    $fulfillmentId: ID!
+    $trackingNumbers: [String!]!
+    $company: String
+    $notifyCustomer: Boolean
+  ) {
+    fulfillmentTrackingInfoUpdate(
+      fulfillmentId: $fulfillmentId
+      trackingInfoInput: { numbers: $trackingNumbers, company: $company }
+      notifyCustomer: $notifyCustomer
+    ) {
+      fulfillment {
+        trackingInfo {
+          number
+          company
+        }
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+async function updateFulfillmentTracking(fulfillmentId, trackingNumber, notifyCustomer = false) {
+  const fulfillmentGid = typeof fulfillmentId === "string" ? fulfillmentId : convertIdIntoGid(
+    typeof fulfillmentId === "number" ? BigInt(fulfillmentId) : fulfillmentId,
+    "Fulfillment"
+  );
+  logger.debug(`Updating tracking for fulfillment ${fulfillmentGid}`);
+  const existingTracking = await getFulfillmentTrackingIds(fulfillmentGid);
+  if (!existingTracking) {
+    throw new Error(`Fulfillment not found: ${fulfillmentGid}`);
+  }
+  const updatedTrackingNumbers = existingTracking.trackingNumbers.includes(
+    trackingNumber
+  ) ? existingTracking.trackingNumbers : [...existingTracking.trackingNumbers, trackingNumber];
+  const variables = {
+    fulfillmentId: fulfillmentGid,
+    trackingNumbers: updatedTrackingNumbers,
+    ...existingTracking.trackingCompany ? { company: existingTracking.trackingCompany } : {},
+    notifyCustomer
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation4,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.fulfillmentTrackingInfoUpdate) {
+        throw new Error(
+          "GraphQL response missing 'fulfillmentTrackingInfoUpdate' field"
+        );
+      }
+      const fulfillment = data.fulfillmentTrackingInfoUpdate.fulfillment;
+      const trackingInfo = fulfillment?.trackingInfo ?? [];
+      const trackingNumbers = trackingInfo.map((info) => info.number).filter((num) => num != null);
+      const trackingCompany = trackingInfo[0]?.company ?? null;
+      return {
+        nodes: [{ trackingNumbers, trackingCompany }],
+        userErrors: data.fulfillmentTrackingInfoUpdate.userErrors
+      };
+    }
+  });
+  const trackingResult = result[0];
+  if (!trackingResult) {
+    throw new Error("Unexpected empty result from GraphQL mutation");
+  }
+  logger.debug(
+    `Successfully updated tracking for fulfillment ${fulfillmentGid}`
   );
+  return trackingResult;
 }
 
 // src/mutations/orders/cancelOrderById.ts
-var mutation = gql`#graphql
+var mutation5 = gql`#graphql
   mutation orderCancel($orderId: ID!) {
     orderCancel(
       orderId: $orderId
@@ -318,7 +676,7 @@ async function cancelOrderById(orderId) {
   logger.debug(`Cancelling order ${orderGid}`);
   const variables = { orderId: orderGid };
   await fetchShopifyGraphql({
-    query: mutation,
+    query: mutation5,
     variables,
     dataExtractor: (data) => {
       if (!data.orderCancel) {
@@ -334,68 +692,474 @@ async function cancelOrderById(orderId) {
   return true;
 }
 
-// src/queries/orders/getOrderById.ts
-var import_zod5 = __toESM(require("zod"), 1);
-
-// src/queries/orders/getOrderById.queries.ts
-var queryOrderById = gql`#graphql
-  query orderById($id: ID!) {
-    order(id: $id) {
-      id
-      name
-      createdAt
-      updatedAt
-      cancelledAt
-      cancelReason
-      totalPriceSet {
-        shopMoney {
-          amount
-          currencyCode
-        }
-      }
-      customer {
+// src/mutations/refunds/createRefund.ts
+var mutation6 = gql`#graphql
+  mutation createRefund($input: RefundInput!) {
+    refundCreate(input: $input) {
+      refund {
         id
-        lastName
-        defaultEmailAddress {
-          emailAddress
+        totalRefundedSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+          presentmentMoney {
+            amount
+            currencyCode
+          }
         }
-        displayName
-        firstName
       }
-      displayFinancialStatus
-      displayFulfillmentStatus
-      shippingAddress {
-        firstName
-        lastName
-        address1
-        address2
-        city
-        province
-        country
-        zip
+      userErrors {
+        field
+        message
       }
     }
   }
 `;
-var queryOrderByIdFull = gql`#graphql
-  query orderByIdFull($id: ID!) {
-    order(id: $id) {
-      id
-      name
-      createdAt
-      updatedAt
-      processedAt
-      closedAt
-      cancelledAt
-      cancelReason
-      totalPriceSet {
-        shopMoney {
-          amount
-          currencyCode
+function toGid2(id, type) {
+  if (typeof id === "string" && id.startsWith("gid://")) {
+    return id;
+  }
+  return `gid://shopify/${type}/${id}`;
+}
+async function createRefund(orderId, options = {}) {
+  const { currency, note, notify, refundLineItems, shipping, transactions } = options;
+  const orderGid = toGid2(orderId, "Order");
+  logger.debug(`Creating refund for order ${orderGid}`);
+  const variables = {
+    input: {
+      orderId: orderGid,
+      notify,
+      ...currency ? { currency } : {},
+      ...note ? { note } : {},
+      ...refundLineItems?.length ? {
+        refundLineItems: refundLineItems.map((item) => ({
+          lineItemId: toGid2(item.lineItemId, "LineItem"),
+          quantity: item.quantity,
+          ...item.restockType ? { restockType: item.restockType } : {},
+          ...item.locationId ? { locationId: toGid2(item.locationId, "Location") } : {}
+        }))
+      } : {},
+      ...shipping ? {
+        shipping: {
+          ...shipping.fullRefund !== void 0 ? { fullRefund: shipping.fullRefund } : {},
+          ...shipping.amount ? { amount: shipping.amount } : {}
         }
+      } : {},
+      ...transactions?.length ? {
+        transactions: transactions.map((t) => ({
+          amount: t.amount,
+          gateway: t.gateway,
+          kind: "REFUND" /* Refund */,
+          orderId: orderGid,
+          ...t.parentId ? { parentId: toGid2(t.parentId, "OrderTransaction") } : {}
+        }))
+      } : {}
+    }
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation6,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.refundCreate) {
+        throw new Error("GraphQL response missing 'refundCreate' field");
       }
-      customer {
-        id
+      const refund = data.refundCreate.refund;
+      if (!refund) {
+        return {
+          nodes: [],
+          userErrors: data.refundCreate.userErrors
+        };
+      }
+      return {
+        nodes: [
+          {
+            id: refund.id,
+            totalRefunded: {
+              shopMoney: {
+                amount: refund.totalRefundedSet.shopMoney.amount,
+                currencyCode: refund.totalRefundedSet.shopMoney.currencyCode
+              },
+              presentmentMoney: {
+                amount: refund.totalRefundedSet.presentmentMoney.amount,
+                currencyCode: refund.totalRefundedSet.presentmentMoney.currencyCode
+              }
+            }
+          }
+        ],
+        userErrors: data.refundCreate.userErrors
+      };
+    }
+  });
+  const refundResult = result[0];
+  if (!refundResult) {
+    throw new Error("Refund creation returned no result");
+  }
+  logger.debug(`Successfully created refund ${refundResult.id}`);
+  return refundResult;
+}
+
+// src/mutations/productVariantsBulkUpdate/bulkUpdateProductVariants.ts
+var mutation7 = gql`#graphql
+  mutation bulkUpdateProductVariants(
+    $productId: ID!
+    $variants: [ProductVariantsBulkInput!]!
+  ) {
+    productVariantsBulkUpdate(
+      productId: $productId
+      variants: $variants
+    ) {
+      productVariants {
+        id
+        sku
+      }
+      userErrors {
+        code
+        field
+        message
+      }
+    }
+  }
+`;
+async function bulkUpdateProductVariants(productId, variants) {
+  logger.debug(
+    `Bulk updating ${variants.length} variants for product ${productId}`
+  );
+  const variables = {
+    productId,
+    variants
+  };
+  const result = await fetchShopifyGraphql({
+    query: mutation7,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.productVariantsBulkUpdate) {
+        throw new Error(
+          "GraphQL response missing 'productVariantsBulkUpdate' field"
+        );
+      }
+      return {
+        nodes: (data.productVariantsBulkUpdate.productVariants ?? []).map(
+          (v) => ({
+            id: v.id,
+            sku: v.sku ?? null
+          })
+        ),
+        userErrors: data.productVariantsBulkUpdate.userErrors
+      };
+    }
+  });
+  logger.debug(`Successfully updated ${result.length} variants`);
+  return result;
+}
+
+// src/mutations/metaobjects/upsertMetaobject.ts
+var mutation8 = gql`#graphql
+  mutation upsertMetaobject(
+    $handle: MetaobjectHandleInput!
+    $metaobject: MetaobjectUpsertInput!
+  ) {
+    metaobjectUpsert(handle: $handle, metaobject: $metaobject) {
+      metaobject {
+        id
+        handle
+        displayName
+        fields {
+          key
+          value
+        }
+      }
+      userErrors {
+        code
+        field
+        message
+      }
+    }
+  }
+`;
+async function upsertMetaobject(input) {
+  const { type, handle, fields } = input;
+  logger.debug(`Upserting metaobject type=${type} handle=${handle}`);
+  const variables = {
+    handle: { type, handle },
+    metaobject: { fields }
+  };
+  const response = await fetchShopifyGraphql({
+    query: mutation8,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.metaobjectUpsert) {
+        throw new Error("GraphQL response missing 'metaobjectUpsert' field");
+      }
+      const { metaobject, userErrors } = data.metaobjectUpsert;
+      return {
+        nodes: metaobject ? [
+          {
+            id: metaobject.id,
+            handle: metaobject.handle,
+            displayName: metaobject.displayName,
+            fields: metaobject.fields.map((f) => ({
+              key: f.key,
+              value: f.value ?? null
+            }))
+          }
+        ] : [],
+        userErrors
+      };
+    }
+  });
+  const result = response[0];
+  if (!result) {
+    throw new Error("No metaobject returned from upsert operation");
+  }
+  logger.debug(`Metaobject upserted successfully: ${result.id}`);
+  return result;
+}
+
+// src/queries/orders/calculateRefund.queries.ts
+var querySuggestedRefund = gql`#graphql
+  query suggestedRefund(
+    $orderId: ID!
+    $refundLineItems: [RefundLineItemInput!]
+    $refundShipping: Boolean
+    $shippingAmount: Money
+    $suggestFullRefund: Boolean
+  ) {
+    order(id: $orderId) {
+      id
+      name
+      suggestedRefund(
+        refundLineItems: $refundLineItems
+        refundShipping: $refundShipping
+        shippingAmount: $shippingAmount
+        suggestFullRefund: $suggestFullRefund
+      ) {
+        amountSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        maximumRefundableSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        subtotalSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        totalTaxSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        discountedSubtotalSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        totalCartDiscountAmountSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+        }
+        shipping {
+          amountSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          maximumRefundableSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+        }
+        refundLineItems {
+          lineItem {
+            id
+            sku
+            title
+            quantity
+          }
+          quantity
+          priceSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          subtotalSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          totalTaxSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          restockType
+        }
+        suggestedTransactions {
+          gateway
+          kind
+          amountSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          maximumRefundableSet {
+            shopMoney {
+              amount
+              currencyCode
+            }
+          }
+          parentTransaction {
+            id
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/orders/calculateRefund.ts
+function convertLineItemIdToGid(id) {
+  if (typeof id === "string") {
+    return id.startsWith("gid://") ? id : `gid://shopify/LineItem/${id}`;
+  }
+  return `gid://shopify/LineItem/${id}`;
+}
+function mapRestockType(restockType) {
+  switch (restockType) {
+    case "CANCEL":
+      return "CANCEL" /* Cancel */;
+    case "RETURN":
+      return "RETURN" /* Return */;
+    default:
+      return "NO_RESTOCK" /* NoRestock */;
+  }
+}
+async function calculateRefund(orderId, options = {}) {
+  const orderGid = typeof orderId === "string" ? orderId : convertIdIntoGid(
+    typeof orderId === "number" ? BigInt(orderId) : orderId,
+    "Order"
+  );
+  const variables = {
+    orderId: orderGid,
+    refundLineItems: options.refundLineItems?.map((item) => ({
+      lineItemId: convertLineItemIdToGid(item.lineItemId),
+      quantity: item.quantity,
+      restockType: mapRestockType(item.restockType),
+      ...item.locationId ? { locationId: item.locationId } : {}
+    })),
+    refundShipping: options.refundShipping,
+    shippingAmount: options.shippingAmount,
+    suggestFullRefund: options.suggestFullRefund
+  };
+  const response = await fetchShopifyGraphql({
+    query: querySuggestedRefund,
+    variables
+  });
+  if (!response.order?.suggestedRefund) {
+    logger.debug(`No refund suggestion available for order: ${orderId}`);
+    return void 0;
+  }
+  return response.order.suggestedRefund;
+}
+
+// src/queries/orders/getOrderById.ts
+var import_zod3 = __toESM(require("zod"), 1);
+
+// src/utils/zod.ts
+var import_zod2 = __toESM(require("zod"), 1);
+async function returnOutputParsed(data, Model) {
+  const parsed = await Model.safeParseAsync(data);
+  if (!parsed.success) {
+    if (parsed.error instanceof import_zod2.default.ZodError) {
+      const msg = JSON.stringify(parsed.error.format(), null, 2);
+      logger.error(msg);
+    } else {
+      logger.error("Failed to parse:", parsed.error);
+    }
+    throw new Error("Failed to parse product variants");
+  }
+  logger.info("Parsed data successfully");
+  return parsed.data;
+}
+
+// src/queries/orders/getOrderById.queries.ts
+var queryOrderById = gql`#graphql
+  query orderById($id: ID!) {
+    order(id: $id) {
+      id
+      name
+      createdAt
+      updatedAt
+      cancelledAt
+      cancelReason
+      totalPriceSet {
+        shopMoney {
+          amount
+          currencyCode
+        }
+      }
+      customer {
+        id
+        lastName
+        defaultEmailAddress {
+          emailAddress
+        }
+        displayName
+        firstName
+      }
+      displayFinancialStatus
+      displayFulfillmentStatus
+      shippingAddress {
+        firstName
+        lastName
+        address1
+        address2
+        city
+        province
+        country
+        zip
+      }
+    }
+  }
+`;
+var queryOrderByIdFull = gql`#graphql
+  query orderByIdFull($id: ID!) {
+    order(id: $id) {
+      id
+      name
+      createdAt
+      updatedAt
+      processedAt
+      closedAt
+      cancelledAt
+      cancelReason
+      totalPriceSet {
+        shopMoney {
+          amount
+          currencyCode
+        }
+      }
+      customer {
+        id
         firstName
         lastName
         email
@@ -513,38 +1277,38 @@ var queryOrderByIdFull = gql`#graphql
 `;
 
 // src/queries/orders/getOrderById.ts
-var AddressSchema = import_zod5.default.object({
-  firstName: import_zod5.default.string().nullable(),
-  lastName: import_zod5.default.string().nullable(),
-  address1: import_zod5.default.string().nullable(),
-  address2: import_zod5.default.string().nullable(),
-  city: import_zod5.default.string().nullable(),
-  province: import_zod5.default.string().nullable(),
-  country: import_zod5.default.string().nullable(),
-  zip: import_zod5.default.string().nullable()
+var AddressSchema = import_zod3.default.object({
+  firstName: import_zod3.default.string().nullable(),
+  lastName: import_zod3.default.string().nullable(),
+  address1: import_zod3.default.string().nullable(),
+  address2: import_zod3.default.string().nullable(),
+  city: import_zod3.default.string().nullable(),
+  province: import_zod3.default.string().nullable(),
+  country: import_zod3.default.string().nullable(),
+  zip: import_zod3.default.string().nullable()
 }).nullable();
-var GetLeanOrderByIdReturn = import_zod5.default.object({
-  id: import_zod5.default.string(),
-  name: import_zod5.default.string(),
-  createdAt: import_zod5.default.string(),
-  updatedAt: import_zod5.default.string(),
-  cancelledAt: import_zod5.default.string().nullable(),
-  cancelReason: import_zod5.default.string().nullable(),
-  totalPrice: import_zod5.default.object({
-    amount: import_zod5.default.string(),
-    currencyCode: import_zod5.default.string()
+var GetLeanOrderByIdReturn = import_zod3.default.object({
+  id: import_zod3.default.string(),
+  name: import_zod3.default.string(),
+  createdAt: import_zod3.default.string(),
+  updatedAt: import_zod3.default.string(),
+  cancelledAt: import_zod3.default.string().nullable(),
+  cancelReason: import_zod3.default.string().nullable(),
+  totalPrice: import_zod3.default.object({
+    amount: import_zod3.default.string(),
+    currencyCode: import_zod3.default.string()
   }),
-  customer: import_zod5.default.object({
-    id: import_zod5.default.string(),
-    displayName: import_zod5.default.string(),
-    firstName: import_zod5.default.string().nullable(),
-    lastName: import_zod5.default.string().nullable(),
-    emailAddress: import_zod5.default.string().nullable()
+  customer: import_zod3.default.object({
+    id: import_zod3.default.string(),
+    displayName: import_zod3.default.string(),
+    firstName: import_zod3.default.string().nullable(),
+    lastName: import_zod3.default.string().nullable(),
+    emailAddress: import_zod3.default.string().nullable()
   }).nullable(),
-  financialStatus: import_zod5.default.string().nullable(),
-  fulfillmentStatus: import_zod5.default.string().nullable(),
+  financialStatus: import_zod3.default.string().nullable(),
+  fulfillmentStatus: import_zod3.default.string().nullable(),
   shippingAddress: AddressSchema
-}).nullable();
+});
 async function getOrderById(id, detailLevel = "lean") {
   const bigIntId = typeof id === "number" ? BigInt(id) : id;
   if (detailLevel === "lean") {
@@ -562,7 +1326,7 @@ async function getLeanOrderById(id) {
   });
   if (!response.order) {
     logger.debug(`No order found with ID: ${id}`);
-    return null;
+    return void 0;
   }
   const order = response.order;
   const leanOrder = {
@@ -608,13 +1372,13 @@ async function getFullOrderById(id) {
   });
   if (!response.order) {
     logger.debug(`No order found with ID: ${id}`);
-    return null;
+    return void 0;
   }
   return response.order;
 }
 
 // src/queries/orders/getOrderByName.ts
-var import_zod7 = __toESM(require("zod"), 1);
+var import_zod5 = __toESM(require("zod"), 1);
 
 // src/queries/orders/getOrderByName.queries.ts
 var queryOrdersByName = gql`#graphql
@@ -952,23 +1716,23 @@ var queryOrdersByNameFull = gql`#graphql
 `;
 
 // src/queries/orders/getOrderByName.ts
-var GetLeanOrderByNameReturn = import_zod7.default.object({
-  id: import_zod7.default.string(),
-  name: import_zod7.default.string(),
-  createdAt: import_zod7.default.string(),
-  updatedAt: import_zod7.default.string(),
-  totalPrice: import_zod7.default.object({
-    amount: import_zod7.default.string(),
-    currencyCode: import_zod7.default.string()
+var GetLeanOrderByNameReturn = import_zod5.default.object({
+  id: import_zod5.default.string(),
+  name: import_zod5.default.string(),
+  createdAt: import_zod5.default.string(),
+  updatedAt: import_zod5.default.string(),
+  totalPrice: import_zod5.default.object({
+    amount: import_zod5.default.string(),
+    currencyCode: import_zod5.default.string()
   }),
-  customer: import_zod7.default.object({
-    id: import_zod7.default.string(),
-    displayName: import_zod7.default.string(),
-    emailAddress: import_zod7.default.string().nullable()
+  customer: import_zod5.default.object({
+    id: import_zod5.default.string(),
+    displayName: import_zod5.default.string(),
+    emailAddress: import_zod5.default.string().nullable()
   }).nullable(),
-  financialStatus: import_zod7.default.string().nullable(),
-  fulfillmentStatus: import_zod7.default.string().nullable()
-}).nullable();
+  financialStatus: import_zod5.default.string().nullable(),
+  fulfillmentStatus: import_zod5.default.string().nullable()
+});
 async function getOrderByName(orderName, detailLevel = "lean") {
   if (detailLevel === "lean") {
     return getLeanOrderByName(orderName);
@@ -1001,7 +1765,7 @@ async function getLeanOrderByName(orderName) {
   const order = extractedNodes[0];
   if (!order) {
     logger.debug(`No order found with name: ${orderName}`);
-    return null;
+    return void 0;
   }
   const leanOrder = {
     id: order.id,
@@ -1047,25 +1811,69 @@ async function getFullOrderByName(orderName) {
   });
   if (extractedNodes.length === 0) {
     logger.debug(`No order found with name: ${orderName}`);
-    return null;
+    return void 0;
   }
   const order = extractedNodes[0];
   if (!order) {
     logger.debug(`No order found with name: ${orderName}`);
-    return null;
+    return void 0;
+  }
+  return order;
+}
+
+// src/queries/orders/getOrderCancellationInfo.queries.ts
+var queryOrderCancellationInfoByName = gql`#graphql
+  query orderCancellationInfoByName($first: Int!, $queryFilter: String!) {
+    orders(first: $first, query: $queryFilter) {
+      edges {
+        node {
+          id
+          name
+          cancelledAt
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/orders/getOrderCancellationInfo.ts
+async function getOrderCancellationInfoByName(orderName) {
+  const variables = {
+    first: 1,
+    queryFilter: `name:${orderName}`
+  };
+  const response = await fetchShopifyGraphql({
+    query: queryOrderCancellationInfoByName,
+    variables
+  });
+  if (!response.orders) {
+    throw new Error(
+      "Invalid GraphQL response for getOrderCancellationInfoByName: 'orders' field is missing."
+    );
+  }
+  if (!Array.isArray(response.orders.edges)) {
+    throw new Error(
+      "Invalid GraphQL response for getOrderCancellationInfoByName: 'orders.edges' is not an array."
+    );
+  }
+  const firstEdge = response.orders.edges[0];
+  const order = firstEdge?.node;
+  if (!order) {
+    logger.debug(`No order found with name: ${orderName}`);
+    return void 0;
   }
   return order;
 }
 
 // src/queries/productVariants/getLeanProductVariants.ts
-var import_zod9 = __toESM(require("zod"), 1);
-var GetLeanProductVariantsReturn = import_zod9.default.array(
-  import_zod9.default.object({
-    productId: import_zod9.default.string(),
-    productTitle: import_zod9.default.string(),
-    variantId: import_zod9.default.string(),
-    variantTitle: import_zod9.default.string(),
-    sku: import_zod9.default.string()
+var import_zod7 = __toESM(require("zod"), 1);
+var GetLeanProductVariantsReturn = import_zod7.default.array(
+  import_zod7.default.object({
+    productId: import_zod7.default.string(),
+    productTitle: import_zod7.default.string(),
+    variantId: import_zod7.default.string(),
+    variantTitle: import_zod7.default.string(),
+    sku: import_zod7.default.string()
   })
 );
 async function getLeanProductVariants(skus) {
@@ -1133,9 +1941,182 @@ async function getLeanProductVariants(skus) {
   return await returnOutputParsed(allVariants, GetLeanProductVariantsReturn);
 }
 
-// src/queries/orders/getOrderPaymentDetails.ts
+// src/queries/productVariants/getProductVariantsBySkus.ts
+var import_zod9 = __toESM(require("zod"), 1);
+var GetProductVariantsBySkusReturn = import_zod9.default.array(
+  import_zod9.default.object({
+    productId: import_zod9.default.string(),
+    productTitle: import_zod9.default.string(),
+    variantId: import_zod9.default.string(),
+    variantTitle: import_zod9.default.string(),
+    sku: import_zod9.default.string(),
+    status: import_zod9.default.enum(["ACTIVE", "ARCHIVED", "DRAFT"])
+  })
+);
+async function getProductVariantsBySkus(skus, options) {
+  if (skus.length === 0) {
+    return [];
+  }
+  const queryGql = gql`#graphql
+    query productVariantsBySkus($first: Int!, $after: String, $queryFilter: String) {
+      productVariants(first: $first, after: $after, query: $queryFilter) {
+        edges {
+          node {
+            id
+            title
+            sku
+            product {
+              id
+              title
+              status
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `;
+  const skuFilter = skus.map((sku) => `sku:${sku}`).join(" OR ");
+  const statusFilter = options?.activeOnly ? "product_status:active,draft" : "";
+  const queryFilter = [skuFilter, statusFilter].filter(Boolean).join(" AND ");
+  const initialVariables = {
+    first: 250,
+    queryFilter
+  };
+  const extractedNodes = await fetchShopifyGraphql({
+    query: queryGql,
+    variables: initialVariables,
+    dataExtractor: (pageData) => {
+      if (!pageData.productVariants) {
+        throw new Error(
+          "GraphQL response for product variants is missing the 'productVariants' field."
+        );
+      }
+      const nodes = pageData.productVariants.edges.map(
+        (edge) => edge.node
+      );
+      return {
+        nodes,
+        pageInfo: pageData.productVariants.pageInfo
+      };
+    },
+    fetchAllPages: true
+  });
+  const allVariants = extractedNodes.flatMap((v) => {
+    if (!v.sku) {
+      logger.debug(
+        `Product ${v.product.title} (ID: ${v.product.id}) has a variant (ID: ${v.id}) with no SKU. Filtering out.`
+      );
+      return [];
+    }
+    return [
+      {
+        productId: v.product.id,
+        productTitle: v.product.title,
+        variantId: v.id,
+        variantTitle: v.title,
+        sku: v.sku,
+        status: v.product.status
+      }
+    ];
+  });
+  return await returnOutputParsed(allVariants, GetProductVariantsBySkusReturn);
+}
+
+// src/queries/productVariants/getAllProductVariants.ts
 var import_zod11 = __toESM(require("zod"), 1);
 
+// src/queries/productVariants/getAllProductVariants.queries.ts
+var queryAllProductVariants = gql`#graphql
+  query allProductVariants($first: Int!, $after: String) {
+    productVariants(first: $first, after: $after) {
+      edges {
+        node {
+          id
+          legacyResourceId
+          sku
+          barcode
+          inventoryQuantity
+          price
+          title
+          product {
+            status
+            title
+            description
+            handle
+            onlineStoreUrl
+            featuredImage {
+              url
+            }
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+
+// src/queries/productVariants/getAllProductVariants.ts
+var ProductVariantSchema = import_zod11.default.object({
+  status: import_zod11.default.enum(["ACTIVE", "ARCHIVED", "DRAFT"]),
+  sku: import_zod11.default.string(),
+  barcode: import_zod11.default.string().nullable(),
+  price: import_zod11.default.string(),
+  title: import_zod11.default.string(),
+  url: import_zod11.default.string().nullable(),
+  handle: import_zod11.default.string(),
+  description: import_zod11.default.string(),
+  imageUrl: import_zod11.default.string().nullable(),
+  inventoryQuantity: import_zod11.default.number()
+});
+var GetAllProductVariantsReturn = import_zod11.default.array(ProductVariantSchema);
+async function getAllProductVariants() {
+  const initialVariables = { first: 250 };
+  const extractedNodes = await fetchShopifyGraphql({
+    query: queryAllProductVariants,
+    variables: initialVariables,
+    dataExtractor: (pageData) => {
+      if (!pageData.productVariants) {
+        throw new Error(
+          "GraphQL response for product variants is missing the 'productVariants' field."
+        );
+      }
+      const nodes = pageData.productVariants.edges.map(
+        (edge) => edge.node
+      );
+      return {
+        nodes,
+        pageInfo: pageData.productVariants.pageInfo
+      };
+    },
+    fetchAllPages: true
+  });
+  logger.debug(`Fetched ${extractedNodes.length} product variants from Shopify`);
+  const allVariants = extractedNodes.map((v) => {
+    const title = v.title === "Default Title" ? v.product.title : `${v.product.title} ${v.title}`;
+    const url = v.product.onlineStoreUrl ? `${v.product.onlineStoreUrl}?variant=${v.legacyResourceId}` : null;
+    return {
+      status: v.product.status,
+      sku: v.sku ?? "",
+      barcode: v.barcode ?? null,
+      price: v.price,
+      title,
+      url,
+      handle: v.product.handle,
+      description: v.product.description,
+      imageUrl: v.product.featuredImage?.url ?? null,
+      inventoryQuantity: v.inventoryQuantity ?? 0
+    };
+  });
+  return await returnOutputParsed(allVariants, GetAllProductVariantsReturn);
+}
+
 // src/queries/orders/getOrderPaymentDetails.queries.ts
 var queryOrderPaymentDetails = gql`#graphql
   query orderPaymentDetailsById($id: ID!) {
@@ -1158,25 +2139,6 @@ var queryOrderPaymentDetails = gql`#graphql
 `;
 
 // src/queries/orders/getOrderPaymentDetails.ts
-var GetOrderPaymentDetailsByIdReturn = import_zod11.default.object({
-  order: import_zod11.default.object({
-    transactions: import_zod11.default.array(
-      import_zod11.default.object({
-        amountSet: import_zod11.default.object({
-          shopMoney: import_zod11.default.object({
-            amount: import_zod11.default.string(),
-            currencyCode: import_zod11.default.string()
-          })
-        }),
-        createdAt: import_zod11.default.string(),
-        gateway: import_zod11.default.string(),
-        formattedGateway: import_zod11.default.string(),
-        kind: import_zod11.default.string(),
-        paymentId: import_zod11.default.string()
-      })
-    )
-  })
-});
 async function getOrderPaymentDetailsById(id) {
   const variables = {
     id: convertIdIntoGid(id, "Order")
@@ -1187,9 +2149,301 @@ async function getOrderPaymentDetailsById(id) {
   });
   if (!response.order) {
     logger.debug(`No order found with ID: ${id}`);
-    return null;
+    return void 0;
   }
-  return await returnOutputParsed(response, GetOrderPaymentDetailsByIdReturn);
+  return response.order;
+}
+
+// src/queries/fulfillments/getFulfillmentById.queries.ts
+var queryFulfillmentById = gql`#graphql
+  query fulfillmentById($id: ID!) {
+    fulfillment(id: $id) {
+      id
+      name
+      createdAt
+      updatedAt
+      status
+      totalQuantity
+      estimatedDeliveryAt
+      deliveredAt
+      location {
+        id
+        legacyResourceId
+        name
+      }
+      service {
+        handle
+        serviceName
+      }
+      trackingInfo(first: 10) {
+        company
+        number
+        url
+      }
+      originAddress {
+        address1
+        address2
+        city
+        countryCode
+        provinceCode
+        zip
+      }
+      fulfillmentLineItems(first: 100) {
+        edges {
+          node {
+            id
+            quantity
+            originalTotalSet {
+              shopMoney {
+                amount
+                currencyCode
+              }
+            }
+            lineItem {
+              id
+              title
+              sku
+              variant {
+                id
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/fulfillments/getFulfillmentById.ts
+async function getFulfillmentById(id) {
+  const gid = typeof id === "string" ? id : convertIdIntoGid(
+    typeof id === "number" ? BigInt(id) : id,
+    "Fulfillment"
+  );
+  const variables = { id: gid };
+  const response = await fetchShopifyGraphql({
+    query: queryFulfillmentById,
+    variables
+  });
+  if (!response.fulfillment) {
+    logger.debug(`No fulfillment found with ID: ${id}`);
+    return void 0;
+  }
+  return response.fulfillment;
+}
+
+// src/queries/fulfillmentOrders/getFulfillmentOrdersByOrderId.queries.ts
+var queryFulfillmentOrdersByOrderId = gql`#graphql
+  query fulfillmentOrdersByOrderId($orderId: ID!) {
+    order(id: $orderId) {
+      fulfillmentOrders(first: 50) {
+        edges {
+          node {
+            id
+            status
+            lineItems(first: 100) {
+              edges {
+                node {
+                  id
+                  remainingQuantity
+                  totalQuantity
+                  lineItem {
+                    id
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/fulfillmentOrders/getFulfillmentOrdersByOrderId.ts
+async function getFulfillmentOrdersByOrderId(orderId) {
+  const gid = typeof orderId === "string" ? orderId : convertIdIntoGid(
+    typeof orderId === "number" ? BigInt(orderId) : orderId,
+    "Order"
+  );
+  const variables = { orderId: gid };
+  const response = await fetchShopifyGraphql({
+    query: queryFulfillmentOrdersByOrderId,
+    variables
+  });
+  if (!response.order) {
+    logger.debug(`No order found with ID: ${orderId}`);
+    return [];
+  }
+  return response.order.fulfillmentOrders.edges.map((edge) => edge.node);
+}
+
+// src/queries/customers/getCustomersByEmail.queries.ts
+var queryCustomersByEmail = gql`#graphql
+  query customersByEmail($query: String!, $first: Int!) {
+    customers(first: $first, query: $query) {
+      edges {
+        node {
+          id
+          email
+          firstName
+          lastName
+          numberOfOrders
+          amountSpent {
+            amount
+            currencyCode
+          }
+          defaultAddress {
+            id
+            address1
+            address2
+            city
+            province
+            country
+            zip
+            phone
+          }
+          addresses {
+            id
+            address1
+            address2
+            city
+            province
+            country
+            zip
+            phone
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/customers/getCustomersByEmail.ts
+async function getCustomersByEmail(email, limit = 10) {
+  const variables = {
+    query: `email:${email}`,
+    first: limit
+  };
+  const response = await fetchShopifyGraphql({
+    query: queryCustomersByEmail,
+    variables
+  });
+  const customers = response.customers.edges.map((edge) => edge.node);
+  logger.debug(`Found ${customers.length} customers for email: ${email}`);
+  return customers;
+}
+
+// src/queries/customerSegments/getCustomerSegmentMembers.queries.ts
+var queryCustomerSegmentMembersWithStatistics = gql`#graphql
+  query customerSegmentMembersWithStatistics($query: String!, $first: Int!, $statisticsAttributeName: String!) {
+    customerSegmentMembers(query: $query, first: $first) {
+      statistics {
+        attributeStatistics(attributeName: $statisticsAttributeName) {
+          sum
+          average
+        }
+      }
+      edges {
+        node {
+          id
+          firstName
+          lastName
+          displayName
+          defaultEmailAddress {
+            emailAddress
+          }
+        }
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+      totalCount
+    }
+  }
+`;
+
+// src/queries/customerSegments/getCustomerSegmentMembers.ts
+async function getCustomerSegmentMembers(query, statisticsAttributeName, limit = 250) {
+  const variables = {
+    query,
+    first: limit,
+    statisticsAttributeName
+  };
+  const response = await fetchShopifyGraphql({
+    query: queryCustomerSegmentMembersWithStatistics,
+    variables
+  });
+  const members = response.customerSegmentMembers.edges.map((edge) => edge.node);
+  logger.debug(`Found ${members.length} customer segment members`);
+  return {
+    members,
+    totalCount: response.customerSegmentMembers.totalCount,
+    statistics: response.customerSegmentMembers.statistics
+  };
+}
+
+// src/queries/orders/getOrdersByCustomerId.queries.ts
+var queryOrdersByCustomerId = gql`#graphql
+  query ordersByCustomerId($customerId: ID!, $first: Int!) {
+    customer(id: $customerId) {
+      id
+      orders(first: $first, reverse: true) {
+        edges {
+          node {
+            id
+            name
+            createdAt
+            cancelledAt
+            cancelReason
+            displayFulfillmentStatus
+            totalPriceSet {
+              shopMoney {
+                amount
+                currencyCode
+              }
+            }
+            lineItems(first: 100) {
+              edges {
+                node {
+                  sku
+                  title
+                  image {
+                    url
+                    width
+                    height
+                    altText
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+
+// src/queries/orders/getOrdersByCustomerId.ts
+async function getOrdersByCustomerId(customerId, limit = 250) {
+  const bigIntId = typeof customerId === "number" ? BigInt(customerId) : customerId;
+  const gid = convertIdIntoGid(bigIntId, "Customer");
+  const variables = {
+    customerId: gid,
+    first: limit
+  };
+  const response = await fetchShopifyGraphql({
+    query: queryOrdersByCustomerId,
+    variables
+  });
+  if (!response.customer) {
+    logger.debug(`No customer found with ID: ${customerId}`);
+    return [];
+  }
+  const orders = response.customer.orders.edges.map((edge) => edge.node);
+  logger.debug(`Got ${orders.length} orders for customer ${customerId}`);
+  return orders;
 }
 
 // src/utils/parseGid.ts
@@ -1197,15 +2451,68 @@ function parseGid(gid) {
   const match = gid.match(/\d+$/);
   return match ? Number.parseInt(match[0], 10) : 0;
 }
+
+// src/queries/metaobjects/getMetaobjectByHandle.queries.ts
+var queryMetaobjectByHandle = gql`#graphql
+  query metaobjectByHandle($handle: MetaobjectHandleInput!) {
+    metaobjectByHandle(handle: $handle) {
+      id
+      handle
+      type
+      displayName
+      updatedAt
+      fields {
+        key
+        value
+        type
+      }
+    }
+  }
+`;
+
+// src/queries/metaobjects/getMetaobjectByHandle.ts
+async function getMetaobjectByHandle(handle) {
+  const variables = { handle };
+  const response = await fetchShopifyGraphql({
+    query: queryMetaobjectByHandle,
+    variables
+  });
+  if (!response.metaobjectByHandle) {
+    logger.debug(
+      `No metaobject found with type "${handle.type}" and handle "${handle.handle}"`
+    );
+    return void 0;
+  }
+  return response.metaobjectByHandle;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ShopifyUserError,
+  bulkUpdateProductVariants,
+  calculateRefund,
   cancelOrderById,
+  createFile,
+  createFulfillment,
+  createMetaobjectDefinition,
+  createRefund,
   deleteCustomerById,
+  deleteFilesByIds,
+  getAllProductVariants,
+  getCustomerSegmentMembers,
+  getCustomersByEmail,
+  getFulfillmentById,
+  getFulfillmentOrdersByOrderId,
+  getFulfillmentTrackingIds,
   getLeanProductVariants,
+  getMetaobjectByHandle,
   getOrderById,
   getOrderByName,
+  getOrderCancellationInfoByName,
   getOrderPaymentDetailsById,
-  parseGid
+  getOrdersByCustomerId,
+  getProductVariantsBySkus,
+  parseGid,
+  updateFulfillmentTracking,
+  upsertMetaobject
 });
 //# sourceMappingURL=index.cjs.map