@ehrenkind/shopify-lib 0.3.0 → 0.4.1

package/dist/index.cjs

@@ -33,17 +33,20 @@ __export(index_exports, {
   ShopifyUserError: () => ShopifyUserError,
   cancelOrderById: () => cancelOrderById,
   deleteCustomerById: () => deleteCustomerById,
+  getCustomersByEmail: () => getCustomersByEmail,
+  getFulfillmentById: () => getFulfillmentById,
+  getFulfillmentOrdersByOrderId: () => getFulfillmentOrdersByOrderId,
+  getFulfillmentTrackingIds: () => getFulfillmentTrackingIds,
   getLeanProductVariants: () => getLeanProductVariants,
   getOrderById: () => getOrderById,
   getOrderByName: () => getOrderByName,
+  getOrderCancellationInfoByName: () => getOrderCancellationInfoByName,
   getOrderPaymentDetailsById: () => getOrderPaymentDetailsById,
+  getOrdersByCustomerId: () => getOrdersByCustomerId,
   parseGid: () => parseGid
 });
 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 +95,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 +124,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 +153,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 +179,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,25 +246,7 @@ 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
     mutation customerDelete($input: CustomerDeleteInput!) {
@@ -286,10 +277,7 @@ async function deleteCustomerById(customerId) {
       };
     }
   });
-  return returnOutputParsed(
-    response[0]?.deletedCustomerId ?? null,
-    DeleteCustomerByIdReturn
-  );
+  return response[0]?.deletedCustomerId ?? null;
 }
 
 // src/mutations/orders/cancelOrderById.ts
@@ -335,7 +323,24 @@ async function cancelOrderById(orderId) {
 }
 
 // src/queries/orders/getOrderById.ts
-var import_zod5 = __toESM(require("zod"), 1);
+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
@@ -513,36 +518,36 @@ 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") {
@@ -614,7 +619,7 @@ async function getFullOrderById(id) {
 }
 
 // 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,22 +957,22 @@ 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()
+  financialStatus: import_zod5.default.string().nullable(),
+  fulfillmentStatus: import_zod5.default.string().nullable()
 }).nullable();
 async function getOrderByName(orderName, detailLevel = "lean") {
   if (detailLevel === "lean") {
@@ -1057,15 +1062,59 @@ async function getFullOrderByName(orderName) {
   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 null;
+  }
+  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 +1182,6 @@ async function getLeanProductVariants(skus) {
   return await returnOutputParsed(allVariants, GetLeanProductVariantsReturn);
 }
 
-// src/queries/orders/getOrderPaymentDetails.ts
-var import_zod11 = __toESM(require("zod"), 1);
-
 // src/queries/orders/getOrderPaymentDetails.queries.ts
 var queryOrderPaymentDetails = gql`#graphql
   query orderPaymentDetailsById($id: ID!) {
@@ -1158,25 +1204,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")
@@ -1189,7 +1216,286 @@ async function getOrderPaymentDetailsById(id) {
     logger.debug(`No order found with ID: ${id}`);
     return null;
   }
-  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 null;
+  }
+  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/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!) {
+    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/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
@@ -1202,10 +1508,16 @@ function parseGid(gid) {
   ShopifyUserError,
   cancelOrderById,
   deleteCustomerById,
+  getCustomersByEmail,
+  getFulfillmentById,
+  getFulfillmentOrdersByOrderId,
+  getFulfillmentTrackingIds,
   getLeanProductVariants,
   getOrderById,
   getOrderByName,
+  getOrderCancellationInfoByName,
   getOrderPaymentDetailsById,
+  getOrdersByCustomerId,
   parseGid
 });
 //# sourceMappingURL=index.cjs.map