@ehrenkind/shopify-lib 0.4.0 → 0.4.1

package/dist/index.mjs

@@ -1,6 +1,3 @@
-// src/mutations/customers/deleteCustomerById.ts
-import z3 from "zod";
-
 // src/utils/logger.ts
 var { env } = process;
 var gql = String.raw;
@@ -50,7 +47,6 @@ var logger = {
 
 // src/utils/shopifyClient.ts
 import {
-  ApiVersion,
   LogSeverity,
   Session,
   shopifyApi
@@ -58,7 +54,12 @@ import {
 import "@shopify/shopify-api/adapters/node";
 import dotenv from "dotenv";
 import { z } from "zod";
+
+// src/utils/apiVersion.ts
+import { ApiVersion } from "@shopify/shopify-api";
 var SHOPIFY_API_VERSION = ApiVersion.April25;
+
+// src/utils/shopifyClient.ts
 dotenv.config();
 var envSchema = z.object({
   SHOPIFY_API_KEY: z.string({
@@ -133,10 +134,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) {
@@ -199,25 +201,7 @@ async function makeRequest(query, variables) {
   return response.data;
 }
 
-// src/utils/zod.ts
-import z2 from "zod";
-async function returnOutputParsed(data, Model) {
-  const parsed = await Model.safeParseAsync(data);
-  if (!parsed.success) {
-    if (parsed.error instanceof z2.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 = z3.string().nullable();
 async function deleteCustomerById(customerId) {
   const mutation2 = gql`#graphql
     mutation customerDelete($input: CustomerDeleteInput!) {
@@ -248,10 +232,7 @@ async function deleteCustomerById(customerId) {
       };
     }
   });
-  return returnOutputParsed(
-    response[0]?.deletedCustomerId ?? null,
-    DeleteCustomerByIdReturn
-  );
+  return response[0]?.deletedCustomerId ?? null;
 }
 
 // src/mutations/orders/cancelOrderById.ts
@@ -297,7 +278,24 @@ async function cancelOrderById(orderId) {
 }
 
 // src/queries/orders/getOrderById.ts
-import z4 from "zod";
+import z3 from "zod";
+
+// src/utils/zod.ts
+import z2 from "zod";
+async function returnOutputParsed(data, Model) {
+  const parsed = await Model.safeParseAsync(data);
+  if (!parsed.success) {
+    if (parsed.error instanceof z2.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
@@ -475,36 +473,36 @@ var queryOrderByIdFull = gql`#graphql
 `;
 
 // src/queries/orders/getOrderById.ts
-var AddressSchema = z4.object({
-  firstName: z4.string().nullable(),
-  lastName: z4.string().nullable(),
-  address1: z4.string().nullable(),
-  address2: z4.string().nullable(),
-  city: z4.string().nullable(),
-  province: z4.string().nullable(),
-  country: z4.string().nullable(),
-  zip: z4.string().nullable()
+var AddressSchema = z3.object({
+  firstName: z3.string().nullable(),
+  lastName: z3.string().nullable(),
+  address1: z3.string().nullable(),
+  address2: z3.string().nullable(),
+  city: z3.string().nullable(),
+  province: z3.string().nullable(),
+  country: z3.string().nullable(),
+  zip: z3.string().nullable()
 }).nullable();
-var GetLeanOrderByIdReturn = z4.object({
-  id: z4.string(),
-  name: z4.string(),
-  createdAt: z4.string(),
-  updatedAt: z4.string(),
-  cancelledAt: z4.string().nullable(),
-  cancelReason: z4.string().nullable(),
-  totalPrice: z4.object({
-    amount: z4.string(),
-    currencyCode: z4.string()
+var GetLeanOrderByIdReturn = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  createdAt: z3.string(),
+  updatedAt: z3.string(),
+  cancelledAt: z3.string().nullable(),
+  cancelReason: z3.string().nullable(),
+  totalPrice: z3.object({
+    amount: z3.string(),
+    currencyCode: z3.string()
   }),
-  customer: z4.object({
-    id: z4.string(),
-    displayName: z4.string(),
-    firstName: z4.string().nullable(),
-    lastName: z4.string().nullable(),
-    emailAddress: z4.string().nullable()
+  customer: z3.object({
+    id: z3.string(),
+    displayName: z3.string(),
+    firstName: z3.string().nullable(),
+    lastName: z3.string().nullable(),
+    emailAddress: z3.string().nullable()
   }).nullable(),
-  financialStatus: z4.string().nullable(),
-  fulfillmentStatus: z4.string().nullable(),
+  financialStatus: z3.string().nullable(),
+  fulfillmentStatus: z3.string().nullable(),
   shippingAddress: AddressSchema
 }).nullable();
 async function getOrderById(id, detailLevel = "lean") {
@@ -576,7 +574,7 @@ async function getFullOrderById(id) {
 }
 
 // src/queries/orders/getOrderByName.ts
-import z5 from "zod";
+import z4 from "zod";
 
 // src/queries/orders/getOrderByName.queries.ts
 var queryOrdersByName = gql`#graphql
@@ -914,22 +912,22 @@ var queryOrdersByNameFull = gql`#graphql
 `;
 
 // src/queries/orders/getOrderByName.ts
-var GetLeanOrderByNameReturn = z5.object({
-  id: z5.string(),
-  name: z5.string(),
-  createdAt: z5.string(),
-  updatedAt: z5.string(),
-  totalPrice: z5.object({
-    amount: z5.string(),
-    currencyCode: z5.string()
+var GetLeanOrderByNameReturn = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  createdAt: z4.string(),
+  updatedAt: z4.string(),
+  totalPrice: z4.object({
+    amount: z4.string(),
+    currencyCode: z4.string()
   }),
-  customer: z5.object({
-    id: z5.string(),
-    displayName: z5.string(),
-    emailAddress: z5.string().nullable()
+  customer: z4.object({
+    id: z4.string(),
+    displayName: z4.string(),
+    emailAddress: z4.string().nullable()
   }).nullable(),
-  financialStatus: z5.string().nullable(),
-  fulfillmentStatus: z5.string().nullable()
+  financialStatus: z4.string().nullable(),
+  fulfillmentStatus: z4.string().nullable()
 }).nullable();
 async function getOrderByName(orderName, detailLevel = "lean") {
   if (detailLevel === "lean") {
@@ -1019,15 +1017,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
-import z6 from "zod";
-var GetLeanProductVariantsReturn = z6.array(
-  z6.object({
-    productId: z6.string(),
-    productTitle: z6.string(),
-    variantId: z6.string(),
-    variantTitle: z6.string(),
-    sku: z6.string()
+import z5 from "zod";
+var GetLeanProductVariantsReturn = z5.array(
+  z5.object({
+    productId: z5.string(),
+    productTitle: z5.string(),
+    variantId: z5.string(),
+    variantTitle: z5.string(),
+    sku: z5.string()
   })
 );
 async function getLeanProductVariants(skus) {
@@ -1095,9 +1137,6 @@ async function getLeanProductVariants(skus) {
   return await returnOutputParsed(allVariants, GetLeanProductVariantsReturn);
 }
 
-// src/queries/orders/getOrderPaymentDetails.ts
-import z7 from "zod";
-
 // src/queries/orders/getOrderPaymentDetails.queries.ts
 var queryOrderPaymentDetails = gql`#graphql
   query orderPaymentDetailsById($id: ID!) {
@@ -1120,25 +1159,6 @@ var queryOrderPaymentDetails = gql`#graphql
 `;
 
 // src/queries/orders/getOrderPaymentDetails.ts
-var GetOrderPaymentDetailsByIdReturn = z7.object({
-  order: z7.object({
-    transactions: z7.array(
-      z7.object({
-        amountSet: z7.object({
-          shopMoney: z7.object({
-            amount: z7.string(),
-            currencyCode: z7.string()
-          })
-        }),
-        createdAt: z7.string(),
-        gateway: z7.string(),
-        formattedGateway: z7.string(),
-        kind: z7.string(),
-        paymentId: z7.string()
-      })
-    )
-  })
-});
 async function getOrderPaymentDetailsById(id) {
   const variables = {
     id: convertIdIntoGid(id, "Order")
@@ -1151,7 +1171,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
@@ -1163,10 +1462,16 @@ export {
   ShopifyUserError,
   cancelOrderById,
   deleteCustomerById,
+  getCustomersByEmail,
+  getFulfillmentById,
+  getFulfillmentOrdersByOrderId,
+  getFulfillmentTrackingIds,
   getLeanProductVariants,
   getOrderById,
   getOrderByName,
+  getOrderCancellationInfoByName,
   getOrderPaymentDetailsById,
+  getOrdersByCustomerId,
   parseGid
 };
 //# sourceMappingURL=index.mjs.map