@ehrenkind/shopify-lib 0.4.1 → 0.5.0

package/dist/index.cjs

@@ -31,19 +31,32 @@ 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,
   getOrdersByCustomerId: () => getOrdersByCustomerId,
-  parseGid: () => parseGid
+  getProductVariantsBySkus: () => getProductVariantsBySkus,
+  parseGid: () => parseGid,
+  updateFulfillmentTracking: () => updateFulfillmentTracking,
+  upsertMetaobject: () => upsertMetaobject
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -248,7 +261,7 @@ async function makeRequest(query, variables) {
 
 // src/mutations/customers/deleteCustomerById.ts
 async function deleteCustomerById(customerId) {
-  const mutation2 = gql`#graphql
+  const mutation9 = gql`#graphql
     mutation customerDelete($input: CustomerDeleteInput!) {
       customerDelete(input: $input) {
         deletedCustomerId
@@ -263,7 +276,7 @@ async function deleteCustomerById(customerId) {
     input: { id: customerId }
   };
   const response = await fetchShopifyGraphql({
-    query: mutation2,
+    query: mutation9,
     variables,
     dataExtractor: (data) => {
       if (!data.customerDelete) {
@@ -277,11 +290,368 @@ async function deleteCustomerById(customerId) {
       };
     }
   });
-  return response[0]?.deletedCustomerId ?? null;
+  return response[0]?.deletedCustomerId ?? void 0;
 }
 
-// src/mutations/orders/cancelOrderById.ts
+// 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 mutation5 = gql`#graphql
   mutation orderCancel($orderId: ID!) {
     orderCancel(
       orderId: $orderId
@@ -298,28 +668,417 @@ var mutation = gql`#graphql
     }
   }
 `;
-async function cancelOrderById(orderId) {
+async function cancelOrderById(orderId) {
+  const orderGid = typeof orderId === "string" ? orderId : convertIdIntoGid(
+    typeof orderId === "number" ? BigInt(orderId) : orderId,
+    "Order"
+  );
+  logger.debug(`Cancelling order ${orderGid}`);
+  const variables = { orderId: orderGid };
+  await fetchShopifyGraphql({
+    query: mutation5,
+    variables,
+    dataExtractor: (data) => {
+      if (!data.orderCancel) {
+        throw new Error("GraphQL response missing 'orderCancel' field");
+      }
+      return {
+        nodes: [{ success: true }],
+        userErrors: data.orderCancel.orderCancelUserErrors
+      };
+    }
+  });
+  logger.debug(`Order ${orderGid} cancelled successfully`);
+  return true;
+}
+
+// src/mutations/refunds/createRefund.ts
+var mutation6 = gql`#graphql
+  mutation createRefund($input: RefundInput!) {
+    refundCreate(input: $input) {
+      refund {
+        id
+        totalRefundedSet {
+          shopMoney {
+            amount
+            currencyCode
+          }
+          presentmentMoney {
+            amount
+            currencyCode
+          }
+        }
+      }
+      userErrors {
+        field
+        message
+      }
+    }
+  }
+`;
+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");
+      }
+      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"
   );
-  logger.debug(`Cancelling order ${orderGid}`);
-  const variables = { orderId: orderGid };
-  await fetchShopifyGraphql({
-    query: mutation,
-    variables,
-    dataExtractor: (data) => {
-      if (!data.orderCancel) {
-        throw new Error("GraphQL response missing 'orderCancel' field");
-      }
-      return {
-        nodes: [{ success: true }],
-        userErrors: data.orderCancel.orderCancelUserErrors
-      };
-    }
+  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
   });
-  logger.debug(`Order ${orderGid} cancelled successfully`);
-  return true;
+  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
@@ -549,7 +1308,7 @@ var GetLeanOrderByIdReturn = import_zod3.default.object({
   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") {
@@ -567,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 = {
@@ -613,7 +1372,7 @@ async function getFullOrderById(id) {
   });
   if (!response.order) {
     logger.debug(`No order found with ID: ${id}`);
-    return null;
+    return void 0;
   }
   return response.order;
 }
@@ -973,7 +1732,7 @@ var GetLeanOrderByNameReturn = import_zod5.default.object({
   }).nullable(),
   financialStatus: import_zod5.default.string().nullable(),
   fulfillmentStatus: import_zod5.default.string().nullable()
-}).nullable();
+});
 async function getOrderByName(orderName, detailLevel = "lean") {
   if (detailLevel === "lean") {
     return getLeanOrderByName(orderName);
@@ -1006,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,
@@ -1052,12 +1811,12 @@ 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;
 }
@@ -1101,7 +1860,7 @@ async function getOrderCancellationInfoByName(orderName) {
   const order = firstEdge?.node;
   if (!order) {
     logger.debug(`No order found with name: ${orderName}`);
-    return null;
+    return void 0;
   }
   return order;
 }
@@ -1182,6 +1941,182 @@ async function getLeanProductVariants(skus) {
   return await returnOutputParsed(allVariants, GetLeanProductVariantsReturn);
 }
 
+// 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!) {
@@ -1214,7 +2149,7 @@ async function getOrderPaymentDetailsById(id) {
   });
   if (!response.order) {
     logger.debug(`No order found with ID: ${id}`);
-    return null;
+    return void 0;
   }
   return response.order;
 }
@@ -1292,7 +2227,7 @@ async function getFulfillmentById(id) {
   });
   if (!response.fulfillment) {
     logger.debug(`No fulfillment found with ID: ${id}`);
-    return null;
+    return void 0;
   }
   return response.fulfillment;
 }
@@ -1343,43 +2278,6 @@ async function getFulfillmentOrdersByOrderId(orderId) {
   return response.order.fulfillmentOrders.edges.map((edge) => edge.node);
 }
 
-// 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 null;
-  }
-  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/queries/customers/getCustomersByEmail.queries.ts
 var queryCustomersByEmail = gql`#graphql
   query customersByEmail($query: String!, $first: Int!) {
@@ -1436,6 +2334,56 @@ async function getCustomersByEmail(email, limit = 10) {
   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!) {
@@ -1503,21 +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,
   getOrdersByCustomerId,
-  parseGid
+  getProductVariantsBySkus,
+  parseGid,
+  updateFulfillmentTracking,
+  upsertMetaobject
 });
 //# sourceMappingURL=index.cjs.map